Datasets:

unum-cloud

/

ann-codesearch-4m

like 0

Follow

Unum 28

[ "private", "function", "addLongOption", "(", "$", "name", ",", "$", "value", ")", "{", "if", "(", "!", "$", "this", "->", "definition", "->", "hasOption", "(", "$", "name", ")", ")", "{", "throw", "new", "\\", "RuntimeException", "(", "\\", "sprintf", "(", "'The \"--%s\" option does not exist.'", ",", "$", "name", ")", ")", ";", "}", "$", "option", "=", "$", "this", "->", "definition", "->", "getOption", "(", "$", "name", ")", ";", "if", "(", "null", "!==", "$", "value", "&&", "!", "$", "option", "->", "acceptValue", "(", ")", ")", "{", "throw", "new", "\\", "RuntimeException", "(", "\\", "sprintf", "(", "'The \"--%s\" option does not accept a value.'", ",", "$", "name", ")", ")", ";", "}", "if", "(", "\\", "in_array", "(", "$", "value", ",", "[", "''", ",", "null", "]", ",", "true", ")", "&&", "$", "option", "->", "acceptValue", "(", ")", "&&", "\\", "count", "(", "$", "this", "->", "parsed", ")", ")", "{", "// if option accepts an optional or mandatory argument", "// let's see if there is one provided", "$", "next", "=", "\\", "array_shift", "(", "$", "this", "->", "parsed", ")", ";", "$", "nextToken", "=", "$", "next", "[", "0", "]", ";", "if", "(", "(", "isset", "(", "$", "nextToken", "[", "0", "]", ")", "&&", "'-'", "!==", "$", "nextToken", "[", "0", "]", ")", "||", "\\", "in_array", "(", "$", "nextToken", ",", "[", "''", ",", "null", "]", ",", "true", ")", ")", "{", "$", "value", "=", "$", "nextToken", ";", "}", "else", "{", "\\", "array_unshift", "(", "$", "this", "->", "parsed", ",", "$", "next", ")", ";", "}", "}", "if", "(", "null", "===", "$", "value", ")", "{", "if", "(", "$", "option", "->", "isValueRequired", "(", ")", ")", "{", "throw", "new", "\\", "RuntimeException", "(", "\\", "sprintf", "(", "'The \"--%s\" option requires a value.'", ",", "$", "name", ")", ")", ";", "}", "if", "(", "!", "$", "option", "->", "isArray", "(", ")", "&&", "!", "$", "option", "->", "isValueOptional", "(", ")", ")", "{", "$", "value", "=", "true", ";", "}", "}", "if", "(", "$", "option", "->", "isArray", "(", ")", ")", "{", "$", "this", "->", "options", "[", "$", "name", "]", "[", "]", "=", "$", "value", ";", "}", "else", "{", "$", "this", "->", "options", "[", "$", "name", "]", "=", "$", "value", ";", "}", "}" ]

[ "Adds", "a", "long", "option", "value", "." ]

[ "public", "function", "enterNode", "(", "Node", "$", "origNode", ")", "{", "if", "(", "!", "$", "this", "->", "isRequireNode", "(", "$", "origNode", ")", ")", "{", "return", ";", "}", "$", "node", "=", "clone", "$", "origNode", ";", "/*\n * rewrite\n *\n * $foo = require $bar\n *\n * to\n *\n * $foo = require \\Psy\\CodeCleaner\\RequirePass::resolve($bar)\n */", "$", "node", "->", "expr", "=", "new", "StaticCall", "(", "new", "FullyQualifiedName", "(", "'Psy\\CodeCleaner\\RequirePass'", ")", ",", "'resolve'", ",", "[", "new", "Arg", "(", "$", "origNode", "->", "expr", ")", ",", "new", "Arg", "(", "new", "LNumber", "(", "$", "origNode", "->", "getLine", "(", ")", ")", ")", "]", ",", "$", "origNode", "->", "getAttributes", "(", ")", ")", ";", "return", "$", "node", ";", "}" ]

[ "{" ]

[ "public", "static", "function", "resolve", "(", "$", "file", ",", "$", "lineNumber", "=", "null", ")", "{", "$", "file", "=", "(", "string", ")", "$", "file", ";", "if", "(", "$", "file", "===", "''", ")", "{", "// @todo Shell::handleError would be better here, because we could", "// fake the file and line number, but we can't call it statically.", "// So we're duplicating some of the logics here.", "if", "(", "E_WARNING", "&", "\\", "error_reporting", "(", ")", ")", "{", "ErrorException", "::", "throwException", "(", "E_WARNING", ",", "'Filename cannot be empty'", ",", "null", ",", "$", "lineNumber", ")", ";", "}", "// @todo trigger an error as fallback? this is pretty ugly…", "// trigger_error('Filename cannot be empty', E_USER_WARNING);", "}", "if", "(", "$", "file", "===", "''", "||", "!", "\\", "stream_resolve_include_path", "(", "$", "file", ")", ")", "{", "$", "msg", "=", "\\", "sprintf", "(", "\"Failed opening required '%s'\"", ",", "$", "file", ")", ";", "throw", "new", "FatalErrorException", "(", "$", "msg", ",", "0", ",", "E_ERROR", ",", "null", ",", "$", "lineNumber", ")", ";", "}", "return", "$", "file", ";", "}" ]

[ "Runtime", "validation", "that", "$file", "can", "be", "resolved", "as", "an", "include", "path", "." ]

[ "protected", "function", "execute", "(", "InputInterface", "$", "input", ",", "OutputInterface", "$", "output", ")", "{", "$", "depth", "=", "$", "input", "->", "getOption", "(", "'depth'", ")", ";", "$", "target", "=", "$", "this", "->", "resolveCode", "(", "$", "input", "->", "getArgument", "(", "'target'", ")", ")", ";", "$", "output", "->", "page", "(", "$", "this", "->", "presenter", "->", "present", "(", "$", "target", ",", "$", "depth", ",", "$", "input", "->", "getOption", "(", "'all'", ")", "?", "Presenter", "::", "VERBOSE", ":", "0", ")", ")", ";", "if", "(", "\\", "is_object", "(", "$", "target", ")", ")", "{", "$", "this", "->", "setCommandScopeVariables", "(", "new", "\\", "ReflectionObject", "(", "$", "target", ")", ")", ";", "}", "}" ]

[ "{" ]

[ "public", "function", "enterNode", "(", "Node", "$", "node", ")", "{", "if", "(", "!", "$", "node", "instanceof", "Instanceof_", ")", "{", "return", ";", "}", "if", "(", "(", "$", "node", "->", "expr", "instanceof", "Scalar", "&&", "!", "$", "node", "->", "expr", "instanceof", "Encapsed", ")", "||", "$", "node", "->", "expr", "instanceof", "ConstFetch", ")", "{", "throw", "new", "FatalErrorException", "(", "self", "::", "EXCEPTION_MSG", ",", "0", ",", "E_ERROR", ",", "null", ",", "$", "node", "->", "getLine", "(", ")", ")", ";", "}", "}" ]

[ "Validate", "that", "the", "instanceof", "statement", "does", "not", "receive", "a", "scalar", "value", "or", "a", "non", "-", "class", "constant", "." ]

[ "protected", "function", "execute", "(", "InputInterface", "$", "input", ",", "OutputInterface", "$", "output", ")", "{", "$", "code", "=", "$", "input", "->", "getArgument", "(", "'code'", ")", ";", "$", "num", "=", "$", "input", "->", "getOption", "(", "'num'", ")", "?", ":", "1", ";", "$", "shell", "=", "$", "this", "->", "getApplication", "(", ")", ";", "$", "instrumentedCode", "=", "$", "this", "->", "instrumentCode", "(", "$", "code", ")", ";", "self", "::", "$", "times", "=", "[", "]", ";", "for", "(", "$", "i", "=", "0", ";", "$", "i", "<", "$", "num", ";", "$", "i", "++", ")", "{", "$", "_", "=", "$", "shell", "->", "execute", "(", "$", "instrumentedCode", ")", ";", "$", "this", "->", "ensureEndMarked", "(", ")", ";", "}", "$", "shell", "->", "writeReturnValue", "(", "$", "_", ")", ";", "$", "times", "=", "self", "::", "$", "times", ";", "self", "::", "$", "times", "=", "[", "]", ";", "if", "(", "$", "num", "===", "1", ")", "{", "$", "output", "->", "writeln", "(", "\\", "sprintf", "(", "self", "::", "RESULT_MSG", ",", "$", "times", "[", "0", "]", ")", ")", ";", "}", "else", "{", "$", "total", "=", "\\", "array_sum", "(", "$", "times", ")", ";", "\\", "rsort", "(", "$", "times", ")", ";", "$", "median", "=", "$", "times", "[", "\\", "round", "(", "$", "num", "/", "2", ")", "]", ";", "$", "output", "->", "writeln", "(", "\\", "sprintf", "(", "self", "::", "AVG_RESULT_MSG", ",", "$", "total", "/", "$", "num", ",", "$", "median", ",", "$", "total", ")", ")", ";", "}", "}" ]

[ "{" ]

[ "public", "static", "function", "markEnd", "(", "$", "ret", "=", "null", ")", "{", "self", "::", "$", "times", "[", "]", "=", "\\", "microtime", "(", "true", ")", "-", "self", "::", "$", "start", ";", "self", "::", "$", "start", "=", "null", ";", "return", "$", "ret", ";", "}" ]

[ "Internal", "method", "for", "marking", "the", "end", "of", "timeit", "execution", "." ]

[ "private", "function", "instrumentCode", "(", "$", "code", ")", "{", "return", "$", "this", "->", "printer", "->", "prettyPrint", "(", "$", "this", "->", "traverser", "->", "traverse", "(", "$", "this", "->", "parse", "(", "$", "code", ")", ")", ")", ";", "}" ]

[ "Instrument", "code", "for", "timeit", "execution", "." ]

[ "protected", "function", "getInput", "(", "array", "$", "tokens", ")", "{", "$", "var", "=", "''", ";", "$", "firstToken", "=", "\\", "array_pop", "(", "$", "tokens", ")", ";", "if", "(", "self", "::", "tokenIs", "(", "$", "firstToken", ",", "self", "::", "T_STRING", ")", ")", "{", "$", "var", "=", "$", "firstToken", "[", "1", "]", ";", "}", "return", "$", "var", ";", "}" ]

[ "Get", "current", "readline", "input", "word", "." ]

[ "protected", "function", "getNamespaceAndClass", "(", "$", "tokens", ")", "{", "$", "class", "=", "''", ";", "while", "(", "self", "::", "hasToken", "(", "[", "self", "::", "T_NS_SEPARATOR", ",", "self", "::", "T_STRING", "]", ",", "$", "token", "=", "\\", "array_pop", "(", "$", "tokens", ")", ")", ")", "{", "if", "(", "self", "::", "needCompleteClass", "(", "$", "token", ")", ")", "{", "continue", ";", "}", "$", "class", "=", "$", "token", "[", "1", "]", ".", "$", "class", ";", "}", "return", "$", "class", ";", "}" ]

[ "Get", "current", "namespace", "and", "class", "(", "if", "any", ")", "from", "readline", "input", "." ]

[ "public", "static", "function", "hasSyntax", "(", "$", "token", ",", "$", "syntax", "=", "self", "::", "VAR_SYNTAX", ")", "{", "if", "(", "!", "\\", "is_array", "(", "$", "token", ")", ")", "{", "return", "false", ";", "}", "$", "regexp", "=", "\\", "sprintf", "(", "'#%s#'", ",", "$", "syntax", ")", ";", "return", "(", "bool", ")", "\\", "preg_match", "(", "$", "regexp", ",", "$", "token", "[", "1", "]", ")", ";", "}" ]

[ "Check", "whether", "$token", "matches", "a", "given", "syntax", "pattern", "." ]

[ "public", "static", "function", "isOperator", "(", "$", "token", ")", "{", "if", "(", "!", "\\", "is_string", "(", "$", "token", ")", ")", "{", "return", "false", ";", "}", "return", "\\", "strpos", "(", "self", "::", "MISC_OPERATORS", ",", "$", "token", ")", "!==", "false", ";", "}" ]

[ "Check", "whether", "$token", "is", "an", "operator", "." ]

[ "public", "static", "function", "hasToken", "(", "array", "$", "coll", ",", "$", "token", ")", "{", "if", "(", "!", "\\", "is_array", "(", "$", "token", ")", ")", "{", "return", "false", ";", "}", "return", "\\", "in_array", "(", "\\", "token_name", "(", "$", "token", "[", "0", "]", ")", ",", "$", "coll", ")", ";", "}" ]

[ "Check", "whether", "$token", "type", "is", "present", "in", "$coll", "." ]

[ "public", "function", "getParameters", "(", ")", "{", "$", "params", "=", "[", "]", ";", "foreach", "(", "self", "::", "$", "languageConstructs", "[", "$", "this", "->", "keyword", "]", "as", "$", "parameter", "=>", "$", "opts", ")", "{", "\\", "array_push", "(", "$", "params", ",", "new", "ReflectionLanguageConstructParameter", "(", "$", "this", "->", "keyword", ",", "$", "parameter", ",", "$", "opts", ")", ")", ";", "}", "return", "$", "params", ";", "}" ]

[ "Get", "language", "construct", "params", "." ]

[ "public", "function", "present", "(", "$", "value", ",", "$", "depth", "=", "null", ",", "$", "options", "=", "0", ")", "{", "$", "data", "=", "$", "this", "->", "cloner", "->", "cloneVar", "(", "$", "value", ",", "!", "(", "$", "options", "&", "self", "::", "VERBOSE", ")", "?", "Caster", "::", "EXCLUDE_VERBOSE", ":", "0", ")", ";", "if", "(", "null", "!==", "$", "depth", ")", "{", "$", "data", "=", "$", "data", "->", "withMaxDepth", "(", "$", "depth", ")", ";", "}", "// Work around https://github.com/symfony/symfony/issues/23572", "$", "oldLocale", "=", "\\", "setlocale", "(", "LC_NUMERIC", ",", "0", ")", ";", "\\", "setlocale", "(", "LC_NUMERIC", ",", "'C'", ")", ";", "$", "output", "=", "''", ";", "$", "this", "->", "dumper", "->", "dump", "(", "$", "data", ",", "function", "(", "$", "line", ",", "$", "depth", ")", "use", "(", "&", "$", "output", ")", "{", "if", "(", "$", "depth", ">=", "0", ")", "{", "if", "(", "''", "!==", "$", "output", ")", "{", "$", "output", ".=", "PHP_EOL", ";", "}", "$", "output", ".=", "\\", "str_repeat", "(", "' '", ",", "$", "depth", ")", ".", "$", "line", ";", "}", "}", ")", ";", "// Now put the locale back", "\\", "setlocale", "(", "LC_NUMERIC", ",", "$", "oldLocale", ")", ";", "return", "OutputFormatter", "::", "escape", "(", "$", "output", ")", ";", "}" ]

[ "Present", "a", "full", "representation", "of", "the", "value", "." ]

[ "protected", "function", "listItems", "(", "InputInterface", "$", "input", ",", "\\", "Reflector", "$", "reflector", "=", "null", ",", "$", "target", "=", "null", ")", "{", "// only list classes when no Reflector is present.", "//", "// @todo make a NamespaceReflector and pass that in for commands like:", "//", "// ls --classes Foo", "//", "// ... for listing classes in the Foo namespace", "if", "(", "$", "reflector", "!==", "null", "||", "$", "target", "!==", "null", ")", "{", "return", ";", "}", "$", "user", "=", "$", "input", "->", "getOption", "(", "'user'", ")", ";", "$", "internal", "=", "$", "input", "->", "getOption", "(", "'internal'", ")", ";", "$", "ret", "=", "[", "]", ";", "// only list classes, interfaces and traits if we are specifically asked", "if", "(", "$", "input", "->", "getOption", "(", "'classes'", ")", ")", "{", "$", "ret", "=", "\\", "array_merge", "(", "$", "ret", ",", "$", "this", "->", "filterClasses", "(", "'Classes'", ",", "\\", "get_declared_classes", "(", ")", ",", "$", "internal", ",", "$", "user", ")", ")", ";", "}", "if", "(", "$", "input", "->", "getOption", "(", "'interfaces'", ")", ")", "{", "$", "ret", "=", "\\", "array_merge", "(", "$", "ret", ",", "$", "this", "->", "filterClasses", "(", "'Interfaces'", ",", "\\", "get_declared_interfaces", "(", ")", ",", "$", "internal", ",", "$", "user", ")", ")", ";", "}", "if", "(", "$", "input", "->", "getOption", "(", "'traits'", ")", ")", "{", "$", "ret", "=", "\\", "array_merge", "(", "$", "ret", ",", "$", "this", "->", "filterClasses", "(", "'Traits'", ",", "\\", "get_declared_traits", "(", ")", ",", "$", "internal", ",", "$", "user", ")", ")", ";", "}", "return", "\\", "array_map", "(", "[", "$", "this", ",", "'prepareClasses'", "]", ",", "\\", "array_filter", "(", "$", "ret", ")", ")", ";", "}" ]

[ "{" ]

[ "protected", "function", "filterClasses", "(", "$", "key", ",", "$", "classes", ",", "$", "internal", ",", "$", "user", ")", "{", "$", "ret", "=", "[", "]", ";", "if", "(", "$", "internal", ")", "{", "$", "ret", "[", "'Internal '", ".", "$", "key", "]", "=", "\\", "array_filter", "(", "$", "classes", ",", "function", "(", "$", "class", ")", "{", "$", "refl", "=", "new", "\\", "ReflectionClass", "(", "$", "class", ")", ";", "return", "$", "refl", "->", "isInternal", "(", ")", ";", "}", ")", ";", "}", "if", "(", "$", "user", ")", "{", "$", "ret", "[", "'User '", ".", "$", "key", "]", "=", "\\", "array_filter", "(", "$", "classes", ",", "function", "(", "$", "class", ")", "{", "$", "refl", "=", "new", "\\", "ReflectionClass", "(", "$", "class", ")", ";", "return", "!", "$", "refl", "->", "isInternal", "(", ")", ";", "}", ")", ";", "}", "if", "(", "!", "$", "user", "&&", "!", "$", "internal", ")", "{", "$", "ret", "[", "$", "key", "]", "=", "$", "classes", ";", "}", "return", "$", "ret", ";", "}" ]

[ "Filter", "a", "list", "of", "classes", "interfaces", "or", "traits", "." ]

[ "protected", "function", "prepareClasses", "(", "array", "$", "classes", ")", "{", "\\", "natcasesort", "(", "$", "classes", ")", ";", "// My kingdom for a generator.", "$", "ret", "=", "[", "]", ";", "foreach", "(", "$", "classes", "as", "$", "name", ")", "{", "if", "(", "$", "this", "->", "showItem", "(", "$", "name", ")", ")", "{", "$", "ret", "[", "$", "name", "]", "=", "[", "'name'", "=>", "$", "name", ",", "'style'", "=>", "self", "::", "IS_CLASS", ",", "'value'", "=>", "$", "this", "->", "presentSignature", "(", "$", "name", ")", ",", "]", ";", "}", "}", "return", "$", "ret", ";", "}" ]

[ "Prepare", "formatted", "class", "array", "." ]

[ "public", "function", "processCallback", "(", "$", "input", ",", "$", "index", ",", "$", "info", "=", "[", "]", ")", "{", "// Some (Windows?) systems provide incomplete `readline_info`, so let's", "// try to work around it.", "$", "line", "=", "$", "info", "[", "'line_buffer'", "]", ";", "if", "(", "isset", "(", "$", "info", "[", "'end'", "]", ")", ")", "{", "$", "line", "=", "\\", "substr", "(", "$", "line", ",", "0", ",", "$", "info", "[", "'end'", "]", ")", ";", "}", "if", "(", "$", "line", "===", "''", "&&", "$", "input", "!==", "''", ")", "{", "$", "line", "=", "$", "input", ";", "}", "$", "tokens", "=", "\\", "token_get_all", "(", "'<?php '", ".", "$", "line", ")", ";", "// remove whitespaces", "$", "tokens", "=", "\\", "array_filter", "(", "$", "tokens", ",", "function", "(", "$", "token", ")", "{", "return", "!", "AbstractMatcher", "::", "tokenIs", "(", "$", "token", ",", "AbstractMatcher", "::", "T_WHITESPACE", ")", ";", "}", ")", ";", "$", "matches", "=", "[", "]", ";", "foreach", "(", "$", "this", "->", "matchers", "as", "$", "matcher", ")", "{", "if", "(", "$", "matcher", "->", "hasMatched", "(", "$", "tokens", ")", ")", "{", "$", "matches", "=", "\\", "array_merge", "(", "$", "matcher", "->", "getMatches", "(", "$", "tokens", ")", ",", "$", "matches", ")", ";", "}", "}", "$", "matches", "=", "\\", "array_unique", "(", "$", "matches", ")", ";", "return", "!", "empty", "(", "$", "matches", ")", "?", "$", "matches", ":", "[", "''", "]", ";", "}" ]

[ "Handle", "readline", "completion", "." ]

[ "public", "function", "enterNode", "(", "Node", "$", "node", ")", "{", "// @todo support MethodCall and StaticCall as well.", "if", "(", "$", "node", "instanceof", "FuncCall", ")", "{", "// if function name is an expression or a variable, give it a pass for now.", "if", "(", "$", "node", "->", "name", "instanceof", "Expr", "||", "$", "node", "->", "name", "instanceof", "Variable", ")", "{", "return", ";", "}", "$", "name", "=", "(", "string", ")", "$", "node", "->", "name", ";", "if", "(", "$", "name", "===", "'array_multisort'", ")", "{", "return", "$", "this", "->", "validateArrayMultisort", "(", "$", "node", ")", ";", "}", "try", "{", "$", "refl", "=", "new", "\\", "ReflectionFunction", "(", "$", "name", ")", ";", "}", "catch", "(", "\\", "ReflectionException", "$", "e", ")", "{", "// Well, we gave it a shot!", "return", ";", "}", "foreach", "(", "$", "refl", "->", "getParameters", "(", ")", "as", "$", "key", "=>", "$", "param", ")", "{", "if", "(", "\\", "array_key_exists", "(", "$", "key", ",", "$", "node", "->", "args", ")", ")", "{", "$", "arg", "=", "$", "node", "->", "args", "[", "$", "key", "]", ";", "if", "(", "$", "param", "->", "isPassedByReference", "(", ")", "&&", "!", "$", "this", "->", "isPassableByReference", "(", "$", "arg", ")", ")", "{", "throw", "new", "FatalErrorException", "(", "self", "::", "EXCEPTION_MESSAGE", ",", "0", ",", "E_ERROR", ",", "null", ",", "$", "node", "->", "getLine", "(", ")", ")", ";", "}", "}", "}", "}", "}" ]

[ "@throws", "FatalErrorException", "if", "non", "-", "variables", "are", "passed", "by", "reference" ]

[ "private", "function", "validateArrayMultisort", "(", "Node", "$", "node", ")", "{", "$", "nonPassable", "=", "2", ";", "// start with 2 because the first one has to be passable by reference", "foreach", "(", "$", "node", "->", "args", "as", "$", "arg", ")", "{", "if", "(", "$", "this", "->", "isPassableByReference", "(", "$", "arg", ")", ")", "{", "$", "nonPassable", "=", "0", ";", "}", "elseif", "(", "++", "$", "nonPassable", ">", "2", ")", "{", "// There can be *at most* two non-passable-by-reference args in a row. This is about", "// as close as we can get to validating the arguments for this function :-/", "throw", "new", "FatalErrorException", "(", "self", "::", "EXCEPTION_MESSAGE", ",", "0", ",", "E_ERROR", ",", "null", ",", "$", "node", "->", "getLine", "(", ")", ")", ";", "}", "}", "}" ]

[ "Because", "array_multisort", "has", "a", "problematic", "signature", "..." ]

[ "public", "function", "page", "(", "$", "messages", ",", "$", "type", "=", "0", ")", "{", "if", "(", "\\", "is_string", "(", "$", "messages", ")", ")", "{", "$", "messages", "=", "(", "array", ")", "$", "messages", ";", "}", "if", "(", "!", "\\", "is_array", "(", "$", "messages", ")", "&&", "!", "\\", "is_callable", "(", "$", "messages", ")", ")", "{", "throw", "new", "\\", "InvalidArgumentException", "(", "'Paged output requires a string, array or callback'", ")", ";", "}", "$", "this", "->", "startPaging", "(", ")", ";", "if", "(", "\\", "is_callable", "(", "$", "messages", ")", ")", "{", "$", "messages", "(", "$", "this", ")", ";", "}", "else", "{", "$", "this", "->", "write", "(", "$", "messages", ",", "true", ",", "$", "type", ")", ";", "}", "$", "this", "->", "stopPaging", "(", ")", ";", "}" ]

[ "Page", "multiple", "lines", "of", "output", "." ]

[ "public", "function", "write", "(", "$", "messages", ",", "$", "newline", "=", "false", ",", "$", "type", "=", "0", ")", "{", "if", "(", "$", "this", "->", "getVerbosity", "(", ")", "===", "self", "::", "VERBOSITY_QUIET", ")", "{", "return", ";", "}", "$", "messages", "=", "(", "array", ")", "$", "messages", ";", "if", "(", "$", "type", "&", "self", "::", "NUMBER_LINES", ")", "{", "$", "pad", "=", "\\", "strlen", "(", "(", "string", ")", "\\", "count", "(", "$", "messages", ")", ")", ";", "$", "template", "=", "$", "this", "->", "isDecorated", "(", ")", "?", "\"<aside>%{$pad}s</aside>: %s\"", ":", "\"%{$pad}s: %s\"", ";", "if", "(", "$", "type", "&", "self", "::", "OUTPUT_RAW", ")", "{", "$", "messages", "=", "\\", "array_map", "(", "[", "'Symfony\\Component\\Console\\Formatter\\OutputFormatter'", ",", "'escape'", "]", ",", "$", "messages", ")", ";", "}", "foreach", "(", "$", "messages", "as", "$", "i", "=>", "$", "line", ")", "{", "$", "messages", "[", "$", "i", "]", "=", "\\", "sprintf", "(", "$", "template", ",", "$", "i", ",", "$", "line", ")", ";", "}", "// clean this up for super.", "$", "type", "=", "$", "type", "&", "~", "self", "::", "NUMBER_LINES", "&", "~", "self", "::", "OUTPUT_RAW", ";", "}", "parent", "::", "write", "(", "$", "messages", ",", "$", "newline", ",", "$", "type", ")", ";", "}" ]

[ "Writes", "a", "message", "to", "the", "output", "." ]

[ "public", "function", "doWrite", "(", "$", "message", ",", "$", "newline", ")", "{", "if", "(", "$", "this", "->", "paging", ">", "0", ")", "{", "$", "this", "->", "pager", "->", "doWrite", "(", "$", "message", ",", "$", "newline", ")", ";", "}", "else", "{", "parent", "::", "doWrite", "(", "$", "message", ",", "$", "newline", ")", ";", "}", "}" ]

[ "Writes", "a", "message", "to", "the", "output", "." ]

[ "private", "function", "initFormatters", "(", ")", "{", "$", "formatter", "=", "$", "this", "->", "getFormatter", "(", ")", ";", "$", "formatter", "->", "setStyle", "(", "'warning'", ",", "new", "OutputFormatterStyle", "(", "'black'", ",", "'yellow'", ")", ")", ";", "$", "formatter", "->", "setStyle", "(", "'error'", ",", "new", "OutputFormatterStyle", "(", "'black'", ",", "'red'", ",", "[", "'bold'", "]", ")", ")", ";", "$", "formatter", "->", "setStyle", "(", "'aside'", ",", "new", "OutputFormatterStyle", "(", "'blue'", ")", ")", ";", "$", "formatter", "->", "setStyle", "(", "'strong'", ",", "new", "OutputFormatterStyle", "(", "null", ",", "null", ",", "[", "'bold'", "]", ")", ")", ";", "$", "formatter", "->", "setStyle", "(", "'return'", ",", "new", "OutputFormatterStyle", "(", "'cyan'", ")", ")", ";", "$", "formatter", "->", "setStyle", "(", "'urgent'", ",", "new", "OutputFormatterStyle", "(", "'red'", ")", ")", ";", "$", "formatter", "->", "setStyle", "(", "'hidden'", ",", "new", "OutputFormatterStyle", "(", "'black'", ")", ")", ";", "// Visibility", "$", "formatter", "->", "setStyle", "(", "'public'", ",", "new", "OutputFormatterStyle", "(", "null", ",", "null", ",", "[", "'bold'", "]", ")", ")", ";", "$", "formatter", "->", "setStyle", "(", "'protected'", ",", "new", "OutputFormatterStyle", "(", "'yellow'", ")", ")", ";", "$", "formatter", "->", "setStyle", "(", "'private'", ",", "new", "OutputFormatterStyle", "(", "'red'", ")", ")", ";", "$", "formatter", "->", "setStyle", "(", "'global'", ",", "new", "OutputFormatterStyle", "(", "'cyan'", ",", "null", ",", "[", "'bold'", "]", ")", ")", ";", "$", "formatter", "->", "setStyle", "(", "'const'", ",", "new", "OutputFormatterStyle", "(", "'cyan'", ")", ")", ";", "$", "formatter", "->", "setStyle", "(", "'class'", ",", "new", "OutputFormatterStyle", "(", "'blue'", ",", "null", ",", "[", "'underscore'", "]", ")", ")", ";", "$", "formatter", "->", "setStyle", "(", "'function'", ",", "new", "OutputFormatterStyle", "(", "null", ")", ")", ";", "$", "formatter", "->", "setStyle", "(", "'default'", ",", "new", "OutputFormatterStyle", "(", "null", ")", ")", ";", "// Types", "$", "formatter", "->", "setStyle", "(", "'number'", ",", "new", "OutputFormatterStyle", "(", "'magenta'", ")", ")", ";", "$", "formatter", "->", "setStyle", "(", "'string'", ",", "new", "OutputFormatterStyle", "(", "'green'", ")", ")", ";", "$", "formatter", "->", "setStyle", "(", "'bool'", ",", "new", "OutputFormatterStyle", "(", "'cyan'", ")", ")", ";", "$", "formatter", "->", "setStyle", "(", "'keyword'", ",", "new", "OutputFormatterStyle", "(", "'yellow'", ")", ")", ";", "$", "formatter", "->", "setStyle", "(", "'comment'", ",", "new", "OutputFormatterStyle", "(", "'blue'", ")", ")", ";", "$", "formatter", "->", "setStyle", "(", "'object'", ",", "new", "OutputFormatterStyle", "(", "'blue'", ")", ")", ";", "$", "formatter", "->", "setStyle", "(", "'resource'", ",", "new", "OutputFormatterStyle", "(", "'yellow'", ")", ")", ";", "}" ]

[ "Initialize", "output", "formatter", "styles", "." ]

[ "private", "function", "getDefaultPasses", "(", ")", "{", "$", "useStatementPass", "=", "new", "UseStatementPass", "(", ")", ";", "$", "namespacePass", "=", "new", "NamespacePass", "(", "$", "this", ")", ";", "// Try to add implicit `use` statements and an implicit namespace,", "// based on the file in which the `debug` call was made.", "$", "this", "->", "addImplicitDebugContext", "(", "[", "$", "useStatementPass", ",", "$", "namespacePass", "]", ")", ";", "return", "[", "// Validation passes", "new", "AbstractClassPass", "(", ")", ",", "new", "AssignThisVariablePass", "(", ")", ",", "new", "CalledClassPass", "(", ")", ",", "new", "CallTimePassByReferencePass", "(", ")", ",", "new", "FinalClassPass", "(", ")", ",", "new", "FunctionContextPass", "(", ")", ",", "new", "FunctionReturnInWriteContextPass", "(", ")", ",", "new", "InstanceOfPass", "(", ")", ",", "new", "LeavePsyshAlonePass", "(", ")", ",", "new", "LegacyEmptyPass", "(", ")", ",", "new", "ListPass", "(", ")", ",", "new", "LoopContextPass", "(", ")", ",", "new", "PassableByReferencePass", "(", ")", ",", "new", "ValidConstructorPass", "(", ")", ",", "// Rewriting shenanigans", "$", "useStatementPass", ",", "// must run before the namespace pass", "new", "ExitPass", "(", ")", ",", "new", "ImplicitReturnPass", "(", ")", ",", "new", "MagicConstantsPass", "(", ")", ",", "$", "namespacePass", ",", "// must run after the implicit return pass", "new", "RequirePass", "(", ")", ",", "new", "StrictTypesPass", "(", ")", ",", "// Namespace-aware validation (which depends on aforementioned shenanigans)", "new", "ValidClassNamePass", "(", ")", ",", "new", "ValidConstantPass", "(", ")", ",", "new", "ValidFunctionNamePass", "(", ")", ",", "]", ";", "}" ]

[ "Get", "default", "CodeCleaner", "passes", "." ]

[ "private", "function", "addImplicitDebugContext", "(", "array", "$", "passes", ")", "{", "$", "file", "=", "$", "this", "->", "getDebugFile", "(", ")", ";", "if", "(", "$", "file", "===", "null", ")", "{", "return", ";", "}", "try", "{", "$", "code", "=", "@", "\\", "file_get_contents", "(", "$", "file", ")", ";", "if", "(", "!", "$", "code", ")", "{", "return", ";", "}", "$", "stmts", "=", "$", "this", "->", "parse", "(", "$", "code", ",", "true", ")", ";", "if", "(", "$", "stmts", "===", "false", ")", "{", "return", ";", "}", "// Set up a clean traverser for just these code cleaner passes", "$", "traverser", "=", "new", "NodeTraverser", "(", ")", ";", "foreach", "(", "$", "passes", "as", "$", "pass", ")", "{", "$", "traverser", "->", "addVisitor", "(", "$", "pass", ")", ";", "}", "$", "traverser", "->", "traverse", "(", "$", "stmts", ")", ";", "}", "catch", "(", "\\", "Throwable", "$", "e", ")", "{", "// Don't care.", "}", "catch", "(", "\\", "Exception", "$", "e", ")", "{", "// Still don't care.", "}", "}" ]

[ "Warm", "up", "code", "cleaner", "passes", "when", "we", "re", "coming", "from", "a", "debug", "call", "." ]

[ "private", "static", "function", "getDebugFile", "(", ")", "{", "$", "trace", "=", "\\", "debug_backtrace", "(", "DEBUG_BACKTRACE_IGNORE_ARGS", ")", ";", "foreach", "(", "\\", "array_reverse", "(", "$", "trace", ")", "as", "$", "stackFrame", ")", "{", "if", "(", "!", "self", "::", "isDebugCall", "(", "$", "stackFrame", ")", ")", "{", "continue", ";", "}", "if", "(", "\\", "preg_match", "(", "'/eval\\(/'", ",", "$", "stackFrame", "[", "'file'", "]", ")", ")", "{", "\\", "preg_match_all", "(", "'/([^\\(]+)\\((\\d+)/'", ",", "$", "stackFrame", "[", "'file'", "]", ",", "$", "matches", ")", ";", "return", "$", "matches", "[", "1", "]", "[", "0", "]", ";", "}", "return", "$", "stackFrame", "[", "'file'", "]", ";", "}", "}" ]

[ "Search", "the", "stack", "trace", "for", "a", "file", "in", "which", "the", "user", "called", "Psy", "\\", "debug", "." ]

[ "public", "function", "clean", "(", "array", "$", "codeLines", ",", "$", "requireSemicolons", "=", "false", ")", "{", "$", "stmts", "=", "$", "this", "->", "parse", "(", "'<?php '", ".", "\\", "implode", "(", "PHP_EOL", ",", "$", "codeLines", ")", ".", "PHP_EOL", ",", "$", "requireSemicolons", ")", ";", "if", "(", "$", "stmts", "===", "false", ")", "{", "return", "false", ";", "}", "// Catch fatal errors before they happen", "$", "stmts", "=", "$", "this", "->", "traverser", "->", "traverse", "(", "$", "stmts", ")", ";", "// Work around https://github.com/nikic/PHP-Parser/issues/399", "$", "oldLocale", "=", "\\", "setlocale", "(", "LC_NUMERIC", ",", "0", ")", ";", "\\", "setlocale", "(", "LC_NUMERIC", ",", "'C'", ")", ";", "$", "code", "=", "$", "this", "->", "printer", "->", "prettyPrint", "(", "$", "stmts", ")", ";", "// Now put the locale back", "\\", "setlocale", "(", "LC_NUMERIC", ",", "$", "oldLocale", ")", ";", "return", "$", "code", ";", "}" ]

[ "Clean", "the", "given", "array", "of", "code", "." ]

[ "protected", "function", "parse", "(", "$", "code", ",", "$", "requireSemicolons", "=", "false", ")", "{", "try", "{", "return", "$", "this", "->", "parser", "->", "parse", "(", "$", "code", ")", ";", "}", "catch", "(", "\\", "PhpParser", "\\", "Error", "$", "e", ")", "{", "if", "(", "$", "this", "->", "parseErrorIsUnclosedString", "(", "$", "e", ",", "$", "code", ")", ")", "{", "return", "false", ";", "}", "if", "(", "$", "this", "->", "parseErrorIsUnterminatedComment", "(", "$", "e", ",", "$", "code", ")", ")", "{", "return", "false", ";", "}", "if", "(", "$", "this", "->", "parseErrorIsTrailingComma", "(", "$", "e", ",", "$", "code", ")", ")", "{", "return", "false", ";", "}", "if", "(", "!", "$", "this", "->", "parseErrorIsEOF", "(", "$", "e", ")", ")", "{", "throw", "ParseErrorException", "::", "fromParseError", "(", "$", "e", ")", ";", "}", "if", "(", "$", "requireSemicolons", ")", "{", "return", "false", ";", "}", "try", "{", "// Unexpected EOF, try again with an implicit semicolon", "return", "$", "this", "->", "parser", "->", "parse", "(", "$", "code", ".", "';'", ")", ";", "}", "catch", "(", "\\", "PhpParser", "\\", "Error", "$", "e", ")", "{", "return", "false", ";", "}", "}", "}" ]

[ "Lex", "and", "parse", "a", "block", "of", "code", "." ]

[ "private", "function", "parseErrorIsUnclosedString", "(", "\\", "PhpParser", "\\", "Error", "$", "e", ",", "$", "code", ")", "{", "if", "(", "$", "e", "->", "getRawMessage", "(", ")", "!==", "'Syntax error, unexpected T_ENCAPSED_AND_WHITESPACE'", ")", "{", "return", "false", ";", "}", "try", "{", "$", "this", "->", "parser", "->", "parse", "(", "$", "code", ".", "\"';\"", ")", ";", "}", "catch", "(", "\\", "Exception", "$", "e", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "A", "special", "test", "for", "unclosed", "single", "-", "quoted", "strings", "." ]

[ "public", "function", "enterNode", "(", "Node", "$", "node", ")", "{", "parent", "::", "enterNode", "(", "$", "node", ")", ";", "if", "(", "self", "::", "isConditional", "(", "$", "node", ")", ")", "{", "$", "this", "->", "conditionalScopes", "++", ";", "}", "elseif", "(", "$", "node", "instanceof", "Function_", ")", "{", "$", "name", "=", "$", "this", "->", "getFullyQualifiedName", "(", "$", "node", "->", "name", ")", ";", "// @todo add an \"else\" here which adds a runtime check for instances where we can't tell", "// whether a function is being redefined by static analysis alone.", "if", "(", "$", "this", "->", "conditionalScopes", "===", "0", ")", "{", "if", "(", "\\", "function_exists", "(", "$", "name", ")", "||", "isset", "(", "$", "this", "->", "currentScope", "[", "\\", "strtolower", "(", "$", "name", ")", "]", ")", ")", "{", "$", "msg", "=", "\\", "sprintf", "(", "'Cannot redeclare %s()'", ",", "$", "name", ")", ";", "throw", "new", "FatalErrorException", "(", "$", "msg", ",", "0", ",", "E_ERROR", ",", "null", ",", "$", "node", "->", "getLine", "(", ")", ")", ";", "}", "}", "$", "this", "->", "currentScope", "[", "\\", "strtolower", "(", "$", "name", ")", "]", "=", "true", ";", "}", "}" ]

[ "Store", "newly", "defined", "function", "names", "on", "the", "way", "in", "to", "allow", "recursion", "." ]

[ "public", "function", "leaveNode", "(", "Node", "$", "node", ")", "{", "if", "(", "self", "::", "isConditional", "(", "$", "node", ")", ")", "{", "$", "this", "->", "conditionalScopes", "--", ";", "}", "elseif", "(", "$", "node", "instanceof", "FuncCall", ")", "{", "// if function name is an expression or a variable, give it a pass for now.", "$", "name", "=", "$", "node", "->", "name", ";", "if", "(", "!", "$", "name", "instanceof", "Expr", "&&", "!", "$", "name", "instanceof", "Variable", ")", "{", "$", "shortName", "=", "\\", "implode", "(", "'\\\\'", ",", "$", "name", "->", "parts", ")", ";", "$", "fullName", "=", "$", "this", "->", "getFullyQualifiedName", "(", "$", "name", ")", ";", "$", "inScope", "=", "isset", "(", "$", "this", "->", "currentScope", "[", "\\", "strtolower", "(", "$", "fullName", ")", "]", ")", ";", "if", "(", "!", "$", "inScope", "&&", "!", "\\", "function_exists", "(", "$", "shortName", ")", "&&", "!", "\\", "function_exists", "(", "$", "fullName", ")", ")", "{", "$", "message", "=", "\\", "sprintf", "(", "'Call to undefined function %s()'", ",", "$", "name", ")", ";", "throw", "new", "FatalErrorException", "(", "$", "message", ",", "0", ",", "E_ERROR", ",", "null", ",", "$", "node", "->", "getLine", "(", ")", ")", ";", "}", "}", "}", "}" ]

[ "Validate", "that", "function", "calls", "will", "succeed", "." ]

[ "public", "function", "leaveNode", "(", "Node", "$", "node", ")", "{", "if", "(", "$", "node", "instanceof", "ConstFetch", "&&", "\\", "count", "(", "$", "node", "->", "name", "->", "parts", ")", ">", "1", ")", "{", "$", "name", "=", "$", "this", "->", "getFullyQualifiedName", "(", "$", "node", "->", "name", ")", ";", "if", "(", "!", "\\", "defined", "(", "$", "name", ")", ")", "{", "$", "msg", "=", "\\", "sprintf", "(", "'Undefined constant %s'", ",", "$", "name", ")", ";", "throw", "new", "FatalErrorException", "(", "$", "msg", ",", "0", ",", "E_ERROR", ",", "null", ",", "$", "node", "->", "getLine", "(", ")", ")", ";", "}", "}", "elseif", "(", "$", "node", "instanceof", "ClassConstFetch", ")", "{", "$", "this", "->", "validateClassConstFetchExpression", "(", "$", "node", ")", ";", "}", "}" ]

[ "Validate", "that", "namespaced", "constant", "references", "will", "succeed", "." ]

[ "protected", "function", "validateClassConstFetchExpression", "(", "ClassConstFetch", "$", "stmt", ")", "{", "// For PHP Parser 4.x", "$", "constName", "=", "$", "stmt", "->", "name", "instanceof", "Identifier", "?", "$", "stmt", "->", "name", "->", "toString", "(", ")", ":", "$", "stmt", "->", "name", ";", "// give the `class` pseudo-constant a pass", "if", "(", "$", "constName", "===", "'class'", ")", "{", "return", ";", "}", "// if class name is an expression, give it a pass for now", "if", "(", "!", "$", "stmt", "->", "class", "instanceof", "Expr", ")", "{", "$", "className", "=", "$", "this", "->", "getFullyQualifiedName", "(", "$", "stmt", "->", "class", ")", ";", "// if the class doesn't exist, don't throw an exception… it might be", "// defined in the same line it's used or something stupid like that.", "if", "(", "\\", "class_exists", "(", "$", "className", ")", "||", "\\", "interface_exists", "(", "$", "className", ")", ")", "{", "$", "refl", "=", "new", "\\", "ReflectionClass", "(", "$", "className", ")", ";", "if", "(", "!", "$", "refl", "->", "hasConstant", "(", "$", "constName", ")", ")", "{", "$", "constType", "=", "\\", "class_exists", "(", "$", "className", ")", "?", "'Class'", ":", "'Interface'", ";", "$", "msg", "=", "\\", "sprintf", "(", "'%s constant \\'%s::%s\\' not found'", ",", "$", "constType", ",", "$", "className", ",", "$", "constName", ")", ";", "throw", "new", "FatalErrorException", "(", "$", "msg", ",", "0", ",", "E_ERROR", ",", "null", ",", "$", "stmt", "->", "getLine", "(", ")", ")", ";", "}", "}", "}", "}" ]

[ "Validate", "a", "class", "constant", "fetch", "expression", "." ]

[ "public", "static", "function", "getCurrentConfigDir", "(", ")", "{", "$", "configDirs", "=", "self", "::", "getHomeConfigDirs", "(", ")", ";", "foreach", "(", "$", "configDirs", "as", "$", "configDir", ")", "{", "if", "(", "@", "\\", "is_dir", "(", "$", "configDir", ")", ")", "{", "return", "$", "configDir", ";", "}", "}", "return", "$", "configDirs", "[", "0", "]", ";", "}" ]

[ "Get", "the", "current", "home", "config", "directory", "." ]

[ "public", "static", "function", "getConfigFiles", "(", "array", "$", "names", ",", "$", "configDir", "=", "null", ")", "{", "$", "dirs", "=", "(", "$", "configDir", "===", "null", ")", "?", "self", "::", "getConfigDirs", "(", ")", ":", "[", "$", "configDir", "]", ";", "return", "self", "::", "getRealFiles", "(", "$", "dirs", ",", "$", "names", ")", ";", "}" ]

[ "Find", "real", "config", "files", "in", "config", "directories", "." ]

[ "public", "static", "function", "getDataFiles", "(", "array", "$", "names", ",", "$", "dataDir", "=", "null", ")", "{", "$", "dirs", "=", "(", "$", "dataDir", "===", "null", ")", "?", "self", "::", "getDataDirs", "(", ")", ":", "[", "$", "dataDir", "]", ";", "return", "self", "::", "getRealFiles", "(", "$", "dirs", ",", "$", "names", ")", ";", "}" ]

[ "Find", "real", "data", "files", "in", "config", "directories", "." ]

[ "public", "static", "function", "getRuntimeDir", "(", ")", "{", "$", "xdg", "=", "new", "Xdg", "(", ")", ";", "\\", "set_error_handler", "(", "[", "'Psy\\Exception\\ErrorException'", ",", "'throwException'", "]", ")", ";", "try", "{", "// XDG doesn't really work on Windows, sometimes complains about", "// permissions, sometimes tries to remove non-empty directories.", "// It's a bit flaky. So we'll give this a shot first...", "$", "runtimeDir", "=", "$", "xdg", "->", "getRuntimeDir", "(", "false", ")", ";", "}", "catch", "(", "\\", "Exception", "$", "e", ")", "{", "// Well. That didn't work. Fall back to a boring old folder in the", "// system temp dir.", "$", "runtimeDir", "=", "\\", "sys_get_temp_dir", "(", ")", ";", "}", "\\", "restore_error_handler", "(", ")", ";", "return", "\\", "strtr", "(", "$", "runtimeDir", ",", "'\\\\'", ",", "'/'", ")", ".", "'/psysh'", ";", "}" ]

[ "Get", "a", "runtime", "directory", "." ]

[ "public", "static", "function", "touchFileWithMkdir", "(", "$", "file", ")", "{", "if", "(", "\\", "file_exists", "(", "$", "file", ")", ")", "{", "if", "(", "\\", "is_writable", "(", "$", "file", ")", ")", "{", "return", "$", "file", ";", "}", "\\", "trigger_error", "(", "\\", "sprintf", "(", "'Writing to %s is not allowed.'", ",", "$", "file", ")", ",", "E_USER_NOTICE", ")", ";", "return", "false", ";", "}", "$", "dir", "=", "\\", "dirname", "(", "$", "file", ")", ";", "if", "(", "!", "\\", "is_dir", "(", "$", "dir", ")", ")", "{", "// Just try making it and see if it works", "@", "\\", "mkdir", "(", "$", "dir", ",", "0700", ",", "true", ")", ";", "}", "if", "(", "!", "\\", "is_dir", "(", "$", "dir", ")", "||", "!", "\\", "is_writable", "(", "$", "dir", ")", ")", "{", "\\", "trigger_error", "(", "\\", "sprintf", "(", "'Writing to %s is not allowed.'", ",", "$", "dir", ")", ",", "E_USER_NOTICE", ")", ";", "return", "false", ";", "}", "\\", "touch", "(", "$", "file", ")", ";", "return", "$", "file", ";", "}" ]

[ "Ensure", "that", "$file", "exists", "and", "is", "writable", "make", "the", "parent", "directory", "if", "necessary", "." ]

[ "protected", "function", "listItems", "(", "InputInterface", "$", "input", ",", "\\", "Reflector", "$", "reflector", "=", "null", ",", "$", "target", "=", "null", ")", "{", "// only list traits when no Reflector is present.", "//", "// @todo make a NamespaceReflector and pass that in for commands like:", "//", "// ls --traits Foo", "//", "// ... for listing traits in the Foo namespace", "if", "(", "$", "reflector", "!==", "null", "||", "$", "target", "!==", "null", ")", "{", "return", ";", "}", "// only list traits if we are specifically asked", "if", "(", "!", "$", "input", "->", "getOption", "(", "'traits'", ")", ")", "{", "return", ";", "}", "$", "traits", "=", "$", "this", "->", "prepareTraits", "(", "\\", "get_declared_traits", "(", ")", ")", ";", "if", "(", "empty", "(", "$", "traits", ")", ")", "{", "return", ";", "}", "return", "[", "'Traits'", "=>", "$", "traits", ",", "]", ";", "}" ]

[ "{" ]

[ "protected", "function", "prepareTraits", "(", "array", "$", "traits", ")", "{", "\\", "natcasesort", "(", "$", "traits", ")", ";", "// My kingdom for a generator.", "$", "ret", "=", "[", "]", ";", "foreach", "(", "$", "traits", "as", "$", "name", ")", "{", "if", "(", "$", "this", "->", "showItem", "(", "$", "name", ")", ")", "{", "$", "ret", "[", "$", "name", "]", "=", "[", "'name'", "=>", "$", "name", ",", "'style'", "=>", "self", "::", "IS_CLASS", ",", "'value'", "=>", "$", "this", "->", "presentSignature", "(", "$", "name", ")", ",", "]", ";", "}", "}", "return", "$", "ret", ";", "}" ]

[ "Prepare", "formatted", "trait", "array", "." ]

[ "public", "function", "createParser", "(", "$", "kind", "=", "null", ")", "{", "if", "(", "$", "this", "->", "hasKindsSupport", "(", ")", ")", "{", "$", "originalFactory", "=", "new", "OriginalParserFactory", "(", ")", ";", "$", "kind", "=", "$", "kind", "?", ":", "$", "this", "->", "getDefaultKind", "(", ")", ";", "if", "(", "!", "\\", "in_array", "(", "$", "kind", ",", "static", "::", "getPossibleKinds", "(", ")", ")", ")", "{", "throw", "new", "\\", "InvalidArgumentException", "(", "'Unknown parser kind'", ")", ";", "}", "$", "parser", "=", "$", "originalFactory", "->", "create", "(", "\\", "constant", "(", "'PhpParser\\ParserFactory::'", ".", "$", "kind", ")", ")", ";", "}", "else", "{", "if", "(", "$", "kind", "!==", "null", ")", "{", "throw", "new", "\\", "InvalidArgumentException", "(", "'Install PHP Parser v2.x to specify parser kind'", ")", ";", "}", "$", "parser", "=", "new", "Parser", "(", "new", "Lexer", "(", ")", ")", ";", "}", "return", "$", "parser", ";", "}" ]

[ "New", "parser", "instance", "with", "given", "kind", "." ]

[ "public", "function", "enterNode", "(", "Node", "$", "node", ")", "{", "if", "(", "$", "node", "instanceof", "Class_", ")", "{", "$", "this", "->", "class", "=", "$", "node", ";", "$", "this", "->", "abstractMethods", "=", "[", "]", ";", "}", "elseif", "(", "$", "node", "instanceof", "ClassMethod", ")", "{", "if", "(", "$", "node", "->", "isAbstract", "(", ")", ")", "{", "$", "name", "=", "\\", "sprintf", "(", "'%s::%s'", ",", "$", "this", "->", "class", "->", "name", ",", "$", "node", "->", "name", ")", ";", "$", "this", "->", "abstractMethods", "[", "]", "=", "$", "name", ";", "if", "(", "$", "node", "->", "stmts", "!==", "null", ")", "{", "$", "msg", "=", "\\", "sprintf", "(", "'Abstract function %s cannot contain body'", ",", "$", "name", ")", ";", "throw", "new", "FatalErrorException", "(", "$", "msg", ",", "0", ",", "E_ERROR", ",", "null", ",", "$", "node", "->", "getLine", "(", ")", ")", ";", "}", "}", "}", "}" ]

[ "@throws", "RuntimeException", "if", "the", "node", "is", "an", "abstract", "function", "with", "a", "body" ]

[ "public", "function", "leaveNode", "(", "Node", "$", "node", ")", "{", "if", "(", "$", "node", "instanceof", "Class_", ")", "{", "$", "count", "=", "\\", "count", "(", "$", "this", "->", "abstractMethods", ")", ";", "if", "(", "$", "count", ">", "0", "&&", "!", "$", "node", "->", "isAbstract", "(", ")", ")", "{", "$", "msg", "=", "\\", "sprintf", "(", "'Class %s contains %d abstract method%s must therefore be declared abstract or implement the remaining methods (%s)'", ",", "$", "node", "->", "name", ",", "$", "count", ",", "(", "$", "count", "===", "1", ")", "?", "''", ":", "'s'", ",", "\\", "implode", "(", "', '", ",", "$", "this", "->", "abstractMethods", ")", ")", ";", "throw", "new", "FatalErrorException", "(", "$", "msg", ",", "0", ",", "E_ERROR", ",", "null", ",", "$", "node", "->", "getLine", "(", ")", ")", ";", "}", "}", "}" ]

[ "@throws", "RuntimeException", "if", "the", "node", "is", "a", "non", "-", "abstract", "class", "with", "abstract", "methods" ]

[ "public", "function", "handle", "(", "$", "request", ",", "Closure", "$", "next", ",", "$", "description", "=", "null", ")", "{", "if", "(", "config", "(", "'LaravelLogger.loggerMiddlewareEnabled'", ")", "&&", "$", "this", "->", "shouldLog", "(", "$", "request", ")", ")", "{", "ActivityLogger", "::", "activity", "(", "$", "description", ")", ";", "}", "return", "$", "next", "(", "$", "request", ")", ";", "}" ]

[ "Handle", "an", "incoming", "request", "." ]

[ "protected", "function", "shouldLog", "(", "$", "request", ")", "{", "foreach", "(", "config", "(", "'LaravelLogger.loggerMiddlewareExcept'", ",", "[", "]", ")", "as", "$", "except", ")", "{", "if", "(", "$", "except", "!==", "'/'", ")", "{", "$", "except", "=", "trim", "(", "$", "except", ",", "'/'", ")", ";", "}", "if", "(", "$", "request", "->", "is", "(", "$", "except", ")", ")", "{", "return", "false", ";", "}", "}", "return", "true", ";", "}" ]

[ "Determine", "if", "the", "request", "has", "a", "URI", "that", "should", "log", "." ]

[ "public", "function", "register", "(", ")", "{", "$", "this", "->", "loadRoutesFrom", "(", "__DIR__", ".", "'/routes/web.php'", ")", ";", "$", "this", "->", "loadViewsFrom", "(", "__DIR__", ".", "'/resources/views/'", ",", "'LaravelLogger'", ")", ";", "$", "this", "->", "loadMigrationsFrom", "(", "__DIR__", ".", "'/database/migrations'", ")", ";", "if", "(", "file_exists", "(", "config_path", "(", "'laravel-logger.php'", ")", ")", ")", "{", "$", "this", "->", "mergeConfigFrom", "(", "config_path", "(", "'laravel-logger.php'", ")", ",", "'LaravelLogger'", ")", ";", "}", "else", "{", "$", "this", "->", "mergeConfigFrom", "(", "__DIR__", ".", "'/config/laravel-logger.php'", ",", "'LaravelLogger'", ")", ";", "}", "$", "this", "->", "registerEventListeners", "(", ")", ";", "$", "this", "->", "publishFiles", "(", ")", ";", "}" ]

[ "Register", "the", "application", "services", "." ]

[ "private", "function", "registerEventListeners", "(", ")", "{", "$", "listeners", "=", "$", "this", "->", "getListeners", "(", ")", ";", "foreach", "(", "$", "listeners", "as", "$", "listenerKey", "=>", "$", "listenerValues", ")", "{", "foreach", "(", "$", "listenerValues", "as", "$", "listenerValue", ")", "{", "\\", "Event", "::", "listen", "(", "$", "listenerKey", ",", "$", "listenerValue", ")", ";", "}", "}", "}" ]

[ "Register", "the", "list", "of", "listeners", "and", "events", "." ]

[ "private", "function", "publishFiles", "(", ")", "{", "$", "publishTag", "=", "'LaravelLogger'", ";", "$", "this", "->", "publishes", "(", "[", "__DIR__", ".", "'/config/laravel-logger.php'", "=>", "base_path", "(", "'config/laravel-logger.php'", ")", ",", "]", ",", "$", "publishTag", ")", ";", "$", "this", "->", "publishes", "(", "[", "__DIR__", ".", "'/resources/views'", "=>", "base_path", "(", "'resources/views/vendor/'", ".", "$", "publishTag", ")", ",", "]", ",", "$", "publishTag", ")", ";", "$", "this", "->", "publishes", "(", "[", "__DIR__", ".", "'/resources/lang'", "=>", "base_path", "(", "'resources/lang/vendor/'", ".", "$", "publishTag", ")", ",", "]", ",", "$", "publishTag", ")", ";", "}" ]

[ "Publish", "files", "for", "Laravel", "Logger", "." ]

[ "public", "function", "up", "(", ")", "{", "$", "activity", "=", "new", "Activity", "(", ")", ";", "$", "connection", "=", "$", "activity", "->", "getConnectionName", "(", ")", ";", "$", "table", "=", "$", "activity", "->", "getTableName", "(", ")", ";", "$", "tableCheck", "=", "Schema", "::", "connection", "(", "$", "connection", ")", "->", "hasTable", "(", "$", "table", ")", ";", "if", "(", "!", "$", "tableCheck", ")", "{", "Schema", "::", "connection", "(", "$", "connection", ")", "->", "create", "(", "$", "table", ",", "function", "(", "Blueprint", "$", "table", ")", "{", "$", "table", "->", "increments", "(", "'id'", ")", ";", "$", "table", "->", "longText", "(", "'description'", ")", ";", "$", "table", "->", "string", "(", "'userType'", ")", ";", "$", "table", "->", "integer", "(", "'userId'", ")", "->", "nullable", "(", ")", ";", "$", "table", "->", "longText", "(", "'route'", ")", "->", "nullable", "(", ")", ";", "$", "table", "->", "ipAddress", "(", "'ipAddress'", ")", "->", "nullable", "(", ")", ";", "$", "table", "->", "text", "(", "'userAgent'", ")", "->", "nullable", "(", ")", ";", "$", "table", "->", "string", "(", "'locale'", ")", "->", "nullable", "(", ")", ";", "$", "table", "->", "longText", "(", "'referer'", ")", "->", "nullable", "(", ")", ";", "$", "table", "->", "string", "(", "'methodType'", ")", "->", "nullable", "(", ")", ";", "$", "table", "->", "timestamps", "(", ")", ";", "$", "table", "->", "softDeletes", "(", ")", ";", "}", ")", ";", "}", "}" ]

[ "Run", "the", "migrations", "." ]

[ "public", "function", "down", "(", ")", "{", "$", "activity", "=", "new", "Activity", "(", ")", ";", "$", "connection", "=", "$", "activity", "->", "getConnectionName", "(", ")", ";", "$", "table", "=", "$", "activity", "->", "getTableName", "(", ")", ";", "Schema", "::", "connection", "(", "$", "connection", ")", "->", "dropIfExists", "(", "$", "table", ")", ";", "}" ]

[ "Reverse", "the", "migrations", "." ]

[ "private", "function", "mapAdditionalDetails", "(", "$", "collectionItems", ")", "{", "$", "collectionItems", "->", "map", "(", "function", "(", "$", "collectionItem", ")", "{", "$", "eventTime", "=", "Carbon", "::", "parse", "(", "$", "collectionItem", "->", "updated_at", ")", ";", "$", "collectionItem", "[", "'timePassed'", "]", "=", "$", "eventTime", "->", "diffForHumans", "(", ")", ";", "$", "collectionItem", "[", "'userAgentDetails'", "]", "=", "UserAgentDetails", "::", "details", "(", "$", "collectionItem", "->", "useragent", ")", ";", "$", "collectionItem", "[", "'langDetails'", "]", "=", "UserAgentDetails", "::", "localeLang", "(", "$", "collectionItem", "->", "locale", ")", ";", "$", "collectionItem", "[", "'userDetails'", "]", "=", "config", "(", "'LaravelLogger.defaultUserModel'", ")", "::", "find", "(", "$", "collectionItem", "->", "userId", ")", ";", "return", "$", "collectionItem", ";", "}", ")", ";", "return", "$", "collectionItems", ";", "}" ]

[ "Add", "additional", "details", "to", "a", "collections", "." ]

[ "public", "function", "showAccessLogEntry", "(", "Request", "$", "request", ",", "$", "id", ")", "{", "$", "activity", "=", "Activity", "::", "findOrFail", "(", "$", "id", ")", ";", "$", "userDetails", "=", "config", "(", "'LaravelLogger.defaultUserModel'", ")", "::", "find", "(", "$", "activity", "->", "userId", ")", ";", "$", "userAgentDetails", "=", "UserAgentDetails", "::", "details", "(", "$", "activity", "->", "useragent", ")", ";", "$", "ipAddressDetails", "=", "IpAddressDetails", "::", "checkIP", "(", "$", "activity", "->", "ipAddress", ")", ";", "$", "langDetails", "=", "UserAgentDetails", "::", "localeLang", "(", "$", "activity", "->", "locale", ")", ";", "$", "eventTime", "=", "Carbon", "::", "parse", "(", "$", "activity", "->", "created_at", ")", ";", "$", "timePassed", "=", "$", "eventTime", "->", "diffForHumans", "(", ")", ";", "if", "(", "config", "(", "'LaravelLogger.loggerPaginationEnabled'", ")", ")", "{", "$", "userActivities", "=", "Activity", "::", "where", "(", "'userId'", ",", "$", "activity", "->", "userId", ")", "->", "orderBy", "(", "'created_at'", ",", "'desc'", ")", "->", "paginate", "(", "config", "(", "'LaravelLogger.loggerPaginationPerPage'", ")", ")", ";", "$", "totalUserActivities", "=", "$", "userActivities", "->", "total", "(", ")", ";", "}", "else", "{", "$", "userActivities", "=", "Activity", "::", "where", "(", "'userId'", ",", "$", "activity", "->", "userId", ")", "->", "orderBy", "(", "'created_at'", ",", "'desc'", ")", "->", "get", "(", ")", ";", "$", "totalUserActivities", "=", "$", "userActivities", "->", "count", "(", ")", ";", "}", "self", "::", "mapAdditionalDetails", "(", "$", "userActivities", ")", ";", "$", "data", "=", "[", "'activity'", "=>", "$", "activity", ",", "'userDetails'", "=>", "$", "userDetails", ",", "'ipAddressDetails'", "=>", "$", "ipAddressDetails", ",", "'timePassed'", "=>", "$", "timePassed", ",", "'userAgentDetails'", "=>", "$", "userAgentDetails", ",", "'langDetails'", "=>", "$", "langDetails", ",", "'userActivities'", "=>", "$", "userActivities", ",", "'totalUserActivities'", "=>", "$", "totalUserActivities", ",", "'isClearedEntry'", "=>", "false", ",", "]", ";", "return", "View", "(", "'LaravelLogger::logger.activity-log-item'", ",", "$", "data", ")", ";", "}" ]

[ "Show", "an", "individual", "activity", "log", "entry", "." ]

[ "public", "function", "clearActivityLog", "(", "Request", "$", "request", ")", "{", "$", "activities", "=", "Activity", "::", "all", "(", ")", ";", "foreach", "(", "$", "activities", "as", "$", "activity", ")", "{", "$", "activity", "->", "delete", "(", ")", ";", "}", "return", "redirect", "(", "'activity'", ")", "->", "with", "(", "'success'", ",", "trans", "(", "'LaravelLogger::laravel-logger.messages.logClearedSuccessfuly'", ")", ")", ";", "}" ]

[ "Remove", "the", "specified", "resource", "from", "storage", "." ]

[ "public", "function", "showClearedActivityLog", "(", ")", "{", "if", "(", "config", "(", "'LaravelLogger.loggerPaginationEnabled'", ")", ")", "{", "$", "activities", "=", "Activity", "::", "onlyTrashed", "(", ")", "->", "orderBy", "(", "'created_at'", ",", "'desc'", ")", "->", "paginate", "(", "config", "(", "'LaravelLogger.loggerPaginationPerPage'", ")", ")", ";", "$", "totalActivities", "=", "$", "activities", "->", "total", "(", ")", ";", "}", "else", "{", "$", "activities", "=", "Activity", "::", "onlyTrashed", "(", ")", "->", "orderBy", "(", "'created_at'", ",", "'desc'", ")", "->", "get", "(", ")", ";", "$", "totalActivities", "=", "$", "activities", "->", "count", "(", ")", ";", "}", "self", "::", "mapAdditionalDetails", "(", "$", "activities", ")", ";", "$", "data", "=", "[", "'activities'", "=>", "$", "activities", ",", "'totalActivities'", "=>", "$", "totalActivities", ",", "]", ";", "return", "View", "(", "'LaravelLogger::logger.activity-log-cleared'", ",", "$", "data", ")", ";", "}" ]

[ "Show", "the", "cleared", "activity", "log", "-", "softdeleted", "records", "." ]

[ "public", "function", "showClearedAccessLogEntry", "(", "Request", "$", "request", ",", "$", "id", ")", "{", "$", "activity", "=", "self", "::", "getClearedActvity", "(", "$", "id", ")", ";", "$", "userDetails", "=", "config", "(", "'LaravelLogger.defaultUserModel'", ")", "::", "find", "(", "$", "activity", "->", "userId", ")", ";", "$", "userAgentDetails", "=", "UserAgentDetails", "::", "details", "(", "$", "activity", "->", "useragent", ")", ";", "$", "ipAddressDetails", "=", "IpAddressDetails", "::", "checkIP", "(", "$", "activity", "->", "ipAddress", ")", ";", "$", "langDetails", "=", "UserAgentDetails", "::", "localeLang", "(", "$", "activity", "->", "locale", ")", ";", "$", "eventTime", "=", "Carbon", "::", "parse", "(", "$", "activity", "->", "created_at", ")", ";", "$", "timePassed", "=", "$", "eventTime", "->", "diffForHumans", "(", ")", ";", "$", "data", "=", "[", "'activity'", "=>", "$", "activity", ",", "'userDetails'", "=>", "$", "userDetails", ",", "'ipAddressDetails'", "=>", "$", "ipAddressDetails", ",", "'timePassed'", "=>", "$", "timePassed", ",", "'userAgentDetails'", "=>", "$", "userAgentDetails", ",", "'langDetails'", "=>", "$", "langDetails", ",", "'isClearedEntry'", "=>", "true", ",", "]", ";", "return", "View", "(", "'LaravelLogger::logger.activity-log-item'", ",", "$", "data", ")", ";", "}" ]

[ "Show", "an", "individual", "cleared", "(", "soft", "deleted", ")", "activity", "log", "entry", "." ]

[ "private", "static", "function", "getClearedActvity", "(", "$", "id", ")", "{", "$", "activity", "=", "Activity", "::", "onlyTrashed", "(", ")", "->", "where", "(", "'id'", ",", "$", "id", ")", "->", "get", "(", ")", ";", "if", "(", "count", "(", "$", "activity", ")", "!=", "1", ")", "{", "return", "abort", "(", "404", ")", ";", "}", "return", "$", "activity", "[", "0", "]", ";", "}" ]

[ "Get", "Cleared", "(", "Soft", "Deleted", ")", "Activity", "-", "Helper", "Method", "." ]

[ "public", "function", "destroyActivityLog", "(", "Request", "$", "request", ")", "{", "$", "activities", "=", "Activity", "::", "onlyTrashed", "(", ")", "->", "get", "(", ")", ";", "foreach", "(", "$", "activities", "as", "$", "activity", ")", "{", "$", "activity", "->", "forceDelete", "(", ")", ";", "}", "return", "redirect", "(", "'activity'", ")", "->", "with", "(", "'success'", ",", "trans", "(", "'LaravelLogger::laravel-logger.messages.logDestroyedSuccessfuly'", ")", ")", ";", "}" ]

[ "Destroy", "the", "specified", "resource", "from", "storage", "." ]

[ "public", "function", "restoreClearedActivityLog", "(", "Request", "$", "request", ")", "{", "$", "activities", "=", "Activity", "::", "onlyTrashed", "(", ")", "->", "get", "(", ")", ";", "foreach", "(", "$", "activities", "as", "$", "activity", ")", "{", "$", "activity", "->", "restore", "(", ")", ";", "}", "return", "redirect", "(", "'activity'", ")", "->", "with", "(", "'success'", ",", "trans", "(", "'LaravelLogger::laravel-logger.messages.logRestoredSuccessfuly'", ")", ")", ";", "}" ]

[ "Restore", "the", "specified", "resource", "from", "soft", "deleted", "storage", "." ]

[ "public", "static", "function", "details", "(", "$", "ua", ")", "{", "$", "ua", "=", "is_null", "(", "$", "ua", ")", "?", "$", "_SERVER", "[", "'HTTP_USER_AGENT'", "]", ":", "$", "ua", ";", "// Enumerate all common platforms, this is usually placed in braces (order is important! First come first serve..)", "$", "platforms", "=", "'Windows|iPad|iPhone|Macintosh|Android|BlackBerry|Unix|Linux'", ";", "// All browsers except MSIE/Trident and..", "// NOT for browsers that use this syntax: Version/0.xx Browsername", "$", "browsers", "=", "'Firefox|Chrome|Opera'", ";", "// Specifically for browsers that use this syntax: Version/0.xx Browername", "$", "browsers_v", "=", "'Safari|Mobile'", ";", "// Mobile is mentioned in Android and BlackBerry UA's", "// Fill in your most common engines..", "$", "engines", "=", "'Gecko|Trident|Webkit|Presto'", ";", "// Regex the crap out of the user agent, making multiple selections and..", "$", "regex_pat", "=", "\"/((Mozilla)\\/[\\d\\.]+|(Opera)\\/[\\d\\.]+)\\s\\(.*?((MSIE)\\s([\\d\\.]+).*?(Windows)|({$platforms})).*?\\s.*?({$engines})[\\/\\s]+[\\d\\.]+(\\;\\srv\\:([\\d\\.]+)|.*?).*?(Version[\\/\\s]([\\d\\.]+)(.*?({$browsers_v})|$)|(({$browsers})[\\/\\s]+([\\d\\.]+))|$).*/i\"", ";", "// .. placing them in this order, delimited by |", "$", "replace_pat", "=", "'$7$8|$2$3|$9|${17}${15}$5$3|${18}${13}$6${11}'", ";", "// Run the preg_replace .. and explode on |", "$", "ua_array", "=", "explode", "(", "'|'", ",", "preg_replace", "(", "$", "regex_pat", ",", "$", "replace_pat", ",", "$", "ua", ",", "PREG_PATTERN_ORDER", ")", ")", ";", "if", "(", "count", "(", "$", "ua_array", ")", ">", "1", ")", "{", "$", "return", "[", "'platform'", "]", "=", "$", "ua_array", "[", "0", "]", ";", "// Windows / iPad / MacOS / BlackBerry", "$", "return", "[", "'type'", "]", "=", "$", "ua_array", "[", "1", "]", ";", "// Mozilla / Opera etc.", "$", "return", "[", "'renderer'", "]", "=", "$", "ua_array", "[", "2", "]", ";", "// WebKit / Presto / Trident / Gecko etc.", "$", "return", "[", "'browser'", "]", "=", "$", "ua_array", "[", "3", "]", ";", "// Chrome / Safari / MSIE / Firefox", "/*\n Not necessary but this will filter out Chromes ridiculously long version\n numbers 31.0.1234.122 becomes 31.0, while a \"normal\" 3 digit version number\n like 10.2.1 would stay 10.2.1, 11.0 stays 11.0. Non-match stays what it is.\n */", "if", "(", "preg_match", "(", "\"/^[\\d]+\\.[\\d]+(?:\\.[\\d]{0,2}$)?/\"", ",", "$", "ua_array", "[", "4", "]", ",", "$", "matches", ")", ")", "{", "$", "return", "[", "'version'", "]", "=", "$", "matches", "[", "0", "]", ";", "}", "else", "{", "$", "return", "[", "'version'", "]", "=", "$", "ua_array", "[", "4", "]", ";", "}", "}", "else", "{", "return", "false", ";", "}", "// Replace some browsernames e.g. MSIE -> Internet Explorer", "switch", "(", "strtolower", "(", "$", "return", "[", "'browser'", "]", ")", ")", "{", "case", "'msie'", ":", "case", "'trident'", ":", "$", "return", "[", "'browser'", "]", "=", "'Internet Explorer'", ";", "break", ";", "case", "''", ":", "// IE 11 is a steamy turd (thanks Microsoft...)", "if", "(", "strtolower", "(", "$", "return", "[", "'renderer'", "]", ")", "==", "'trident'", ")", "{", "$", "return", "[", "'browser'", "]", "=", "'Internet Explorer'", ";", "}", "break", ";", "}", "switch", "(", "strtolower", "(", "$", "return", "[", "'platform'", "]", ")", ")", "{", "case", "'android'", ":", "// These browsers claim to be Safari but are BB Mobile", "case", "'blackberry'", ":", "// and Android Mobile", "if", "(", "$", "return", "[", "'browser'", "]", "==", "'Safari'", "||", "$", "return", "[", "'browser'", "]", "==", "'Mobile'", "||", "$", "return", "[", "'browser'", "]", "==", "''", ")", "{", "$", "return", "[", "'browser'", "]", "=", "\"{$return['platform']} mobile\"", ";", "}", "break", ";", "}", "return", "$", "return", ";", "}" ]

[ "Get", "the", "user", "s", "agents", "details", "." ]

[ "public", "static", "function", "checkIP", "(", "$", "ip", "=", "null", ",", "$", "purpose", "=", "'location'", ",", "$", "deep_detect", "=", "true", ")", "{", "$", "output", "=", "null", ";", "if", "(", "filter_var", "(", "$", "ip", ",", "FILTER_VALIDATE_IP", ")", "===", "false", ")", "{", "$", "ip", "=", "$", "_SERVER", "[", "'REMOTE_ADDR'", "]", ";", "if", "(", "$", "deep_detect", ")", "{", "if", "(", "filter_var", "(", "@", "$", "_SERVER", "[", "'HTTP_X_FORWARDED_FOR'", "]", ",", "FILTER_VALIDATE_IP", ")", ")", "{", "$", "ip", "=", "$", "_SERVER", "[", "'HTTP_X_FORWARDED_FOR'", "]", ";", "}", "if", "(", "filter_var", "(", "@", "$", "_SERVER", "[", "'HTTP_CLIENT_IP'", "]", ",", "FILTER_VALIDATE_IP", ")", ")", "{", "$", "ip", "=", "$", "_SERVER", "[", "'HTTP_CLIENT_IP'", "]", ";", "}", "}", "}", "$", "purpose", "=", "str_replace", "(", "[", "'name'", ",", "\"\\n\"", ",", "\"\\t\"", ",", "' '", ",", "'-'", ",", "'_'", "]", ",", "null", ",", "strtolower", "(", "trim", "(", "$", "purpose", ")", ")", ")", ";", "$", "support", "=", "[", "'country'", ",", "'countrycode'", ",", "'state'", ",", "'region'", ",", "'city'", ",", "'location'", ",", "'address'", "]", ";", "$", "continents", "=", "[", "'AF'", "=>", "'Africa'", ",", "'AN'", "=>", "'Antarctica'", ",", "'AS'", "=>", "'Asia'", ",", "'EU'", "=>", "'Europe'", ",", "'OC'", "=>", "'Australia (Oceania)'", ",", "'NA'", "=>", "'North America'", ",", "'SA'", "=>", "'South America'", ",", "]", ";", "if", "(", "filter_var", "(", "$", "ip", ",", "FILTER_VALIDATE_IP", ")", "&&", "in_array", "(", "$", "purpose", ",", "$", "support", ")", ")", "{", "$", "ipdat", "=", "@", "json_decode", "(", "file_get_contents", "(", "'http://www.geoplugin.net/json.gp?ip='", ".", "$", "ip", ")", ")", ";", "if", "(", "@", "strlen", "(", "trim", "(", "$", "ipdat", "->", "geoplugin_countryCode", ")", ")", "==", "2", ")", "{", "switch", "(", "$", "purpose", ")", "{", "case", "'location'", ":", "$", "output", "=", "[", "'city'", "=>", "@", "$", "ipdat", "->", "geoplugin_city", ",", "'state'", "=>", "@", "$", "ipdat", "->", "geoplugin_regionName", ",", "'country'", "=>", "@", "$", "ipdat", "->", "geoplugin_countryName", ",", "'countryCode'", "=>", "@", "$", "ipdat", "->", "geoplugin_countryCode", ",", "'continent'", "=>", "@", "$", "continents", "[", "strtoupper", "(", "$", "ipdat", "->", "geoplugin_continentCode", ")", "]", ",", "'continent_code'", "=>", "@", "$", "ipdat", "->", "geoplugin_continentCode", ",", "'latitude'", "=>", "@", "$", "ipdat", "->", "geoplugin_latitude", ",", "'longitude'", "=>", "@", "$", "ipdat", "->", "geoplugin_longitude", ",", "'currencyCode'", "=>", "@", "$", "ipdat", "->", "geoplugin_currencyCode", ",", "'areaCode'", "=>", "@", "$", "ipdat", "->", "geoplugin_areaCode", ",", "'dmaCode'", "=>", "@", "$", "ipdat", "->", "geoplugin_dmaCode", ",", "'region'", "=>", "@", "$", "ipdat", "->", "geoplugin_region", ",", "]", ";", "break", ";", "case", "'address'", ":", "$", "address", "=", "[", "$", "ipdat", "->", "geoplugin_countryName", "]", ";", "if", "(", "@", "strlen", "(", "$", "ipdat", "->", "geoplugin_regionName", ")", ">=", "1", ")", "{", "$", "address", "[", "]", "=", "$", "ipdat", "->", "geoplugin_regionName", ";", "}", "if", "(", "@", "strlen", "(", "$", "ipdat", "->", "geoplugin_city", ")", ">=", "1", ")", "{", "$", "address", "[", "]", "=", "$", "ipdat", "->", "geoplugin_city", ";", "}", "$", "output", "=", "implode", "(", "', '", ",", "array_reverse", "(", "$", "address", ")", ")", ";", "break", ";", "case", "'city'", ":", "$", "output", "=", "@", "$", "ipdat", "->", "geoplugin_city", ";", "break", ";", "case", "'state'", ":", "$", "output", "=", "@", "$", "ipdat", "->", "geoplugin_regionName", ";", "break", ";", "case", "'region'", ":", "$", "output", "=", "@", "$", "ipdat", "->", "geoplugin_regionName", ";", "break", ";", "case", "'country'", ":", "$", "output", "=", "@", "$", "ipdat", "->", "geoplugin_countryName", ";", "break", ";", "case", "'countrycode'", ":", "$", "output", "=", "@", "$", "ipdat", "->", "geoplugin_countryCode", ";", "break", ";", "}", "}", "}", "return", "$", "output", ";", "}" ]

[ "Get", "the", "Location", "of", "the", "IP", "Address", "." ]

[ "public", "static", "function", "activity", "(", "$", "description", "=", "null", ")", "{", "$", "userType", "=", "trans", "(", "'LaravelLogger::laravel-logger.userTypes.guest'", ")", ";", "$", "userId", "=", "null", ";", "if", "(", "\\", "Auth", "::", "check", "(", ")", ")", "{", "$", "userType", "=", "trans", "(", "'LaravelLogger::laravel-logger.userTypes.registered'", ")", ";", "$", "userId", "=", "\\", "Request", "::", "user", "(", ")", "->", "id", ";", "}", "if", "(", "Crawler", "::", "isCrawler", "(", ")", ")", "{", "$", "userType", "=", "trans", "(", "'LaravelLogger::laravel-logger.userTypes.crawler'", ")", ";", "$", "description", "=", "$", "userType", ".", "' '", ".", "trans", "(", "'LaravelLogger::laravel-logger.verbTypes.crawled'", ")", ".", "' '", ".", "\\", "Request", "::", "fullUrl", "(", ")", ";", "}", "if", "(", "!", "$", "description", ")", "{", "switch", "(", "strtolower", "(", "\\", "Request", "::", "method", "(", ")", ")", ")", "{", "case", "'post'", ":", "$", "verb", "=", "trans", "(", "'LaravelLogger::laravel-logger.verbTypes.created'", ")", ";", "break", ";", "case", "'patch'", ":", "case", "'put'", ":", "$", "verb", "=", "trans", "(", "'LaravelLogger::laravel-logger.verbTypes.edited'", ")", ";", "break", ";", "case", "'delete'", ":", "$", "verb", "=", "trans", "(", "'LaravelLogger::laravel-logger.verbTypes.deleted'", ")", ";", "break", ";", "case", "'get'", ":", "default", ":", "$", "verb", "=", "trans", "(", "'LaravelLogger::laravel-logger.verbTypes.viewed'", ")", ";", "break", ";", "}", "$", "description", "=", "$", "verb", ".", "' '", ".", "\\", "Request", "::", "path", "(", ")", ";", "}", "$", "data", "=", "[", "'description'", "=>", "$", "description", ",", "'userType'", "=>", "$", "userType", ",", "'userId'", "=>", "$", "userId", ",", "'route'", "=>", "\\", "Request", "::", "fullUrl", "(", ")", ",", "'ipAddress'", "=>", "\\", "Request", "::", "ip", "(", ")", ",", "'userAgent'", "=>", "\\", "Request", "::", "header", "(", "'user-agent'", ")", ",", "'locale'", "=>", "\\", "Request", "::", "header", "(", "'accept-language'", ")", ",", "'referer'", "=>", "\\", "Request", "::", "header", "(", "'referer'", ")", ",", "'methodType'", "=>", "\\", "Request", "::", "method", "(", ")", ",", "]", ";", "// Validation Instance", "$", "validator", "=", "Validator", "::", "make", "(", "$", "data", ",", "Activity", "::", "Rules", "(", "[", "]", ")", ")", ";", "if", "(", "$", "validator", "->", "fails", "(", ")", ")", "{", "$", "errors", "=", "self", "::", "prepareErrorMessage", "(", "$", "validator", "->", "errors", "(", ")", ",", "$", "data", ")", ";", "if", "(", "config", "(", "'LaravelLogger.logDBActivityLogFailuresToFile'", ")", ")", "{", "Log", "::", "error", "(", "'Failed to record activity event. Failed Validation: '", ".", "$", "errors", ")", ";", "}", "}", "else", "{", "self", "::", "storeActivity", "(", "$", "data", ")", ";", "}", "}" ]

[ "Laravel", "Logger", "Log", "Activity", "." ]

[ "private", "static", "function", "storeActivity", "(", "$", "data", ")", "{", "Activity", "::", "create", "(", "[", "'description'", "=>", "$", "data", "[", "'description'", "]", ",", "'userType'", "=>", "$", "data", "[", "'userType'", "]", ",", "'userId'", "=>", "$", "data", "[", "'userId'", "]", ",", "'route'", "=>", "$", "data", "[", "'route'", "]", ",", "'ipAddress'", "=>", "$", "data", "[", "'ipAddress'", "]", ",", "'userAgent'", "=>", "$", "data", "[", "'userAgent'", "]", ",", "'locale'", "=>", "$", "data", "[", "'locale'", "]", ",", "'referer'", "=>", "$", "data", "[", "'referer'", "]", ",", "'methodType'", "=>", "$", "data", "[", "'methodType'", "]", ",", "]", ")", ";", "}" ]

[ "Store", "activity", "entry", "to", "database", "." ]

[ "private", "static", "function", "prepareErrorMessage", "(", "$", "validatorErrors", ",", "$", "data", ")", "{", "$", "errors", "=", "json_decode", "(", "json_encode", "(", "$", "validatorErrors", ",", "true", ")", ")", ";", "array_walk", "(", "$", "errors", ",", "function", "(", "&", "$", "value", ",", "$", "key", ")", "use", "(", "$", "data", ")", "{", "array_push", "(", "$", "value", ",", "\"Value: $data[$key]\"", ")", ";", "}", ")", ";", "return", "json_encode", "(", "$", "errors", ",", "true", ")", ";", "}" ]

[ "Prepare", "Error", "Message", "(", "add", "the", "actual", "value", "of", "the", "error", "field", ")", "." ]

[ "public", "function", "process", "(", "ServerRequestInterface", "$", "request", ",", "RequestHandlerInterface", "$", "handler", ")", ":", "ResponseInterface", "{", "$", "scheme", "=", "$", "request", "->", "getUri", "(", ")", "->", "getScheme", "(", ")", ";", "$", "host", "=", "$", "request", "->", "getUri", "(", ")", "->", "getHost", "(", ")", ";", "/* If rules say we should not authenticate call next and return. */", "if", "(", "false", "===", "$", "this", "->", "shouldAuthenticate", "(", "$", "request", ")", ")", "{", "return", "$", "handler", "->", "handle", "(", "$", "request", ")", ";", "}", "/* HTTP allowed only if secure is false or server is in relaxed array. */", "if", "(", "\"https\"", "!==", "$", "scheme", "&&", "true", "===", "$", "this", "->", "options", "[", "\"secure\"", "]", ")", "{", "if", "(", "!", "in_array", "(", "$", "host", ",", "$", "this", "->", "options", "[", "\"relaxed\"", "]", ")", ")", "{", "$", "message", "=", "sprintf", "(", "\"Insecure use of middleware over %s denied by configuration.\"", ",", "strtoupper", "(", "$", "scheme", ")", ")", ";", "throw", "new", "RuntimeException", "(", "$", "message", ")", ";", "}", "}", "/* If token cannot be found or decoded return with 401 Unauthorized. */", "try", "{", "$", "token", "=", "$", "this", "->", "fetchToken", "(", "$", "request", ")", ";", "$", "decoded", "=", "$", "this", "->", "decodeToken", "(", "$", "token", ")", ";", "}", "catch", "(", "RuntimeException", "|", "DomainException", "$", "exception", ")", "{", "$", "response", "=", "(", "new", "ResponseFactory", ")", "->", "createResponse", "(", "401", ")", ";", "return", "$", "this", "->", "processError", "(", "$", "response", ",", "[", "\"message\"", "=>", "$", "exception", "->", "getMessage", "(", ")", ",", "\"uri\"", "=>", "(", "string", ")", "$", "request", "->", "getUri", "(", ")", "]", ")", ";", "}", "$", "params", "=", "[", "\"decoded\"", "=>", "$", "decoded", "]", ";", "/* Add decoded token to request as attribute when requested. */", "if", "(", "$", "this", "->", "options", "[", "\"attribute\"", "]", ")", "{", "$", "request", "=", "$", "request", "->", "withAttribute", "(", "$", "this", "->", "options", "[", "\"attribute\"", "]", ",", "$", "decoded", ")", ";", "}", "/* Modify $request before calling next middleware. */", "if", "(", "is_callable", "(", "$", "this", "->", "options", "[", "\"before\"", "]", ")", ")", "{", "$", "response", "=", "(", "new", "ResponseFactory", ")", "->", "createResponse", "(", "200", ")", ";", "$", "beforeRequest", "=", "$", "this", "->", "options", "[", "\"before\"", "]", "(", "$", "request", ",", "$", "params", ")", ";", "if", "(", "$", "beforeRequest", "instanceof", "ServerRequestInterface", ")", "{", "$", "request", "=", "$", "beforeRequest", ";", "}", "}", "/* Everything ok, call next middleware. */", "$", "response", "=", "$", "handler", "->", "handle", "(", "$", "request", ")", ";", "/* Modify $response before returning. */", "if", "(", "is_callable", "(", "$", "this", "->", "options", "[", "\"after\"", "]", ")", ")", "{", "$", "afterResponse", "=", "$", "this", "->", "options", "[", "\"after\"", "]", "(", "$", "response", ",", "$", "params", ")", ";", "if", "(", "$", "afterResponse", "instanceof", "ResponseInterface", ")", "{", "return", "$", "afterResponse", ";", "}", "}", "return", "$", "response", ";", "}" ]

[ "Process", "a", "request", "in", "PSR", "-", "15", "style", "and", "return", "a", "response", "." ]

[ "public", "function", "withRules", "(", "array", "$", "rules", ")", ":", "self", "{", "$", "new", "=", "clone", "$", "this", ";", "/* Clear the stack */", "unset", "(", "$", "new", "->", "rules", ")", ";", "$", "new", "->", "rules", "=", "new", "\\", "SplStack", ";", "/* Add the rules */", "foreach", "(", "$", "rules", "as", "$", "callable", ")", "{", "$", "new", "=", "$", "new", "->", "addRule", "(", "$", "callable", ")", ";", "}", "return", "$", "new", ";", "}" ]

[ "Set", "all", "rules", "in", "the", "stack", "." ]

[ "private", "function", "shouldAuthenticate", "(", "ServerRequestInterface", "$", "request", ")", ":", "bool", "{", "/* If any of the rules in stack return false will not authenticate */", "foreach", "(", "$", "this", "->", "rules", "as", "$", "callable", ")", "{", "if", "(", "false", "===", "$", "callable", "(", "$", "request", ")", ")", "{", "return", "false", ";", "}", "}", "return", "true", ";", "}" ]

[ "Check", "if", "middleware", "should", "authenticate", "." ]

[ "private", "function", "processError", "(", "ResponseInterface", "$", "response", ",", "array", "$", "arguments", ")", ":", "ResponseInterface", "{", "if", "(", "is_callable", "(", "$", "this", "->", "options", "[", "\"error\"", "]", ")", ")", "{", "$", "handlerResponse", "=", "$", "this", "->", "options", "[", "\"error\"", "]", "(", "$", "response", ",", "$", "arguments", ")", ";", "if", "(", "$", "handlerResponse", "instanceof", "ResponseInterface", ")", "{", "return", "$", "handlerResponse", ";", "}", "}", "return", "$", "response", ";", "}" ]

[ "Call", "the", "error", "handler", "if", "it", "exists", "." ]

[ "private", "function", "fetchToken", "(", "ServerRequestInterface", "$", "request", ")", ":", "string", "{", "/* Check for token in header. */", "$", "header", "=", "$", "request", "->", "getHeaderLine", "(", "$", "this", "->", "options", "[", "\"header\"", "]", ")", ";", "if", "(", "false", "===", "empty", "(", "$", "header", ")", ")", "{", "if", "(", "preg_match", "(", "$", "this", "->", "options", "[", "\"regexp\"", "]", ",", "$", "header", ",", "$", "matches", ")", ")", "{", "$", "this", "->", "log", "(", "LogLevel", "::", "DEBUG", ",", "\"Using token from request header\"", ")", ";", "return", "$", "matches", "[", "1", "]", ";", "}", "}", "/* Token not found in header try a cookie. */", "$", "cookieParams", "=", "$", "request", "->", "getCookieParams", "(", ")", ";", "if", "(", "isset", "(", "$", "cookieParams", "[", "$", "this", "->", "options", "[", "\"cookie\"", "]", "]", ")", ")", "{", "$", "this", "->", "log", "(", "LogLevel", "::", "DEBUG", ",", "\"Using token from cookie\"", ")", ";", "return", "$", "cookieParams", "[", "$", "this", "->", "options", "[", "\"cookie\"", "]", "]", ";", "}", ";", "/* If everything fails log and throw. */", "$", "this", "->", "log", "(", "LogLevel", "::", "WARNING", ",", "\"Token not found\"", ")", ";", "throw", "new", "RuntimeException", "(", "\"Token not found.\"", ")", ";", "}" ]

[ "Fetch", "the", "access", "token", "." ]

[ "private", "function", "decodeToken", "(", "string", "$", "token", ")", ":", "array", "{", "try", "{", "$", "decoded", "=", "JWT", "::", "decode", "(", "$", "token", ",", "$", "this", "->", "options", "[", "\"secret\"", "]", ",", "(", "array", ")", "$", "this", "->", "options", "[", "\"algorithm\"", "]", ")", ";", "return", "(", "array", ")", "$", "decoded", ";", "}", "catch", "(", "Exception", "$", "exception", ")", "{", "$", "this", "->", "log", "(", "LogLevel", "::", "WARNING", ",", "$", "exception", "->", "getMessage", "(", ")", ",", "[", "$", "token", "]", ")", ";", "throw", "$", "exception", ";", "}", "}" ]

[ "Decode", "the", "token", "." ]

[ "private", "function", "secret", "(", "$", "secret", ")", ":", "void", "{", "if", "(", "false", "===", "is_array", "(", "$", "secret", ")", "&&", "false", "===", "is_string", "(", "$", "secret", ")", ")", "{", "throw", "new", "InvalidArgumentException", "(", "'Secret must be either a string or an array of \"kid\" => \"secret\" pairs'", ")", ";", "}", "$", "this", "->", "options", "[", "\"secret\"", "]", "=", "$", "secret", ";", "}" ]

[ "Set", "the", "secret", "key", "." ]

[ "private", "function", "error", "(", "callable", "$", "error", ")", ":", "void", "{", "if", "(", "$", "error", "instanceof", "Closure", ")", "{", "$", "this", "->", "options", "[", "\"error\"", "]", "=", "$", "error", "->", "bindTo", "(", "$", "this", ")", ";", "}", "else", "{", "$", "this", "->", "options", "[", "\"error\"", "]", "=", "$", "error", ";", "}", "}" ]

[ "Set", "the", "error", "handler", "." ]

[ "private", "function", "before", "(", "callable", "$", "before", ")", ":", "void", "{", "if", "(", "$", "before", "instanceof", "Closure", ")", "{", "$", "this", "->", "options", "[", "\"before\"", "]", "=", "$", "before", "->", "bindTo", "(", "$", "this", ")", ";", "}", "else", "{", "$", "this", "->", "options", "[", "\"before\"", "]", "=", "$", "before", ";", "}", "}" ]

[ "Set", "the", "before", "handler", "." ]

[ "private", "function", "after", "(", "callable", "$", "after", ")", ":", "void", "{", "if", "(", "$", "after", "instanceof", "Closure", ")", "{", "$", "this", "->", "options", "[", "\"after\"", "]", "=", "$", "after", "->", "bindTo", "(", "$", "this", ")", ";", "}", "else", "{", "$", "this", "->", "options", "[", "\"after\"", "]", "=", "$", "after", ";", "}", "}" ]

[ "Set", "the", "after", "handler", "." ]

[ "public", "static", "function", "restore", "(", "$", "clear", "=", "true", ")", "{", "if", "(", "$", "clear", ")", "{", "libxml_clear_errors", "(", ")", ";", "}", "libxml_use_internal_errors", "(", "self", "::", "$", "internalErrors", ")", ";", "libxml_disable_entity_loader", "(", "self", "::", "$", "disableEntities", ")", ";", "}" ]

[ "Restore", "error", "reporting", "." ]

[ "protected", "function", "parseStyleAttribute", "(", ")", "{", "if", "(", "!", "$", "this", "->", "element", "->", "hasAttribute", "(", "'style'", ")", ")", "{", "// possible if style attribute has been removed", "if", "(", "$", "this", "->", "styleString", "!==", "''", ")", "{", "$", "this", "->", "styleString", "=", "''", ";", "$", "this", "->", "properties", "=", "[", "]", ";", "}", "return", ";", "}", "// if style attribute is not changed", "if", "(", "$", "this", "->", "element", "->", "getAttribute", "(", "'style'", ")", "===", "$", "this", "->", "styleString", ")", "{", "return", ";", "}", "// save style attribute as is (without trimming)", "$", "this", "->", "styleString", "=", "$", "this", "->", "element", "->", "getAttribute", "(", "'style'", ")", ";", "$", "styleString", "=", "trim", "(", "$", "this", "->", "styleString", ",", "' ;'", ")", ";", "if", "(", "$", "styleString", "===", "''", ")", "{", "$", "this", "->", "properties", "=", "[", "]", ";", "return", ";", "}", "$", "properties", "=", "explode", "(", "';'", ",", "$", "styleString", ")", ";", "foreach", "(", "$", "properties", "as", "$", "property", ")", "{", "list", "(", "$", "name", ",", "$", "value", ")", "=", "explode", "(", "':'", ",", "$", "property", ")", ";", "$", "name", "=", "trim", "(", "$", "name", ")", ";", "$", "value", "=", "trim", "(", "$", "value", ")", ";", "$", "this", "->", "properties", "[", "$", "name", "]", "=", "$", "value", ";", "}", "}" ]

[ "Parses", "style", "attribute", "of", "the", "element", "." ]

[ "protected", "function", "updateStyleAttribute", "(", ")", "{", "$", "this", "->", "styleString", "=", "$", "this", "->", "buildStyleString", "(", ")", ";", "$", "this", "->", "element", "->", "setAttribute", "(", "'style'", ",", "$", "this", "->", "styleString", ")", ";", "}" ]

[ "Updates", "style", "attribute", "of", "the", "element", "." ]

[ "public", "function", "setProperty", "(", "$", "name", ",", "$", "value", ")", "{", "if", "(", "!", "is_string", "(", "$", "name", ")", ")", "{", "throw", "new", "InvalidArgumentException", "(", "sprintf", "(", "'%s expects parameter 1 to be string, %s given'", ",", "__METHOD__", ",", "(", "is_object", "(", "$", "name", ")", "?", "get_class", "(", "$", "name", ")", ":", "gettype", "(", "$", "name", ")", ")", ")", ")", ";", "}", "if", "(", "!", "is_string", "(", "$", "value", ")", ")", "{", "throw", "new", "InvalidArgumentException", "(", "sprintf", "(", "'%s expects parameter 2 to be string, %s given'", ",", "__METHOD__", ",", "(", "is_object", "(", "$", "value", ")", "?", "get_class", "(", "$", "value", ")", ":", "gettype", "(", "$", "value", ")", ")", ")", ")", ";", "}", "$", "this", "->", "parseStyleAttribute", "(", ")", ";", "$", "this", "->", "properties", "[", "$", "name", "]", "=", "$", "value", ";", "$", "this", "->", "updateStyleAttribute", "(", ")", ";", "return", "$", "this", ";", "}" ]

[ "@param", "string", "$name", "@param", "string", "$value" ]

[ "public", "function", "setMultipleProperties", "(", "array", "$", "properties", ")", "{", "$", "this", "->", "parseStyleAttribute", "(", ")", ";", "foreach", "(", "$", "properties", "as", "$", "propertyName", "=>", "$", "value", ")", "{", "if", "(", "!", "is_string", "(", "$", "propertyName", ")", ")", "{", "throw", "new", "InvalidArgumentException", "(", "sprintf", "(", "'Property name must be a string, %s given'", ",", "(", "is_object", "(", "$", "propertyName", ")", "?", "get_class", "(", "$", "propertyName", ")", ":", "gettype", "(", "$", "propertyName", ")", ")", ")", ")", ";", "}", "if", "(", "!", "is_string", "(", "$", "value", ")", ")", "{", "throw", "new", "InvalidArgumentException", "(", "sprintf", "(", "'Property value must be a string, %s given'", ",", "(", "is_object", "(", "$", "value", ")", "?", "get_class", "(", "$", "value", ")", ":", "gettype", "(", "$", "value", ")", ")", ")", ")", ";", "}", "$", "this", "->", "properties", "[", "$", "propertyName", "]", "=", "$", "value", ";", "}", "$", "this", "->", "updateStyleAttribute", "(", ")", ";", "return", "$", "this", ";", "}" ]

[ "@param", "array", "$properties" ]

[ "public", "function", "getProperty", "(", "$", "name", ",", "$", "default", "=", "null", ")", "{", "if", "(", "!", "is_string", "(", "$", "name", ")", ")", "{", "throw", "new", "InvalidArgumentException", "(", "sprintf", "(", "'%s expects parameter 1 to be string, %s given'", ",", "__METHOD__", ",", "(", "is_object", "(", "$", "name", ")", "?", "get_class", "(", "$", "name", ")", ":", "gettype", "(", "$", "name", ")", ")", ")", ")", ";", "}", "$", "this", "->", "parseStyleAttribute", "(", ")", ";", "if", "(", "!", "array_key_exists", "(", "$", "name", ",", "$", "this", "->", "properties", ")", ")", "{", "return", "$", "default", ";", "}", "return", "$", "this", "->", "properties", "[", "$", "name", "]", ";", "}" ]

[ "@param", "string", "$name", "@param", "mixed", "$default" ]

[ "public", "function", "getMultipleProperties", "(", "array", "$", "propertyNames", ")", "{", "$", "this", "->", "parseStyleAttribute", "(", ")", ";", "$", "result", "=", "[", "]", ";", "foreach", "(", "$", "propertyNames", "as", "$", "propertyName", ")", "{", "if", "(", "!", "is_string", "(", "$", "propertyName", ")", ")", "{", "throw", "new", "InvalidArgumentException", "(", "sprintf", "(", "'Property name must be a string, %s given'", ",", "(", "is_object", "(", "$", "propertyName", ")", "?", "get_class", "(", "$", "propertyName", ")", ":", "gettype", "(", "$", "propertyName", ")", ")", ")", ")", ";", "}", "if", "(", "array_key_exists", "(", "$", "propertyName", ",", "$", "this", "->", "properties", ")", ")", "{", "$", "result", "[", "$", "propertyName", "]", "=", "$", "this", "->", "properties", "[", "$", "propertyName", "]", ";", "}", "}", "return", "$", "result", ";", "}" ]

[ "@param", "array", "$propertyNames" ]

[ "public", "function", "removeProperty", "(", "$", "name", ")", "{", "if", "(", "!", "is_string", "(", "$", "name", ")", ")", "{", "throw", "new", "InvalidArgumentException", "(", "sprintf", "(", "'%s expects parameter 1 to be string, %s given'", ",", "__METHOD__", ",", "(", "is_object", "(", "$", "name", ")", "?", "get_class", "(", "$", "name", ")", ":", "gettype", "(", "$", "name", ")", ")", ")", ")", ";", "}", "$", "this", "->", "parseStyleAttribute", "(", ")", ";", "unset", "(", "$", "this", "->", "properties", "[", "$", "name", "]", ")", ";", "$", "this", "->", "updateStyleAttribute", "(", ")", ";", "return", "$", "this", ";", "}" ]

[ "@param", "string", "$name" ]

[ "public", "function", "removeMultipleProperties", "(", "array", "$", "propertyNames", ")", "{", "$", "this", "->", "parseStyleAttribute", "(", ")", ";", "foreach", "(", "$", "propertyNames", "as", "$", "propertyName", ")", "{", "if", "(", "!", "is_string", "(", "$", "propertyName", ")", ")", "{", "throw", "new", "InvalidArgumentException", "(", "sprintf", "(", "'Property name must be a string, %s given'", ",", "(", "is_object", "(", "$", "propertyName", ")", "?", "get_class", "(", "$", "propertyName", ")", ":", "gettype", "(", "$", "propertyName", ")", ")", ")", ")", ";", "}", "unset", "(", "$", "this", "->", "properties", "[", "$", "propertyName", "]", ")", ";", "}", "$", "this", "->", "updateStyleAttribute", "(", ")", ";", "return", "$", "this", ";", "}" ]

[ "@param", "array", "$propertyNames" ]

[ "public", "function", "removeAllProperties", "(", "array", "$", "exclusions", "=", "[", "]", ")", "{", "$", "this", "->", "parseStyleAttribute", "(", ")", ";", "$", "preservedProperties", "=", "[", "]", ";", "foreach", "(", "$", "exclusions", "as", "$", "propertyName", ")", "{", "if", "(", "!", "is_string", "(", "$", "propertyName", ")", ")", "{", "throw", "new", "InvalidArgumentException", "(", "sprintf", "(", "'Property name must be a string, %s given'", ",", "(", "is_object", "(", "$", "propertyName", ")", "?", "get_class", "(", "$", "propertyName", ")", ":", "gettype", "(", "$", "propertyName", ")", ")", ")", ")", ";", "}", "if", "(", "!", "array_key_exists", "(", "$", "propertyName", ",", "$", "this", "->", "properties", ")", ")", "{", "continue", ";", "}", "$", "preservedProperties", "[", "$", "propertyName", "]", "=", "$", "this", "->", "properties", "[", "$", "propertyName", "]", ";", "}", "$", "this", "->", "properties", "=", "$", "preservedProperties", ";", "$", "this", "->", "updateStyleAttribute", "(", ")", ";", "return", "$", "this", ";", "}" ]

[ "@param", "string", "[]", "$exclusions" ]

[ "public", "static", "function", "createBySelector", "(", "$", "selector", ",", "$", "value", "=", "null", ",", "array", "$", "attributes", "=", "[", "]", ")", "{", "return", "Document", "::", "create", "(", ")", "->", "createElementBySelector", "(", "$", "selector", ",", "$", "value", ",", "$", "attributes", ")", ";", "}" ]

[ "Creates", "a", "new", "element", "node", "by", "CSS", "selector", "." ]

[ "public", "function", "prependChild", "(", "$", "nodes", ")", "{", "if", "(", "$", "this", "->", "node", "->", "ownerDocument", "===", "null", ")", "{", "throw", "new", "LogicException", "(", "'Can not prepend child to element without owner document'", ")", ";", "}", "$", "returnArray", "=", "true", ";", "if", "(", "!", "is_array", "(", "$", "nodes", ")", ")", "{", "$", "nodes", "=", "[", "$", "nodes", "]", ";", "$", "returnArray", "=", "false", ";", "}", "$", "nodes", "=", "array_reverse", "(", "$", "nodes", ")", ";", "$", "result", "=", "[", "]", ";", "$", "referenceNode", "=", "$", "this", "->", "node", "->", "firstChild", ";", "foreach", "(", "$", "nodes", "as", "$", "node", ")", "{", "$", "result", "[", "]", "=", "$", "this", "->", "insertBefore", "(", "$", "node", ",", "$", "referenceNode", ")", ";", "$", "referenceNode", "=", "$", "this", "->", "node", "->", "firstChild", ";", "}", "return", "$", "returnArray", "?", "$", "result", ":", "$", "result", "[", "0", "]", ";", "}" ]

[ "Adds", "a", "new", "child", "at", "the", "start", "of", "the", "children", "." ]

[ "public", "function", "insertBefore", "(", "$", "node", ",", "$", "referenceNode", "=", "null", ")", "{", "if", "(", "$", "this", "->", "node", "->", "ownerDocument", "===", "null", ")", "{", "throw", "new", "LogicException", "(", "'Can not insert child to element without owner document'", ")", ";", "}", "if", "(", "$", "node", "instanceof", "Element", ")", "{", "$", "node", "=", "$", "node", "->", "getNode", "(", ")", ";", "}", "if", "(", "!", "$", "node", "instanceof", "DOMNode", ")", "{", "throw", "new", "InvalidArgumentException", "(", "sprintf", "(", "'Argument 1 passed to %s must be an instance of %s\\Element or DOMNode, %s given'", ",", "__METHOD__", ",", "__NAMESPACE__", ",", "(", "is_object", "(", "$", "node", ")", "?", "get_class", "(", "$", "node", ")", ":", "gettype", "(", "$", "node", ")", ")", ")", ")", ";", "}", "if", "(", "$", "referenceNode", "!==", "null", ")", "{", "if", "(", "$", "referenceNode", "instanceof", "Element", ")", "{", "$", "referenceNode", "=", "$", "referenceNode", "->", "getNode", "(", ")", ";", "}", "if", "(", "!", "$", "referenceNode", "instanceof", "DOMNode", ")", "{", "throw", "new", "InvalidArgumentException", "(", "sprintf", "(", "'Argument 2 passed to %s must be an instance of %s\\Element or DOMNode, %s given'", ",", "__METHOD__", ",", "__NAMESPACE__", ",", "(", "is_object", "(", "$", "referenceNode", ")", "?", "get_class", "(", "$", "referenceNode", ")", ":", "gettype", "(", "$", "referenceNode", ")", ")", ")", ")", ";", "}", "}", "Errors", "::", "disable", "(", ")", ";", "$", "clonedNode", "=", "$", "node", "->", "cloneNode", "(", "true", ")", ";", "$", "newNode", "=", "$", "this", "->", "node", "->", "ownerDocument", "->", "importNode", "(", "$", "clonedNode", ",", "true", ")", ";", "$", "insertedNode", "=", "$", "this", "->", "node", "->", "insertBefore", "(", "$", "newNode", ",", "$", "referenceNode", ")", ";", "Errors", "::", "restore", "(", ")", ";", "return", "new", "Element", "(", "$", "insertedNode", ")", ";", "}" ]

[ "Adds", "a", "new", "child", "before", "a", "reference", "node", "." ]

[ "public", "function", "insertAfter", "(", "$", "node", ",", "$", "referenceNode", "=", "null", ")", "{", "if", "(", "$", "referenceNode", "===", "null", ")", "{", "return", "$", "this", "->", "insertBefore", "(", "$", "node", ")", ";", "}", "if", "(", "$", "referenceNode", "instanceof", "Element", ")", "{", "$", "referenceNode", "=", "$", "referenceNode", "->", "getNode", "(", ")", ";", "}", "if", "(", "!", "$", "referenceNode", "instanceof", "DOMNode", ")", "{", "throw", "new", "InvalidArgumentException", "(", "sprintf", "(", "'Argument 2 passed to %s must be an instance of %s\\Element or DOMNode, %s given'", ",", "__METHOD__", ",", "__NAMESPACE__", ",", "(", "is_object", "(", "$", "referenceNode", ")", "?", "get_class", "(", "$", "referenceNode", ")", ":", "gettype", "(", "$", "referenceNode", ")", ")", ")", ")", ";", "}", "return", "$", "this", "->", "insertBefore", "(", "$", "node", ",", "$", "referenceNode", "->", "nextSibling", ")", ";", "}" ]

[ "Adds", "a", "new", "child", "after", "a", "reference", "node", "." ]

[ "public", "function", "has", "(", "$", "expression", ",", "$", "type", "=", "Query", "::", "TYPE_CSS", ")", "{", "return", "$", "this", "->", "toDocument", "(", ")", "->", "has", "(", "$", "expression", ",", "$", "type", ")", ";", "}" ]

[ "Checks", "the", "existence", "of", "the", "node", "." ]

[ "public", "function", "find", "(", "$", "expression", ",", "$", "type", "=", "Query", "::", "TYPE_CSS", ",", "$", "wrapElement", "=", "true", ")", "{", "return", "$", "this", "->", "toDocument", "(", ")", "->", "find", "(", "$", "expression", ",", "$", "type", ",", "$", "wrapElement", ")", ";", "}" ]

[ "Searches", "for", "an", "node", "in", "the", "DOM", "tree", "for", "a", "given", "XPath", "expression", "or", "a", "CSS", "selector", "." ]

[ "public", "function", "findInDocument", "(", "$", "expression", ",", "$", "type", "=", "Query", "::", "TYPE_CSS", ",", "$", "wrapNode", "=", "true", ")", "{", "$", "ownerDocument", "=", "$", "this", "->", "getDocument", "(", ")", ";", "if", "(", "$", "ownerDocument", "===", "null", ")", "{", "throw", "new", "LogicException", "(", "'Can not search in context without owner document'", ")", ";", "}", "return", "$", "ownerDocument", "->", "find", "(", "$", "expression", ",", "$", "type", ",", "$", "wrapNode", ",", "$", "this", "->", "node", ")", ";", "}" ]

[ "Searches", "for", "an", "node", "in", "the", "owner", "document", "using", "current", "node", "as", "context", "." ]

[ "public", "function", "first", "(", "$", "expression", ",", "$", "type", "=", "Query", "::", "TYPE_CSS", ",", "$", "wrapNode", "=", "true", ")", "{", "return", "$", "this", "->", "toDocument", "(", ")", "->", "first", "(", "$", "expression", ",", "$", "type", ",", "$", "wrapNode", ")", ";", "}" ]

[ "Searches", "for", "an", "node", "in", "the", "DOM", "tree", "and", "returns", "first", "element", "or", "null", "." ]

[ "public", "function", "firstInDocument", "(", "$", "expression", ",", "$", "type", "=", "Query", "::", "TYPE_CSS", ",", "$", "wrapNode", "=", "true", ")", "{", "$", "ownerDocument", "=", "$", "this", "->", "getDocument", "(", ")", ";", "if", "(", "$", "ownerDocument", "===", "null", ")", "{", "throw", "new", "LogicException", "(", "'Can not search in context without owner document'", ")", ";", "}", "return", "$", "ownerDocument", "->", "first", "(", "$", "expression", ",", "$", "type", ",", "$", "wrapNode", ",", "$", "this", "->", "node", ")", ";", "}" ]

[ "Searches", "for", "an", "node", "in", "the", "owner", "document", "using", "current", "node", "as", "context", "and", "returns", "first", "element", "or", "null", "." ]

[ "public", "function", "xpath", "(", "$", "expression", ",", "$", "wrapNode", "=", "true", ")", "{", "return", "$", "this", "->", "find", "(", "$", "expression", ",", "Query", "::", "TYPE_XPATH", ",", "$", "wrapNode", ")", ";", "}" ]

[ "Searches", "for", "an", "node", "in", "the", "DOM", "tree", "for", "a", "given", "XPath", "expression", "." ]

[ "public", "function", "count", "(", "$", "expression", ",", "$", "type", "=", "Query", "::", "TYPE_CSS", ")", "{", "return", "$", "this", "->", "toDocument", "(", ")", "->", "count", "(", "$", "expression", ",", "$", "type", ")", ";", "}" ]

[ "Counts", "nodes", "for", "a", "given", "XPath", "expression", "or", "a", "CSS", "selector", "." ]

[ "public", "function", "matches", "(", "$", "selector", ",", "$", "strict", "=", "false", ")", "{", "if", "(", "!", "is_string", "(", "$", "selector", ")", ")", "{", "throw", "new", "InvalidArgumentException", "(", "sprintf", "(", "'%s expects parameter 1 to be string, %s given'", ",", "__METHOD__", ",", "gettype", "(", "$", "selector", ")", ")", ")", ";", "}", "if", "(", "!", "$", "this", "->", "node", "instanceof", "DOMElement", ")", "{", "return", "false", ";", "}", "if", "(", "$", "selector", "===", "'*'", ")", "{", "return", "true", ";", "}", "if", "(", "!", "$", "strict", ")", "{", "$", "innerHtml", "=", "$", "this", "->", "html", "(", ")", ";", "$", "html", "=", "\"<root>$innerHtml</root>\"", ";", "$", "selector", "=", "'root > '", ".", "trim", "(", "$", "selector", ")", ";", "$", "document", "=", "new", "Document", "(", ")", ";", "$", "document", "->", "loadHtml", "(", "$", "html", ",", "LIBXML_HTML_NODEFDTD", "|", "LIBXML_HTML_NOIMPLIED", ")", ";", "return", "$", "document", "->", "has", "(", "$", "selector", ")", ";", "}", "$", "segments", "=", "Query", "::", "getSegments", "(", "$", "selector", ")", ";", "if", "(", "!", "array_key_exists", "(", "'tag'", ",", "$", "segments", ")", ")", "{", "throw", "new", "RuntimeException", "(", "sprintf", "(", "'Tag name must be specified in %s'", ",", "$", "selector", ")", ")", ";", "}", "if", "(", "$", "segments", "[", "'tag'", "]", "!==", "$", "this", "->", "tag", "&&", "$", "segments", "[", "'tag'", "]", "!==", "'*'", ")", "{", "return", "false", ";", "}", "$", "segments", "[", "'id'", "]", "=", "array_key_exists", "(", "'id'", ",", "$", "segments", ")", "?", "$", "segments", "[", "'id'", "]", ":", "null", ";", "if", "(", "$", "segments", "[", "'id'", "]", "!==", "$", "this", "->", "getAttribute", "(", "'id'", ")", ")", "{", "return", "false", ";", "}", "$", "classes", "=", "$", "this", "->", "hasAttribute", "(", "'class'", ")", "?", "explode", "(", "' '", ",", "trim", "(", "$", "this", "->", "getAttribute", "(", "'class'", ")", ")", ")", ":", "[", "]", ";", "$", "segments", "[", "'classes'", "]", "=", "array_key_exists", "(", "'classes'", ",", "$", "segments", ")", "?", "$", "segments", "[", "'classes'", "]", ":", "[", "]", ";", "$", "diff1", "=", "array_diff", "(", "$", "segments", "[", "'classes'", "]", ",", "$", "classes", ")", ";", "$", "diff2", "=", "array_diff", "(", "$", "classes", ",", "$", "segments", "[", "'classes'", "]", ")", ";", "if", "(", "count", "(", "$", "diff1", ")", ">", "0", "||", "count", "(", "$", "diff2", ")", ">", "0", ")", "{", "return", "false", ";", "}", "$", "attributes", "=", "$", "this", "->", "attributes", "(", ")", ";", "unset", "(", "$", "attributes", "[", "'id'", "]", ",", "$", "attributes", "[", "'class'", "]", ")", ";", "$", "segments", "[", "'attributes'", "]", "=", "array_key_exists", "(", "'attributes'", ",", "$", "segments", ")", "?", "$", "segments", "[", "'attributes'", "]", ":", "[", "]", ";", "$", "diff1", "=", "array_diff_assoc", "(", "$", "segments", "[", "'attributes'", "]", ",", "$", "attributes", ")", ";", "$", "diff2", "=", "array_diff_assoc", "(", "$", "attributes", ",", "$", "segments", "[", "'attributes'", "]", ")", ";", "// if the attributes are not equal", "if", "(", "count", "(", "$", "diff1", ")", ">", "0", "||", "count", "(", "$", "diff2", ")", ">", "0", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Checks", "that", "the", "node", "matches", "selector", "." ]

[ "public", "function", "setAttribute", "(", "$", "name", ",", "$", "value", ")", "{", "if", "(", "is_numeric", "(", "$", "value", ")", ")", "{", "$", "value", "=", "(", "string", ")", "$", "value", ";", "}", "if", "(", "!", "is_string", "(", "$", "value", ")", "&&", "$", "value", "!==", "null", ")", "{", "throw", "new", "InvalidArgumentException", "(", "sprintf", "(", "'%s expects parameter 2 to be string or null, %s given'", ",", "__METHOD__", ",", "(", "is_object", "(", "$", "value", ")", "?", "get_class", "(", "$", "value", ")", ":", "gettype", "(", "$", "value", ")", ")", ")", ")", ";", "}", "$", "this", "->", "node", "->", "setAttribute", "(", "$", "name", ",", "$", "value", ")", ";", "return", "$", "this", ";", "}" ]

[ "Set", "an", "attribute", "on", "the", "element", "." ]

[ "public", "function", "getAttribute", "(", "$", "name", ",", "$", "default", "=", "null", ")", "{", "if", "(", "$", "this", "->", "hasAttribute", "(", "$", "name", ")", ")", "{", "return", "$", "this", "->", "node", "->", "getAttribute", "(", "$", "name", ")", ";", "}", "return", "$", "default", ";", "}" ]

[ "Access", "to", "the", "element", "s", "attributes", "." ]

[ "public", "function", "removeAllAttributes", "(", "array", "$", "exclusions", "=", "[", "]", ")", "{", "if", "(", "!", "$", "this", "->", "node", "instanceof", "DOMElement", ")", "{", "return", "$", "this", ";", "}", "foreach", "(", "$", "this", "->", "attributes", "(", ")", "as", "$", "name", "=>", "$", "value", ")", "{", "if", "(", "in_array", "(", "$", "name", ",", "$", "exclusions", ",", "true", ")", ")", "{", "continue", ";", "}", "$", "this", "->", "node", "->", "removeAttribute", "(", "$", "name", ")", ";", "}", "return", "$", "this", ";", "}" ]

[ "Unset", "all", "attributes", "of", "the", "element", "." ]