Datasets:

unum-cloud

/

ann-codesearch-4m

like 0

Follow

Unum 28

[ "public", "function", "ccAddress", "(", "$", "email", ",", "$", "name", "=", "null", ")", "{", "$", "this", "->", "getMailer", "(", ")", "->", "addCC", "(", "$", "email", ",", "(", "empty", "(", "$", "name", ")", ")", "?", "$", "email", ":", "$", "name", ")", ";", "return", "$", "this", ";", "}" ]

[ "Add", "a", "single", "CC", "address", "with", "optional", "name" ]

[ "public", "function", "bccAddresses", "(", "array", "$", "emails", ")", "{", "foreach", "(", "$", "emails", "as", "$", "name", "=>", "$", "mail", ")", "{", "if", "(", "is_int", "(", "$", "name", ")", ")", "{", "$", "this", "->", "bccAddress", "(", "$", "mail", ")", ";", "}", "else", "{", "$", "this", "->", "bccAddress", "(", "$", "mail", ",", "$", "name", ")", ";", "}", "}", "return", "$", "this", ";", "}" ]

[ "Add", "multiple", "BCC", "addresses", "into", "the", "mailer", "object", "." ]

[ "public", "function", "bccAddress", "(", "$", "email", ",", "$", "name", "=", "null", ")", "{", "$", "this", "->", "getMailer", "(", ")", "->", "addBCC", "(", "$", "email", ",", "(", "empty", "(", "$", "name", ")", ")", "?", "$", "email", ":", "$", "name", ")", ";", "return", "$", "this", ";", "}" ]

[ "Add", "a", "single", "BCC", "address", "with", "optional", "name" ]

[ "public", "function", "addAttachment", "(", "$", "filePath", ",", "$", "name", "=", "null", ")", "{", "$", "this", "->", "getMailer", "(", ")", "->", "addAttachment", "(", "$", "filePath", ",", "empty", "(", "$", "name", ")", "?", "pathinfo", "(", "$", "filePath", ",", "PATHINFO_BASENAME", ")", ":", "$", "name", ")", ";", "return", "$", "this", ";", "}" ]

[ "Add", "attachment", "." ]

[ "public", "function", "addReplyTo", "(", "$", "email", ",", "$", "name", "=", "null", ")", "{", "$", "this", "->", "getMailer", "(", ")", "->", "addReplyTo", "(", "$", "email", ",", "empty", "(", "$", "name", ")", "?", "$", "email", ":", "$", "name", ")", ";", "return", "$", "this", ";", "}" ]

[ "Add", "ReplyTo", "Address", "." ]

[ "public", "function", "send", "(", ")", "{", "if", "(", "empty", "(", "$", "this", "->", "mailer", "->", "Subject", ")", "||", "empty", "(", "$", "this", "->", "mailer", "->", "Body", ")", ")", "{", "throw", "new", "Exception", "(", "\"Mail subject() and body() can not be empty in order to send mail.\"", ")", ";", "}", "if", "(", "!", "$", "this", "->", "getMailer", "(", ")", "->", "send", "(", ")", ")", "{", "Yii", "::", "error", "(", "$", "this", "->", "getError", "(", ")", ",", "__METHOD__", ")", ";", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Trigger", "the", "send", "event", "of", "the", "mailer" ]

[ "private", "function", "getUserAuthClass", "(", ")", "{", "if", "(", "$", "this", "instanceof", "UserBehaviorInterface", ")", "{", "$", "class", "=", "$", "this", "->", "userAuthClass", "(", ")", ";", "if", "(", "!", "$", "class", ")", "{", "// return false;", "return", "false", ";", "}", "if", "(", "!", "is_object", "(", "$", "class", ")", ")", "{", "return", "Yii", "::", "createObject", "(", "$", "class", ")", ";", "}", "return", "$", "class", ";", "}", "return", "false", ";", "}" ]

[ "Whether", "the", "rest", "controller", "is", "protected", "or", "not", "." ]

[ "public", "function", "behaviors", "(", ")", "{", "$", "behaviors", "=", "parent", "::", "behaviors", "(", ")", ";", "if", "(", "!", "$", "this", "->", "getUserAuthClass", "(", ")", ")", "{", "unset", "(", "$", "behaviors", "[", "'authenticator'", "]", ")", ";", "}", "else", "{", "// change to admin user auth class", "$", "behaviors", "[", "'authenticator'", "]", "=", "[", "'class'", "=>", "CompositeAuth", "::", "className", "(", ")", ",", "'user'", "=>", "$", "this", "->", "getUserAuthClass", "(", ")", ",", "'authMethods'", "=>", "[", "QueryParamAuth", "::", "className", "(", ")", ",", "HttpBearerAuth", "::", "className", "(", ")", ",", "]", ",", "]", ";", "if", "(", "$", "this", "->", "enableCors", ")", "{", "$", "behaviors", "[", "'authenticator'", "]", "[", "'except'", "]", "=", "[", "'options'", "]", ";", "}", "}", "if", "(", "$", "this", "->", "enableCors", ")", "{", "$", "behaviors", "[", "'cors'", "]", "=", "Cors", "::", "class", ";", "}", "$", "behaviors", "[", "'contentNegotiator'", "]", "=", "[", "'class'", "=>", "ContentNegotiator", "::", "className", "(", ")", ",", "'formats'", "=>", "[", "'application/json'", "=>", "Response", "::", "FORMAT_JSON", ",", "'application/xml'", "=>", "Response", "::", "FORMAT_XML", ",", "]", ",", "'languages'", "=>", "$", "this", "->", "languages", ",", "]", ";", "// by default rate limiter behavior is removed as it requires a database", "// user given from the admin module.", "if", "(", "isset", "(", "$", "behaviors", "[", "'rateLimiter'", "]", ")", ")", "{", "unset", "(", "$", "behaviors", "[", "'rateLimiter'", "]", ")", ";", "}", "if", "(", "$", "this", "->", "jsonCruft", ")", "{", "$", "behaviors", "[", "'cruft'", "]", "=", "JsonCruftFilter", "::", "class", ";", "}", "return", "$", "behaviors", ";", "}" ]

[ "Override", "the", "default", "{{", "yii", "\\", "rest", "\\", "Controller", "::", "behaviors", "()", "}}", "method", ".", "The", "following", "changes", "are", "differ", "to", "the", "base", "implementation", ":" ]

[ "public", "function", "sendModelError", "(", "Model", "$", "model", ")", "{", "if", "(", "!", "$", "model", "->", "hasErrors", "(", ")", ")", "{", "throw", "new", "InvalidParamException", "(", "'The model as thrown an uknown Error.'", ")", ";", "}", "Yii", "::", "$", "app", "->", "response", "->", "setStatusCode", "(", "422", ",", "'Data Validation Failed.'", ")", ";", "$", "result", "=", "[", "]", ";", "foreach", "(", "$", "model", "->", "getFirstErrors", "(", ")", "as", "$", "name", "=>", "$", "message", ")", "{", "$", "result", "[", "]", "=", "[", "'field'", "=>", "$", "name", ",", "'message'", "=>", "$", "message", ",", "]", ";", "}", "return", "$", "result", ";", "}" ]

[ "Send", "Model", "errors", "with", "correct", "headers", "." ]

[ "public", "function", "sendArrayError", "(", "array", "$", "errors", ")", "{", "Yii", "::", "$", "app", "->", "response", "->", "setStatusCode", "(", "422", ",", "'Data Validation Failed.'", ")", ";", "$", "result", "=", "[", "]", ";", "foreach", "(", "$", "errors", "as", "$", "key", "=>", "$", "value", ")", "{", "$", "messages", "=", "(", "array", ")", "$", "value", ";", "foreach", "(", "$", "messages", "as", "$", "msg", ")", "{", "$", "result", "[", "]", "=", "[", "'field'", "=>", "$", "key", ",", "'message'", "=>", "$", "msg", "]", ";", "}", "}", "return", "$", "result", ";", "}" ]

[ "Send", "Array", "validation", "error", "." ]

[ "public", "function", "parse", "(", "$", "value", ",", "$", "sub", ")", "{", "$", "label", "=", "$", "sub", "?", ":", "$", "value", ";", "// if obfuscation is enabled generate tag string due to yii tag method will encode attributes.", "if", "(", "$", "this", "->", "obfuscate", ")", "{", "if", "(", "!", "$", "sub", ")", "{", "$", "label", "=", "$", "this", "->", "obfuscate", "(", "$", "label", ")", ";", "}", "return", "'<a href=\"'", ".", "$", "this", "->", "obfuscate", "(", "\"mailto:{$value}\"", ")", ".", "'\" rel=\"nofollow\">'", ".", "$", "label", ".", "'</a>'", ";", "}", "return", "Html", "::", "mailto", "(", "$", "label", ",", "$", "value", ",", "[", "'rel'", "=>", "'nofollow'", ",", "]", ")", ";", "}" ]

[ "Generate", "the", "Mail", "Tag", "." ]

[ "public", "function", "obfuscate", "(", "$", "email", ")", "{", "$", "output", "=", "null", ";", "for", "(", "$", "i", "=", "0", ";", "$", "i", "<", "strlen", "(", "$", "email", ")", ";", "$", "i", "++", ")", "{", "$", "output", ".=", "'&#'", ".", "ord", "(", "$", "email", "[", "$", "i", "]", ")", ".", "';'", ";", "}", "return", "$", "output", ";", "}" ]

[ "Obfucscate", "email", "adresse" ]

[ "public", "function", "autoFormat", "(", "$", "value", ")", "{", "// email validation", "if", "(", "(", "new", "EmailValidator", "(", ")", ")", "->", "validate", "(", "$", "value", ")", ")", "{", "return", "$", "this", "->", "asEmail", "(", "$", "value", ")", ";", "}", "// url validator", "if", "(", "(", "new", "UrlValidator", "(", ")", ")", "->", "validate", "(", "$", "value", ")", ")", "{", "return", "$", "this", "->", "asUrl", "(", "$", "value", ")", ";", "}", "// boolean type", "if", "(", "is_bool", "(", "$", "value", ")", ")", "{", "return", "$", "this", "->", "asBoolean", "(", "$", "value", ")", ";", "}", "return", "$", "value", ";", "}" ]

[ "Auto", "format", "the", "value", "to", "a", "given", "format", "like", "url", "email", "." ]

[ "public", "static", "function", "csv", "(", "$", "input", ",", "array", "$", "keys", "=", "[", "]", ",", "$", "header", "=", "true", ")", "{", "$", "delimiter", "=", "\",\"", ";", "$", "input", "=", "self", "::", "transformInput", "(", "$", "input", ")", ";", "$", "array", "=", "self", "::", "generateContentArray", "(", "$", "input", ",", "$", "keys", ",", "$", "header", ")", ";", "return", "self", "::", "generateOutputString", "(", "$", "array", ",", "$", "delimiter", ")", ";", "}" ]

[ "Export", "an", "Array", "or", "ActiveQuery", "instance", "into", "a", "CSV", "formated", "string", "." ]

[ "public", "static", "function", "xlsx", "(", "$", "input", ",", "array", "$", "keys", "=", "[", "]", ",", "$", "header", "=", "true", ")", "{", "$", "input", "=", "self", "::", "transformInput", "(", "$", "input", ")", ";", "$", "array", "=", "self", "::", "generateContentArray", "(", "$", "input", ",", "$", "keys", ",", "$", "header", ")", ";", "$", "writer", "=", "new", "XLSXWriter", "(", ")", ";", "$", "writer", "->", "writeSheet", "(", "$", "array", ")", ";", "return", "$", "writer", "->", "writeToString", "(", ")", ";", "}" ]

[ "Export", "an", "Array", "or", "ActiveQuery", "instance", "into", "a", "Excel", "formatted", "string", "." ]

[ "protected", "static", "function", "generateContentArray", "(", "$", "contentRows", ",", "$", "keys", ",", "$", "generateHeader", "=", "true", ")", "{", "if", "(", "is_scalar", "(", "$", "contentRows", ")", ")", "{", "throw", "new", "Exception", "(", "\"Content must be either an array, object or traversable\"", ")", ";", "}", "$", "attributeKeys", "=", "$", "keys", ";", "$", "header", "=", "[", "]", ";", "$", "rows", "=", "[", "]", ";", "$", "i", "=", "0", ";", "foreach", "(", "$", "contentRows", "as", "$", "content", ")", "{", "// handle rows content", "if", "(", "!", "empty", "(", "$", "keys", ")", "&&", "is_array", "(", "$", "content", ")", ")", "{", "foreach", "(", "$", "content", "as", "$", "k", "=>", "$", "v", ")", "{", "if", "(", "!", "in_array", "(", "$", "k", ",", "$", "keys", ")", ")", "{", "unset", "(", "$", "content", "[", "$", "k", "]", ")", ";", "}", "}", "}", "elseif", "(", "!", "empty", "(", "$", "keys", ")", "&&", "is_object", "(", "$", "content", ")", ")", "{", "$", "attributeKeys", "[", "get_class", "(", "$", "content", ")", "]", "=", "$", "keys", ";", "}", "$", "rows", "[", "$", "i", "]", "=", "ArrayHelper", "::", "toArray", "(", "$", "content", ",", "$", "attributeKeys", ",", "false", ")", ";", "// handler header", "if", "(", "$", "i", "==", "0", "&&", "$", "generateHeader", ")", "{", "if", "(", "$", "content", "instanceof", "ActiveRecordInterface", ")", "{", "foreach", "(", "$", "content", "as", "$", "k", "=>", "$", "v", ")", "{", "if", "(", "empty", "(", "$", "keys", ")", ")", "{", "$", "header", "[", "]", "=", "$", "content", "->", "getAttributeLabel", "(", "$", "k", ")", ";", "}", "elseif", "(", "in_array", "(", "$", "k", ",", "$", "keys", ")", ")", "{", "$", "header", "[", "]", "=", "$", "content", "->", "getAttributeLabel", "(", "$", "k", ")", ";", "}", "}", "}", "else", "{", "$", "header", "=", "array_keys", "(", "$", "rows", "[", "0", "]", ")", ";", "}", "}", "$", "i", "++", ";", "}", "if", "(", "$", "generateHeader", ")", "{", "return", "ArrayHelper", "::", "merge", "(", "[", "$", "header", "]", ",", "$", "rows", ")", ";", "}", "return", "$", "rows", ";", "}" ]

[ "Generate", "content", "by", "rows", "." ]

[ "protected", "static", "function", "generateRow", "(", "array", "$", "row", ",", "$", "delimiter", ",", "$", "enclose", ")", "{", "array_walk", "(", "$", "row", ",", "function", "(", "&", "$", "item", ")", "use", "(", "$", "enclose", ")", "{", "if", "(", "is_bool", "(", "$", "item", ")", ")", "{", "$", "item", "=", "(", "int", ")", "$", "item", ";", "}", "elseif", "(", "is_null", "(", "$", "item", ")", ")", "{", "$", "item", "=", "''", ";", "}", "elseif", "(", "!", "is_scalar", "(", "$", "item", ")", ")", "{", "$", "item", "=", "\"[array]\"", ";", "}", "$", "item", "=", "$", "enclose", ".", "Html", "::", "encode", "(", "$", "item", ")", ".", "$", "enclose", ";", "}", ")", ";", "return", "implode", "(", "$", "delimiter", ",", "$", "row", ")", ".", "PHP_EOL", ";", "}" ]

[ "Generate", "a", "row", "by", "its", "items", "." ]

[ "public", "function", "setDay", "(", "$", "name", ",", "array", "$", "time", ")", "{", "if", "(", "is_numeric", "(", "$", "name", ")", ")", "{", "if", "(", "!", "array_key_exists", "(", "$", "name", ",", "$", "this", "->", "_dayMap", ")", ")", "{", "throw", "new", "InvalidConfigException", "(", "\"The given day numeric value {$name} is not available in the list of valid day values.\"", ")", ";", "}", "$", "name", "=", "$", "this", "->", "_dayMap", "[", "$", "name", "]", ";", "}", "if", "(", "!", "array_search", "(", "$", "name", ",", "$", "this", "->", "_dayMap", ")", ")", "{", "throw", "new", "InvalidConfigException", "(", "\"The given day {$name} is not in the list of valid day names.\")", ";", "", "}", "foreach", "(", "$", "time", "as", "$", "from", "=>", "$", "to", ")", "{", "$", "this", "->", "_days", "[", "]", "=", "\"{$name} {$from}-{$to}\"", ";", "}", "}" ]

[ "Set", "a", "a", "value", "for", "a", "day", "." ]

[ "public", "function", "setTelephone", "(", "$", "telephone", ")", "{", "/**\n * Hack to support leading + sign\n * @see \\luya\\cms\\models\\NavItemPageBlockItem::rules()\n * @link https://github.com/luyadev/luya/pull/1815\n */", "$", "telephone", "=", "ltrim", "(", "$", "telephone", ",", "'\\\\'", ")", ";", "$", "validator", "=", "new", "RegularExpressionValidator", "(", "[", "'pattern'", "=>", "'#^(?:0|\\+[0-9]{2})[\\d\\- ()]+$#'", "]", ")", ";", "if", "(", "$", "validator", "->", "validate", "(", "$", "telephone", ",", "$", "error", ")", ")", "{", "$", "this", "->", "_telephone", "=", "$", "telephone", ";", "}", "else", "{", "$", "this", "->", "_telephone", "=", "false", ";", "}", "}" ]

[ "Setter", "method", "for", "telephone", "number", "." ]

[ "public", "static", "function", "dir", "(", "$", "sourcePath", ",", "$", "outZipPath", ")", "{", "$", "pathInfo", "=", "pathInfo", "(", "$", "sourcePath", ")", ";", "$", "parentPath", "=", "$", "pathInfo", "[", "'dirname'", "]", ";", "$", "dirName", "=", "$", "pathInfo", "[", "'basename'", "]", ";", "$", "z", "=", "new", "ZipArchive", "(", ")", ";", "$", "z", "->", "open", "(", "$", "outZipPath", ",", "ZIPARCHIVE", "::", "CREATE", ")", ";", "$", "z", "->", "addEmptyDir", "(", "$", "dirName", ")", ";", "self", "::", "folderToZip", "(", "$", "sourcePath", ",", "$", "z", ",", "strlen", "(", "\"$parentPath/\"", ")", ")", ";", "$", "z", "->", "close", "(", ")", ";", "return", "true", ";", "}" ]

[ "Zip", "a", "folder", "(", "include", "itself", ")", "." ]

[ "public", "function", "actionCreate", "(", "$", "name", ",", "$", "module", "=", "false", ")", "{", "if", "(", "empty", "(", "$", "module", ")", ")", "{", "return", "parent", "::", "actionCreate", "(", "$", "name", ")", ";", "}", "if", "(", "!", "isset", "(", "$", "this", "->", "migrationPath", "[", "$", "module", "]", ")", ")", "{", "throw", "new", "Exception", "(", "\"The module \\\"$module\\\" does not exist in the application modules configuration.\"", ")", ";", "}", "// apply custom migration code to generate new migrations for a module specific path", "if", "(", "!", "preg_match", "(", "'/^[\\w\\\\\\\\]+$/'", ",", "$", "name", ")", ")", "{", "throw", "new", "Exception", "(", "'The migration name should contain letters, digits, underscore and/or backslash characters only.'", ")", ";", "}", "$", "className", "=", "'m'", ".", "gmdate", "(", "'ymd_His'", ")", ".", "'_'", ".", "$", "name", ";", "$", "migrationPath", "=", "$", "this", "->", "migrationPath", "[", "$", "module", "]", ";", "$", "file", "=", "$", "migrationPath", ".", "DIRECTORY_SEPARATOR", ".", "$", "className", ".", "'.php'", ";", "if", "(", "$", "this", "->", "confirm", "(", "\"Create new migration '$file'?\"", ")", ")", "{", "$", "content", "=", "$", "this", "->", "generateMigrationSourceCode", "(", "[", "'name'", "=>", "$", "name", ",", "'className'", "=>", "$", "className", ",", "'namespace'", "=>", "null", ",", "]", ")", ";", "FileHelper", "::", "createDirectory", "(", "$", "migrationPath", ")", ";", "file_put_contents", "(", "$", "file", ",", "$", "content", ")", ";", "$", "this", "->", "stdout", "(", "\"New migration created successfully.\\n\"", ",", "Console", "::", "FG_GREEN", ")", ";", "}", "}" ]

[ "@inheritDoc" ]

[ "public", "function", "transferMessage", "(", "$", "message", ",", "$", "file", "=", "__FILE__", ",", "$", "line", "=", "__LINE__", ")", "{", "return", "$", "this", "->", "apiServerSendData", "(", "$", "this", "->", "getExceptionArray", "(", "[", "'message'", "=>", "$", "message", ",", "'file'", "=>", "$", "file", ",", "'line'", "=>", "$", "line", ",", "]", ")", ")", ";", "}" ]

[ "Send", "a", "custom", "message", "to", "the", "api", "server", "event", "its", "not", "related", "to", "an", "exception", "." ]

[ "private", "function", "apiServerSendData", "(", "array", "$", "data", ")", "{", "if", "(", "$", "this", "->", "transferException", ")", "{", "$", "curl", "=", "new", "Curl", "(", ")", ";", "$", "curl", "->", "setOpt", "(", "CURLOPT_CONNECTTIMEOUT", ",", "2", ")", ";", "$", "curl", "->", "setOpt", "(", "CURLOPT_TIMEOUT", ",", "2", ")", ";", "$", "curl", "->", "post", "(", "Url", "::", "ensureHttp", "(", "rtrim", "(", "$", "this", "->", "api", ",", "'/'", ")", ")", ".", "'/create'", ",", "[", "'error_json'", "=>", "Json", "::", "encode", "(", "$", "data", ")", ",", "]", ")", ";", "$", "this", "->", "lastTransferCall", "=", "$", "curl", ";", "return", "$", "curl", "->", "isSuccess", "(", ")", ";", "}", "return", "null", ";", "}" ]

[ "Send", "the", "array", "data", "to", "the", "api", "server", "." ]

[ "public", "function", "getExceptionArray", "(", "$", "exception", ")", "{", "$", "_message", "=", "'Uknonwn exception object, not instance of \\Exception.'", ";", "$", "_file", "=", "'unknown'", ";", "$", "_line", "=", "0", ";", "$", "_trace", "=", "[", "]", ";", "$", "_previousException", "=", "[", "]", ";", "if", "(", "is_object", "(", "$", "exception", ")", ")", "{", "$", "prev", "=", "$", "exception", "->", "getPrevious", "(", ")", ";", "if", "(", "!", "empty", "(", "$", "prev", ")", ")", "{", "$", "_previousException", "=", "[", "'message'", "=>", "$", "prev", "->", "getMessage", "(", ")", ",", "'file'", "=>", "$", "prev", "->", "getFile", "(", ")", ",", "'line'", "=>", "$", "prev", "->", "getLine", "(", ")", ",", "'trace'", "=>", "$", "this", "->", "buildTrace", "(", "$", "prev", ")", ",", "]", ";", "}", "$", "_trace", "=", "$", "this", "->", "buildTrace", "(", "$", "exception", ")", ";", "$", "_message", "=", "$", "exception", "->", "getMessage", "(", ")", ";", "$", "_file", "=", "$", "exception", "->", "getFile", "(", ")", ";", "$", "_line", "=", "$", "exception", "->", "getLine", "(", ")", ";", "}", "elseif", "(", "is_string", "(", "$", "exception", ")", ")", "{", "$", "_message", "=", "'exception string: '", ".", "$", "exception", ";", "}", "elseif", "(", "is_array", "(", "$", "exception", ")", ")", "{", "$", "_message", "=", "isset", "(", "$", "exception", "[", "'message'", "]", ")", "?", "$", "exception", "[", "'message'", "]", ":", "'exception array dump: '", ".", "print_r", "(", "$", "exception", ",", "true", ")", ";", "$", "_file", "=", "isset", "(", "$", "exception", "[", "'file'", "]", ")", "?", "$", "exception", "[", "'file'", "]", ":", "__FILE__", ";", "$", "_line", "=", "isset", "(", "$", "exception", "[", "'line'", "]", ")", "?", "$", "exception", "[", "'line'", "]", ":", "__LINE__", ";", "}", "return", "[", "'message'", "=>", "$", "_message", ",", "'file'", "=>", "$", "_file", ",", "'line'", "=>", "$", "_line", ",", "'requestUri'", "=>", "isset", "(", "$", "_SERVER", "[", "'REQUEST_URI'", "]", ")", "?", "$", "_SERVER", "[", "'REQUEST_URI'", "]", ":", "null", ",", "'serverName'", "=>", "isset", "(", "$", "_SERVER", "[", "'SERVER_NAME'", "]", ")", "?", "$", "_SERVER", "[", "'SERVER_NAME'", "]", ":", "null", ",", "'date'", "=>", "date", "(", "'d.m.Y H:i'", ")", ",", "'trace'", "=>", "$", "_trace", ",", "'previousException'", "=>", "$", "_previousException", ",", "'ip'", "=>", "isset", "(", "$", "_SERVER", "[", "'REMOTE_ADDR'", "]", ")", "?", "$", "_SERVER", "[", "'REMOTE_ADDR'", "]", ":", "null", ",", "'get'", "=>", "isset", "(", "$", "_GET", ")", "?", "ArrayHelper", "::", "coverSensitiveValues", "(", "$", "_GET", ",", "$", "this", "->", "sensitiveKeys", ")", ":", "[", "]", ",", "'post'", "=>", "isset", "(", "$", "_POST", ")", "?", "ArrayHelper", "::", "coverSensitiveValues", "(", "$", "_POST", ",", "$", "this", "->", "sensitiveKeys", ")", ":", "[", "]", ",", "'bodyParams'", "=>", "Yii", "::", "$", "app", "instanceof", "Application", "?", "ArrayHelper", "::", "coverSensitiveValues", "(", "Yii", "::", "$", "app", "->", "request", "->", "bodyParams", ")", ":", "[", "]", ",", "'session'", "=>", "isset", "(", "$", "_SESSION", ")", "?", "ArrayHelper", "::", "coverSensitiveValues", "(", "$", "_SESSION", ",", "$", "this", "->", "sensitiveKeys", ")", ":", "[", "]", ",", "'server'", "=>", "isset", "(", "$", "_SERVER", ")", "?", "ArrayHelper", "::", "coverSensitiveValues", "(", "$", "_SERVER", ",", "$", "this", "->", "sensitiveKeys", ")", ":", "[", "]", ",", "'profiling'", "=>", "Yii", "::", "getLogger", "(", ")", "->", "profiling", ",", "'logger'", "=>", "Yii", "::", "getLogger", "(", ")", "->", "messages", ",", "]", ";", "}" ]

[ "Get", "an", "readable", "array", "to", "transfer", "from", "an", "exception" ]

[ "private", "function", "buildTrace", "(", "$", "exception", ")", "{", "$", "_trace", "=", "[", "]", ";", "foreach", "(", "$", "exception", "->", "getTrace", "(", ")", "as", "$", "key", "=>", "$", "item", ")", "{", "$", "_trace", "[", "$", "key", "]", "=", "[", "'file'", "=>", "isset", "(", "$", "item", "[", "'file'", "]", ")", "?", "$", "item", "[", "'file'", "]", ":", "null", ",", "'line'", "=>", "isset", "(", "$", "item", "[", "'line'", "]", ")", "?", "$", "item", "[", "'line'", "]", ":", "null", ",", "'function'", "=>", "isset", "(", "$", "item", "[", "'function'", "]", ")", "?", "$", "item", "[", "'function'", "]", ":", "null", ",", "'class'", "=>", "isset", "(", "$", "item", "[", "'class'", "]", ")", "?", "$", "item", "[", "'class'", "]", ":", "null", ",", "]", ";", "}", "return", "$", "_trace", ";", "}" ]

[ "Build", "trace", "array", "from", "exception", "." ]

[ "public", "function", "getIsAdmin", "(", ")", "{", "if", "(", "$", "this", "->", "_isAdmin", "===", "null", ")", "{", "if", "(", "$", "this", "->", "getIsConsoleRequest", "(", ")", "&&", "!", "$", "this", "->", "forceWebRequest", "&&", "!", "Yii", "::", "$", "app", "->", "hasModule", "(", "'admin'", ")", ")", "{", "$", "this", "->", "_isAdmin", "=", "false", ";", "}", "else", "{", "// if there is only an application with admin module and set as default route", "// this might by the admin module even when pathInfo is empty", "if", "(", "Yii", "::", "$", "app", "->", "defaultRoute", "==", "'admin'", "&&", "empty", "(", "$", "this", "->", "pathInfo", ")", ")", "{", "$", "this", "->", "_isAdmin", "=", "true", ";", "}", "else", "{", "$", "resolver", "=", "Yii", "::", "$", "app", "->", "composition", "->", "getResolvedPathInfo", "(", "$", "this", ")", ";", "$", "parts", "=", "explode", "(", "'/'", ",", "$", "resolver", "->", "resolvedPath", ")", ";", "$", "first", "=", "reset", "(", "$", "parts", ")", ";", "if", "(", "preg_match", "(", "'/admin/i'", ",", "$", "first", ",", "$", "results", ")", ")", "{", "$", "this", "->", "_isAdmin", "=", "true", ";", "}", "else", "{", "$", "this", "->", "_isAdmin", "=", "false", ";", "}", "}", "}", "}", "return", "$", "this", "->", "_isAdmin", ";", "}" ]

[ "Getter", "method", "resolves", "the", "current", "url", "request", "and", "check", "if", "admin", "context", "." ]

[ "public", "function", "verbosePrint", "(", "$", "message", ",", "$", "section", "=", "null", ")", "{", "if", "(", "$", "this", "->", "verbose", ")", "{", "$", "this", "->", "output", "(", "(", "!", "empty", "(", "$", "section", ")", ")", "?", "$", "section", ".", "': '", ".", "$", "message", ":", "$", "message", ")", ";", "}", "}" ]

[ "Method", "to", "print", "informations", "directly", "when", "verbose", "is", "enabled", "." ]

[ "public", "function", "selectModule", "(", "array", "$", "options", "=", "[", "]", ")", "{", "$", "modules", "=", "[", "]", ";", "foreach", "(", "Yii", "::", "$", "app", "->", "getModules", "(", ")", "as", "$", "id", "=>", "$", "object", ")", "{", "if", "(", "!", "$", "object", "instanceof", "\\", "luya", "\\", "base", "\\", "Module", ")", "{", "continue", ";", "}", "if", "(", "isset", "(", "$", "options", "[", "'onlyAdmin'", "]", ")", "&&", "$", "options", "[", "'onlyAdmin'", "]", ")", "{", "if", "(", "!", "$", "object", "instanceof", "AdminModuleInterface", ")", "{", "continue", ";", "}", "}", "if", "(", "isset", "(", "$", "options", "[", "'hideCore'", "]", ")", "&&", "$", "options", "[", "'hideCore'", "]", ")", "{", "if", "(", "$", "object", "instanceof", "CoreModuleInterface", ")", "{", "continue", ";", "}", "}", "$", "modules", "[", "$", "id", "]", "=", "$", "id", ";", "}", "$", "text", "=", "(", "isset", "(", "$", "options", "[", "'text'", "]", ")", ")", "?", "$", "options", "[", "'text'", "]", ":", "'Please select a module:'", ";", "return", "$", "this", "->", "select", "(", "$", "text", ",", "$", "modules", ")", ";", "}" ]

[ "Get", "selection", "list", "for", "console", "commands", "with", "defined", "options", "." ]

[ "public", "function", "createClassName", "(", "$", "string", ",", "$", "suffix", "=", "false", ")", "{", "$", "name", "=", "Inflector", "::", "camelize", "(", "$", "string", ")", ";", "if", "(", "$", "suffix", "!==", "false", "&&", "StringHelper", "::", "endsWith", "(", "$", "name", ",", "$", "suffix", ",", "false", ")", ")", "{", "$", "name", "=", "substr", "(", "$", "name", ",", "0", ",", "-", "(", "strlen", "(", "$", "suffix", ")", ")", ")", ";", "}", "return", "$", "name", ".", "$", "suffix", ";", "}" ]

[ "Generates", "a", "class", "name", "with", "camelcase", "style", "and", "specific", "suffix", "if", "not", "already", "provided" ]

[ "public", "function", "getSqlTablesArray", "(", ")", "{", "$", "names", "=", "Yii", "::", "$", "app", "->", "db", "->", "schema", "->", "tableNames", ";", "return", "array_combine", "(", "$", "names", ",", "$", "names", ")", ";", "}" ]

[ "Get", "the", "sql", "tables", "from", "the", "current", "database", "connection" ]

[ "public", "function", "generateRules", "(", "$", "table", ")", "{", "$", "types", "=", "[", "]", ";", "$", "lengths", "=", "[", "]", ";", "foreach", "(", "$", "table", "->", "columns", "as", "$", "column", ")", "{", "if", "(", "$", "column", "->", "autoIncrement", ")", "{", "continue", ";", "}", "if", "(", "!", "$", "column", "->", "allowNull", "&&", "$", "column", "->", "defaultValue", "===", "null", ")", "{", "$", "types", "[", "'required'", "]", "[", "]", "=", "$", "column", "->", "name", ";", "}", "switch", "(", "$", "column", "->", "type", ")", "{", "case", "Schema", "::", "TYPE_SMALLINT", ":", "case", "Schema", "::", "TYPE_INTEGER", ":", "case", "Schema", "::", "TYPE_BIGINT", ":", "$", "types", "[", "'integer'", "]", "[", "]", "=", "$", "column", "->", "name", ";", "break", ";", "case", "Schema", "::", "TYPE_BOOLEAN", ":", "$", "types", "[", "'boolean'", "]", "[", "]", "=", "$", "column", "->", "name", ";", "break", ";", "case", "Schema", "::", "TYPE_FLOAT", ":", "case", "'double'", ":", "// Schema::TYPE_DOUBLE, which is available since Yii 2.0.3", "case", "Schema", "::", "TYPE_DECIMAL", ":", "case", "Schema", "::", "TYPE_MONEY", ":", "$", "types", "[", "'number'", "]", "[", "]", "=", "$", "column", "->", "name", ";", "break", ";", "case", "Schema", "::", "TYPE_DATE", ":", "case", "Schema", "::", "TYPE_TIME", ":", "case", "Schema", "::", "TYPE_DATETIME", ":", "case", "Schema", "::", "TYPE_TIMESTAMP", ":", "$", "types", "[", "'safe'", "]", "[", "]", "=", "$", "column", "->", "name", ";", "break", ";", "default", ":", "// strings", "if", "(", "$", "column", "->", "size", ">", "0", ")", "{", "$", "lengths", "[", "$", "column", "->", "size", "]", "[", "]", "=", "$", "column", "->", "name", ";", "}", "else", "{", "$", "types", "[", "'string'", "]", "[", "]", "=", "$", "column", "->", "name", ";", "}", "}", "}", "$", "rules", "=", "[", "]", ";", "foreach", "(", "$", "types", "as", "$", "type", "=>", "$", "columns", ")", "{", "$", "rules", "[", "]", "=", "\"[['\"", ".", "implode", "(", "\"', '\"", ",", "$", "columns", ")", ".", "\"'], '$type']\"", ";", "}", "foreach", "(", "$", "lengths", "as", "$", "length", "=>", "$", "columns", ")", "{", "$", "rules", "[", "]", "=", "\"[['\"", ".", "implode", "(", "\"', '\"", ",", "$", "columns", ")", ".", "\"'], 'string', 'max' => $length]\"", ";", "}", "$", "db", "=", "$", "this", "->", "getDbConnection", "(", ")", ";", "// Unique indexes rules", "try", "{", "$", "uniqueIndexes", "=", "$", "db", "->", "getSchema", "(", ")", "->", "findUniqueIndexes", "(", "$", "table", ")", ";", "foreach", "(", "$", "uniqueIndexes", "as", "$", "uniqueColumns", ")", "{", "// Avoid validating auto incremental columns", "if", "(", "!", "$", "this", "->", "isColumnAutoIncremental", "(", "$", "table", ",", "$", "uniqueColumns", ")", ")", "{", "$", "attributesCount", "=", "count", "(", "$", "uniqueColumns", ")", ";", "if", "(", "$", "attributesCount", "===", "1", ")", "{", "$", "rules", "[", "]", "=", "\"[['\"", ".", "$", "uniqueColumns", "[", "0", "]", ".", "\"'], 'unique']\"", ";", "}", "elseif", "(", "$", "attributesCount", ">", "1", ")", "{", "$", "labels", "=", "array_intersect_key", "(", "$", "this", "->", "generateLabels", "(", "$", "table", ")", ",", "array_flip", "(", "$", "uniqueColumns", ")", ")", ";", "$", "lastLabel", "=", "array_pop", "(", "$", "labels", ")", ";", "$", "columnsList", "=", "implode", "(", "\"', '\"", ",", "$", "uniqueColumns", ")", ";", "$", "rules", "[", "]", "=", "\"[['$columnsList'], 'unique', 'targetAttribute' => ['$columnsList'], 'message' => 'The combination of \"", ".", "implode", "(", "', '", ",", "$", "labels", ")", ".", "\" and $lastLabel has already been taken.']\"", ";", "}", "}", "}", "}", "catch", "(", "NotSupportedException", "$", "e", ")", "{", "// doesn't support unique indexes information...do nothing", "}", "// Exist rules for foreign keys", "foreach", "(", "$", "table", "->", "foreignKeys", "as", "$", "refs", ")", "{", "$", "refTable", "=", "$", "refs", "[", "0", "]", ";", "$", "refTableSchema", "=", "$", "db", "->", "getTableSchema", "(", "$", "refTable", ")", ";", "if", "(", "$", "refTableSchema", "===", "null", ")", "{", "// Foreign key could point to non-existing table: https://github.com/yiisoft/yii2-gii/issues/34", "continue", ";", "}", "$", "refClassName", "=", "$", "this", "->", "generateClassName", "(", "$", "refTable", ")", ";", "unset", "(", "$", "refs", "[", "0", "]", ")", ";", "$", "attributes", "=", "implode", "(", "\"', '\"", ",", "array_keys", "(", "$", "refs", ")", ")", ";", "$", "targetAttributes", "=", "[", "]", ";", "foreach", "(", "$", "refs", "as", "$", "key", "=>", "$", "value", ")", "{", "$", "targetAttributes", "[", "]", "=", "\"'$key' => '$value'\"", ";", "}", "$", "targetAttributes", "=", "implode", "(", "', '", ",", "$", "targetAttributes", ")", ";", "$", "rules", "[", "]", "=", "\"[['$attributes'], 'exist', 'skipOnError' => true, 'targetClass' => $refClassName::className(), 'targetAttribute' => [$targetAttributes]]\"", ";", "}", "return", "$", "rules", ";", "}" ]

[ "Generates", "validation", "rules", "for", "the", "specified", "table", "." ]

[ "protected", "function", "isColumnAutoIncremental", "(", "$", "table", ",", "$", "columns", ")", "{", "foreach", "(", "$", "columns", "as", "$", "column", ")", "{", "if", "(", "isset", "(", "$", "table", "->", "columns", "[", "$", "column", "]", ")", "&&", "$", "table", "->", "columns", "[", "$", "column", "]", "->", "autoIncrement", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Checks", "if", "any", "of", "the", "specified", "columns", "is", "auto", "incremental", "." ]

[ "public", "function", "autoEncodeAttributes", "(", ")", "{", "foreach", "(", "$", "this", "->", "attributes", "as", "$", "name", ")", "{", "if", "(", "!", "isset", "(", "$", "this", "->", "owner", "->", "getDirtyAttributes", "(", ")", "[", "$", "name", "]", ")", ")", "{", "continue", ";", "}", "$", "value", "=", "$", "this", "->", "owner", "->", "{", "$", "name", "}", ";", "if", "(", "is_array", "(", "$", "value", ")", ")", "{", "$", "this", "->", "owner", "->", "{", "$", "name", "}", "=", "$", "this", "->", "jsonEncode", "(", "$", "name", ")", ";", "}", "}", "}" ]

[ "Encode", "attributes", "." ]

[ "public", "static", "function", "coverSensitiveValues", "(", "array", "$", "data", ",", "array", "$", "keys", "=", "[", "]", ")", "{", "if", "(", "empty", "(", "$", "keys", ")", ")", "{", "$", "keys", "=", "self", "::", "$", "sensitiveDefaultKeys", ";", "}", "$", "clean", "=", "[", "]", ";", "foreach", "(", "$", "keys", "as", "$", "key", ")", "{", "$", "kw", "=", "strtolower", "(", "$", "key", ")", ";", "foreach", "(", "$", "data", "as", "$", "k", "=>", "$", "v", ")", "{", "if", "(", "is_array", "(", "$", "v", ")", ")", "{", "$", "clean", "[", "$", "k", "]", "=", "static", "::", "coverSensitiveValues", "(", "$", "v", ",", "$", "keys", ")", ";", "}", "elseif", "(", "is_scalar", "(", "$", "v", ")", "&&", "(", "$", "kw", "==", "strtolower", "(", "$", "k", ")", "||", "StringHelper", "::", "startsWith", "(", "strtolower", "(", "$", "k", ")", ",", "$", "kw", ")", ")", ")", "{", "$", "v", "=", "str_repeat", "(", "\"*\"", ",", "strlen", "(", "$", "v", ")", ")", ";", "$", "clean", "[", "$", "k", "]", "=", "$", "v", ";", "}", "}", "}", "// the later overrides the former", "return", "array_replace", "(", "$", "data", ",", "$", "clean", ")", ";", "}" ]

[ "Cover", "senstive", "values", "from", "a", "given", "list", "of", "keys", "." ]

[ "public", "static", "function", "arrayUnshiftAssoc", "(", "&", "$", "arr", ",", "$", "key", ",", "$", "val", ")", "{", "$", "arr", "=", "array_reverse", "(", "$", "arr", ",", "true", ")", ";", "$", "arr", "[", "$", "key", "]", "=", "$", "val", ";", "return", "array_reverse", "(", "$", "arr", ",", "true", ")", ";", "}" ]

[ "Prepend", "an", "assoc", "array", "item", "as", "first", "entry", "for", "a", "given", "array", "." ]

[ "public", "static", "function", "typeCast", "(", "array", "$", "array", ")", "{", "$", "return", "=", "[", "]", ";", "foreach", "(", "$", "array", "as", "$", "k", "=>", "$", "v", ")", "{", "if", "(", "is_numeric", "(", "$", "v", ")", ")", "{", "$", "return", "[", "$", "k", "]", "=", "StringHelper", "::", "typeCastNumeric", "(", "$", "v", ")", ";", "}", "elseif", "(", "is_array", "(", "$", "v", ")", ")", "{", "$", "return", "[", "$", "k", "]", "=", "self", "::", "typeCast", "(", "$", "v", ")", ";", "}", "else", "{", "$", "return", "[", "$", "k", "]", "=", "$", "v", ";", "}", "}", "return", "$", "return", ";", "}" ]

[ "TypeCast", "values", "from", "a", "mixed", "array", "source", ".", "numeric", "values", "will", "be", "casted", "as", "integer", "." ]

[ "public", "static", "function", "search", "(", "array", "$", "array", ",", "$", "searchText", ",", "$", "sensitive", "=", "false", ")", "{", "$", "function", "=", "(", "$", "sensitive", ")", "?", "'strpos'", ":", "'stripos'", ";", "return", "array_filter", "(", "$", "array", ",", "function", "(", "$", "item", ")", "use", "(", "$", "searchText", ",", "$", "function", ")", "{", "$", "response", "=", "false", ";", "foreach", "(", "$", "item", "as", "$", "key", "=>", "$", "value", ")", "{", "if", "(", "$", "response", ")", "{", "continue", ";", "}", "if", "(", "$", "function", "(", "$", "value", ",", "\"$searchText\"", ")", "!==", "false", ")", "{", "$", "response", "=", "true", ";", "}", "}", "return", "$", "response", ";", "}", ")", ";", "}" ]

[ "Search", "trough", "all", "keys", "inside", "of", "an", "array", "any", "occurence", "will", "return", "the", "rest", "of", "the", "array", "." ]

[ "public", "static", "function", "searchColumn", "(", "array", "$", "array", ",", "$", "column", ",", "$", "search", ")", "{", "$", "array", "=", "array_values", "(", "$", "array", ")", ";", "// align array keys", "$", "columns", "=", "array_column", "(", "$", "array", ",", "$", "column", ")", ";", "$", "key", "=", "array_search", "(", "$", "search", ",", "$", "columns", ")", ";", "return", "(", "$", "key", "!==", "false", ")", "?", "$", "array", "[", "$", "key", "]", ":", "false", ";", "}" ]

[ "Search", "for", "a", "Column", "Value", "inside", "a", "Multidimension", "array", "and", "return", "the", "array", "with", "the", "found", "key", "." ]

[ "public", "static", "function", "searchColumns", "(", "array", "$", "array", ",", "$", "column", ",", "$", "search", ")", "{", "$", "keys", "=", "array_filter", "(", "$", "array", ",", "function", "(", "$", "var", ")", "use", "(", "$", "column", ",", "$", "search", ")", "{", "return", "strcasecmp", "(", "$", "search", ",", "$", "var", "[", "$", "column", "]", ")", "==", "0", "?", "true", ":", "false", ";", "}", ")", ";", "return", "$", "keys", ";", "}" ]

[ "Search", "for", "columns", "with", "the", "given", "search", "value", "returns", "the", "full", "array", "with", "all", "valid", "items", "." ]

[ "public", "static", "function", "generateRange", "(", "$", "from", ",", "$", "to", ",", "$", "text", "=", "null", ")", "{", "$", "range", "=", "range", "(", "$", "from", ",", "$", "to", ")", ";", "$", "array", "=", "array_combine", "(", "$", "range", ",", "$", "range", ")", ";", "if", "(", "$", "text", ")", "{", "array_walk", "(", "$", "array", ",", "function", "(", "&", "$", "item", ",", "$", "key", ")", "use", "(", "$", "text", ")", "{", "if", "(", "is_array", "(", "$", "text", ")", ")", "{", "list", "(", "$", "singular", ",", "$", "plural", ")", "=", "$", "text", ";", "if", "(", "$", "key", "==", "1", ")", "{", "$", "item", "=", "\"{$key} {$singular}\"", ";", "}", "else", "{", "$", "item", "=", "\"{$key} {$plural}\"", ";", "}", "}", "else", "{", "$", "item", "=", "\"{$key} {$text}\"", ";", "}", "}", ")", ";", "}", "return", "$", "array", ";", "}" ]

[ "Generate", "an", "Array", "from", "a", "Rang", "with", "an", "appending", "optional", "Text", "." ]

[ "public", "static", "function", "humanReadableFilesize", "(", "$", "size", ")", "{", "$", "mod", "=", "1024", ";", "$", "units", "=", "explode", "(", "' '", ",", "'B KB MB GB TB PB'", ")", ";", "for", "(", "$", "i", "=", "0", ";", "$", "size", ">", "$", "mod", ";", "++", "$", "i", ")", "{", "$", "size", "/=", "$", "mod", ";", "}", "return", "round", "(", "$", "size", ",", "2", ")", ".", "' '", ".", "$", "units", "[", "$", "i", "]", ";", "}" ]

[ "Generate", "a", "human", "readable", "size", "informations", "from", "provided", "Byte", "/", "s", "size" ]

[ "public", "static", "function", "ensureExtension", "(", "$", "file", ",", "$", "extension", ")", "{", "$", "info", "=", "pathinfo", "(", "$", "file", ")", ";", "if", "(", "!", "isset", "(", "$", "info", "[", "'extension'", "]", ")", "||", "empty", "(", "$", "info", "[", "'extension'", "]", ")", ")", "{", "$", "file", "=", "rtrim", "(", "$", "file", ",", "'.'", ")", ".", "'.'", ".", "$", "extension", ";", "}", "return", "$", "file", ";", "}" ]

[ "Append", "a", "file", "extension", "to", "a", "path", "/", "file", "if", "there", "is", "no", "or", "an", "empty", "extension", "provided", "this", "helper", "methods", "is", "used", "to", "make", "sure", "the", "right", "extension", "existing", "on", "files", "." ]

[ "public", "static", "function", "classInfo", "(", "$", "file", ")", "{", "if", "(", "is_file", "(", "$", "file", ")", ")", "{", "$", "phpCode", "=", "file_get_contents", "(", "$", "file", ")", ";", "}", "else", "{", "$", "phpCode", "=", "$", "file", ";", "}", "$", "namespace", "=", "false", ";", "if", "(", "preg_match", "(", "'/^namespace\\s+(.+?);(\\s+|\\r\\n)?$/sm'", ",", "$", "phpCode", ",", "$", "results", ")", ")", "{", "$", "namespace", "=", "$", "results", "[", "1", "]", ";", "}", "$", "classes", "=", "self", "::", "classNameByTokens", "(", "$", "phpCode", ")", ";", "return", "[", "'namespace'", "=>", "$", "namespace", ",", "'class'", "=>", "end", "(", "$", "classes", ")", "]", ";", "}" ]

[ "Provide", "class", "informations", "from", "a", "file", "path", "or", "file", "content", "." ]

[ "private", "static", "function", "classNameByTokens", "(", "$", "phpCode", ")", "{", "$", "classes", "=", "[", "]", ";", "$", "tokens", "=", "token_get_all", "(", "$", "phpCode", ")", ";", "$", "count", "=", "count", "(", "$", "tokens", ")", ";", "for", "(", "$", "i", "=", "2", ";", "$", "i", "<", "$", "count", ";", "$", "i", "++", ")", "{", "if", "(", "$", "tokens", "[", "$", "i", "-", "2", "]", "[", "0", "]", "==", "T_CLASS", "&&", "$", "tokens", "[", "$", "i", "-", "1", "]", "[", "0", "]", "==", "T_WHITESPACE", "&&", "$", "tokens", "[", "$", "i", "]", "[", "0", "]", "==", "T_STRING", ")", "{", "$", "classes", "[", "]", "=", "$", "tokens", "[", "$", "i", "]", "[", "1", "]", ";", "}", "}", "return", "$", "classes", ";", "}" ]

[ "Tokenize", "the", "php", "code", "from", "a", "given", "class", "in", "in", "order", "to", "determine", "the", "class", "name", "." ]

[ "public", "static", "function", "getFileInfo", "(", "$", "sourceFile", ")", "{", "$", "path", "=", "pathinfo", "(", "$", "sourceFile", ")", ";", "return", "(", "object", ")", "[", "'extension'", "=>", "(", "isset", "(", "$", "path", "[", "'extension'", "]", ")", "&&", "!", "empty", "(", "$", "path", "[", "'extension'", "]", ")", ")", "?", "mb_strtolower", "(", "$", "path", "[", "'extension'", "]", ",", "'UTF-8'", ")", ":", "false", ",", "'name'", "=>", "(", "isset", "(", "$", "path", "[", "'filename'", "]", ")", "&&", "!", "empty", "(", "$", "path", "[", "'filename'", "]", ")", ")", "?", "$", "path", "[", "'filename'", "]", ":", "false", ",", "'source'", "=>", "$", "sourceFile", ",", "'sourceFilename'", "=>", "(", "isset", "(", "$", "path", "[", "'dirname'", "]", ")", "&&", "isset", "(", "$", "path", "[", "'filename'", "]", ")", ")", "?", "$", "path", "[", "'dirname'", "]", ".", "DIRECTORY_SEPARATOR", ".", "$", "path", "[", "'filename'", "]", ":", "false", ",", "]", ";", "}" ]

[ "Get", "extension", "and", "name", "from", "a", "file", "for", "the", "provided", "source", "/", "path", "of", "the", "file", "." ]

[ "public", "static", "function", "writeFile", "(", "$", "fileName", ",", "$", "content", ")", "{", "try", "{", "$", "response", "=", "file_put_contents", "(", "Yii", "::", "getAlias", "(", "$", "fileName", ")", ",", "$", "content", ")", ";", "if", "(", "$", "response", "===", "false", ")", "{", "return", "false", ";", "}", "}", "catch", "(", "Exception", "$", "error", ")", "{", "return", "false", ";", "}", "return", "true", ";", "}" ]

[ "Basic", "helper", "method", "to", "write", "files", "with", "exception", "capture", ".", "The", "fileName", "will", "auto", "wrapped", "trough", "the", "Yii", "::", "getAlias", "function", "." ]

[ "public", "static", "function", "unlink", "(", "$", "file", ")", "{", "// no errors should be thrown, return false instead.", "try", "{", "if", "(", "parent", "::", "unlink", "(", "$", "file", ")", ")", "{", "return", "true", ";", "}", "}", "catch", "(", "\\", "Exception", "$", "e", ")", "{", "}", "// try to force symlinks", "if", "(", "is_link", "(", "$", "file", ")", ")", "{", "$", "sym", "=", "@", "readlink", "(", "$", "file", ")", ";", "if", "(", "$", "sym", ")", "{", "if", "(", "@", "unlink", "(", "$", "file", ")", ")", "{", "return", "true", ";", "}", "}", "}", "// try to use realpath", "if", "(", "realpath", "(", "$", "file", ")", "&&", "realpath", "(", "$", "file", ")", "!==", "$", "file", ")", "{", "if", "(", "@", "unlink", "(", "realpath", "(", "$", "file", ")", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Unlink", "a", "file", "which", "handles", "symlinks", "." ]

[ "public", "function", "routeHasLanguageCompositionPrefix", "(", "$", "route", ",", "$", "language", ")", "{", "$", "parts", "=", "explode", "(", "\"/\"", ",", "$", "route", ")", ";", "if", "(", "isset", "(", "$", "parts", "[", "0", "]", ")", "&&", "$", "parts", "[", "0", "]", "==", "$", "language", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Ensure", "whether", "a", "route", "starts", "with", "a", "language", "short", "key", "or", "not", "." ]

[ "public", "function", "parseRequest", "(", "$", "request", ")", "{", "// extra data from request to composition, which changes the pathInfo of the Request-Object.", "$", "resolver", "=", "$", "this", "->", "getComposition", "(", ")", "->", "getResolvedPathInfo", "(", "$", "request", ")", ";", "try", "{", "$", "request", "->", "setPathInfo", "(", "$", "resolver", "->", "resolvedPath", ")", ";", "}", "catch", "(", "NotFoundHttpException", "$", "error", ")", "{", "// the resolver has thrown an 404 excpetion, stop parsing request and return false (which is: page not found)", "return", "false", ";", "}", "$", "parsedRequest", "=", "parent", "::", "parseRequest", "(", "$", "request", ")", ";", "// ensure if the parsed route first match equals the composition pattern.", "// This can be the case when composition is hidden, but not default language is loaded and a", "// url composition route is loaded!", "// @see https://github.com/luyadev/luya/issues/1146", "$", "res", "=", "$", "this", "->", "routeHasLanguageCompositionPrefix", "(", "$", "parsedRequest", "[", "0", "]", ",", "$", "resolver", "->", "getResolvedKeyValue", "(", "'langShortCode'", ")", ")", ";", "// set the application language based from the parsed composition request:", "Yii", "::", "$", "app", "->", "setLocale", "(", "$", "this", "->", "composition", "->", "langShortCode", ")", ";", "// if enableStrictParsing is enabled and the route is not found, $parsedRequest will return `false`.", "if", "(", "$", "res", "===", "false", "&&", "(", "$", "this", "->", "composition", "->", "hidden", "||", "$", "parsedRequest", "===", "false", ")", ")", "{", "return", "$", "parsedRequest", ";", "}", "$", "composition", "=", "$", "this", "->", "composition", "->", "createRoute", "(", ")", ";", "$", "length", "=", "strlen", "(", "$", "composition", ")", ";", "$", "route", "=", "$", "parsedRequest", "[", "0", "]", ";", "if", "(", "substr", "(", "$", "route", ",", "0", ",", "$", "length", "+", "1", ")", "==", "$", "composition", ".", "'/'", ")", "{", "$", "parsedRequest", "[", "0", "]", "=", "substr", "(", "$", "parsedRequest", "[", "0", "]", ",", "$", "length", ")", ";", "}", "// remove start trailing slashes from route.", "$", "parsedRequest", "[", "0", "]", "=", "ltrim", "(", "$", "parsedRequest", "[", "0", "]", ",", "'/'", ")", ";", "return", "$", "parsedRequest", ";", "}" ]

[ "Extend", "functionality", "of", "parent", "::", "parseRequest", "()", "by", "verify", "and", "resolve", "the", "composition", "informations", "." ]

[ "public", "function", "addRules", "(", "$", "rules", ",", "$", "append", "=", "true", ")", "{", "foreach", "(", "$", "rules", "as", "$", "key", "=>", "$", "rule", ")", "{", "if", "(", "is_array", "(", "$", "rule", ")", "&&", "isset", "(", "$", "rule", "[", "'composition'", "]", ")", ")", "{", "foreach", "(", "$", "rule", "[", "'composition'", "]", "as", "$", "composition", "=>", "$", "pattern", ")", "{", "$", "rules", "[", "]", "=", "[", "'pattern'", "=>", "$", "pattern", ",", "'route'", "=>", "$", "composition", ".", "'/'", ".", "$", "rule", "[", "'route'", "]", ",", "]", ";", "}", "}", "}", "return", "parent", "::", "addRules", "(", "$", "rules", ",", "$", "append", ")", ";", "}" ]

[ "Extend", "functionality", "of", "parent", "::", "addRules", "by", "the", "ability", "to", "add", "composition", "routes", "." ]

[ "public", "function", "getMenu", "(", ")", "{", "if", "(", "$", "this", "->", "_menu", "===", "null", ")", "{", "$", "menu", "=", "Yii", "::", "$", "app", "->", "get", "(", "'menu'", ",", "false", ")", ";", "if", "(", "$", "menu", ")", "{", "$", "this", "->", "_menu", "=", "$", "menu", ";", "}", "else", "{", "$", "this", "->", "_menu", "=", "false", ";", "}", "}", "return", "$", "this", "->", "_menu", ";", "}" ]

[ "Get", "the", "menu", "component", "if", "its", "registered", "in", "the", "current", "applications", "." ]

[ "public", "function", "getComposition", "(", ")", "{", "if", "(", "$", "this", "->", "_composition", "===", "null", ")", "{", "$", "this", "->", "_composition", "=", "Yii", "::", "$", "app", "->", "get", "(", "'composition'", ")", ";", "}", "return", "$", "this", "->", "_composition", ";", "}" ]

[ "Get", "the", "composition", "component" ]

[ "public", "function", "createUrl", "(", "$", "params", ")", "{", "$", "response", "=", "$", "this", "->", "internalCreateUrl", "(", "$", "params", ")", ";", "if", "(", "$", "this", "->", "contextNavItemId", ")", "{", "return", "$", "this", "->", "urlReplaceModule", "(", "$", "response", ",", "$", "this", "->", "contextNavItemId", ",", "$", "this", "->", "getComposition", "(", ")", ")", ";", "}", "return", "$", "response", ";", "}" ]

[ "Extend", "createUrl", "method", "by", "verify", "its", "context", "implementation", "to", "add", "cms", "urls", "prepand", "to", "the", "requested", "createurl", "params", "." ]

[ "public", "function", "createMenuItemUrl", "(", "$", "params", ",", "$", "navItemId", ",", "$", "composition", "=", "null", ")", "{", "$", "composition", "=", "empty", "(", "$", "composition", ")", "?", "$", "this", "->", "getComposition", "(", ")", ":", "$", "composition", ";", "$", "url", "=", "$", "this", "->", "internalCreateUrl", "(", "$", "params", ",", "$", "composition", ")", ";", "if", "(", "!", "$", "this", "->", "menu", ")", "{", "return", "$", "url", ";", "}", "return", "$", "this", "->", "urlReplaceModule", "(", "$", "url", ",", "$", "navItemId", ",", "$", "composition", ")", ";", "}" ]

[ "Create", "an", "url", "for", "a", "menu", "item", "." ]

[ "public", "function", "internalCreateUrl", "(", "$", "params", ",", "$", "composition", "=", "null", ")", "{", "$", "params", "=", "(", "array", ")", "$", "params", ";", "$", "composition", "=", "empty", "(", "$", "composition", ")", "?", "$", "this", "->", "getComposition", "(", ")", ":", "$", "composition", ";", "$", "originalParams", "=", "$", "params", ";", "// prepand the original route, whether is hidden or not!", "// https://github.com/luyadev/luya/issues/1146", "$", "params", "[", "0", "]", "=", "$", "composition", "->", "prependTo", "(", "$", "params", "[", "0", "]", ",", "$", "composition", "->", "createRoute", "(", ")", ")", ";", "$", "response", "=", "parent", "::", "createUrl", "(", "$", "params", ")", ";", "// Check if the parsed route with the prepand composition has been found or not.", "if", "(", "strpos", "(", "$", "response", ",", "rtrim", "(", "$", "params", "[", "0", "]", ",", "'/'", ")", ")", "!==", "false", ")", "{", "// we got back the same url from the createUrl, no match against composition route.", "$", "response", "=", "parent", "::", "createUrl", "(", "$", "originalParams", ")", ";", "}", "$", "response", "=", "$", "this", "->", "removeBaseUrl", "(", "$", "response", ")", ";", "$", "response", "=", "$", "composition", "->", "prependTo", "(", "$", "response", ")", ";", "return", "$", "this", "->", "prependBaseUrl", "(", "$", "response", ")", ";", "}" ]

[ "Yii2", "createUrl", "base", "implementation", "extends", "the", "prepand", "of", "the", "comosition" ]

[ "public", "function", "internalCreateAbsoluteUrl", "(", "$", "params", ",", "$", "scheme", "=", "null", ")", "{", "$", "params", "=", "(", "array", ")", "$", "params", ";", "$", "url", "=", "$", "this", "->", "internalCreateUrl", "(", "$", "params", ")", ";", "if", "(", "strpos", "(", "$", "url", ",", "'://'", ")", "===", "false", ")", "{", "$", "url", "=", "$", "this", "->", "getHostInfo", "(", ")", ".", "$", "url", ";", "}", "if", "(", "is_string", "(", "$", "scheme", ")", "&&", "(", "$", "pos", "=", "strpos", "(", "$", "url", ",", "'://'", ")", ")", "!==", "false", ")", "{", "$", "url", "=", "$", "scheme", ".", "substr", "(", "$", "url", ",", "$", "pos", ")", ";", "}", "return", "$", "url", ";", "}" ]

[ "Create", "absolute", "url", "from", "the", "given", "route", "params", "." ]

[ "private", "function", "findModuleInRoute", "(", "$", "route", ")", "{", "$", "route", "=", "parse_url", "(", "$", "route", ",", "PHP_URL_PATH", ")", ";", "$", "parts", "=", "array_values", "(", "array_filter", "(", "explode", "(", "'/'", ",", "$", "route", ")", ")", ")", ";", "if", "(", "isset", "(", "$", "parts", "[", "0", "]", ")", "&&", "array_key_exists", "(", "$", "parts", "[", "0", "]", ",", "Yii", "::", "$", "app", "->", "getApplicationModules", "(", ")", ")", ")", "{", "return", "$", "parts", "[", "0", "]", ";", "}", "return", "false", ";", "}" ]

[ "See", "if", "the", "module", "of", "a", "provided", "route", "exists", "in", "the", "luya", "application", "list", "." ]

[ "private", "function", "urlReplaceModule", "(", "$", "url", ",", "$", "navItemId", ",", "Composition", "$", "composition", ")", "{", "$", "route", "=", "$", "composition", "->", "removeFrom", "(", "$", "this", "->", "removeBaseUrl", "(", "$", "url", ")", ")", ";", "$", "moduleName", "=", "$", "this", "->", "findModuleInRoute", "(", "$", "route", ")", ";", "if", "(", "$", "moduleName", "===", "false", "||", "$", "this", "->", "menu", "===", "false", ")", "{", "return", "$", "url", ";", "}", "$", "item", "=", "$", "this", "->", "menu", "->", "find", "(", ")", "->", "where", "(", "[", "'id'", "=>", "$", "navItemId", "]", ")", "->", "with", "(", "'hidden'", ")", "->", "lang", "(", "$", "composition", "[", "'langShortCode'", "]", ")", "->", "one", "(", ")", ";", "if", "(", "!", "$", "item", ")", "{", "throw", "new", "BadRequestHttpException", "(", "\"Unable to find nav_item_id '$navItemId' to generate the module link for url '$url'.\"", ")", ";", "}", "$", "isOutgoingModulePage", "=", "$", "item", "->", "type", "==", "2", "&&", "$", "moduleName", "!==", "$", "item", "->", "moduleName", ";", "// 1. if the current page is a module and the requested url is not the same module, its an outgoing link to", "// another module which should not be modificated.", "// 2. If the current page (nav) context is the homepage, we have to keep the original link as it wont work because the homepage", "// does not have a route prefix.", "if", "(", "$", "isOutgoingModulePage", "||", "$", "item", "->", "isHome", ")", "{", "return", "$", "url", ";", "}", "// 1. if the current page is a module and the requested url is not the same module, its an outgoing link to", "// another module and ...", "// 2. if current controller context has an other module as the requested url, its an outgoing link to another module which should not be modificated.", "if", "(", "$", "isOutgoingModulePage", "&&", "$", "moduleName", "!==", "Yii", "::", "$", "app", "->", "controller", "->", "module", "->", "id", ")", "{", "return", "$", "url", ";", "}", "return", "preg_replace", "(", "\"/$moduleName/\"", ",", "rtrim", "(", "$", "item", "->", "link", ",", "'/'", ")", ",", "ltrim", "(", "$", "route", ",", "'/'", ")", ",", "1", ")", ";", "}" ]

[ "Replace", "the", "url", "with", "the", "current", "module", "context", "." ]

[ "public", "function", "setAreaServed", "(", "$", "areaServed", ")", "{", "ObjectHelper", "::", "isInstanceOf", "(", "$", "areaServed", ",", "[", "Place", "::", "class", ",", "TextValue", "::", "class", "]", ")", ";", "$", "this", "->", "_areaServed", "=", "$", "areaServed", ";", "return", "$", "this", ";", "}" ]

[ "Set", "Area", "Served", "." ]

[ "public", "function", "inGroup", "(", "$", "alias", ")", "{", "if", "(", "$", "this", "->", "isGuest", ")", "{", "return", "false", ";", "}", "$", "identity", "=", "$", "this", "->", "identity", ";", "if", "(", "!", "$", "identity", "instanceof", "GroupUserIdentityInterface", ")", "{", "throw", "new", "InvalidConfigException", "(", "'The $identityClass must be instance of luya\\web\\GroupUserIdentityInterface.'", ")", ";", "}", "$", "groups", "=", "(", "array", ")", "$", "alias", ";", "foreach", "(", "$", "groups", "as", "$", "groupAlias", ")", "{", "if", "(", "in_array", "(", "$", "groupAlias", ",", "$", "identity", "->", "authGroups", "(", ")", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Checks", "whether", "a", "user", "exists", "for", "the", "provided", "group", "based", "on", "the", "GroupUserIdentityInterface", "implementation" ]

[ "public", "static", "function", "isInstanceOf", "(", "$", "object", ",", "$", "haystack", ",", "$", "throwException", "=", "true", ")", "{", "// if instances is an object (compare object directly) we have to get the class name to compare with instanceof later", "if", "(", "is_object", "(", "$", "haystack", ")", ")", "{", "$", "haystack", "=", "get_class", "(", "$", "haystack", ")", ";", "}", "$", "haystack", "=", "(", "array", ")", "$", "haystack", ";", "foreach", "(", "$", "haystack", "as", "$", "class", ")", "{", "if", "(", "$", "object", "instanceof", "$", "class", ")", "{", "return", "true", ";", "}", "}", "if", "(", "$", "throwException", ")", "{", "throw", "new", "Exception", "(", "\"The given object must be an instance of: \"", ".", "implode", "(", "\",\"", ",", "$", "haystack", ")", ")", ";", "}", "return", "false", ";", "}" ]

[ "Checks", "a", "given", "variable", "if", "its", "an", "instance", "of", "an", "element", "in", "the", "$instances", "list", "." ]

[ "public", "static", "function", "isTraitInstanceOf", "(", "$", "object", ",", "$", "haystack", ")", "{", "$", "traits", "=", "static", "::", "traitsList", "(", "$", "object", ")", ";", "// if its an object, the all traits for the given object.", "if", "(", "is_object", "(", "$", "haystack", ")", ")", "{", "$", "haystack", "=", "static", "::", "traitsList", "(", "$", "haystack", ")", ";", "}", "foreach", "(", "(", "array", ")", "$", "haystack", "as", "$", "stack", ")", "{", "if", "(", "in_array", "(", "$", "stack", ",", "$", "traits", ")", ")", "{", "return", "true", ";", "}", "}", "return", "false", ";", "}" ]

[ "Check", "whether", "a", "given", "object", "contains", "a", "trait", "." ]

[ "public", "static", "function", "traitsList", "(", "$", "object", ",", "$", "autoload", "=", "true", ")", "{", "$", "traits", "=", "[", "]", ";", "// Get traits of all parent classes", "do", "{", "$", "traits", "=", "array_merge", "(", "class_uses", "(", "$", "object", ",", "$", "autoload", ")", ",", "$", "traits", ")", ";", "}", "while", "(", "$", "object", "=", "get_parent_class", "(", "$", "object", ")", ")", ";", "// Get traits of all parent traits", "$", "traitsToSearch", "=", "$", "traits", ";", "while", "(", "!", "empty", "(", "$", "traitsToSearch", ")", ")", "{", "$", "newTraits", "=", "class_uses", "(", "array_pop", "(", "$", "traitsToSearch", ")", ",", "$", "autoload", ")", ";", "$", "traits", "=", "array_merge", "(", "$", "newTraits", ",", "$", "traits", ")", ";", "$", "traitsToSearch", "=", "array_merge", "(", "$", "newTraits", ",", "$", "traitsToSearch", ")", ";", "}", ";", "foreach", "(", "$", "traits", "as", "$", "trait", "=>", "$", "same", ")", "{", "$", "traits", "=", "array_merge", "(", "class_uses", "(", "$", "trait", ",", "$", "autoload", ")", ",", "$", "traits", ")", ";", "}", "return", "$", "traits", ";", "}" ]

[ "Get", "an", "array", "with", "all", "traits", "for", "a", "given", "object" ]

[ "public", "static", "function", "callMethodSanitizeArguments", "(", "$", "object", ",", "$", "method", ",", "array", "$", "argumentsList", "=", "[", "]", ")", "{", "// get class reflection object", "$", "reflection", "=", "new", "ReflectionMethod", "(", "$", "object", ",", "$", "method", ")", ";", "// array where the sanitized arguemnts will be stored", "$", "methodArgs", "=", "[", "]", ";", "foreach", "(", "$", "reflection", "->", "getParameters", "(", ")", "as", "$", "param", ")", "{", "// add the argument into the method list when existing", "if", "(", "array_key_exists", "(", "$", "param", "->", "name", ",", "$", "argumentsList", ")", ")", "{", "$", "methodArgs", "[", "]", "=", "$", "argumentsList", "[", "$", "param", "->", "name", "]", ";", "}", "// check if the provided arguemnt is optional or not", "if", "(", "!", "$", "param", "->", "isOptional", "(", ")", "&&", "!", "array_key_exists", "(", "$", "param", "->", "name", ",", "$", "argumentsList", ")", ")", "{", "throw", "new", "Exception", "(", "sprintf", "(", "\"The argument '%s' is required for method '%s' in class '%s'.\"", ",", "$", "param", "->", "name", ",", "$", "method", ",", "get_class", "(", "$", "object", ")", ")", ")", ";", "}", "}", "return", "call_user_func_array", "(", "[", "$", "object", ",", "$", "method", "]", ",", "$", "methodArgs", ")", ";", "}" ]

[ "Call", "a", "method", "and", "ensure", "arguments", "." ]

[ "public", "function", "resolveRoute", "(", "$", "route", ")", "{", "$", "routeParts", "=", "explode", "(", "'/'", ",", "$", "route", ")", ";", "foreach", "(", "$", "routeParts", "as", "$", "k", "=>", "$", "v", ")", "{", "if", "(", "(", "$", "k", "==", "0", "&&", "$", "v", "==", "$", "this", "->", "id", ")", "||", "(", "empty", "(", "$", "v", ")", ")", ")", "{", "unset", "(", "$", "routeParts", "[", "$", "k", "]", ")", ";", "}", "}", "if", "(", "count", "(", "$", "routeParts", ")", "==", "0", ")", "{", "return", "$", "this", "->", "defaultRoute", ";", "}", "return", "implode", "(", "'/'", ",", "$", "routeParts", ")", ";", "}" ]

[ "Extract", "the", "current", "module", "from", "the", "route", "and", "return", "the", "new", "resolved", "route", "." ]

[ "public", "function", "getControllerFiles", "(", ")", "{", "$", "files", "=", "[", "]", ";", "try", "{", "// https://github.com/yiisoft/yii2/blob/master/framework/base/Module.php#L253", "foreach", "(", "FileHelper", "::", "findFiles", "(", "$", "this", "->", "controllerPath", ")", "as", "$", "file", ")", "{", "$", "files", "[", "$", "this", "->", "fileToName", "(", "$", "this", "->", "controllerPath", ",", "$", "file", ")", "]", "=", "$", "file", ";", "}", "}", "catch", "(", "InvalidParamException", "$", "e", ")", "{", "try", "{", "$", "staticPath", "=", "static", "::", "staticBasePath", "(", ")", ".", "DIRECTORY_SEPARATOR", ".", "'controllers'", ";", "foreach", "(", "FileHelper", "::", "findFiles", "(", "$", "staticPath", ")", "as", "$", "file", ")", "{", "$", "files", "[", "$", "this", "->", "fileToName", "(", "$", "staticPath", ",", "$", "file", ")", "]", "=", "$", "file", ";", "}", "}", "catch", "(", "InvalidParamException", "$", "e", ")", "{", "// catch if folder not found.", "}", "}", ";", "return", "$", "files", ";", "}" ]

[ "Returns", "all", "controller", "files", "of", "this", "module", "from", "the", "getControllerPath", "()", "folder", "where", "the", "key", "is", "the", "reusable", "id", "of", "this", "controller", "and", "value", "the", "file", "on", "the", "server", "." ]

[ "public", "static", "function", "registerTranslation", "(", "$", "prefix", ",", "$", "basePath", ",", "array", "$", "fileMap", ")", "{", "if", "(", "!", "isset", "(", "Yii", "::", "$", "app", "->", "i18n", "->", "translations", "[", "$", "prefix", "]", ")", ")", "{", "Yii", "::", "$", "app", "->", "i18n", "->", "translations", "[", "$", "prefix", "]", "=", "[", "'class'", "=>", "'yii\\i18n\\PhpMessageSource'", ",", "'basePath'", "=>", "$", "basePath", ",", "'fileMap'", "=>", "$", "fileMap", ",", "]", ";", "}", "}" ]

[ "Register", "a", "Translation", "to", "the", "i18n", "component", "." ]

[ "public", "static", "function", "baseT", "(", "$", "category", ",", "$", "message", ",", "array", "$", "params", "=", "[", "]", ",", "$", "language", "=", "null", ")", "{", "static", "::", "onLoad", "(", ")", ";", "return", "Yii", "::", "t", "(", "$", "category", ",", "$", "message", ",", "$", "params", ",", "$", "language", ")", ";", "}" ]

[ "Base", "translation", "method", "which", "invokes", "the", "onLoad", "function", "." ]

[ "public", "function", "setSuffix", "(", "$", "suffix", ")", "{", "$", "this", "->", "_suffix", "=", "$", "suffix", ";", "$", "this", "->", "request", "->", "setPathInfo", "(", "implode", "(", "'/'", ",", "[", "$", "this", "->", "module", "->", "id", ",", "$", "suffix", "]", ")", ")", ";", "}" ]

[ "Setter", "for", "the", "suffix", "property", "." ]

[ "public", "function", "getRequestRoute", "(", ")", "{", "if", "(", "$", "this", "->", "_requestRoute", "!==", "null", ")", "{", "return", "$", "this", "->", "_requestRoute", ";", "}", "if", "(", "$", "this", "->", "_defaultRoute", "!==", "null", "&&", "empty", "(", "$", "this", "->", "getSuffix", "(", ")", ")", ")", "{", "$", "array", "=", "$", "this", "->", "_defaultRoute", ";", "}", "else", "{", "// parse request against urlManager", "$", "route", "=", "$", "this", "->", "urlManager", "->", "parseRequest", "(", "$", "this", "->", "request", ")", ";", "// return human readable array", "$", "array", "=", "[", "'route'", "=>", "$", "route", "[", "0", "]", ",", "'args'", "=>", "$", "route", "[", "1", "]", ",", "'originalArgs'", "=>", "$", "route", "[", "1", "]", ",", "]", ";", "}", "// resolve the current route by the module", "$", "array", "[", "'route'", "]", "=", "$", "this", "->", "module", "->", "resolveRoute", "(", "$", "array", "[", "'route'", "]", ")", ";", "// if there are no arguments, all get params are assigned. In order to use the original arguments from parse request use `originalArgs` instead of `args`.", "if", "(", "empty", "(", "$", "array", "[", "'args'", "]", ")", ")", "{", "$", "array", "[", "'args'", "]", "=", "$", "this", "->", "request", "->", "get", "(", ")", ";", "}", "// @see https://github.com/luyadev/luya/issues/1267", "if", "(", "$", "this", "->", "_defaultRoute", "!==", "null", ")", "{", "$", "array", "[", "'args'", "]", "=", "array_merge", "(", "$", "this", "->", "_defaultRoute", "[", "'args'", "]", ",", "$", "array", "[", "'args'", "]", ")", ";", "}", "$", "this", "->", "_requestRoute", "=", "$", "array", ";", "return", "$", "array", ";", "}" ]

[ "Determine", "the", "default", "route", "based", "on", "current", "defaultRoutes", "or", "parsedRequested", "by", "the", "UrlManager", "." ]

[ "public", "function", "defaultRoute", "(", "$", "controller", ",", "$", "action", "=", "null", ",", "array", "$", "args", "=", "[", "]", ")", "{", "$", "this", "->", "_defaultRoute", "=", "[", "'route'", "=>", "implode", "(", "'/'", ",", "[", "$", "this", "->", "module", "->", "id", ",", "$", "controller", ",", "(", "empty", "(", "$", "action", ")", ")", "?", "'index'", ":", "$", "action", "]", ")", ",", "'args'", "=>", "$", "args", ",", "'originalArgs'", "=>", "$", "args", ",", "]", ";", "}" ]

[ "Inject", "a", "defaultRoute", "." ]

[ "public", "function", "getUrlRule", "(", ")", "{", "$", "request", "=", "$", "this", "->", "getRequestRoute", "(", ")", ";", "return", "[", "'module'", "=>", "$", "this", "->", "module", "->", "id", ",", "'route'", "=>", "$", "this", "->", "module", "->", "id", ".", "'/'", ".", "$", "request", "[", "'route'", "]", ",", "'params'", "=>", "$", "request", "[", "'originalArgs'", "]", ",", "]", ";", "}" ]

[ "Returns", "the", "url", "rule", "parameters", "which", "are", "taken", "from", "the", "requested", "route", "." ]

[ "public", "function", "run", "(", ")", "{", "$", "requestRoute", "=", "$", "this", "->", "getRequestRoute", "(", ")", ";", "// create controller object", "$", "controller", "=", "$", "this", "->", "module", "->", "createController", "(", "$", "requestRoute", "[", "'route'", "]", ")", ";", "// throw error if the requests request does not returns a valid controller object", "if", "(", "!", "isset", "(", "$", "controller", "[", "0", "]", ")", "&&", "!", "is_object", "(", "$", "controller", "[", "0", "]", ")", ")", "{", "throw", "new", "NotFoundHttpException", "(", "sprintf", "(", "\"Unable to create controller '%s' for module '%s'.\"", ",", "$", "requestRoute", "[", "'route'", "]", ",", "$", "this", "->", "module", "->", "id", ")", ")", ";", "}", "Yii", "::", "debug", "(", "'LUYA module run module \"'", ".", "$", "this", "->", "module", "->", "id", ".", "'\" route '", ".", "$", "requestRoute", "[", "'route'", "]", ",", "__METHOD__", ")", ";", "$", "this", "->", "controller", "=", "$", "controller", "[", "0", "]", ";", "$", "originalController", "=", "Yii", "::", "$", "app", "->", "controller", ";", "/**\n * Override the current application controller in order to ensure current() url handling which is used\n * for relativ urls/rules.\n *\n * @see https://github.com/luyadev/luya/issues/1730\n */", "$", "this", "->", "controller", "->", "on", "(", "Controller", "::", "EVENT_BEFORE_ACTION", ",", "function", "(", "$", "event", ")", "{", "Yii", "::", "$", "app", "->", "controller", "=", "$", "this", "->", "controller", ";", "}", ")", ";", "/**\n * Restore the original controller instance after rendering.\n *\n * @see https://github.com/luyadev/luya/issues/1768\n */", "$", "this", "->", "controller", "->", "on", "(", "Controller", "::", "EVENT_AFTER_ACTION", ",", "function", "(", "$", "event", ")", "use", "(", "$", "originalController", ")", "{", "Yii", "::", "$", "app", "->", "controller", "=", "$", "originalController", ";", "}", ")", ";", "// run the action on the provided controller object", "return", "$", "this", "->", "controller", "->", "runAction", "(", "$", "controller", "[", "1", "]", ",", "$", "requestRoute", "[", "'args'", "]", ")", ";", "}" ]

[ "Run", "the", "route", "based", "on", "the", "values", "." ]

[ "public", "function", "iteration", "(", "$", "value", ",", "$", "key", "=", "null", ")", "{", "if", "(", "is_null", "(", "$", "key", ")", ")", "{", "$", "this", "->", "_iterations", "[", "]", "=", "$", "value", ";", "}", "else", "{", "$", "this", "->", "_iterations", "[", "$", "key", "]", "=", "$", "value", ";", "}", "}" ]

[ "Add", "Iteration" ]

[ "public", "function", "getResolvedKeyValue", "(", "$", "key", ")", "{", "$", "keys", "=", "$", "this", "->", "resolvedValues", ";", "return", "isset", "(", "$", "keys", "[", "$", "key", "]", ")", "?", "$", "keys", "[", "$", "key", "]", ":", "false", ";", "}" ]

[ "Get", "a", "value", "for", "a", "given", "resolved", "pattern", "key", "." ]

[ "protected", "function", "getInternalResolverArray", "(", ")", "{", "if", "(", "$", "this", "->", "_resolved", "===", "null", ")", "{", "$", "requestPathInfo", "=", "$", "this", "->", "trailingPathInfo", "(", ")", ";", "$", "newRegex", "=", "$", "this", "->", "buildRegexPattern", "(", ")", ";", "// extract the rules from the regex pattern, this means you get array with keys for every rule inside the pattern string", "// example pattern: <langShortCode:[a-z]{2}>-<countryShortCode:[a-z]{2}>", "/* [0]=>\n array(3) {\n [0]=> string(24) \"<langShortCode:[a-z]{2}>\"\n [1]=> string(13) \"langShortCode\"\n [2]=> string(8) \"[a-z]{2}\"\n }\n [1]=>\n array(3) {\n [0]=> string(27) \"<countryShortCode:[a-z]{2}>\"\n [1]=> string(16) \"countryShortCode\"\n [2]=> string(8) \"[a-z]{2}\"\n }\n */", "preg_match_all", "(", "static", "::", "VAR_MATCH_REGEX", ",", "$", "this", "->", "composition", "->", "pattern", ",", "$", "patternDefinitions", ",", "PREG_SET_ORDER", ")", ";", "foreach", "(", "$", "patternDefinitions", "as", "$", "definition", ")", "{", "$", "newRegex", "=", "str_replace", "(", "$", "definition", "[", "0", "]", ",", "'('", ".", "rtrim", "(", "ltrim", "(", "$", "definition", "[", "2", "]", ",", "'('", ")", ",", "')'", ")", ".", "')'", ",", "$", "newRegex", ")", ";", "}", "preg_match_all", "(", "$", "newRegex", ",", "$", "requestPathInfo", ",", "$", "matches", ",", "PREG_SET_ORDER", ")", ";", "if", "(", "isset", "(", "$", "matches", "[", "0", "]", ")", "&&", "!", "empty", "(", "$", "matches", "[", "0", "]", ")", ")", "{", "$", "keys", "=", "[", "]", ";", "$", "matches", "=", "$", "matches", "[", "0", "]", ";", "$", "compositionPrefix", "=", "$", "matches", "[", "0", "]", ";", "unset", "(", "$", "matches", "[", "0", "]", ")", ";", "$", "matches", "=", "array_values", "(", "$", "matches", ")", ";", "foreach", "(", "$", "matches", "as", "$", "k", "=>", "$", "v", ")", "{", "$", "keys", "[", "$", "patternDefinitions", "[", "$", "k", "]", "[", "1", "]", "]", "=", "$", "v", ";", "}", "$", "route", "=", "StringHelper", "::", "replaceFirst", "(", "$", "compositionPrefix", ",", "''", ",", "$", "requestPathInfo", ")", ";", "}", "else", "{", "$", "matches", "=", "[", "]", ";", "$", "keys", "=", "$", "this", "->", "composition", "->", "default", ";", "$", "route", "=", "$", "requestPathInfo", ";", "}", "// the validation check for validates composition values is enabled", "if", "(", "$", "this", "->", "composition", "->", "expectedValues", ")", "{", "foreach", "(", "$", "keys", "as", "$", "k", "=>", "$", "v", ")", "{", "$", "possibleValues", "=", "$", "this", "->", "composition", "->", "expectedValues", "[", "$", "k", "]", ";", "if", "(", "!", "in_array", "(", "$", "v", ",", "$", "possibleValues", ")", ")", "{", "throw", "new", "NotFoundHttpException", "(", "\"The requested composition key \\\"{$k}\\\" with value \\\"{$v}\\\" is not in the possible values list.\"", ")", ";", "}", "}", "}", "$", "this", "->", "_resolved", "=", "[", "'route'", "=>", "rtrim", "(", "$", "route", ",", "'/'", ")", ",", "'values'", "=>", "$", "keys", ",", "]", ";", "}", "return", "$", "this", "->", "_resolved", ";", "}" ]

[ "Resolve", "the", "current", "data", "." ]

[ "public", "static", "function", "slug", "(", "$", "string", ",", "$", "replacement", "=", "'-'", ",", "$", "lowercase", "=", "true", ",", "$", "transliterate", "=", "true", ")", "{", "if", "(", "$", "transliterate", ")", "{", "return", "parent", "::", "slug", "(", "$", "string", ",", "$", "replacement", ",", "$", "lowercase", ")", ";", "}", "$", "string", "=", "preg_replace", "(", "'/[`%\\+=\\{\\}\\|\\\\\\.<>\\/\\_]+/u'", ",", "''", ",", "$", "string", ")", ";", "// replace those chars with nothing", "$", "string", "=", "preg_replace", "(", "'/[=\\s—–-]+/u', $r", "e", "l", "acement, $s", "t", "i", "ng); /", "/", " ", "eplace single and double spaces by $replacement char.", "$", "string", "=", "trim", "(", "$", "string", ",", "$", "replacement", ")", ";", "return", "$", "lowercase", "?", "mb_strtolower", "(", "$", "string", ")", ":", "$", "string", ";", "}" ]

[ "From", "yii", "/", "helpers", "/", "BaseInflector", ":" ]

[ "public", "function", "setAuthor", "(", "$", "author", ")", "{", "ObjectHelper", "::", "isInstanceOf", "(", "$", "author", ",", "[", "Organization", "::", "class", ",", "PersonInterface", "::", "class", "]", ")", ";", "$", "this", "->", "_author", "=", "$", "author", ";", "return", "$", "this", ";", "}" ]

[ "The", "author", "of", "this", "content", "or", "rating", ".", "Please", "note", "that", "author", "is", "special", "in", "that", "HTML", "5", "provides", "a", "special", "mechanism", "for", "indicating", "authorship", "via", "the", "rel", "tag", ".", "That", "is", "equivalent", "to", "this", "and", "may", "be", "used", "interchangeably", "." ]

[ "public", "function", "setCopyrightHolder", "(", "$", "copyrightHolder", ")", "{", "ObjectHelper", "::", "isInstanceOf", "(", "$", "copyrightHolder", ",", "[", "Organization", "::", "class", ",", "PersonInterface", "::", "class", "]", ")", ";", "$", "this", "->", "_copyrightHolder", "=", "$", "copyrightHolder", ";", "return", "$", "this", ";", "}" ]

[ "The", "party", "holding", "the", "legal", "copyright", "to", "the", "CreativeWork", "." ]

[ "public", "function", "setCreator", "(", "$", "creator", ")", "{", "ObjectHelper", "::", "isInstanceOf", "(", "$", "creator", ",", "[", "Organization", "::", "class", ",", "PersonInterface", "::", "class", "]", ")", ";", "$", "this", "->", "_creator", "=", "$", "creator", ";", "return", "$", "this", ";", "}" ]

[ "The", "creator", "/", "author", "of", "this", "CreativeWork", ".", "This", "is", "the", "same", "as", "the", "Author", "property", "for", "CreativeWork", "." ]

[ "public", "function", "setProducer", "(", "$", "producer", ")", "{", "ObjectHelper", "::", "isInstanceOf", "(", "$", "producer", ",", "[", "Organization", "::", "class", ",", "PersonInterface", "::", "class", "]", ")", ";", "$", "this", "->", "_producer", "=", "$", "producer", ";", "return", "$", "this", ";", "}" ]

[ "The", "person", "or", "organization", "who", "produced", "the", "work", "(", "e", ".", "g", ".", "music", "album", "movie", "tv", "/", "radio", "series", "etc", ".", ")", "." ]

[ "public", "function", "setProvider", "(", "$", "provider", ")", "{", "ObjectHelper", "::", "isInstanceOf", "(", "$", "provider", ",", "[", "Organization", "::", "class", ",", "PersonInterface", "::", "class", "]", ")", ";", "$", "this", "->", "_provider", "=", "$", "provider", ";", "return", "$", "this", ";", "}" ]

[ "The", "service", "provider", "service", "operator", "or", "service", "performer", ";", "the", "goods", "producer", ".", "Another", "party", "(", "a", "seller", ")", "may", "offer", "those", "services", "or", "goods", "on", "behalf", "of", "the", "provider", ".", "A", "provider", "may", "also", "serve", "as", "the", "seller", ".", "Supersedes", "carrier", "." ]

[ "public", "function", "setPublisher", "(", "$", "publisher", ")", "{", "ObjectHelper", "::", "isInstanceOf", "(", "$", "publisher", ",", "[", "Organization", "::", "class", ",", "Person", "::", "class", "]", ")", ";", "$", "this", "->", "_publisher", "=", "$", "publisher", ";", "return", "$", "this", ";", "}" ]

[ "The", "publisher", "of", "the", "creative", "work", "." ]

[ "public", "function", "setNewValue", "(", "string", "$", "field", ",", "$", "value", ")", ":", "void", "{", "$", "this", "->", "assertValidField", "(", "$", "field", ")", ";", "$", "this", "->", "documentChangeSet", "[", "$", "field", "]", "[", "1", "]", "=", "$", "value", ";", "$", "this", "->", "getDocumentManager", "(", ")", "->", "getUnitOfWork", "(", ")", "->", "setDocumentChangeSet", "(", "$", "this", "->", "getDocument", "(", ")", ",", "$", "this", "->", "documentChangeSet", ")", ";", "}" ]

[ "Sets", "the", "new", "value", "of", "this", "field", "." ]

[ "public", "function", "getDocumentNamespace", "(", "string", "$", "documentNamespaceAlias", ")", ":", "string", "{", "if", "(", "!", "isset", "(", "$", "this", "->", "attributes", "[", "'documentNamespaces'", "]", "[", "$", "documentNamespaceAlias", "]", ")", ")", "{", "throw", "MongoDBException", "::", "unknownDocumentNamespace", "(", "$", "documentNamespaceAlias", ")", ";", "}", "return", "trim", "(", "$", "this", "->", "attributes", "[", "'documentNamespaces'", "]", "[", "$", "documentNamespaceAlias", "]", ",", "'\\\\'", ")", ";", "}" ]

[ "Resolves", "a", "registered", "namespace", "alias", "to", "the", "full", "namespace", "." ]

[ "public", "function", "setProxyDir", "(", "string", "$", "dir", ")", ":", "void", "{", "$", "this", "->", "getProxyManagerConfiguration", "(", ")", "->", "setProxiesTargetDir", "(", "$", "dir", ")", ";", "// Recreate proxy generator to ensure its path was updated", "if", "(", "$", "this", "->", "autoGenerateProxyClasses", "!==", "self", "::", "AUTOGENERATE_FILE_NOT_EXISTS", ")", "{", "return", ";", "}", "$", "this", "->", "setAutoGenerateProxyClasses", "(", "$", "this", "->", "autoGenerateProxyClasses", ")", ";", "}" ]

[ "Sets", "the", "directory", "where", "Doctrine", "generates", "any", "necessary", "proxy", "class", "files", "." ]

[ "public", "function", "setAutoGenerateProxyClasses", "(", "int", "$", "mode", ")", ":", "void", "{", "$", "this", "->", "autoGenerateProxyClasses", "=", "$", "mode", ";", "$", "proxyManagerConfig", "=", "$", "this", "->", "getProxyManagerConfiguration", "(", ")", ";", "switch", "(", "$", "mode", ")", "{", "case", "self", "::", "AUTOGENERATE_FILE_NOT_EXISTS", ":", "$", "proxyManagerConfig", "->", "setGeneratorStrategy", "(", "new", "FileWriterGeneratorStrategy", "(", "new", "FileLocator", "(", "$", "proxyManagerConfig", "->", "getProxiesTargetDir", "(", ")", ")", ")", ")", ";", "break", ";", "case", "self", "::", "AUTOGENERATE_EVAL", ":", "$", "proxyManagerConfig", "->", "setGeneratorStrategy", "(", "new", "EvaluatingGeneratorStrategy", "(", ")", ")", ";", "break", ";", "default", ":", "throw", "new", "InvalidArgumentException", "(", "'Invalid proxy generation strategy given - only AUTOGENERATE_FILE_NOT_EXISTS and AUTOGENERATE_EVAL are supported.'", ")", ";", "}", "}" ]

[ "Sets", "an", "int", "flag", "that", "indicates", "whether", "proxy", "classes", "should", "always", "be", "regenerated", "during", "each", "script", "execution", "." ]

[ "public", "function", "addFilter", "(", "string", "$", "name", ",", "string", "$", "className", ",", "array", "$", "parameters", "=", "[", "]", ")", ":", "void", "{", "$", "this", "->", "attributes", "[", "'filters'", "]", "[", "$", "name", "]", "=", "[", "'class'", "=>", "$", "className", ",", "'parameters'", "=>", "$", "parameters", ",", "]", ";", "}" ]

[ "Add", "a", "filter", "to", "the", "list", "of", "possible", "filters", "." ]

[ "public", "function", "geoNear", "(", "$", "x", ",", "$", "y", "=", "null", ")", ":", "Stage", "\\", "GeoNear", "{", "return", "$", "this", "->", "builder", "->", "geoNear", "(", "$", "x", ",", "$", "y", ")", ";", "}" ]

[ "Outputs", "documents", "in", "order", "of", "nearest", "to", "farthest", "from", "a", "specified", "point", ".", "You", "can", "only", "use", "this", "as", "the", "first", "stage", "of", "a", "pipeline", "." ]

[ "public", "function", "sort", "(", "$", "fieldName", ",", "$", "order", "=", "null", ")", ":", "Stage", "\\", "Sort", "{", "return", "$", "this", "->", "builder", "->", "sort", "(", "$", "fieldName", ",", "$", "order", ")", ";", "}" ]

[ "Sorts", "all", "input", "documents", "and", "returns", "them", "to", "the", "pipeline", "in", "sorted", "order", "." ]

[ "public", "function", "getHydratorFor", "(", "string", "$", "className", ")", ":", "HydratorInterface", "{", "if", "(", "isset", "(", "$", "this", "->", "hydrators", "[", "$", "className", "]", ")", ")", "{", "return", "$", "this", "->", "hydrators", "[", "$", "className", "]", ";", "}", "$", "hydratorClassName", "=", "str_replace", "(", "'\\\\'", ",", "''", ",", "$", "className", ")", ".", "'Hydrator'", ";", "$", "fqn", "=", "$", "this", "->", "hydratorNamespace", ".", "'\\\\'", ".", "$", "hydratorClassName", ";", "$", "class", "=", "$", "this", "->", "dm", "->", "getClassMetadata", "(", "$", "className", ")", ";", "if", "(", "!", "class_exists", "(", "$", "fqn", ",", "false", ")", ")", "{", "$", "fileName", "=", "$", "this", "->", "hydratorDir", ".", "DIRECTORY_SEPARATOR", ".", "$", "hydratorClassName", ".", "'.php'", ";", "switch", "(", "$", "this", "->", "autoGenerate", ")", "{", "case", "Configuration", "::", "AUTOGENERATE_NEVER", ":", "require", "$", "fileName", ";", "break", ";", "case", "Configuration", "::", "AUTOGENERATE_ALWAYS", ":", "$", "this", "->", "generateHydratorClass", "(", "$", "class", ",", "$", "hydratorClassName", ",", "$", "fileName", ")", ";", "require", "$", "fileName", ";", "break", ";", "case", "Configuration", "::", "AUTOGENERATE_FILE_NOT_EXISTS", ":", "if", "(", "!", "file_exists", "(", "$", "fileName", ")", ")", "{", "$", "this", "->", "generateHydratorClass", "(", "$", "class", ",", "$", "hydratorClassName", ",", "$", "fileName", ")", ";", "}", "require", "$", "fileName", ";", "break", ";", "case", "Configuration", "::", "AUTOGENERATE_EVAL", ":", "$", "this", "->", "generateHydratorClass", "(", "$", "class", ",", "$", "hydratorClassName", ",", "null", ")", ";", "break", ";", "}", "}", "$", "this", "->", "hydrators", "[", "$", "className", "]", "=", "new", "$", "fqn", "(", "$", "this", "->", "dm", ",", "$", "this", "->", "unitOfWork", ",", "$", "class", ")", ";", "return", "$", "this", "->", "hydrators", "[", "$", "className", "]", ";", "}" ]

[ "Gets", "the", "hydrator", "object", "for", "the", "given", "document", "class", "." ]

[ "public", "function", "generateHydratorClasses", "(", "array", "$", "classes", ",", "?", "string", "$", "toDir", "=", "null", ")", ":", "void", "{", "$", "hydratorDir", "=", "$", "toDir", "?", ":", "$", "this", "->", "hydratorDir", ";", "$", "hydratorDir", "=", "rtrim", "(", "$", "hydratorDir", ",", "DIRECTORY_SEPARATOR", ")", ".", "DIRECTORY_SEPARATOR", ";", "foreach", "(", "$", "classes", "as", "$", "class", ")", "{", "$", "hydratorClassName", "=", "str_replace", "(", "'\\\\'", ",", "''", ",", "$", "class", "->", "name", ")", ".", "'Hydrator'", ";", "$", "hydratorFileName", "=", "$", "hydratorDir", ".", "$", "hydratorClassName", ".", "'.php'", ";", "$", "this", "->", "generateHydratorClass", "(", "$", "class", ",", "$", "hydratorClassName", ",", "$", "hydratorFileName", ")", ";", "}", "}" ]

[ "Generates", "hydrator", "classes", "for", "all", "given", "classes", "." ]

[ "public", "static", "function", "isAtomic", "(", "string", "$", "strategy", ")", ":", "bool", "{", "return", "$", "strategy", "===", "ClassMetadata", "::", "STORAGE_STRATEGY_ATOMIC_SET", "||", "$", "strategy", "===", "ClassMetadata", "::", "STORAGE_STRATEGY_ATOMIC_SET_ARRAY", ";", "}" ]

[ "Returns", "whether", "update", "query", "must", "be", "included", "in", "query", "updating", "owning", "document", "." ]

[ "public", "static", "function", "isHash", "(", "string", "$", "strategy", ")", ":", "bool", "{", "return", "$", "strategy", "===", "ClassMetadata", "::", "STORAGE_STRATEGY_SET", "||", "$", "strategy", "===", "ClassMetadata", "::", "STORAGE_STRATEGY_ATOMIC_SET", ";", "}" ]

[ "Returns", "whether", "Collection", "hold", "associative", "array", "." ]

[ "public", "static", "function", "isList", "(", "?", "string", "$", "strategy", ")", ":", "bool", "{", "return", "$", "strategy", "!==", "ClassMetadata", "::", "STORAGE_STRATEGY_SET", "&&", "$", "strategy", "!==", "ClassMetadata", "::", "STORAGE_STRATEGY_ATOMIC_SET", ";", "}" ]

[ "Returns", "whether", "Collection", "hold", "array", "indexed", "by", "consecutive", "numbers", "." ]

[ "public", "static", "function", "usesSet", "(", "string", "$", "strategy", ")", ":", "bool", "{", "return", "in_array", "(", "$", "strategy", ",", "[", "ClassMetadata", "::", "STORAGE_STRATEGY_SET", ",", "ClassMetadata", "::", "STORAGE_STRATEGY_SET_ARRAY", ",", "ClassMetadata", "::", "STORAGE_STRATEGY_ATOMIC_SET", ",", "ClassMetadata", "::", "STORAGE_STRATEGY_ATOMIC_SET_ARRAY", ",", "]", ")", ";", "}" ]

[ "Returns", "whether", "strategy", "uses", "$set", "to", "update", "its", "data", "." ]

[ "public", "function", "out", "(", "string", "$", "collection", ")", ":", "Stage", "\\", "Out", "{", "try", "{", "$", "class", "=", "$", "this", "->", "dm", "->", "getClassMetadata", "(", "$", "collection", ")", ";", "}", "catch", "(", "BaseMappingException", "$", "e", ")", "{", "$", "this", "->", "collection", "=", "$", "collection", ";", "return", "$", "this", ";", "}", "$", "this", "->", "fromDocument", "(", "$", "class", ")", ";", "return", "$", "this", ";", "}" ]

[ "{" ]

[ "public", "function", "generateProxyClasses", "(", "array", "$", "classes", ")", ":", "int", "{", "$", "concreteClasses", "=", "array_filter", "(", "$", "classes", ",", "static", "function", "(", "ClassMetadata", "$", "metadata", ")", ":", "bool", "{", "return", "!", "(", "$", "metadata", "->", "isMappedSuperclass", "||", "$", "metadata", "->", "isQueryResultDocument", "||", "$", "metadata", "->", "getReflectionClass", "(", ")", "->", "isAbstract", "(", ")", ")", ";", "}", ")", ";", "foreach", "(", "$", "concreteClasses", "as", "$", "metadata", ")", "{", "$", "this", "->", "proxyFactory", "->", "createProxy", "(", "$", "metadata", "->", "getName", "(", ")", ",", "static", "function", "(", ")", "{", "// empty closure, serves its purpose, for now", "}", ",", "[", "'skippedProperties'", "=>", "$", "this", "->", "skippedFieldsFqns", "(", "$", "metadata", ")", ",", "]", ")", ";", "}", "return", "count", "(", "$", "concreteClasses", ")", ";", "}" ]

[ "{", "@inheritdoc", "}" ]

[ "public", "function", "showLatencyStats", "(", "bool", "$", "histograms", "=", "false", ")", ":", "self", "{", "$", "this", "->", "latencyStats", "=", "$", "histograms", "?", "self", "::", "LATENCY_STATS_HISTOGRAMS", ":", "self", "::", "LATENCY_STATS_SIMPLE", ";", "return", "$", "this", ";", "}" ]

[ "Adds", "latency", "statistics", "to", "the", "return", "document", "." ]

[ "public", "function", "getExpression", "(", ")", ":", "array", "{", "$", "collStats", "=", "[", "]", ";", "if", "(", "$", "this", "->", "latencyStats", "!==", "self", "::", "LATENCY_STATS_NONE", ")", "{", "$", "collStats", "[", "'latencyStats'", "]", "=", "[", "'histograms'", "=>", "$", "this", "->", "latencyStats", "===", "self", "::", "LATENCY_STATS_HISTOGRAMS", "]", ";", "}", "if", "(", "$", "this", "->", "storageStats", ")", "{", "$", "collStats", "[", "'storageStats'", "]", "=", "[", "]", ";", "}", "return", "[", "'$collStats'", "=>", "$", "collStats", "]", ";", "}" ]

[ "{" ]