Datasets:

unum-cloud

/

ann-codesearch-4m

like 0

Follow

Unum 28

[ "public", "function", "create", "(", "$", "friendlyName", ",", "$", "ipAddress", ",", "$", "options", "=", "array", "(", ")", ")", "{", "$", "options", "=", "new", "Values", "(", "$", "options", ")", ";", "$", "data", "=", "Values", "::", "of", "(", "array", "(", "'FriendlyName'", "=>", "$", "friendlyName", ",", "'IpAddress'", "=>", "$", "ipAddress", ",", "'CidrPrefixLength'", "=>", "$", "options", "[", "'cidrPrefixLength'", "]", ",", ")", ")", ";", "$", "payload", "=", "$", "this", "->", "version", "->", "create", "(", "'POST'", ",", "$", "this", "->", "uri", ",", "array", "(", ")", ",", "$", "data", ")", ";", "return", "new", "IpAddressInstance", "(", "$", "this", "->", "version", ",", "$", "payload", ",", "$", "this", "->", "solution", "[", "'accountSid'", "]", ",", "$", "this", "->", "solution", "[", "'ipAccessControlListSid'", "]", ")", ";", "}" ]

[ "Create", "a", "new", "IpAddressInstance" ]

[ "public", "function", "getContext", "(", "$", "sid", ")", "{", "return", "new", "IpAddressContext", "(", "$", "this", "->", "version", ",", "$", "this", "->", "solution", "[", "'accountSid'", "]", ",", "$", "this", "->", "solution", "[", "'ipAccessControlListSid'", "]", ",", "$", "sid", ")", ";", "}" ]

[ "Constructs", "a", "IpAddressContext" ]

[ "protected", "function", "proxy", "(", ")", "{", "if", "(", "!", "$", "this", "->", "context", ")", "{", "$", "this", "->", "context", "=", "new", "FunctionContext", "(", "$", "this", "->", "version", ",", "$", "this", "->", "solution", "[", "'serviceSid'", "]", ",", "$", "this", "->", "solution", "[", "'sid'", "]", ")", ";", "}", "return", "$", "this", "->", "context", ";", "}" ]

[ "Generate", "an", "instance", "context", "for", "the", "instance", "the", "context", "is", "capable", "of", "performing", "various", "actions", ".", "All", "instance", "actions", "are", "proxied", "to", "the", "context" ]

[ "protected", "function", "proxy", "(", ")", "{", "if", "(", "!", "$", "this", "->", "context", ")", "{", "$", "this", "->", "context", "=", "new", "AssetContext", "(", "$", "this", "->", "version", ",", "$", "this", "->", "solution", "[", "'serviceSid'", "]", ",", "$", "this", "->", "solution", "[", "'sid'", "]", ")", ";", "}", "return", "$", "this", "->", "context", ";", "}" ]

[ "Generate", "an", "instance", "context", "for", "the", "instance", "the", "context", "is", "capable", "of", "performing", "various", "actions", ".", "All", "instance", "actions", "are", "proxied", "to", "the", "context" ]

[ "protected", "function", "proxy", "(", ")", "{", "if", "(", "!", "$", "this", "->", "context", ")", "{", "$", "this", "->", "context", "=", "new", "WorkerStatisticsContext", "(", "$", "this", "->", "version", ",", "$", "this", "->", "solution", "[", "'workspaceSid'", "]", ",", "$", "this", "->", "solution", "[", "'workerSid'", "]", ")", ";", "}", "return", "$", "this", "->", "context", ";", "}" ]

[ "Generate", "an", "instance", "context", "for", "the", "instance", "the", "context", "is", "capable", "of", "performing", "various", "actions", ".", "All", "instance", "actions", "are", "proxied", "to", "the", "context" ]

[ "public", "function", "create", "(", "$", "type", ",", "$", "options", "=", "array", "(", ")", ")", "{", "$", "options", "=", "new", "Values", "(", "$", "options", ")", ";", "$", "data", "=", "Values", "::", "of", "(", "array", "(", "'Type'", "=>", "$", "type", ",", "'FriendlyName'", "=>", "$", "options", "[", "'friendlyName'", "]", ",", "'Certificate'", "=>", "$", "options", "[", "'certificate'", "]", ",", "'PrivateKey'", "=>", "$", "options", "[", "'privateKey'", "]", ",", "'Sandbox'", "=>", "Serialize", "::", "booleanToString", "(", "$", "options", "[", "'sandbox'", "]", ")", ",", "'ApiKey'", "=>", "$", "options", "[", "'apiKey'", "]", ",", "'Secret'", "=>", "$", "options", "[", "'secret'", "]", ",", ")", ")", ";", "$", "payload", "=", "$", "this", "->", "version", "->", "create", "(", "'POST'", ",", "$", "this", "->", "uri", ",", "array", "(", ")", ",", "$", "data", ")", ";", "return", "new", "CredentialInstance", "(", "$", "this", "->", "version", ",", "$", "payload", ")", ";", "}" ]

[ "Create", "a", "new", "CredentialInstance" ]

[ "public", "function", "getContext", "(", "$", "channelSid", ")", "{", "return", "new", "UserChannelContext", "(", "$", "this", "->", "version", ",", "$", "this", "->", "solution", "[", "'serviceSid'", "]", ",", "$", "this", "->", "solution", "[", "'userSid'", "]", ",", "$", "channelSid", ")", ";", "}" ]

[ "Constructs", "a", "UserChannelContext" ]

[ "protected", "function", "proxy", "(", ")", "{", "if", "(", "!", "$", "this", "->", "context", ")", "{", "$", "this", "->", "context", "=", "new", "ChallengeContext", "(", "$", "this", "->", "version", ",", "$", "this", "->", "solution", "[", "'serviceSid'", "]", ",", "$", "this", "->", "solution", "[", "'identity'", "]", ",", "$", "this", "->", "solution", "[", "'factorSid'", "]", ",", "$", "this", "->", "solution", "[", "'sid'", "]", ")", ";", "}", "return", "$", "this", "->", "context", ";", "}" ]

[ "Generate", "an", "instance", "context", "for", "the", "instance", "the", "context", "is", "capable", "of", "performing", "various", "actions", ".", "All", "instance", "actions", "are", "proxied", "to", "the", "context" ]

[ "protected", "function", "getCredentials", "(", ")", "{", "if", "(", "!", "$", "this", "->", "_credentials", ")", "{", "$", "this", "->", "_credentials", "=", "new", "CredentialList", "(", "$", "this", "->", "version", ",", "$", "this", "->", "solution", "[", "'accountSid'", "]", ",", "$", "this", "->", "solution", "[", "'sid'", "]", ")", ";", "}", "return", "$", "this", "->", "_credentials", ";", "}" ]

[ "Access", "the", "credentials" ]

[ "protected", "function", "proxy", "(", ")", "{", "if", "(", "!", "$", "this", "->", "context", ")", "{", "$", "this", "->", "context", "=", "new", "PhoneNumberContext", "(", "$", "this", "->", "version", ",", "$", "this", "->", "solution", "[", "'trunkSid'", "]", ",", "$", "this", "->", "solution", "[", "'sid'", "]", ")", ";", "}", "return", "$", "this", "->", "context", ";", "}" ]

[ "Generate", "an", "instance", "context", "for", "the", "instance", "the", "context", "is", "capable", "of", "performing", "various", "actions", ".", "All", "instance", "actions", "are", "proxied", "to", "the", "context" ]

[ "protected", "function", "proxy", "(", ")", "{", "if", "(", "!", "$", "this", "->", "context", ")", "{", "$", "this", "->", "context", "=", "new", "AssistantContext", "(", "$", "this", "->", "version", ",", "$", "this", "->", "solution", "[", "'sid'", "]", ")", ";", "}", "return", "$", "this", "->", "context", ";", "}" ]

[ "Generate", "an", "instance", "context", "for", "the", "instance", "the", "context", "is", "capable", "of", "performing", "various", "actions", ".", "All", "instance", "actions", "are", "proxied", "to", "the", "context" ]

[ "protected", "function", "getUserBindings", "(", ")", "{", "if", "(", "!", "$", "this", "->", "_userBindings", ")", "{", "$", "this", "->", "_userBindings", "=", "new", "UserBindingList", "(", "$", "this", "->", "version", ",", "$", "this", "->", "solution", "[", "'serviceSid'", "]", ",", "$", "this", "->", "solution", "[", "'sid'", "]", ")", ";", "}", "return", "$", "this", "->", "_userBindings", ";", "}" ]

[ "Access", "the", "userBindings" ]

[ "protected", "function", "proxy", "(", ")", "{", "if", "(", "!", "$", "this", "->", "context", ")", "{", "$", "this", "->", "context", "=", "new", "DeviceContext", "(", "$", "this", "->", "version", ",", "$", "this", "->", "solution", "[", "'fleetSid'", "]", ",", "$", "this", "->", "solution", "[", "'sid'", "]", ")", ";", "}", "return", "$", "this", "->", "context", ";", "}" ]

[ "Generate", "an", "instance", "context", "for", "the", "instance", "the", "context", "is", "capable", "of", "performing", "various", "actions", ".", "All", "instance", "actions", "are", "proxied", "to", "the", "context" ]

[ "public", "function", "getContext", "(", "$", "sid", ")", "{", "return", "new", "NotificationContext", "(", "$", "this", "->", "version", ",", "$", "this", "->", "solution", "[", "'accountSid'", "]", ",", "$", "this", "->", "solution", "[", "'callSid'", "]", ",", "$", "sid", ")", ";", "}" ]

[ "Constructs", "a", "NotificationContext" ]

[ "public", "function", "handle", "(", "ReactionHasBeenAdded", "$", "event", ")", ":", "void", "{", "$", "reaction", "=", "$", "event", "->", "getReaction", "(", ")", ";", "$", "reactant", "=", "$", "reaction", "->", "getReactant", "(", ")", ";", "(", "new", "ReactionCounterService", "(", "$", "reactant", ")", ")", "->", "addReaction", "(", "$", "reaction", ")", ";", "(", "new", "ReactionTotalService", "(", "$", "reactant", ")", ")", "->", "addReaction", "(", "$", "reaction", ")", ";", "}" ]

[ "Handle", "the", "event", "." ]

[ "public", "function", "handle", "(", "ReactionHasBeenRemoved", "$", "event", ")", ":", "void", "{", "$", "reaction", "=", "$", "event", "->", "getReaction", "(", ")", ";", "$", "reactant", "=", "$", "reaction", "->", "getReactant", "(", ")", ";", "(", "new", "ReactionCounterService", "(", "$", "reactant", ")", ")", "->", "removeReaction", "(", "$", "reaction", ")", ";", "(", "new", "ReactionTotalService", "(", "$", "reactant", ")", ")", "->", "removeReaction", "(", "$", "reaction", ")", ";", "}" ]

[ "Handle", "the", "event", "." ]

[ "public", "function", "handle", "(", ")", ":", "void", "{", "$", "this", "->", "dbMigrate", "(", ")", ";", "$", "this", "->", "populateReactionTypes", "(", ")", ";", "$", "this", "->", "populateReacters", "(", ")", ";", "$", "this", "->", "populateReactants", "(", ")", ";", "$", "this", "->", "populateReactions", "(", ")", ";", "$", "this", "->", "dbCleanup", "(", ")", ";", "$", "this", "->", "filesystemCleanup", "(", ")", ";", "}" ]

[ "Execute", "the", "console", "command", "." ]

[ "public", "function", "handle", "(", "Dispatcher", "$", "events", ")", ":", "void", "{", "if", "(", "$", "reactableType", "=", "$", "this", "->", "argument", "(", "'reactableType'", ")", ")", "{", "$", "reactableType", "=", "$", "this", "->", "normalizeReactableModelType", "(", "$", "reactableType", ")", ";", "}", "if", "(", "$", "reactionType", "=", "$", "this", "->", "argument", "(", "'type'", ")", ")", "{", "$", "reactionType", "=", "ReactionType", "::", "fromName", "(", "$", "reactionType", ")", ";", "}", "$", "reactantsQuery", "=", "Reactant", "::", "query", "(", ")", ";", "if", "(", "$", "reactableType", ")", "{", "$", "reactantsQuery", "->", "where", "(", "'type'", ",", "$", "reactableType", ")", ";", "}", "$", "reactants", "=", "$", "reactantsQuery", "->", "get", "(", ")", ";", "foreach", "(", "$", "reactants", "as", "$", "reactant", ")", "{", "/** @var \\Illuminate\\Database\\Eloquent\\Builder $query */", "$", "query", "=", "$", "reactant", "->", "reactions", "(", ")", ";", "if", "(", "$", "reactionType", ")", "{", "$", "query", "->", "where", "(", "'reaction_type_id'", ",", "$", "reactionType", "->", "getId", "(", ")", ")", ";", "}", "$", "counters", "=", "$", "reactant", "->", "getReactionCounters", "(", ")", ";", "/** @var \\Cog\\Laravel\\Love\\Reactant\\ReactionCounter\\Models\\ReactionCounter $counter */", "foreach", "(", "$", "counters", "as", "$", "counter", ")", "{", "if", "(", "$", "reactionType", "&&", "!", "$", "counter", "->", "isReactionOfType", "(", "$", "reactionType", ")", ")", "{", "continue", ";", "}", "$", "counter", "->", "update", "(", "[", "'count'", "=>", "0", ",", "'weight'", "=>", "0", ",", "]", ")", ";", "}", "$", "reactions", "=", "$", "query", "->", "get", "(", ")", ";", "$", "this", "->", "recountCounters", "(", "$", "reactant", ",", "$", "reactions", ")", ";", "$", "this", "->", "recountTotal", "(", "$", "reactant", ")", ";", "}", "}" ]

[ "Execute", "the", "console", "command", "." ]

[ "private", "function", "reactableModelFromType", "(", "string", "$", "modelType", ")", ":", "ReactableContract", "{", "if", "(", "!", "class_exists", "(", "$", "modelType", ")", ")", "{", "$", "modelType", "=", "$", "this", "->", "findModelTypeInMorphMap", "(", "$", "modelType", ")", ";", "}", "$", "model", "=", "new", "$", "modelType", ";", "if", "(", "!", "$", "model", "instanceof", "ReactableContract", ")", "{", "throw", "ReactableInvalid", "::", "notImplementInterface", "(", "$", "modelType", ")", ";", "}", "return", "$", "model", ";", "}" ]

[ "Instantiate", "model", "from", "type", "or", "morph", "map", "value", "." ]

[ "private", "function", "findModelTypeInMorphMap", "(", "string", "$", "modelType", ")", ":", "string", "{", "$", "morphMap", "=", "Relation", "::", "morphMap", "(", ")", ";", "if", "(", "!", "isset", "(", "$", "morphMap", "[", "$", "modelType", "]", ")", ")", "{", "throw", "ReactableInvalid", "::", "classNotExists", "(", "$", "modelType", ")", ";", "}", "return", "$", "morphMap", "[", "$", "modelType", "]", ";", "}" ]

[ "Find", "model", "type", "in", "morph", "mappings", "registry", "." ]

[ "public", "function", "boot", "(", ")", ":", "void", "{", "$", "this", "->", "registerConsoleCommands", "(", ")", ";", "$", "this", "->", "registerObservers", "(", ")", ";", "$", "this", "->", "registerPublishes", "(", ")", ";", "$", "this", "->", "registerMigrations", "(", ")", ";", "$", "this", "->", "registerListeners", "(", ")", ";", "}" ]

[ "Bootstrap", "the", "application", "events", "." ]

[ "private", "function", "registerListeners", "(", ")", ":", "void", "{", "Event", "::", "listen", "(", "ReactionHasBeenAdded", "::", "class", ",", "IncrementAggregates", "::", "class", ")", ";", "Event", "::", "listen", "(", "ReactionHasBeenRemoved", "::", "class", ",", "DecrementAggregates", "::", "class", ")", ";", "}" ]

[ "Register", "the", "Love", "event", "listeners", "." ]

[ "public", "function", "addHistory", "(", "$", "line", ")", "{", "if", "(", "$", "this", "->", "eraseDups", ")", "{", "if", "(", "(", "$", "key", "=", "\\", "array_search", "(", "$", "line", ",", "$", "this", "->", "history", ")", ")", "!==", "false", ")", "{", "unset", "(", "$", "this", "->", "history", "[", "$", "key", "]", ")", ";", "}", "}", "$", "this", "->", "history", "[", "]", "=", "$", "line", ";", "if", "(", "$", "this", "->", "historySize", ">", "0", ")", "{", "$", "histsize", "=", "\\", "count", "(", "$", "this", "->", "history", ")", ";", "if", "(", "$", "histsize", ">", "$", "this", "->", "historySize", ")", "{", "$", "this", "->", "history", "=", "\\", "array_slice", "(", "$", "this", "->", "history", ",", "$", "histsize", "-", "$", "this", "->", "historySize", ")", ";", "}", "}", "$", "this", "->", "history", "=", "\\", "array_values", "(", "$", "this", "->", "history", ")", ";", "return", "true", ";", "}" ]

[ "{" ]

[ "private", "function", "getStdin", "(", ")", "{", "if", "(", "!", "isset", "(", "$", "this", "->", "stdin", ")", ")", "{", "$", "this", "->", "stdin", "=", "\\", "fopen", "(", "'php://stdin'", ",", "'r'", ")", ";", "}", "if", "(", "\\", "feof", "(", "$", "this", "->", "stdin", ")", ")", "{", "throw", "new", "BreakException", "(", "'Ctrl+D'", ")", ";", "}", "return", "$", "this", "->", "stdin", ";", "}" ]

[ "Get", "a", "STDIN", "file", "handle", "." ]

[ "public", "function", "getMatches", "(", "array", "$", "tokens", ",", "array", "$", "info", "=", "[", "]", ")", "{", "$", "var", "=", "\\", "str_replace", "(", "'$'", ",", "''", ",", "$", "this", "->", "getInput", "(", "$", "tokens", ")", ")", ";", "return", "\\", "array_filter", "(", "\\", "array_keys", "(", "$", "this", "->", "getVariables", "(", ")", ")", ",", "function", "(", "$", "variable", ")", "use", "(", "$", "var", ")", "{", "return", "AbstractMatcher", "::", "startsWith", "(", "$", "var", ",", "$", "variable", ")", ";", "}", ")", ";", "}" ]

[ "{" ]

[ "public", "function", "hasMatched", "(", "array", "$", "tokens", ")", "{", "$", "token", "=", "\\", "array_pop", "(", "$", "tokens", ")", ";", "switch", "(", "true", ")", "{", "case", "self", "::", "hasToken", "(", "[", "self", "::", "T_OPEN_TAG", ",", "self", "::", "T_VARIABLE", "]", ",", "$", "token", ")", ":", "case", "\\", "is_string", "(", "$", "token", ")", "&&", "$", "token", "===", "'$'", ":", "case", "self", "::", "isOperator", "(", "$", "token", ")", ":", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "{" ]

[ "public", "function", "getMatches", "(", "array", "$", "tokens", ",", "array", "$", "info", "=", "[", "]", ")", "{", "$", "input", "=", "$", "this", "->", "getInput", "(", "$", "tokens", ")", ";", "$", "firstToken", "=", "\\", "array_pop", "(", "$", "tokens", ")", ";", "if", "(", "self", "::", "tokenIs", "(", "$", "firstToken", ",", "self", "::", "T_STRING", ")", ")", "{", "// second token is the object operator", "\\", "array_pop", "(", "$", "tokens", ")", ";", "}", "$", "objectToken", "=", "\\", "array_pop", "(", "$", "tokens", ")", ";", "$", "objectName", "=", "\\", "str_replace", "(", "'$'", ",", "''", ",", "$", "objectToken", "[", "1", "]", ")", ";", "$", "object", "=", "$", "this", "->", "getVariable", "(", "$", "objectName", ")", ";", "if", "(", "!", "$", "object", "instanceof", "\\", "MongoDB", ")", "{", "return", "[", "]", ";", "}", "return", "\\", "array_filter", "(", "$", "object", "->", "getCollectionNames", "(", ")", ",", "function", "(", "$", "var", ")", "use", "(", "$", "input", ")", "{", "return", "AbstractMatcher", "::", "startsWith", "(", "$", "input", ",", "$", "var", ")", ";", "}", ")", ";", "}" ]

[ "{" ]

[ "public", "function", "hasMatched", "(", "array", "$", "tokens", ")", "{", "$", "token", "=", "\\", "array_pop", "(", "$", "tokens", ")", ";", "$", "prevToken", "=", "\\", "array_pop", "(", "$", "tokens", ")", ";", "switch", "(", "true", ")", "{", "case", "self", "::", "tokenIs", "(", "$", "token", ",", "self", "::", "T_OBJECT_OPERATOR", ")", ":", "case", "self", "::", "tokenIs", "(", "$", "prevToken", ",", "self", "::", "T_OBJECT_OPERATOR", ")", ":", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "{" ]

[ "protected", "function", "listItems", "(", "InputInterface", "$", "input", ",", "\\", "Reflector", "$", "reflector", "=", "null", ",", "$", "target", "=", "null", ")", "{", "// only list constants when no Reflector is present.", "//", "// @todo make a NamespaceReflector and pass that in for commands like:", "//", "// ls --constants Foo", "//", "// ... for listing constants in the Foo namespace", "if", "(", "$", "reflector", "!==", "null", "||", "$", "target", "!==", "null", ")", "{", "return", ";", "}", "// only list constants if we are specifically asked", "if", "(", "!", "$", "input", "->", "getOption", "(", "'constants'", ")", ")", "{", "return", ";", "}", "$", "user", "=", "$", "input", "->", "getOption", "(", "'user'", ")", ";", "$", "internal", "=", "$", "input", "->", "getOption", "(", "'internal'", ")", ";", "$", "category", "=", "$", "input", "->", "getOption", "(", "'category'", ")", ";", "$", "ret", "=", "[", "]", ";", "if", "(", "$", "user", ")", "{", "$", "ret", "[", "'User Constants'", "]", "=", "$", "this", "->", "getConstants", "(", "'user'", ")", ";", "}", "if", "(", "$", "internal", ")", "{", "$", "ret", "[", "'Interal Constants'", "]", "=", "$", "this", "->", "getConstants", "(", "'internal'", ")", ";", "}", "if", "(", "$", "category", ")", "{", "$", "label", "=", "\\", "ucfirst", "(", "$", "category", ")", ".", "' Constants'", ";", "$", "ret", "[", "$", "label", "]", "=", "$", "this", "->", "getConstants", "(", "$", "category", ")", ";", "}", "if", "(", "!", "$", "user", "&&", "!", "$", "internal", "&&", "!", "$", "category", ")", "{", "$", "ret", "[", "'Constants'", "]", "=", "$", "this", "->", "getConstants", "(", ")", ";", "}", "return", "\\", "array_map", "(", "[", "$", "this", ",", "'prepareConstants'", "]", ",", "\\", "array_filter", "(", "$", "ret", ")", ")", ";", "}" ]

[ "{" ]

[ "protected", "function", "getConstants", "(", "$", "category", "=", "null", ")", "{", "if", "(", "!", "$", "category", ")", "{", "return", "\\", "get_defined_constants", "(", ")", ";", "}", "$", "consts", "=", "\\", "get_defined_constants", "(", "true", ")", ";", "if", "(", "$", "category", "===", "'internal'", ")", "{", "unset", "(", "$", "consts", "[", "'user'", "]", ")", ";", "return", "\\", "call_user_func_array", "(", "'array_merge'", ",", "$", "consts", ")", ";", "}", "return", "isset", "(", "$", "consts", "[", "$", "category", "]", ")", "?", "$", "consts", "[", "$", "category", "]", ":", "[", "]", ";", "}" ]

[ "Get", "defined", "constants", "." ]

[ "protected", "function", "prepareConstants", "(", "array", "$", "constants", ")", "{", "// My kingdom for a generator.", "$", "ret", "=", "[", "]", ";", "$", "names", "=", "\\", "array_keys", "(", "$", "constants", ")", ";", "\\", "natcasesort", "(", "$", "names", ")", ";", "foreach", "(", "$", "names", "as", "$", "name", ")", "{", "if", "(", "$", "this", "->", "showItem", "(", "$", "name", ")", ")", "{", "$", "ret", "[", "$", "name", "]", "=", "[", "'name'", "=>", "$", "name", ",", "'style'", "=>", "self", "::", "IS_CONSTANT", ",", "'value'", "=>", "$", "this", "->", "presentRef", "(", "$", "constants", "[", "$", "name", "]", ")", ",", "]", ";", "}", "}", "return", "$", "ret", ";", "}" ]

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

[ "private", "function", "reload", "(", "Shell", "$", "shell", ")", "{", "\\", "clearstatcache", "(", ")", ";", "$", "modified", "=", "[", "]", ";", "foreach", "(", "\\", "get_included_files", "(", ")", "as", "$", "file", ")", "{", "$", "timestamp", "=", "\\", "filemtime", "(", "$", "file", ")", ";", "if", "(", "!", "isset", "(", "$", "this", "->", "timestamps", "[", "$", "file", "]", ")", ")", "{", "$", "this", "->", "timestamps", "[", "$", "file", "]", "=", "$", "timestamp", ";", "continue", ";", "}", "if", "(", "$", "this", "->", "timestamps", "[", "$", "file", "]", "===", "$", "timestamp", ")", "{", "continue", ";", "}", "if", "(", "!", "$", "this", "->", "lintFile", "(", "$", "file", ")", ")", "{", "$", "msg", "=", "\\", "sprintf", "(", "'Modified file \"%s\" could not be reloaded'", ",", "$", "file", ")", ";", "$", "shell", "->", "writeException", "(", "new", "ParseErrorException", "(", "$", "msg", ")", ")", ";", "continue", ";", "}", "$", "modified", "[", "]", "=", "$", "file", ";", "$", "this", "->", "timestamps", "[", "$", "file", "]", "=", "$", "timestamp", ";", "}", "// switch (count($modified)) {", "// case 0:", "// return;", "// case 1:", "// printf(\"Reloading modified file: \\\"%s\\\"\\n\", str_replace(getcwd(), '.', $file));", "// break;", "// default:", "// printf(\"Reloading %d modified files\\n\", count($modified));", "// break;", "// }", "foreach", "(", "$", "modified", "as", "$", "file", ")", "{", "runkit_import", "(", "$", "file", ",", "(", "RUNKIT_IMPORT_FUNCTIONS", "|", "RUNKIT_IMPORT_CLASSES", "|", "RUNKIT_IMPORT_CLASS_METHODS", "|", "RUNKIT_IMPORT_CLASS_CONSTS", "|", "RUNKIT_IMPORT_CLASS_PROPS", "|", "RUNKIT_IMPORT_OVERRIDE", ")", ")", ";", "}", "}" ]

[ "Look", "through", "included", "files", "and", "update", "anything", "with", "a", "new", "timestamp", "." ]

[ "private", "function", "lintFile", "(", "$", "file", ")", "{", "// first try to parse it", "try", "{", "$", "this", "->", "parser", "->", "parse", "(", "\\", "file_get_contents", "(", "$", "file", ")", ")", ";", "}", "catch", "(", "\\", "Exception", "$", "e", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Should", "this", "file", "be", "re", "-", "imported?" ]

[ "protected", "function", "execute", "(", "InputInterface", "$", "input", ",", "OutputInterface", "$", "output", ")", "{", "$", "buf", "=", "$", "this", "->", "getApplication", "(", ")", "->", "getCodeBuffer", "(", ")", ";", "if", "(", "$", "input", "->", "getOption", "(", "'clear'", ")", ")", "{", "$", "this", "->", "getApplication", "(", ")", "->", "resetCodeBuffer", "(", ")", ";", "$", "output", "->", "writeln", "(", "$", "this", "->", "formatLines", "(", "$", "buf", ",", "'urgent'", ")", ",", "ShellOutput", "::", "NUMBER_LINES", ")", ";", "}", "else", "{", "$", "output", "->", "writeln", "(", "$", "this", "->", "formatLines", "(", "$", "buf", ")", ",", "ShellOutput", "::", "NUMBER_LINES", ")", ";", "}", "}" ]

[ "{" ]

[ "protected", "function", "formatLines", "(", "array", "$", "lines", ",", "$", "type", "=", "'return'", ")", "{", "$", "template", "=", "\\", "sprintf", "(", "'<%s>%%s</%s>'", ",", "$", "type", ",", "$", "type", ")", ";", "return", "\\", "array_map", "(", "function", "(", "$", "line", ")", "use", "(", "$", "template", ")", "{", "return", "\\", "sprintf", "(", "$", "template", ",", "$", "line", ")", ";", "}", ",", "$", "lines", ")", ";", "}" ]

[ "A", "helper", "method", "for", "wrapping", "buffer", "lines", "in", "<urgent", ">", "and", "<return", ">", "formatter", "strings", "." ]

[ "public", "static", "function", "format", "(", "\\", "Reflector", "$", "reflector", ")", "{", "switch", "(", "true", ")", "{", "case", "$", "reflector", "instanceof", "\\", "ReflectionFunction", ":", "case", "$", "reflector", "instanceof", "ReflectionLanguageConstruct", ":", "return", "self", "::", "formatFunction", "(", "$", "reflector", ")", ";", "// this case also covers \\ReflectionObject:", "case", "$", "reflector", "instanceof", "\\", "ReflectionClass", ":", "return", "self", "::", "formatClass", "(", "$", "reflector", ")", ";", "case", "$", "reflector", "instanceof", "ReflectionClassConstant", ":", "case", "$", "reflector", "instanceof", "\\", "ReflectionClassConstant", ":", "return", "self", "::", "formatClassConstant", "(", "$", "reflector", ")", ";", "case", "$", "reflector", "instanceof", "\\", "ReflectionMethod", ":", "return", "self", "::", "formatMethod", "(", "$", "reflector", ")", ";", "case", "$", "reflector", "instanceof", "\\", "ReflectionProperty", ":", "return", "self", "::", "formatProperty", "(", "$", "reflector", ")", ";", "case", "$", "reflector", "instanceof", "ReflectionConstant_", ":", "return", "self", "::", "formatConstant", "(", "$", "reflector", ")", ";", "default", ":", "throw", "new", "\\", "InvalidArgumentException", "(", "'Unexpected Reflector class: '", ".", "\\", "get_class", "(", "$", "reflector", ")", ")", ";", "}", "}" ]

[ "Format", "a", "signature", "for", "the", "given", "reflector", "." ]

[ "private", "static", "function", "formatModifiers", "(", "\\", "Reflector", "$", "reflector", ")", "{", "if", "(", "$", "reflector", "instanceof", "\\", "ReflectionClass", "&&", "$", "reflector", "->", "isTrait", "(", ")", ")", "{", "// For some reason, PHP 5.x returns `abstract public` modifiers for", "// traits. Let's just ignore that business entirely.", "if", "(", "\\", "version_compare", "(", "PHP_VERSION", ",", "'7.0.0'", ",", "'<'", ")", ")", "{", "return", "[", "]", ";", "}", "}", "return", "\\", "implode", "(", "' '", ",", "\\", "array_map", "(", "function", "(", "$", "modifier", ")", "{", "return", "\\", "sprintf", "(", "'<keyword>%s</keyword>'", ",", "$", "modifier", ")", ";", "}", ",", "\\", "Reflection", "::", "getModifierNames", "(", "$", "reflector", "->", "getModifiers", "(", ")", ")", ")", ")", ";", "}" ]

[ "Print", "the", "method", "property", "or", "class", "modifiers", "." ]

[ "private", "static", "function", "formatClass", "(", "\\", "ReflectionClass", "$", "reflector", ")", "{", "$", "chunks", "=", "[", "]", ";", "if", "(", "$", "modifiers", "=", "self", "::", "formatModifiers", "(", "$", "reflector", ")", ")", "{", "$", "chunks", "[", "]", "=", "$", "modifiers", ";", "}", "if", "(", "$", "reflector", "->", "isTrait", "(", ")", ")", "{", "$", "chunks", "[", "]", "=", "'trait'", ";", "}", "else", "{", "$", "chunks", "[", "]", "=", "$", "reflector", "->", "isInterface", "(", ")", "?", "'interface'", ":", "'class'", ";", "}", "$", "chunks", "[", "]", "=", "\\", "sprintf", "(", "'<class>%s</class>'", ",", "self", "::", "formatName", "(", "$", "reflector", ")", ")", ";", "if", "(", "$", "parent", "=", "$", "reflector", "->", "getParentClass", "(", ")", ")", "{", "$", "chunks", "[", "]", "=", "'extends'", ";", "$", "chunks", "[", "]", "=", "\\", "sprintf", "(", "'<class>%s</class>'", ",", "$", "parent", "->", "getName", "(", ")", ")", ";", "}", "$", "interfaces", "=", "$", "reflector", "->", "getInterfaceNames", "(", ")", ";", "if", "(", "!", "empty", "(", "$", "interfaces", ")", ")", "{", "\\", "sort", "(", "$", "interfaces", ")", ";", "$", "chunks", "[", "]", "=", "'implements'", ";", "$", "chunks", "[", "]", "=", "\\", "implode", "(", "', '", ",", "\\", "array_map", "(", "function", "(", "$", "name", ")", "{", "return", "\\", "sprintf", "(", "'<class>%s</class>'", ",", "$", "name", ")", ";", "}", ",", "$", "interfaces", ")", ")", ";", "}", "return", "\\", "implode", "(", "' '", ",", "$", "chunks", ")", ";", "}" ]

[ "Format", "a", "class", "signature", "." ]

[ "private", "static", "function", "formatClassConstant", "(", "$", "reflector", ")", "{", "$", "value", "=", "$", "reflector", "->", "getValue", "(", ")", ";", "$", "style", "=", "self", "::", "getTypeStyle", "(", "$", "value", ")", ";", "return", "\\", "sprintf", "(", "'<keyword>const</keyword> <const>%s</const> = <%s>%s</%s>'", ",", "self", "::", "formatName", "(", "$", "reflector", ")", ",", "$", "style", ",", "OutputFormatter", "::", "escape", "(", "Json", "::", "encode", "(", "$", "value", ")", ")", ",", "$", "style", ")", ";", "}" ]

[ "Format", "a", "constant", "signature", "." ]

[ "private", "static", "function", "formatConstant", "(", "$", "reflector", ")", "{", "$", "value", "=", "$", "reflector", "->", "getValue", "(", ")", ";", "$", "style", "=", "self", "::", "getTypeStyle", "(", "$", "value", ")", ";", "return", "\\", "sprintf", "(", "'<keyword>define</keyword>(<string>%s</string>, <%s>%s</%s>)'", ",", "OutputFormatter", "::", "escape", "(", "Json", "::", "encode", "(", "$", "reflector", "->", "getName", "(", ")", ")", ")", ",", "$", "style", ",", "OutputFormatter", "::", "escape", "(", "Json", "::", "encode", "(", "$", "value", ")", ")", ",", "$", "style", ")", ";", "}" ]

[ "Format", "a", "constant", "signature", "." ]

[ "private", "static", "function", "getTypeStyle", "(", "$", "value", ")", "{", "if", "(", "\\", "is_int", "(", "$", "value", ")", "||", "\\", "is_float", "(", "$", "value", ")", ")", "{", "return", "'number'", ";", "}", "elseif", "(", "\\", "is_string", "(", "$", "value", ")", ")", "{", "return", "'string'", ";", "}", "elseif", "(", "\\", "is_bool", "(", "$", "value", ")", "||", "\\", "is_null", "(", "$", "value", ")", ")", "{", "return", "'bool'", ";", "}", "else", "{", "return", "'strong'", ";", "// @codeCoverageIgnore", "}", "}" ]

[ "Helper", "for", "getting", "output", "style", "for", "a", "given", "value", "s", "type", "." ]

[ "private", "static", "function", "formatFunction", "(", "\\", "ReflectionFunctionAbstract", "$", "reflector", ")", "{", "return", "\\", "sprintf", "(", "'<keyword>function</keyword> %s<function>%s</function>(%s)'", ",", "$", "reflector", "->", "returnsReference", "(", ")", "?", "'&'", ":", "''", ",", "self", "::", "formatName", "(", "$", "reflector", ")", ",", "\\", "implode", "(", "', '", ",", "self", "::", "formatFunctionParams", "(", "$", "reflector", ")", ")", ")", ";", "}" ]

[ "Format", "a", "function", "signature", "." ]

[ "private", "static", "function", "formatMethod", "(", "\\", "ReflectionMethod", "$", "reflector", ")", "{", "return", "\\", "sprintf", "(", "'%s %s'", ",", "self", "::", "formatModifiers", "(", "$", "reflector", ")", ",", "self", "::", "formatFunction", "(", "$", "reflector", ")", ")", ";", "}" ]

[ "Format", "a", "method", "signature", "." ]

[ "private", "static", "function", "formatFunctionParams", "(", "\\", "ReflectionFunctionAbstract", "$", "reflector", ")", "{", "$", "params", "=", "[", "]", ";", "foreach", "(", "$", "reflector", "->", "getParameters", "(", ")", "as", "$", "param", ")", "{", "$", "hint", "=", "''", ";", "try", "{", "if", "(", "$", "param", "->", "isArray", "(", ")", ")", "{", "$", "hint", "=", "'<keyword>array</keyword> '", ";", "}", "elseif", "(", "$", "class", "=", "$", "param", "->", "getClass", "(", ")", ")", "{", "$", "hint", "=", "\\", "sprintf", "(", "'<class>%s</class> '", ",", "$", "class", "->", "getName", "(", ")", ")", ";", "}", "}", "catch", "(", "\\", "Exception", "$", "e", ")", "{", "// sometimes we just don't know...", "// bad class names, or autoloaded classes that haven't been loaded yet, or whathaveyou.", "// come to think of it, the only time I've seen this is with the intl extension.", "// Hax: we'll try to extract it :P", "// @codeCoverageIgnoreStart", "$", "chunks", "=", "\\", "explode", "(", "'$'", ".", "$", "param", "->", "getName", "(", ")", ",", "(", "string", ")", "$", "param", ")", ";", "$", "chunks", "=", "\\", "explode", "(", "' '", ",", "\\", "trim", "(", "$", "chunks", "[", "0", "]", ")", ")", ";", "$", "guess", "=", "\\", "end", "(", "$", "chunks", ")", ";", "$", "hint", "=", "\\", "sprintf", "(", "'<urgent>%s</urgent> '", ",", "$", "guess", ")", ";", "// @codeCoverageIgnoreEnd", "}", "if", "(", "$", "param", "->", "isOptional", "(", ")", ")", "{", "if", "(", "!", "$", "param", "->", "isDefaultValueAvailable", "(", ")", ")", "{", "$", "value", "=", "'unknown'", ";", "$", "typeStyle", "=", "'urgent'", ";", "}", "else", "{", "$", "value", "=", "$", "param", "->", "getDefaultValue", "(", ")", ";", "$", "typeStyle", "=", "self", "::", "getTypeStyle", "(", "$", "value", ")", ";", "$", "value", "=", "\\", "is_array", "(", "$", "value", ")", "?", "'array()'", ":", "\\", "is_null", "(", "$", "value", ")", "?", "'null'", ":", "\\", "var_export", "(", "$", "value", ",", "true", ")", ";", "}", "$", "default", "=", "\\", "sprintf", "(", "' = <%s>%s</%s>'", ",", "$", "typeStyle", ",", "OutputFormatter", "::", "escape", "(", "$", "value", ")", ",", "$", "typeStyle", ")", ";", "}", "else", "{", "$", "default", "=", "''", ";", "}", "$", "params", "[", "]", "=", "\\", "sprintf", "(", "'%s%s<strong>$%s</strong>%s'", ",", "$", "param", "->", "isPassedByReference", "(", ")", "?", "'&'", ":", "''", ",", "$", "hint", ",", "$", "param", "->", "getName", "(", ")", ",", "$", "default", ")", ";", "}", "return", "$", "params", ";", "}" ]

[ "Print", "the", "function", "params", "." ]

[ "protected", "function", "setComment", "(", "$", "comment", ")", "{", "$", "this", "->", "desc", "=", "''", ";", "$", "this", "->", "tags", "=", "[", "]", ";", "$", "this", "->", "comment", "=", "$", "comment", ";", "$", "this", "->", "parseComment", "(", "$", "comment", ")", ";", "}" ]

[ "Set", "and", "parse", "the", "docblock", "comment", "." ]

[ "protected", "static", "function", "prefixLength", "(", "array", "$", "lines", ")", "{", "// find only lines with interesting things", "$", "lines", "=", "\\", "array_filter", "(", "$", "lines", ",", "function", "(", "$", "line", ")", "{", "return", "\\", "substr", "(", "$", "line", ",", "\\", "strspn", "(", "$", "line", ",", "\"* \\t\\n\\r\\0\\x0B\"", ")", ")", ";", "}", ")", ";", "// if we sort the lines, we only have to compare two items", "\\", "sort", "(", "$", "lines", ")", ";", "$", "first", "=", "\\", "reset", "(", "$", "lines", ")", ";", "$", "last", "=", "\\", "end", "(", "$", "lines", ")", ";", "// find the longest common substring", "$", "count", "=", "\\", "min", "(", "\\", "strlen", "(", "$", "first", ")", ",", "\\", "strlen", "(", "$", "last", ")", ")", ";", "for", "(", "$", "i", "=", "0", ";", "$", "i", "<", "$", "count", ";", "$", "i", "++", ")", "{", "if", "(", "$", "first", "[", "$", "i", "]", "!==", "$", "last", "[", "$", "i", "]", ")", "{", "return", "$", "i", ";", "}", "}", "return", "$", "count", ";", "}" ]

[ "Find", "the", "length", "of", "the", "docblock", "prefix", "." ]

[ "protected", "function", "parseComment", "(", "$", "comment", ")", "{", "// Strip the opening and closing tags of the docblock", "$", "comment", "=", "\\", "substr", "(", "$", "comment", ",", "3", ",", "-", "2", ")", ";", "// Split into arrays of lines", "$", "comment", "=", "\\", "array_filter", "(", "\\", "preg_split", "(", "'/\\r?\\n\\r?/'", ",", "$", "comment", ")", ")", ";", "// Trim asterisks and whitespace from the beginning and whitespace from the end of lines", "$", "prefixLength", "=", "self", "::", "prefixLength", "(", "$", "comment", ")", ";", "$", "comment", "=", "\\", "array_map", "(", "function", "(", "$", "line", ")", "use", "(", "$", "prefixLength", ")", "{", "return", "\\", "rtrim", "(", "\\", "substr", "(", "$", "line", ",", "$", "prefixLength", ")", ")", ";", "}", ",", "$", "comment", ")", ";", "// Group the lines together by @tags", "$", "blocks", "=", "[", "]", ";", "$", "b", "=", "-", "1", ";", "foreach", "(", "$", "comment", "as", "$", "line", ")", "{", "if", "(", "self", "::", "isTagged", "(", "$", "line", ")", ")", "{", "$", "b", "++", ";", "$", "blocks", "[", "]", "=", "[", "]", ";", "}", "elseif", "(", "$", "b", "===", "-", "1", ")", "{", "$", "b", "=", "0", ";", "$", "blocks", "[", "]", "=", "[", "]", ";", "}", "$", "blocks", "[", "$", "b", "]", "[", "]", "=", "$", "line", ";", "}", "// Parse the blocks", "foreach", "(", "$", "blocks", "as", "$", "block", "=>", "$", "body", ")", "{", "$", "body", "=", "\\", "trim", "(", "\\", "implode", "(", "\"\\n\"", ",", "$", "body", ")", ")", ";", "if", "(", "$", "block", "===", "0", "&&", "!", "self", "::", "isTagged", "(", "$", "body", ")", ")", "{", "// This is the description block", "$", "this", "->", "desc", "=", "$", "body", ";", "}", "else", "{", "// This block is tagged", "$", "tag", "=", "\\", "substr", "(", "self", "::", "strTag", "(", "$", "body", ")", ",", "1", ")", ";", "$", "body", "=", "\\", "ltrim", "(", "\\", "substr", "(", "$", "body", ",", "\\", "strlen", "(", "$", "tag", ")", "+", "2", ")", ")", ";", "if", "(", "isset", "(", "self", "::", "$", "vectors", "[", "$", "tag", "]", ")", ")", "{", "// The tagged block is a vector", "$", "count", "=", "\\", "count", "(", "self", "::", "$", "vectors", "[", "$", "tag", "]", ")", ";", "if", "(", "$", "body", ")", "{", "$", "parts", "=", "\\", "preg_split", "(", "'/\\s+/'", ",", "$", "body", ",", "$", "count", ")", ";", "}", "else", "{", "$", "parts", "=", "[", "]", ";", "}", "// Default the trailing values", "$", "parts", "=", "\\", "array_pad", "(", "$", "parts", ",", "$", "count", ",", "null", ")", ";", "// Store as a mapped array", "$", "this", "->", "tags", "[", "$", "tag", "]", "[", "]", "=", "\\", "array_combine", "(", "self", "::", "$", "vectors", "[", "$", "tag", "]", ",", "$", "parts", ")", ";", "}", "else", "{", "// The tagged block is only text", "$", "this", "->", "tags", "[", "$", "tag", "]", "[", "]", "=", "$", "body", ";", "}", "}", "}", "}" ]

[ "Parse", "the", "comment", "into", "the", "component", "parts", "and", "set", "the", "state", "of", "the", "object", "." ]

[ "public", "function", "enterNode", "(", "Node", "$", "node", ")", "{", "if", "(", "$", "node", "instanceof", "Array_", "||", "$", "this", "->", "isCallNode", "(", "$", "node", ")", ")", "{", "$", "items", "=", "$", "node", "instanceof", "Array_", "?", "$", "node", "->", "items", ":", "$", "node", "->", "args", ";", "foreach", "(", "$", "items", "as", "$", "item", ")", "{", "if", "(", "$", "item", "&&", "$", "item", "->", "byRef", "&&", "$", "this", "->", "isCallNode", "(", "$", "item", "->", "value", ")", ")", "{", "throw", "new", "FatalErrorException", "(", "self", "::", "EXCEPTION_MESSAGE", ",", "0", ",", "E_ERROR", ",", "null", ",", "$", "node", "->", "getLine", "(", ")", ")", ";", "}", "}", "}", "elseif", "(", "$", "node", "instanceof", "Isset_", "||", "$", "node", "instanceof", "Unset_", ")", "{", "foreach", "(", "$", "node", "->", "vars", "as", "$", "var", ")", "{", "if", "(", "!", "$", "this", "->", "isCallNode", "(", "$", "var", ")", ")", "{", "continue", ";", "}", "$", "msg", "=", "(", "$", "node", "instanceof", "Isset_", "&&", "$", "this", "->", "atLeastPhp55", ")", "?", "self", "::", "PHP55_MESSAGE", ":", "self", "::", "EXCEPTION_MESSAGE", ";", "throw", "new", "FatalErrorException", "(", "$", "msg", ",", "0", ",", "E_ERROR", ",", "null", ",", "$", "node", "->", "getLine", "(", ")", ")", ";", "}", "}", "elseif", "(", "$", "node", "instanceof", "Empty_", "&&", "!", "$", "this", "->", "atLeastPhp55", "&&", "$", "this", "->", "isCallNode", "(", "$", "node", "->", "expr", ")", ")", "{", "throw", "new", "FatalErrorException", "(", "self", "::", "EXCEPTION_MESSAGE", ",", "0", ",", "E_ERROR", ",", "null", ",", "$", "node", "->", "getLine", "(", ")", ")", ";", "// @codeCoverageIgnore", "}", "elseif", "(", "$", "node", "instanceof", "Assign", "&&", "$", "this", "->", "isCallNode", "(", "$", "node", "->", "var", ")", ")", "{", "throw", "new", "FatalErrorException", "(", "self", "::", "EXCEPTION_MESSAGE", ",", "0", ",", "E_ERROR", ",", "null", ",", "$", "node", "->", "getLine", "(", ")", ")", ";", "}", "}" ]

[ "Validate", "that", "the", "functions", "are", "used", "correctly", "." ]

[ "public", "function", "enterNode", "(", "Node", "$", "node", ")", "{", "parent", "::", "enterNode", "(", "$", "node", ")", ";", "if", "(", "self", "::", "isConditional", "(", "$", "node", ")", ")", "{", "$", "this", "->", "conditionalScopes", "++", ";", "}", "else", "{", "// @todo add an \"else\" here which adds a runtime check for instances where we can't tell", "// whether a class is being redefined by static analysis alone.", "if", "(", "$", "this", "->", "conditionalScopes", "===", "0", ")", "{", "if", "(", "$", "node", "instanceof", "Class_", ")", "{", "$", "this", "->", "validateClassStatement", "(", "$", "node", ")", ";", "}", "elseif", "(", "$", "node", "instanceof", "Interface_", ")", "{", "$", "this", "->", "validateInterfaceStatement", "(", "$", "node", ")", ";", "}", "elseif", "(", "$", "node", "instanceof", "Trait_", ")", "{", "$", "this", "->", "validateTraitStatement", "(", "$", "node", ")", ";", "}", "}", "}", "}" ]

[ "Validate", "class", "interface", "and", "trait", "definitions", "." ]

[ "public", "function", "leaveNode", "(", "Node", "$", "node", ")", "{", "if", "(", "self", "::", "isConditional", "(", "$", "node", ")", ")", "{", "$", "this", "->", "conditionalScopes", "--", ";", "}", "elseif", "(", "$", "node", "instanceof", "New_", ")", "{", "$", "this", "->", "validateNewExpression", "(", "$", "node", ")", ";", "}", "elseif", "(", "$", "node", "instanceof", "ClassConstFetch", ")", "{", "$", "this", "->", "validateClassConstFetchExpression", "(", "$", "node", ")", ";", "}", "elseif", "(", "$", "node", "instanceof", "StaticCall", ")", "{", "$", "this", "->", "validateStaticCallExpression", "(", "$", "node", ")", ";", "}", "}" ]

[ "Validate", "new", "expressions", "class", "constant", "fetches", "and", "static", "calls", "." ]

[ "protected", "function", "validateClassStatement", "(", "Class_", "$", "stmt", ")", "{", "$", "this", "->", "ensureCanDefine", "(", "$", "stmt", ",", "self", "::", "CLASS_TYPE", ")", ";", "if", "(", "isset", "(", "$", "stmt", "->", "extends", ")", ")", "{", "$", "this", "->", "ensureClassExists", "(", "$", "this", "->", "getFullyQualifiedName", "(", "$", "stmt", "->", "extends", ")", ",", "$", "stmt", ")", ";", "}", "$", "this", "->", "ensureInterfacesExist", "(", "$", "stmt", "->", "implements", ",", "$", "stmt", ")", ";", "}" ]

[ "Validate", "a", "class", "definition", "statement", "." ]

[ "protected", "function", "validateInterfaceStatement", "(", "Interface_", "$", "stmt", ")", "{", "$", "this", "->", "ensureCanDefine", "(", "$", "stmt", ",", "self", "::", "INTERFACE_TYPE", ")", ";", "$", "this", "->", "ensureInterfacesExist", "(", "$", "stmt", "->", "extends", ",", "$", "stmt", ")", ";", "}" ]

[ "Validate", "an", "interface", "definition", "statement", "." ]

[ "protected", "function", "validateNewExpression", "(", "New_", "$", "stmt", ")", "{", "// if class name is an expression or an anonymous class, give it a pass for now", "if", "(", "!", "$", "stmt", "->", "class", "instanceof", "Expr", "&&", "!", "$", "stmt", "->", "class", "instanceof", "Class_", ")", "{", "$", "this", "->", "ensureClassExists", "(", "$", "this", "->", "getFullyQualifiedName", "(", "$", "stmt", "->", "class", ")", ",", "$", "stmt", ")", ";", "}", "}" ]

[ "Validate", "a", "new", "expression", "." ]

[ "protected", "function", "validateClassConstFetchExpression", "(", "ClassConstFetch", "$", "stmt", ")", "{", "// there is no need to check exists for ::class const for php 5.5 or newer", "if", "(", "\\", "strtolower", "(", "$", "stmt", "->", "name", ")", "===", "'class'", "&&", "$", "this", "->", "atLeastPhp55", ")", "{", "return", ";", "}", "// if class name is an expression, give it a pass for now", "if", "(", "!", "$", "stmt", "->", "class", "instanceof", "Expr", ")", "{", "$", "this", "->", "ensureClassOrInterfaceExists", "(", "$", "this", "->", "getFullyQualifiedName", "(", "$", "stmt", "->", "class", ")", ",", "$", "stmt", ")", ";", "}", "}" ]

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

[ "protected", "function", "validateStaticCallExpression", "(", "StaticCall", "$", "stmt", ")", "{", "// if class name is an expression, give it a pass for now", "if", "(", "!", "$", "stmt", "->", "class", "instanceof", "Expr", ")", "{", "$", "this", "->", "ensureMethodExists", "(", "$", "this", "->", "getFullyQualifiedName", "(", "$", "stmt", "->", "class", ")", ",", "$", "stmt", "->", "name", ",", "$", "stmt", ")", ";", "}", "}" ]

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

[ "protected", "function", "ensureCanDefine", "(", "Stmt", "$", "stmt", ",", "$", "scopeType", "=", "self", "::", "CLASS_TYPE", ")", "{", "$", "name", "=", "$", "this", "->", "getFullyQualifiedName", "(", "$", "stmt", "->", "name", ")", ";", "// check for name collisions", "$", "errorType", "=", "null", ";", "if", "(", "$", "this", "->", "classExists", "(", "$", "name", ")", ")", "{", "$", "errorType", "=", "self", "::", "CLASS_TYPE", ";", "}", "elseif", "(", "$", "this", "->", "interfaceExists", "(", "$", "name", ")", ")", "{", "$", "errorType", "=", "self", "::", "INTERFACE_TYPE", ";", "}", "elseif", "(", "$", "this", "->", "traitExists", "(", "$", "name", ")", ")", "{", "$", "errorType", "=", "self", "::", "TRAIT_TYPE", ";", "}", "if", "(", "$", "errorType", "!==", "null", ")", "{", "throw", "$", "this", "->", "createError", "(", "\\", "sprintf", "(", "'%s named %s already exists'", ",", "\\", "ucfirst", "(", "$", "errorType", ")", ",", "$", "name", ")", ",", "$", "stmt", ")", ";", "}", "// Store creation for the rest of this code snippet so we can find local", "// issue too", "$", "this", "->", "currentScope", "[", "\\", "strtolower", "(", "$", "name", ")", "]", "=", "$", "scopeType", ";", "}" ]

[ "Ensure", "that", "no", "class", "interface", "or", "trait", "name", "collides", "with", "a", "new", "definition", "." ]

[ "protected", "function", "ensureClassExists", "(", "$", "name", ",", "$", "stmt", ")", "{", "if", "(", "!", "$", "this", "->", "classExists", "(", "$", "name", ")", ")", "{", "throw", "$", "this", "->", "createError", "(", "\\", "sprintf", "(", "'Class \\'%s\\' not found'", ",", "$", "name", ")", ",", "$", "stmt", ")", ";", "}", "}" ]

[ "Ensure", "that", "a", "referenced", "class", "exists", "." ]

[ "protected", "function", "ensureClassOrInterfaceExists", "(", "$", "name", ",", "$", "stmt", ")", "{", "if", "(", "!", "$", "this", "->", "classExists", "(", "$", "name", ")", "&&", "!", "$", "this", "->", "interfaceExists", "(", "$", "name", ")", ")", "{", "throw", "$", "this", "->", "createError", "(", "\\", "sprintf", "(", "'Class \\'%s\\' not found'", ",", "$", "name", ")", ",", "$", "stmt", ")", ";", "}", "}" ]

[ "Ensure", "that", "a", "referenced", "class", "_or", "interface_", "exists", "." ]

[ "protected", "function", "ensureClassOrTraitExists", "(", "$", "name", ",", "$", "stmt", ")", "{", "if", "(", "!", "$", "this", "->", "classExists", "(", "$", "name", ")", "&&", "!", "$", "this", "->", "traitExists", "(", "$", "name", ")", ")", "{", "throw", "$", "this", "->", "createError", "(", "\\", "sprintf", "(", "'Class \\'%s\\' not found'", ",", "$", "name", ")", ",", "$", "stmt", ")", ";", "}", "}" ]

[ "Ensure", "that", "a", "referenced", "class", "_or", "trait_", "exists", "." ]

[ "protected", "function", "ensureMethodExists", "(", "$", "class", ",", "$", "name", ",", "$", "stmt", ")", "{", "$", "this", "->", "ensureClassOrTraitExists", "(", "$", "class", ",", "$", "stmt", ")", ";", "// let's pretend all calls to self, parent and static are valid", "if", "(", "\\", "in_array", "(", "\\", "strtolower", "(", "$", "class", ")", ",", "[", "'self'", ",", "'parent'", ",", "'static'", "]", ")", ")", "{", "return", ";", "}", "// ... and all calls to classes defined right now", "if", "(", "$", "this", "->", "findInScope", "(", "$", "class", ")", "===", "self", "::", "CLASS_TYPE", ")", "{", "return", ";", "}", "// if method name is an expression, give it a pass for now", "if", "(", "$", "name", "instanceof", "Expr", ")", "{", "return", ";", "}", "if", "(", "!", "\\", "method_exists", "(", "$", "class", ",", "$", "name", ")", "&&", "!", "\\", "method_exists", "(", "$", "class", ",", "'__callStatic'", ")", ")", "{", "throw", "$", "this", "->", "createError", "(", "\\", "sprintf", "(", "'Call to undefined method %s::%s()'", ",", "$", "class", ",", "$", "name", ")", ",", "$", "stmt", ")", ";", "}", "}" ]

[ "Ensure", "that", "a", "statically", "called", "method", "exists", "." ]

[ "protected", "function", "ensureInterfacesExist", "(", "$", "interfaces", ",", "$", "stmt", ")", "{", "foreach", "(", "$", "interfaces", "as", "$", "interface", ")", "{", "/** @var string $name */", "$", "name", "=", "$", "this", "->", "getFullyQualifiedName", "(", "$", "interface", ")", ";", "if", "(", "!", "$", "this", "->", "interfaceExists", "(", "$", "name", ")", ")", "{", "throw", "$", "this", "->", "createError", "(", "\\", "sprintf", "(", "'Interface \\'%s\\' not found'", ",", "$", "name", ")", ",", "$", "stmt", ")", ";", "}", "}", "}" ]

[ "Ensure", "that", "a", "referenced", "interface", "exists", "." ]

[ "protected", "function", "getScopeType", "(", "Stmt", "$", "stmt", ")", "{", "if", "(", "$", "stmt", "instanceof", "Class_", ")", "{", "return", "self", "::", "CLASS_TYPE", ";", "}", "elseif", "(", "$", "stmt", "instanceof", "Interface_", ")", "{", "return", "self", "::", "INTERFACE_TYPE", ";", "}", "elseif", "(", "$", "stmt", "instanceof", "Trait_", ")", "{", "return", "self", "::", "TRAIT_TYPE", ";", "}", "}" ]

[ "Get", "a", "symbol", "type", "key", "for", "storing", "in", "the", "scope", "name", "cache", "." ]

[ "protected", "function", "classExists", "(", "$", "name", ")", "{", "// Give `self`, `static` and `parent` a pass. This will actually let", "// some errors through, since we're not checking whether the keyword is", "// being used in a class scope.", "if", "(", "\\", "in_array", "(", "\\", "strtolower", "(", "$", "name", ")", ",", "[", "'self'", ",", "'static'", ",", "'parent'", "]", ")", ")", "{", "return", "true", ";", "}", "return", "\\", "class_exists", "(", "$", "name", ")", "||", "$", "this", "->", "findInScope", "(", "$", "name", ")", "===", "self", "::", "CLASS_TYPE", ";", "}" ]

[ "Check", "whether", "a", "class", "exists", "or", "has", "been", "defined", "in", "the", "current", "code", "snippet", "." ]

[ "protected", "function", "findInScope", "(", "$", "name", ")", "{", "$", "name", "=", "\\", "strtolower", "(", "$", "name", ")", ";", "if", "(", "isset", "(", "$", "this", "->", "currentScope", "[", "$", "name", "]", ")", ")", "{", "return", "$", "this", "->", "currentScope", "[", "$", "name", "]", ";", "}", "}" ]

[ "Find", "a", "symbol", "in", "the", "current", "code", "snippet", "scope", "." ]

[ "public", "static", "function", "fetchProperty", "(", "$", "object", ",", "$", "property", ")", "{", "$", "refl", "=", "new", "\\", "ReflectionObject", "(", "$", "object", ")", ";", "$", "prop", "=", "$", "refl", "->", "getProperty", "(", "$", "property", ")", ";", "$", "prop", "->", "setAccessible", "(", "true", ")", ";", "return", "$", "prop", "->", "getValue", "(", "$", "object", ")", ";", "}" ]

[ "Fetch", "a", "property", "of", "an", "object", "bypassing", "visibility", "restrictions", "." ]

[ "public", "static", "function", "assignProperty", "(", "$", "object", ",", "$", "property", ",", "$", "value", ")", "{", "$", "refl", "=", "new", "\\", "ReflectionObject", "(", "$", "object", ")", ";", "$", "prop", "=", "$", "refl", "->", "getProperty", "(", "$", "property", ")", ";", "$", "prop", "->", "setAccessible", "(", "true", ")", ";", "$", "prop", "->", "setValue", "(", "$", "object", ",", "$", "value", ")", ";", "return", "$", "value", ";", "}" ]

[ "Assign", "the", "value", "of", "a", "property", "of", "an", "object", "bypassing", "visibility", "restrictions", "." ]

[ "public", "static", "function", "callMethod", "(", "$", "object", ",", "$", "method", ",", "$", "args", "=", "null", ")", "{", "$", "args", "=", "\\", "func_get_args", "(", ")", ";", "$", "object", "=", "\\", "array_shift", "(", "$", "args", ")", ";", "$", "method", "=", "\\", "array_shift", "(", "$", "args", ")", ";", "$", "refl", "=", "new", "\\", "ReflectionObject", "(", "$", "object", ")", ";", "$", "reflMethod", "=", "$", "refl", "->", "getMethod", "(", "$", "method", ")", ";", "$", "reflMethod", "->", "setAccessible", "(", "true", ")", ";", "return", "$", "reflMethod", "->", "invokeArgs", "(", "$", "object", ",", "$", "args", ")", ";", "}" ]

[ "Call", "a", "method", "on", "an", "object", "bypassing", "visibility", "restrictions", "." ]

[ "public", "static", "function", "fetchStaticProperty", "(", "$", "class", ",", "$", "property", ")", "{", "$", "refl", "=", "new", "\\", "ReflectionClass", "(", "$", "class", ")", ";", "$", "prop", "=", "$", "refl", "->", "getProperty", "(", "$", "property", ")", ";", "$", "prop", "->", "setAccessible", "(", "true", ")", ";", "return", "$", "prop", "->", "getValue", "(", ")", ";", "}" ]

[ "Fetch", "a", "property", "of", "a", "class", "bypassing", "visibility", "restrictions", "." ]

[ "public", "static", "function", "assignStaticProperty", "(", "$", "class", ",", "$", "property", ",", "$", "value", ")", "{", "$", "refl", "=", "new", "\\", "ReflectionClass", "(", "$", "class", ")", ";", "$", "prop", "=", "$", "refl", "->", "getProperty", "(", "$", "property", ")", ";", "$", "prop", "->", "setAccessible", "(", "true", ")", ";", "$", "prop", "->", "setValue", "(", "$", "value", ")", ";", "return", "$", "value", ";", "}" ]

[ "Assign", "the", "value", "of", "a", "static", "property", "of", "a", "class", "bypassing", "visibility", "restrictions", "." ]

[ "public", "static", "function", "callStatic", "(", "$", "class", ",", "$", "method", ",", "$", "args", "=", "null", ")", "{", "$", "args", "=", "\\", "func_get_args", "(", ")", ";", "$", "class", "=", "\\", "array_shift", "(", "$", "args", ")", ";", "$", "method", "=", "\\", "array_shift", "(", "$", "args", ")", ";", "$", "refl", "=", "new", "\\", "ReflectionClass", "(", "$", "class", ")", ";", "$", "reflMethod", "=", "$", "refl", "->", "getMethod", "(", "$", "method", ")", ";", "$", "reflMethod", "->", "setAccessible", "(", "true", ")", ";", "return", "$", "reflMethod", "->", "invokeArgs", "(", "null", ",", "$", "args", ")", ";", "}" ]

[ "Call", "a", "static", "method", "on", "a", "class", "bypassing", "visibility", "restrictions", "." ]

[ "public", "function", "setCommands", "(", "array", "$", "commands", ")", "{", "$", "names", "=", "[", "]", ";", "foreach", "(", "$", "commands", "as", "$", "command", ")", "{", "$", "names", "=", "\\", "array_merge", "(", "[", "$", "command", "->", "getName", "(", ")", "]", ",", "$", "names", ")", ";", "$", "names", "=", "\\", "array_merge", "(", "$", "command", "->", "getAliases", "(", ")", ",", "$", "names", ")", ";", "}", "$", "this", "->", "commands", "=", "$", "names", ";", "}" ]

[ "Set", "Commands", "for", "completion", "." ]

[ "protected", "function", "matchCommand", "(", "$", "name", ")", "{", "foreach", "(", "$", "this", "->", "commands", "as", "$", "cmd", ")", "{", "if", "(", "$", "this", "->", "startsWith", "(", "$", "name", ",", "$", "cmd", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Check", "whether", "input", "matches", "a", "defined", "command", "." ]

[ "public", "function", "getMatches", "(", "array", "$", "tokens", ",", "array", "$", "info", "=", "[", "]", ")", "{", "$", "input", "=", "$", "this", "->", "getInput", "(", "$", "tokens", ")", ";", "return", "\\", "array_filter", "(", "$", "this", "->", "commands", ",", "function", "(", "$", "command", ")", "use", "(", "$", "input", ")", "{", "return", "AbstractMatcher", "::", "startsWith", "(", "$", "input", ",", "$", "command", ")", ";", "}", ")", ";", "}" ]

[ "{" ]

[ "public", "function", "hasMatched", "(", "array", "$", "tokens", ")", "{", "/* $openTag */", "\\", "array_shift", "(", "$", "tokens", ")", ";", "$", "command", "=", "\\", "array_shift", "(", "$", "tokens", ")", ";", "switch", "(", "true", ")", "{", "case", "self", "::", "tokenIs", "(", "$", "command", ",", "self", "::", "T_STRING", ")", "&&", "!", "$", "this", "->", "isCommand", "(", "$", "command", "[", "1", "]", ")", "&&", "$", "this", "->", "matchCommand", "(", "$", "command", "[", "1", "]", ")", "&&", "empty", "(", "$", "tokens", ")", ":", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "{" ]

[ "public", "static", "function", "export", "(", "$", "class", ",", "$", "name", ",", "$", "return", "=", "false", ")", "{", "$", "refl", "=", "new", "self", "(", "$", "class", ",", "$", "name", ")", ";", "$", "value", "=", "$", "refl", "->", "getValue", "(", ")", ";", "$", "str", "=", "\\", "sprintf", "(", "'Constant [ public %s %s ] { %s }'", ",", "\\", "gettype", "(", "$", "value", ")", ",", "$", "refl", "->", "getName", "(", ")", ",", "$", "value", ")", ";", "if", "(", "$", "return", ")", "{", "return", "$", "str", ";", "}", "echo", "$", "str", ".", "\"\\n\"", ";", "}" ]

[ "Exports", "a", "reflection", "." ]

[ "public", "function", "getDeclaringClass", "(", ")", "{", "$", "parent", "=", "$", "this", "->", "class", ";", "// Since we don't have real reflection constants, we can't see where", "// it's actually defined. Let's check for a constant that is also", "// available on the parent class which has exactly the same value.", "//", "// While this isn't _technically_ correct, it's prolly close enough.", "do", "{", "$", "class", "=", "$", "parent", ";", "$", "parent", "=", "$", "class", "->", "getParentClass", "(", ")", ";", "}", "while", "(", "$", "parent", "&&", "$", "parent", "->", "hasConstant", "(", "$", "this", "->", "name", ")", "&&", "$", "parent", "->", "getConstant", "(", "$", "this", "->", "name", ")", "===", "$", "this", "->", "value", ")", ";", "return", "$", "class", ";", "}" ]

[ "Gets", "the", "declaring", "class", "." ]

[ "protected", "function", "getTarget", "(", "$", "valueName", ")", "{", "$", "valueName", "=", "\\", "trim", "(", "$", "valueName", ")", ";", "$", "matches", "=", "[", "]", ";", "switch", "(", "true", ")", "{", "case", "\\", "preg_match", "(", "self", "::", "CLASS_OR_FUNC", ",", "$", "valueName", ",", "$", "matches", ")", ":", "return", "[", "$", "this", "->", "resolveName", "(", "$", "matches", "[", "0", "]", ",", "true", ")", ",", "null", ",", "0", "]", ";", "case", "\\", "preg_match", "(", "self", "::", "CLASS_MEMBER", ",", "$", "valueName", ",", "$", "matches", ")", ":", "return", "[", "$", "this", "->", "resolveName", "(", "$", "matches", "[", "1", "]", ")", ",", "$", "matches", "[", "2", "]", ",", "Mirror", "::", "CONSTANT", "|", "Mirror", "::", "METHOD", "]", ";", "case", "\\", "preg_match", "(", "self", "::", "CLASS_STATIC", ",", "$", "valueName", ",", "$", "matches", ")", ":", "return", "[", "$", "this", "->", "resolveName", "(", "$", "matches", "[", "1", "]", ")", ",", "$", "matches", "[", "2", "]", ",", "Mirror", "::", "STATIC_PROPERTY", "|", "Mirror", "::", "PROPERTY", "]", ";", "case", "\\", "preg_match", "(", "self", "::", "INSTANCE_MEMBER", ",", "$", "valueName", ",", "$", "matches", ")", ":", "if", "(", "$", "matches", "[", "2", "]", "===", "'->'", ")", "{", "$", "kind", "=", "Mirror", "::", "METHOD", "|", "Mirror", "::", "PROPERTY", ";", "}", "else", "{", "$", "kind", "=", "Mirror", "::", "CONSTANT", "|", "Mirror", "::", "METHOD", ";", "}", "return", "[", "$", "this", "->", "resolveObject", "(", "$", "matches", "[", "1", "]", ")", ",", "$", "matches", "[", "3", "]", ",", "$", "kind", "]", ";", "default", ":", "return", "[", "$", "this", "->", "resolveObject", "(", "$", "valueName", ")", ",", "null", ",", "0", "]", ";", "}", "}" ]

[ "Get", "the", "target", "for", "a", "value", "." ]

[ "protected", "function", "resolveName", "(", "$", "name", ",", "$", "includeFunctions", "=", "false", ")", "{", "$", "shell", "=", "$", "this", "->", "getApplication", "(", ")", ";", "// While not *technically* 100% accurate, let's treat `self` and `static` as equivalent.", "if", "(", "\\", "in_array", "(", "\\", "strtolower", "(", "$", "name", ")", ",", "[", "'self'", ",", "'static'", "]", ")", ")", "{", "if", "(", "$", "boundClass", "=", "$", "shell", "->", "getBoundClass", "(", ")", ")", "{", "return", "$", "boundClass", ";", "}", "if", "(", "$", "boundObject", "=", "$", "shell", "->", "getBoundObject", "(", ")", ")", "{", "return", "\\", "get_class", "(", "$", "boundObject", ")", ";", "}", "$", "msg", "=", "\\", "sprintf", "(", "'Cannot use \"%s\" when no class scope is active'", ",", "\\", "strtolower", "(", "$", "name", ")", ")", ";", "throw", "new", "ErrorException", "(", "$", "msg", ",", "0", ",", "E_USER_ERROR", ",", "\"eval()'d code\"", ",", "1", ")", ";", "}", "if", "(", "\\", "substr", "(", "$", "name", ",", "0", ",", "1", ")", "===", "'\\\\'", ")", "{", "return", "$", "name", ";", "}", "if", "(", "$", "namespace", "=", "$", "shell", "->", "getNamespace", "(", ")", ")", "{", "$", "fullName", "=", "$", "namespace", ".", "'\\\\'", ".", "$", "name", ";", "if", "(", "\\", "class_exists", "(", "$", "fullName", ")", "||", "\\", "interface_exists", "(", "$", "fullName", ")", "||", "(", "$", "includeFunctions", "&&", "\\", "function_exists", "(", "$", "fullName", ")", ")", ")", "{", "return", "$", "fullName", ";", "}", "}", "return", "$", "name", ";", "}" ]

[ "Resolve", "a", "class", "or", "function", "name", "(", "with", "the", "current", "shell", "namespace", ")", "." ]

[ "protected", "function", "getTargetAndReflector", "(", "$", "valueName", ")", "{", "list", "(", "$", "value", ",", "$", "member", ",", "$", "kind", ")", "=", "$", "this", "->", "getTarget", "(", "$", "valueName", ")", ";", "return", "[", "$", "value", ",", "Mirror", "::", "get", "(", "$", "value", ",", "$", "member", ",", "$", "kind", ")", "]", ";", "}" ]

[ "Get", "a", "Reflector", "and", "documentation", "for", "a", "function", "class", "or", "instance", "constant", "method", "or", "property", "." ]

[ "protected", "function", "resolveCode", "(", "$", "code", ")", "{", "try", "{", "$", "value", "=", "$", "this", "->", "getApplication", "(", ")", "->", "execute", "(", "$", "code", ",", "true", ")", ";", "}", "catch", "(", "\\", "Exception", "$", "e", ")", "{", "// Swallow all exceptions?", "}", "if", "(", "!", "isset", "(", "$", "value", ")", "||", "$", "value", "instanceof", "NoReturnValue", ")", "{", "throw", "new", "RuntimeException", "(", "'Unknown target: '", ".", "$", "code", ")", ";", "}", "return", "$", "value", ";", "}" ]

[ "Resolve", "code", "to", "a", "value", "in", "the", "current", "scope", "." ]

[ "private", "function", "resolveObject", "(", "$", "code", ")", "{", "$", "value", "=", "$", "this", "->", "resolveCode", "(", "$", "code", ")", ";", "if", "(", "!", "\\", "is_object", "(", "$", "value", ")", ")", "{", "throw", "new", "RuntimeException", "(", "'Unable to inspect a non-object'", ")", ";", "}", "return", "$", "value", ";", "}" ]

[ "Resolve", "code", "to", "an", "object", "in", "the", "current", "scope", "." ]

[ "protected", "function", "setCommandScopeVariables", "(", "\\", "Reflector", "$", "reflector", ")", "{", "$", "vars", "=", "[", "]", ";", "switch", "(", "\\", "get_class", "(", "$", "reflector", ")", ")", "{", "case", "'ReflectionClass'", ":", "case", "'ReflectionObject'", ":", "$", "vars", "[", "'__class'", "]", "=", "$", "reflector", "->", "name", ";", "if", "(", "$", "reflector", "->", "inNamespace", "(", ")", ")", "{", "$", "vars", "[", "'__namespace'", "]", "=", "$", "reflector", "->", "getNamespaceName", "(", ")", ";", "}", "break", ";", "case", "'ReflectionMethod'", ":", "$", "vars", "[", "'__method'", "]", "=", "\\", "sprintf", "(", "'%s::%s'", ",", "$", "reflector", "->", "class", ",", "$", "reflector", "->", "name", ")", ";", "$", "vars", "[", "'__class'", "]", "=", "$", "reflector", "->", "class", ";", "$", "classReflector", "=", "$", "reflector", "->", "getDeclaringClass", "(", ")", ";", "if", "(", "$", "classReflector", "->", "inNamespace", "(", ")", ")", "{", "$", "vars", "[", "'__namespace'", "]", "=", "$", "classReflector", "->", "getNamespaceName", "(", ")", ";", "}", "break", ";", "case", "'ReflectionFunction'", ":", "$", "vars", "[", "'__function'", "]", "=", "$", "reflector", "->", "name", ";", "if", "(", "$", "reflector", "->", "inNamespace", "(", ")", ")", "{", "$", "vars", "[", "'__namespace'", "]", "=", "$", "reflector", "->", "getNamespaceName", "(", ")", ";", "}", "break", ";", "case", "'ReflectionGenerator'", ":", "$", "funcReflector", "=", "$", "reflector", "->", "getFunction", "(", ")", ";", "$", "vars", "[", "'__function'", "]", "=", "$", "funcReflector", "->", "name", ";", "if", "(", "$", "funcReflector", "->", "inNamespace", "(", ")", ")", "{", "$", "vars", "[", "'__namespace'", "]", "=", "$", "funcReflector", "->", "getNamespaceName", "(", ")", ";", "}", "if", "(", "$", "fileName", "=", "$", "reflector", "->", "getExecutingFile", "(", ")", ")", "{", "$", "vars", "[", "'__file'", "]", "=", "$", "fileName", ";", "$", "vars", "[", "'__line'", "]", "=", "$", "reflector", "->", "getExecutingLine", "(", ")", ";", "$", "vars", "[", "'__dir'", "]", "=", "\\", "dirname", "(", "$", "fileName", ")", ";", "}", "break", ";", "case", "'ReflectionProperty'", ":", "case", "'ReflectionClassConstant'", ":", "case", "'Psy\\Reflection\\ReflectionClassConstant'", ":", "$", "classReflector", "=", "$", "reflector", "->", "getDeclaringClass", "(", ")", ";", "$", "vars", "[", "'__class'", "]", "=", "$", "classReflector", "->", "name", ";", "if", "(", "$", "classReflector", "->", "inNamespace", "(", ")", ")", "{", "$", "vars", "[", "'__namespace'", "]", "=", "$", "classReflector", "->", "getNamespaceName", "(", ")", ";", "}", "// no line for these, but this'll do", "if", "(", "$", "fileName", "=", "$", "reflector", "->", "getDeclaringClass", "(", ")", "->", "getFileName", "(", ")", ")", "{", "$", "vars", "[", "'__file'", "]", "=", "$", "fileName", ";", "$", "vars", "[", "'__dir'", "]", "=", "\\", "dirname", "(", "$", "fileName", ")", ";", "}", "break", ";", "case", "'Psy\\Reflection\\ReflectionConstant_'", ":", "if", "(", "$", "reflector", "->", "inNamespace", "(", ")", ")", "{", "$", "vars", "[", "'__namespace'", "]", "=", "$", "reflector", "->", "getNamespaceName", "(", ")", ";", "}", "break", ";", "}", "if", "(", "$", "reflector", "instanceof", "\\", "ReflectionClass", "||", "$", "reflector", "instanceof", "\\", "ReflectionFunctionAbstract", ")", "{", "if", "(", "$", "fileName", "=", "$", "reflector", "->", "getFileName", "(", ")", ")", "{", "$", "vars", "[", "'__file'", "]", "=", "$", "fileName", ";", "$", "vars", "[", "'__line'", "]", "=", "$", "reflector", "->", "getStartLine", "(", ")", ";", "$", "vars", "[", "'__dir'", "]", "=", "\\", "dirname", "(", "$", "fileName", ")", ";", "}", "}", "$", "this", "->", "context", "->", "setCommandScopeVariables", "(", "$", "vars", ")", ";", "}" ]

[ "Given", "a", "Reflector", "instance", "set", "command", "-", "scope", "variables", "in", "the", "shell", "execution", "context", ".", "This", "is", "used", "to", "inject", "magic", "$__class", "$__method", "and", "$__file", "variables", "(", "as", "well", "as", "a", "handful", "of", "others", ")", "." ]

[ "protected", "function", "listItems", "(", "InputInterface", "$", "input", ",", "\\", "Reflector", "$", "reflector", "=", "null", ",", "$", "target", "=", "null", ")", "{", "// only list globals when no Reflector is present.", "if", "(", "$", "reflector", "!==", "null", "||", "$", "target", "!==", "null", ")", "{", "return", ";", "}", "// only list globals if we are specifically asked", "if", "(", "!", "$", "input", "->", "getOption", "(", "'globals'", ")", ")", "{", "return", ";", "}", "$", "globals", "=", "$", "this", "->", "prepareGlobals", "(", "$", "this", "->", "getGlobals", "(", ")", ")", ";", "if", "(", "empty", "(", "$", "globals", ")", ")", "{", "return", ";", "}", "return", "[", "'Global Variables'", "=>", "$", "globals", ",", "]", ";", "}" ]

[ "{" ]

[ "protected", "function", "getGlobals", "(", ")", "{", "global", "$", "GLOBALS", ";", "$", "names", "=", "\\", "array_keys", "(", "$", "GLOBALS", ")", ";", "\\", "natcasesort", "(", "$", "names", ")", ";", "$", "ret", "=", "[", "]", ";", "foreach", "(", "$", "names", "as", "$", "name", ")", "{", "$", "ret", "[", "$", "name", "]", "=", "$", "GLOBALS", "[", "$", "name", "]", ";", "}", "return", "$", "ret", ";", "}" ]

[ "Get", "defined", "global", "variables", "." ]

[ "protected", "function", "prepareGlobals", "(", "$", "globals", ")", "{", "// My kingdom for a generator.", "$", "ret", "=", "[", "]", ";", "foreach", "(", "$", "globals", "as", "$", "name", "=>", "$", "value", ")", "{", "if", "(", "$", "this", "->", "showItem", "(", "$", "name", ")", ")", "{", "$", "fname", "=", "'$'", ".", "$", "name", ";", "$", "ret", "[", "$", "fname", "]", "=", "[", "'name'", "=>", "$", "fname", ",", "'style'", "=>", "self", "::", "IS_GLOBAL", ",", "'value'", "=>", "$", "this", "->", "presentRef", "(", "$", "value", ")", ",", "]", ";", "}", "}", "return", "$", "ret", ";", "}" ]

[ "Prepare", "formatted", "global", "variable", "array", "." ]

[ "public", "function", "enterNode", "(", "Node", "$", "node", ")", "{", "if", "(", "$", "node", "instanceof", "Namespace_", ")", "{", "$", "this", "->", "namespace", "=", "isset", "(", "$", "node", "->", "name", ")", "?", "$", "node", "->", "name", "->", "parts", ":", "[", "]", ";", "}", "elseif", "(", "$", "node", "instanceof", "Class_", ")", "{", "$", "constructor", "=", "null", ";", "foreach", "(", "$", "node", "->", "stmts", "as", "$", "stmt", ")", "{", "if", "(", "$", "stmt", "instanceof", "ClassMethod", ")", "{", "// If we find a new-style constructor, no need to look for the old-style", "if", "(", "'__construct'", "===", "\\", "strtolower", "(", "$", "stmt", "->", "name", ")", ")", "{", "$", "this", "->", "validateConstructor", "(", "$", "stmt", ",", "$", "node", ")", ";", "return", ";", "}", "// We found a possible old-style constructor (unless there is also a __construct method)", "if", "(", "empty", "(", "$", "this", "->", "namespace", ")", "&&", "\\", "strtolower", "(", "$", "node", "->", "name", ")", "===", "\\", "strtolower", "(", "$", "stmt", "->", "name", ")", ")", "{", "$", "constructor", "=", "$", "stmt", ";", "}", "}", "}", "if", "(", "$", "constructor", ")", "{", "$", "this", "->", "validateConstructor", "(", "$", "constructor", ",", "$", "node", ")", ";", "}", "}", "}" ]

[ "Validate", "that", "the", "constructor", "is", "not", "static", "and", "does", "not", "have", "a", "return", "type", "." ]

[ "private", "function", "validateConstructor", "(", "Node", "$", "constructor", ",", "Node", "$", "classNode", ")", "{", "if", "(", "$", "constructor", "->", "isStatic", "(", ")", ")", "{", "// For PHP Parser 4.x", "$", "className", "=", "$", "classNode", "->", "name", "instanceof", "Identifier", "?", "$", "classNode", "->", "name", "->", "toString", "(", ")", ":", "$", "classNode", "->", "name", ";", "$", "msg", "=", "\\", "sprintf", "(", "'Constructor %s::%s() cannot be static'", ",", "\\", "implode", "(", "'\\\\'", ",", "\\", "array_merge", "(", "$", "this", "->", "namespace", ",", "(", "array", ")", "$", "className", ")", ")", ",", "$", "constructor", "->", "name", ")", ";", "throw", "new", "FatalErrorException", "(", "$", "msg", ",", "0", ",", "E_ERROR", ",", "null", ",", "$", "classNode", "->", "getLine", "(", ")", ")", ";", "}", "if", "(", "\\", "method_exists", "(", "$", "constructor", ",", "'getReturnType'", ")", "&&", "$", "constructor", "->", "getReturnType", "(", ")", ")", "{", "// For PHP Parser 4.x", "$", "className", "=", "$", "classNode", "->", "name", "instanceof", "Identifier", "?", "$", "classNode", "->", "name", "->", "toString", "(", ")", ":", "$", "classNode", "->", "name", ";", "$", "msg", "=", "\\", "sprintf", "(", "'Constructor %s::%s() cannot declare a return type'", ",", "\\", "implode", "(", "'\\\\'", ",", "\\", "array_merge", "(", "$", "this", "->", "namespace", ",", "(", "array", ")", "$", "className", ")", ")", ",", "$", "constructor", "->", "name", ")", ";", "throw", "new", "FatalErrorException", "(", "$", "msg", ",", "0", ",", "E_ERROR", ",", "null", ",", "$", "classNode", "->", "getLine", "(", ")", ")", ";", "}", "}" ]

[ "@throws", "FatalErrorException", "the", "constructor", "function", "is", "static", "@throws", "FatalErrorException", "the", "constructor", "function", "has", "a", "return", "type" ]

[ "public", "function", "getDefaultParameterCompletion", "(", "array", "$", "reflectionParameters", ")", "{", "$", "parametersProcessed", "=", "[", "]", ";", "foreach", "(", "$", "reflectionParameters", "as", "$", "parameter", ")", "{", "if", "(", "!", "$", "parameter", "->", "isDefaultValueAvailable", "(", ")", ")", "{", "return", "[", "]", ";", "}", "$", "defaultValue", "=", "$", "this", "->", "valueToShortString", "(", "$", "parameter", "->", "getDefaultValue", "(", ")", ")", ";", "$", "parametersProcessed", "[", "]", "=", "\"\\${$parameter->getName()} = $defaultValue\"", ";", "}", "if", "(", "empty", "(", "$", "parametersProcessed", ")", ")", "{", "return", "[", "]", ";", "}", "return", "[", "\\", "implode", "(", "', '", ",", "$", "parametersProcessed", ")", ".", "')'", "]", ";", "}" ]

[ "@param", "\\", "ReflectionParameter", "[]", "$reflectionParameters" ]

[ "private", "function", "valueToShortString", "(", "$", "value", ")", "{", "if", "(", "!", "\\", "is_array", "(", "$", "value", ")", ")", "{", "return", "\\", "json_encode", "(", "$", "value", ")", ";", "}", "$", "chunks", "=", "[", "]", ";", "$", "chunksSequential", "=", "[", "]", ";", "$", "allSequential", "=", "true", ";", "foreach", "(", "$", "value", "as", "$", "key", "=>", "$", "item", ")", "{", "$", "allSequential", "=", "$", "allSequential", "&&", "\\", "is_numeric", "(", "$", "key", ")", "&&", "$", "key", "===", "\\", "count", "(", "$", "chunksSequential", ")", ";", "$", "keyString", "=", "$", "this", "->", "valueToShortString", "(", "$", "key", ")", ";", "$", "itemString", "=", "$", "this", "->", "valueToShortString", "(", "$", "item", ")", ";", "$", "chunks", "[", "]", "=", "\"{$keyString} => {$itemString}\"", ";", "$", "chunksSequential", "[", "]", "=", "$", "itemString", ";", "}", "$", "chunksToImplode", "=", "$", "allSequential", "?", "$", "chunksSequential", ":", "$", "chunks", ";", "return", "'['", ".", "\\", "implode", "(", "', '", ",", "$", "chunksToImplode", ")", ".", "']'", ";", "}" ]

[ "Takes", "in", "the", "default", "value", "of", "a", "parameter", "and", "turns", "it", "into", "a", "string", "representation", "that", "fits", "inline", ".", "This", "is", "not", "100%", "true", "to", "the", "original", "(", "newlines", "are", "inlined", "for", "example", ")", "." ]

[ "public", "function", "getMatches", "(", "array", "$", "tokens", ",", "array", "$", "info", "=", "[", "]", ")", "{", "$", "input", "=", "$", "this", "->", "getInput", "(", "$", "tokens", ")", ";", "$", "firstToken", "=", "\\", "array_pop", "(", "$", "tokens", ")", ";", "if", "(", "self", "::", "tokenIs", "(", "$", "firstToken", ",", "self", "::", "T_STRING", ")", ")", "{", "// second token is the nekudotayim operator", "\\", "array_pop", "(", "$", "tokens", ")", ";", "}", "$", "class", "=", "$", "this", "->", "getNamespaceAndClass", "(", "$", "tokens", ")", ";", "try", "{", "$", "reflection", "=", "new", "\\", "ReflectionClass", "(", "$", "class", ")", ";", "}", "catch", "(", "\\", "ReflectionException", "$", "re", ")", "{", "return", "[", "]", ";", "}", "$", "vars", "=", "\\", "array_merge", "(", "\\", "array_map", "(", "function", "(", "$", "var", ")", "{", "return", "'$'", ".", "$", "var", ";", "}", ",", "\\", "array_keys", "(", "$", "reflection", "->", "getStaticProperties", "(", ")", ")", ")", ",", "\\", "array_keys", "(", "$", "reflection", "->", "getConstants", "(", ")", ")", ")", ";", "return", "\\", "array_map", "(", "function", "(", "$", "name", ")", "use", "(", "$", "class", ")", "{", "$", "chunks", "=", "\\", "explode", "(", "'\\\\'", ",", "$", "class", ")", ";", "$", "className", "=", "\\", "array_pop", "(", "$", "chunks", ")", ";", "return", "$", "className", ".", "'::'", ".", "$", "name", ";", "}", ",", "\\", "array_filter", "(", "$", "vars", ",", "function", "(", "$", "var", ")", "use", "(", "$", "input", ")", "{", "return", "AbstractMatcher", "::", "startsWith", "(", "$", "input", ",", "$", "var", ")", ";", "}", ")", ")", ";", "}" ]

[ "{" ]

[ "public", "function", "hasMatched", "(", "array", "$", "tokens", ")", "{", "$", "token", "=", "\\", "array_pop", "(", "$", "tokens", ")", ";", "$", "prevToken", "=", "\\", "array_pop", "(", "$", "tokens", ")", ";", "switch", "(", "true", ")", "{", "case", "self", "::", "tokenIs", "(", "$", "prevToken", ",", "self", "::", "T_DOUBLE_COLON", ")", "&&", "self", "::", "tokenIs", "(", "$", "token", ",", "self", "::", "T_STRING", ")", ":", "case", "self", "::", "tokenIs", "(", "$", "token", ",", "self", "::", "T_DOUBLE_COLON", ")", ":", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "{" ]

[ "public", "static", "function", "format", "(", "\\", "Reflector", "$", "reflector", ")", "{", "$", "docblock", "=", "new", "Docblock", "(", "$", "reflector", ")", ";", "$", "chunks", "=", "[", "]", ";", "if", "(", "!", "empty", "(", "$", "docblock", "->", "desc", ")", ")", "{", "$", "chunks", "[", "]", "=", "'<comment>Description:</comment>'", ";", "$", "chunks", "[", "]", "=", "self", "::", "indent", "(", "OutputFormatter", "::", "escape", "(", "$", "docblock", "->", "desc", ")", ",", "' '", ")", ";", "$", "chunks", "[", "]", "=", "''", ";", "}", "if", "(", "!", "empty", "(", "$", "docblock", "->", "tags", ")", ")", "{", "foreach", "(", "$", "docblock", "::", "$", "vectors", "as", "$", "name", "=>", "$", "vector", ")", "{", "if", "(", "isset", "(", "$", "docblock", "->", "tags", "[", "$", "name", "]", ")", ")", "{", "$", "chunks", "[", "]", "=", "\\", "sprintf", "(", "'<comment>%s:</comment>'", ",", "self", "::", "inflect", "(", "$", "name", ")", ")", ";", "$", "chunks", "[", "]", "=", "self", "::", "formatVector", "(", "$", "vector", ",", "$", "docblock", "->", "tags", "[", "$", "name", "]", ")", ";", "$", "chunks", "[", "]", "=", "''", ";", "}", "}", "$", "tags", "=", "self", "::", "formatTags", "(", "\\", "array_keys", "(", "$", "docblock", "::", "$", "vectors", ")", ",", "$", "docblock", "->", "tags", ")", ";", "if", "(", "!", "empty", "(", "$", "tags", ")", ")", "{", "$", "chunks", "[", "]", "=", "$", "tags", ";", "$", "chunks", "[", "]", "=", "''", ";", "}", "}", "return", "\\", "rtrim", "(", "\\", "implode", "(", "\"\\n\"", ",", "$", "chunks", ")", ")", ";", "}" ]

[ "Format", "a", "docblock", "." ]

[ "private", "static", "function", "formatVector", "(", "array", "$", "vector", ",", "array", "$", "lines", ")", "{", "$", "template", "=", "[", "' '", "]", ";", "foreach", "(", "$", "vector", "as", "$", "type", ")", "{", "$", "max", "=", "0", ";", "foreach", "(", "$", "lines", "as", "$", "line", ")", "{", "$", "chunk", "=", "$", "line", "[", "$", "type", "]", ";", "$", "cur", "=", "empty", "(", "$", "chunk", ")", "?", "0", ":", "\\", "strlen", "(", "$", "chunk", ")", "+", "1", ";", "if", "(", "$", "cur", ">", "$", "max", ")", "{", "$", "max", "=", "$", "cur", ";", "}", "}", "$", "template", "[", "]", "=", "self", "::", "getVectorParamTemplate", "(", "$", "type", ",", "$", "max", ")", ";", "}", "$", "template", "=", "\\", "implode", "(", "' '", ",", "$", "template", ")", ";", "return", "\\", "implode", "(", "\"\\n\"", ",", "\\", "array_map", "(", "function", "(", "$", "line", ")", "use", "(", "$", "template", ")", "{", "$", "escaped", "=", "\\", "array_map", "(", "[", "'Symfony\\Component\\Console\\Formatter\\OutputFormatter'", ",", "'escape'", "]", ",", "$", "line", ")", ";", "return", "\\", "rtrim", "(", "\\", "vsprintf", "(", "$", "template", ",", "$", "escaped", ")", ")", ";", "}", ",", "$", "lines", ")", ")", ";", "}" ]

[ "Format", "a", "docblock", "vector", "for", "example", "@throws", "@param", "or", "@return", "." ]

[ "private", "static", "function", "formatTags", "(", "array", "$", "skip", ",", "array", "$", "tags", ")", "{", "$", "chunks", "=", "[", "]", ";", "foreach", "(", "$", "tags", "as", "$", "name", "=>", "$", "values", ")", "{", "if", "(", "\\", "in_array", "(", "$", "name", ",", "$", "skip", ")", ")", "{", "continue", ";", "}", "foreach", "(", "$", "values", "as", "$", "value", ")", "{", "$", "chunks", "[", "]", "=", "\\", "sprintf", "(", "'<comment>%s%s</comment> %s'", ",", "self", "::", "inflect", "(", "$", "name", ")", ",", "empty", "(", "$", "value", ")", "?", "''", ":", "':'", ",", "OutputFormatter", "::", "escape", "(", "$", "value", ")", ")", ";", "}", "$", "chunks", "[", "]", "=", "''", ";", "}", "return", "\\", "implode", "(", "\"\\n\"", ",", "$", "chunks", ")", ";", "}" ]

[ "Format", "docblock", "tags", "." ]

[ "private", "static", "function", "getVectorParamTemplate", "(", "$", "type", ",", "$", "max", ")", "{", "if", "(", "!", "isset", "(", "self", "::", "$", "vectorParamTemplates", "[", "$", "type", "]", ")", ")", "{", "return", "\\", "sprintf", "(", "'%%-%ds'", ",", "$", "max", ")", ";", "}", "return", "\\", "sprintf", "(", "'<%s>%%-%ds</%s>'", ",", "self", "::", "$", "vectorParamTemplates", "[", "$", "type", "]", ",", "$", "max", ",", "self", "::", "$", "vectorParamTemplates", "[", "$", "type", "]", ")", ";", "}" ]

[ "Get", "a", "docblock", "vector", "template", "." ]

[ "private", "static", "function", "inflect", "(", "$", "text", ")", "{", "$", "words", "=", "\\", "trim", "(", "\\", "preg_replace", "(", "'/[\\s_-]+/'", ",", "' '", ",", "\\", "preg_replace", "(", "'/([a-z])([A-Z])/'", ",", "'$1 $2'", ",", "$", "text", ")", ")", ")", ";", "return", "\\", "implode", "(", "' '", ",", "\\", "array_map", "(", "'ucfirst'", ",", "\\", "explode", "(", "' '", ",", "$", "words", ")", ")", ")", ";", "}" ]

[ "Convert", "underscored", "or", "whitespace", "separated", "words", "into", "sentence", "case", "." ]

[ "public", "function", "enterNode", "(", "Node", "$", "node", ")", "{", "switch", "(", "true", ")", "{", "case", "$", "node", "instanceof", "Do_", ":", "case", "$", "node", "instanceof", "For_", ":", "case", "$", "node", "instanceof", "Foreach_", ":", "case", "$", "node", "instanceof", "Switch_", ":", "case", "$", "node", "instanceof", "While_", ":", "$", "this", "->", "loopDepth", "++", ";", "break", ";", "case", "$", "node", "instanceof", "Break_", ":", "case", "$", "node", "instanceof", "Continue_", ":", "$", "operator", "=", "$", "node", "instanceof", "Break_", "?", "'break'", ":", "'continue'", ";", "if", "(", "$", "this", "->", "loopDepth", "===", "0", ")", "{", "$", "msg", "=", "\\", "sprintf", "(", "\"'%s' not in the 'loop' or 'switch' context\"", ",", "$", "operator", ")", ";", "throw", "new", "FatalErrorException", "(", "$", "msg", ",", "0", ",", "E_ERROR", ",", "null", ",", "$", "node", "->", "getLine", "(", ")", ")", ";", "}", "if", "(", "$", "node", "->", "num", "instanceof", "LNumber", "||", "$", "node", "->", "num", "instanceof", "DNumber", ")", "{", "$", "num", "=", "$", "node", "->", "num", "->", "value", ";", "if", "(", "$", "node", "->", "num", "instanceof", "DNumber", "||", "$", "num", "<", "1", ")", "{", "$", "msg", "=", "\\", "sprintf", "(", "\"'%s' operator accepts only positive numbers\"", ",", "$", "operator", ")", ";", "throw", "new", "FatalErrorException", "(", "$", "msg", ",", "0", ",", "E_ERROR", ",", "null", ",", "$", "node", "->", "getLine", "(", ")", ")", ";", "}", "if", "(", "$", "num", ">", "$", "this", "->", "loopDepth", ")", "{", "$", "msg", "=", "\\", "sprintf", "(", "\"Cannot '%s' %d levels\"", ",", "$", "operator", ",", "$", "num", ")", ";", "throw", "new", "FatalErrorException", "(", "$", "msg", ",", "0", ",", "E_ERROR", ",", "null", ",", "$", "node", "->", "getLine", "(", ")", ")", ";", "}", "}", "elseif", "(", "$", "node", "->", "num", ")", "{", "$", "msg", "=", "\\", "sprintf", "(", "\"'%s' operator with non-constant operand is no longer supported\"", ",", "$", "operator", ")", ";", "throw", "new", "FatalErrorException", "(", "$", "msg", ",", "0", ",", "E_ERROR", ",", "null", ",", "$", "node", "->", "getLine", "(", ")", ")", ";", "}", "break", ";", "}", "}" ]

[ "@throws", "FatalErrorException", "if", "the", "node", "is", "a", "break", "or", "continue", "in", "a", "non", "-", "loop", "or", "switch", "context", "@throws", "FatalErrorException", "if", "the", "node", "is", "trying", "to", "break", "out", "of", "more", "nested", "structures", "than", "exist", "@throws", "FatalErrorException", "if", "the", "node", "is", "a", "break", "or", "continue", "and", "has", "a", "non", "-", "numeric", "argument", "@throws", "FatalErrorException", "if", "the", "node", "is", "a", "break", "or", "continue", "and", "has", "an", "argument", "less", "than", "1" ]

[ "public", "function", "getMatches", "(", "array", "$", "tokens", ",", "array", "$", "info", "=", "[", "]", ")", "{", "$", "input", "=", "$", "this", "->", "getInput", "(", "$", "tokens", ")", ";", "$", "firstToken", "=", "\\", "array_pop", "(", "$", "tokens", ")", ";", "if", "(", "self", "::", "tokenIs", "(", "$", "firstToken", ",", "self", "::", "T_STRING", ")", ")", "{", "// second token is the nekudotayim operator", "\\", "array_pop", "(", "$", "tokens", ")", ";", "}", "$", "class", "=", "$", "this", "->", "getNamespaceAndClass", "(", "$", "tokens", ")", ";", "try", "{", "$", "reflection", "=", "new", "\\", "ReflectionClass", "(", "$", "class", ")", ";", "}", "catch", "(", "\\", "ReflectionException", "$", "re", ")", "{", "return", "[", "]", ";", "}", "if", "(", "self", "::", "needCompleteClass", "(", "$", "tokens", "[", "1", "]", ")", ")", "{", "$", "methods", "=", "$", "reflection", "->", "getMethods", "(", ")", ";", "}", "else", "{", "$", "methods", "=", "$", "reflection", "->", "getMethods", "(", "\\", "ReflectionMethod", "::", "IS_STATIC", ")", ";", "}", "$", "methods", "=", "\\", "array_map", "(", "function", "(", "\\", "ReflectionMethod", "$", "method", ")", "{", "return", "$", "method", "->", "getName", "(", ")", ";", "}", ",", "$", "methods", ")", ";", "return", "\\", "array_map", "(", "function", "(", "$", "name", ")", "use", "(", "$", "class", ")", "{", "$", "chunks", "=", "\\", "explode", "(", "'\\\\'", ",", "$", "class", ")", ";", "$", "className", "=", "\\", "array_pop", "(", "$", "chunks", ")", ";", "return", "$", "className", ".", "'::'", ".", "$", "name", ";", "}", ",", "\\", "array_filter", "(", "$", "methods", ",", "function", "(", "$", "method", ")", "use", "(", "$", "input", ")", "{", "return", "AbstractMatcher", "::", "startsWith", "(", "$", "input", ",", "$", "method", ")", ";", "}", ")", ")", ";", "}" ]

[ "{" ]

[ "public", "function", "enterNode", "(", "Node", "$", "node", ")", "{", "if", "(", "$", "node", "instanceof", "Assign", "&&", "$", "node", "->", "var", "instanceof", "Variable", "&&", "$", "node", "->", "var", "->", "name", "===", "'this'", ")", "{", "throw", "new", "FatalErrorException", "(", "'Cannot re-assign $this'", ",", "0", ",", "E_ERROR", ",", "null", ",", "$", "node", "->", "getLine", "(", ")", ")", ";", "}", "}" ]

[ "Validate", "that", "the", "user", "input", "does", "not", "assign", "the", "$this", "variable", "." ]

[ "public", "function", "enterNode", "(", "Node", "$", "node", ")", "{", "if", "(", "$", "node", "instanceof", "Dir", ")", "{", "return", "new", "FuncCall", "(", "new", "Name", "(", "'getcwd'", ")", ",", "[", "]", ",", "$", "node", "->", "getAttributes", "(", ")", ")", ";", "}", "elseif", "(", "$", "node", "instanceof", "File", ")", "{", "return", "new", "String_", "(", "''", ",", "$", "node", "->", "getAttributes", "(", ")", ")", ";", "}", "}" ]

[ "Swap", "out", "__DIR__", "and", "__FILE__", "constants", "because", "the", "default", "ones", "when", "calling", "eval", "()", "don", "t", "make", "sense", "." ]