Datasets:

semeru

/

code-text-php

like 1

Follow

Semeru Lab 7

[ "protected", "static", "function", "collectUpdates", "(", "$", "batchId", ")", "{", "return", "collect", "(", "static", "::", "$", "updatesQueue", ")", "->", "each", "(", "function", "(", "$", "entry", ")", "use", "(", "$", "batchId", ")", "{", "$", "entry", "->", "change", "(", "[", "'updated_batch_id'", "=>", "$", "batchId", "]", ")", ";", "}", ")", ";", "}" ]

[ "Collect", "the", "updated", "entries", "for", "storage", "." ]

[ "protected", "function", "registerStorageDriver", "(", ")", "{", "$", "driver", "=", "config", "(", "'telescope.driver'", ")", ";", "if", "(", "method_exists", "(", "$", "this", ",", "$", "method", "=", "'register'", ".", "ucfirst", "(", "$", "driver", ")", ".", "'Driver'", ")", ")", "{", "$", "this", "->", "$", "method", "(", ")", ";", "}", "}" ]

[ "Register", "the", "package", "storage", "driver", "." ]

[ "protected", "function", "registerDatabaseDriver", "(", ")", "{", "$", "this", "->", "app", "->", "singleton", "(", "EntriesRepository", "::", "class", ",", "DatabaseEntriesRepository", "::", "class", ")", ";", "$", "this", "->", "app", "->", "singleton", "(", "ClearableRepository", "::", "class", ",", "DatabaseEntriesRepository", "::", "class", ")", ";", "$", "this", "->", "app", "->", "singleton", "(", "PrunableRepository", "::", "class", ",", "DatabaseEntriesRepository", "::", "class", ")", ";", "$", "this", "->", "app", "->", "when", "(", "DatabaseEntriesRepository", "::", "class", ")", "->", "needs", "(", "'$connection'", ")", "->", "give", "(", "config", "(", "'telescope.storage.database.connection'", ")", ")", ";", "$", "this", "->", "app", "->", "when", "(", "DatabaseEntriesRepository", "::", "class", ")", "->", "needs", "(", "'$chunkSize'", ")", "->", "give", "(", "config", "(", "'telescope.storage.database.chunk'", ")", ")", ";", "}" ]

[ "Register", "the", "package", "database", "storage", "driver", "." ]

[ "protected", "function", "status", "(", ")", "{", "if", "(", "!", "config", "(", "'telescope.enabled'", ",", "false", ")", ")", "{", "return", "'disabled'", ";", "}", "if", "(", "cache", "(", "'telescope:pause-recording'", ",", "false", ")", ")", "{", "return", "'paused'", ";", "}", "$", "watcher", "=", "config", "(", "'telescope.watchers.'", ".", "$", "this", "->", "watcher", "(", ")", ")", ";", "if", "(", "!", "$", "watcher", "||", "(", "isset", "(", "$", "watcher", "[", "'enabled'", "]", ")", "&&", "!", "$", "watcher", "[", "'enabled'", "]", ")", ")", "{", "return", "'off'", ";", "}", "return", "'enabled'", ";", "}" ]

[ "Determine", "the", "watcher", "recording", "status", "." ]

[ "public", "function", "recordException", "(", "MessageLogged", "$", "event", ")", "{", "if", "(", "!", "Telescope", "::", "isRecording", "(", ")", "||", "$", "this", "->", "shouldIgnore", "(", "$", "event", ")", ")", "{", "return", ";", "}", "$", "exception", "=", "$", "event", "->", "context", "[", "'exception'", "]", ";", "Telescope", "::", "recordException", "(", "IncomingExceptionEntry", "::", "make", "(", "$", "exception", ",", "[", "'class'", "=>", "get_class", "(", "$", "exception", ")", ",", "'file'", "=>", "$", "exception", "->", "getFile", "(", ")", ",", "'line'", "=>", "$", "exception", "->", "getLine", "(", ")", ",", "'message'", "=>", "$", "exception", "->", "getMessage", "(", ")", ",", "'trace'", "=>", "$", "exception", "->", "getTrace", "(", ")", ",", "'line_preview'", "=>", "ExceptionContext", "::", "get", "(", "$", "exception", ")", ",", "]", ")", "->", "tags", "(", "$", "this", "->", "tags", "(", "$", "event", ")", ")", ")", ";", "}" ]

[ "Record", "an", "exception", "was", "logged", "." ]

[ "public", "function", "recordJob", "(", "$", "connection", ",", "$", "queue", ",", "array", "$", "payload", ")", "{", "if", "(", "!", "Telescope", "::", "isRecording", "(", ")", ")", "{", "return", ";", "}", "$", "content", "=", "array_merge", "(", "[", "'status'", "=>", "'pending'", ",", "]", ",", "$", "this", "->", "defaultJobData", "(", "$", "connection", ",", "$", "queue", ",", "$", "payload", ",", "$", "this", "->", "data", "(", "$", "payload", ")", ")", ")", ";", "Telescope", "::", "recordJob", "(", "$", "entry", "=", "IncomingEntry", "::", "make", "(", "$", "content", ")", "->", "tags", "(", "$", "this", "->", "tags", "(", "$", "payload", ")", ")", ")", ";", "return", "$", "entry", ";", "}" ]

[ "Record", "a", "job", "being", "created", "." ]

[ "public", "function", "recordProcessedJob", "(", "JobProcessed", "$", "event", ")", "{", "if", "(", "!", "Telescope", "::", "isRecording", "(", ")", ")", "{", "return", ";", "}", "$", "uuid", "=", "$", "event", "->", "job", "->", "payload", "(", ")", "[", "'telescope_uuid'", "]", "??", "null", ";", "if", "(", "!", "$", "uuid", ")", "{", "return", ";", "}", "Telescope", "::", "recordUpdate", "(", "EntryUpdate", "::", "make", "(", "$", "uuid", ",", "EntryType", "::", "JOB", ",", "[", "'status'", "=>", "'processed'", "]", ")", ")", ";", "}" ]

[ "Record", "a", "queued", "job", "was", "processed", "." ]

[ "public", "function", "recordFailedJob", "(", "JobFailed", "$", "event", ")", "{", "if", "(", "!", "Telescope", "::", "isRecording", "(", ")", ")", "{", "return", ";", "}", "$", "uuid", "=", "$", "event", "->", "job", "->", "payload", "(", ")", "[", "'telescope_uuid'", "]", "??", "null", ";", "if", "(", "!", "$", "uuid", ")", "{", "return", ";", "}", "Telescope", "::", "recordUpdate", "(", "EntryUpdate", "::", "make", "(", "$", "uuid", ",", "EntryType", "::", "JOB", ",", "[", "'status'", "=>", "'failed'", ",", "'exception'", "=>", "[", "'message'", "=>", "$", "event", "->", "exception", "->", "getMessage", "(", ")", ",", "'trace'", "=>", "$", "event", "->", "exception", "->", "getTrace", "(", ")", ",", "'line'", "=>", "$", "event", "->", "exception", "->", "getLine", "(", ")", ",", "'line_preview'", "=>", "ExceptionContext", "::", "get", "(", "$", "event", "->", "exception", ")", ",", "]", ",", "]", ")", "->", "addTags", "(", "[", "'failed'", "]", ")", ")", ";", "}" ]

[ "Record", "a", "queue", "job", "has", "failed", "." ]

[ "protected", "function", "defaultJobData", "(", "$", "connection", ",", "$", "queue", ",", "array", "$", "payload", ",", "array", "$", "data", ")", "{", "return", "[", "'connection'", "=>", "$", "connection", ",", "'queue'", "=>", "$", "queue", ",", "'name'", "=>", "$", "payload", "[", "'displayName'", "]", ",", "'tries'", "=>", "$", "payload", "[", "'maxTries'", "]", ",", "'timeout'", "=>", "$", "payload", "[", "'timeout'", "]", ",", "'data'", "=>", "$", "data", ",", "]", ";", "}" ]

[ "Get", "the", "default", "entry", "data", "for", "the", "given", "job", "." ]

[ "protected", "function", "authorization", "(", ")", "{", "$", "this", "->", "gate", "(", ")", ";", "Telescope", "::", "auth", "(", "function", "(", "$", "request", ")", "{", "return", "app", "(", ")", "->", "environment", "(", "'local'", ")", "||", "Gate", "::", "check", "(", "'viewTelescope'", ",", "[", "$", "request", "->", "user", "(", ")", "]", ")", ";", "}", ")", ";", "}" ]

[ "Configure", "the", "Telescope", "authorization", "services", "." ]

[ "public", "function", "addTags", "(", "array", "$", "tags", ")", "{", "$", "this", "->", "tagsChanges", "[", "'added'", "]", "=", "array_unique", "(", "array_merge", "(", "$", "this", "->", "tagsChanges", "[", "'added'", "]", ",", "$", "tags", ")", ")", ";", "return", "$", "this", ";", "}" ]

[ "Add", "tags", "to", "the", "entry", "." ]

[ "public", "function", "removeTags", "(", "array", "$", "tags", ")", "{", "$", "this", "->", "tagsChanges", "[", "'removed'", "]", "=", "array_unique", "(", "array_merge", "(", "$", "this", "->", "tagsChanges", "[", "'removed'", "]", ",", "$", "tags", ")", ")", ";", "return", "$", "this", ";", "}" ]

[ "Remove", "tags", "from", "the", "entry", "." ]

[ "public", "function", "recordCommand", "(", "CommandExecuted", "$", "event", ")", "{", "if", "(", "!", "Telescope", "::", "isRecording", "(", ")", "||", "$", "this", "->", "shouldIgnore", "(", "$", "event", ")", ")", "{", "return", ";", "}", "Telescope", "::", "recordRedis", "(", "IncomingEntry", "::", "make", "(", "[", "'connection'", "=>", "$", "event", "->", "connectionName", ",", "'command'", "=>", "$", "this", "->", "formatCommand", "(", "$", "event", "->", "command", ",", "$", "event", "->", "parameters", ")", ",", "'time'", "=>", "number_format", "(", "$", "event", "->", "time", ",", "2", ")", ",", "]", ")", ")", ";", "}" ]

[ "Record", "a", "Redis", "command", "was", "executed", "." ]

[ "private", "function", "formatCommand", "(", "$", "command", ",", "$", "parameters", ")", "{", "$", "parameters", "=", "collect", "(", "$", "parameters", ")", "->", "map", "(", "function", "(", "$", "parameter", ")", "{", "if", "(", "is_array", "(", "$", "parameter", ")", ")", "{", "return", "collect", "(", "$", "parameter", ")", "->", "map", "(", "function", "(", "$", "value", ",", "$", "key", ")", "{", "return", "is_int", "(", "$", "key", ")", "?", "$", "value", ":", "\"{$key} {$value}\"", ";", "}", ")", "->", "implode", "(", "' '", ")", ";", "}", "return", "$", "parameter", ";", "}", ")", "->", "implode", "(", "' '", ")", ";", "return", "\"{$command} {$parameters}\"", ";", "}" ]

[ "Format", "the", "given", "Redis", "command", "." ]

[ "public", "static", "function", "from", "(", "$", "target", ")", "{", "if", "(", "$", "tags", "=", "static", "::", "explicitTags", "(", "[", "$", "target", "]", ")", ")", "{", "return", "$", "tags", ";", "}", "return", "static", "::", "modelsFor", "(", "[", "$", "target", "]", ")", "->", "map", "(", "function", "(", "$", "model", ")", "{", "return", "FormatModel", "::", "given", "(", "$", "model", ")", ";", "}", ")", "->", "all", "(", ")", ";", "}" ]

[ "Get", "the", "tags", "for", "the", "given", "object", "." ]

[ "public", "static", "function", "fromArray", "(", "array", "$", "data", ")", "{", "$", "models", "=", "collect", "(", "$", "data", ")", "->", "map", "(", "function", "(", "$", "value", ")", "{", "if", "(", "$", "value", "instanceof", "Model", ")", "{", "return", "[", "$", "value", "]", ";", "}", "elseif", "(", "$", "value", "instanceof", "EloquentCollection", ")", "{", "return", "$", "value", "->", "flatten", "(", ")", ";", "}", "}", ")", "->", "collapse", "(", ")", "->", "filter", "(", ")", ";", "return", "$", "models", "->", "map", "(", "function", "(", "$", "model", ")", "{", "return", "FormatModel", "::", "given", "(", "$", "model", ")", ";", "}", ")", "->", "all", "(", ")", ";", "}" ]

[ "Determine", "the", "tags", "for", "the", "given", "array", "." ]

[ "protected", "static", "function", "tagsForListener", "(", "$", "job", ")", "{", "return", "collect", "(", "[", "static", "::", "extractListener", "(", "$", "job", ")", ",", "static", "::", "extractEvent", "(", "$", "job", ")", ",", "]", ")", "->", "map", "(", "function", "(", "$", "job", ")", "{", "return", "static", "::", "from", "(", "$", "job", ")", ";", "}", ")", "->", "collapse", "(", ")", "->", "unique", "(", ")", "->", "toArray", "(", ")", ";", "}" ]

[ "Determine", "tags", "for", "the", "given", "queued", "listener", "." ]

[ "protected", "static", "function", "targetsFor", "(", "$", "job", ")", "{", "switch", "(", "true", ")", "{", "case", "$", "job", "instanceof", "BroadcastEvent", ":", "return", "[", "$", "job", "->", "event", "]", ";", "case", "$", "job", "instanceof", "CallQueuedListener", ":", "return", "[", "static", "::", "extractEvent", "(", "$", "job", ")", "]", ";", "case", "$", "job", "instanceof", "SendQueuedMailable", ":", "return", "[", "$", "job", "->", "mailable", "]", ";", "case", "$", "job", "instanceof", "SendQueuedNotifications", ":", "return", "[", "$", "job", "->", "notification", "]", ";", "default", ":", "return", "[", "$", "job", "]", ";", "}", "}" ]

[ "Get", "the", "actual", "target", "for", "the", "given", "job", "." ]

[ "protected", "static", "function", "modelsFor", "(", "array", "$", "targets", ")", "{", "$", "models", "=", "[", "]", ";", "foreach", "(", "$", "targets", "as", "$", "target", ")", "{", "$", "models", "[", "]", "=", "collect", "(", "(", "new", "ReflectionClass", "(", "$", "target", ")", ")", "->", "getProperties", "(", ")", ")", "->", "map", "(", "function", "(", "$", "property", ")", "use", "(", "$", "target", ")", "{", "$", "property", "->", "setAccessible", "(", "true", ")", ";", "$", "value", "=", "$", "property", "->", "getValue", "(", "$", "target", ")", ";", "if", "(", "$", "value", "instanceof", "Model", ")", "{", "return", "[", "$", "value", "]", ";", "}", "elseif", "(", "$", "value", "instanceof", "EloquentCollection", ")", "{", "return", "$", "value", "->", "flatten", "(", ")", ";", "}", "}", ")", "->", "collapse", "(", ")", "->", "filter", "(", ")", "->", "all", "(", ")", ";", "}", "return", "collect", "(", "Arr", "::", "collapse", "(", "$", "models", ")", ")", "->", "unique", "(", ")", ";", "}" ]

[ "Get", "the", "models", "from", "the", "given", "object", "." ]

[ "protected", "static", "function", "extractEvent", "(", "$", "job", ")", "{", "return", "isset", "(", "$", "job", "->", "data", "[", "0", "]", ")", "&&", "is_object", "(", "$", "job", "->", "data", "[", "0", "]", ")", "?", "$", "job", "->", "data", "[", "0", "]", ":", "new", "stdClass", ";", "}" ]

[ "Extract", "the", "event", "from", "a", "queued", "job", "." ]

[ "public", "static", "function", "from", "(", "$", "target", ")", "{", "return", "collect", "(", "(", "new", "ReflectionClass", "(", "$", "target", ")", ")", "->", "getProperties", "(", ")", ")", "->", "mapWithKeys", "(", "function", "(", "$", "property", ")", "use", "(", "$", "target", ")", "{", "$", "property", "->", "setAccessible", "(", "true", ")", ";", "if", "(", "(", "$", "value", "=", "$", "property", "->", "getValue", "(", "$", "target", ")", ")", "instanceof", "Model", ")", "{", "return", "[", "$", "property", "->", "getName", "(", ")", "=>", "FormatModel", "::", "given", "(", "$", "value", ")", "]", ";", "}", "elseif", "(", "is_object", "(", "$", "value", ")", ")", "{", "return", "[", "$", "property", "->", "getName", "(", ")", "=>", "[", "'class'", "=>", "get_class", "(", "$", "value", ")", ",", "'properties'", "=>", "json_decode", "(", "json_encode", "(", "$", "value", ")", ",", "true", ")", ",", "]", ",", "]", ";", "}", "else", "{", "return", "[", "$", "property", "->", "getName", "(", ")", "=>", "json_decode", "(", "json_encode", "(", "$", "value", ")", ",", "true", ")", "]", ";", "}", "}", ")", "->", "toArray", "(", ")", ";", "}" ]

[ "Extract", "the", "properties", "for", "the", "given", "object", "in", "array", "form", "." ]

[ "public", "function", "scopeWithTelescopeOptions", "(", "$", "query", ",", "$", "type", ",", "EntryQueryOptions", "$", "options", ")", "{", "$", "this", "->", "whereType", "(", "$", "query", ",", "$", "type", ")", "->", "whereBatchId", "(", "$", "query", ",", "$", "options", ")", "->", "whereTag", "(", "$", "query", ",", "$", "options", ")", "->", "whereFamilyHash", "(", "$", "query", ",", "$", "options", ")", "->", "whereBeforeSequence", "(", "$", "query", ",", "$", "options", ")", "->", "filter", "(", "$", "query", ",", "$", "options", ")", ";", "return", "$", "query", ";", "}" ]

[ "Scope", "the", "query", "for", "the", "given", "query", "options", "." ]

[ "protected", "function", "whereBatchId", "(", "$", "query", ",", "EntryQueryOptions", "$", "options", ")", "{", "$", "query", "->", "when", "(", "$", "options", "->", "batchId", ",", "function", "(", "$", "query", ",", "$", "batchId", ")", "{", "return", "$", "query", "->", "where", "(", "'batch_id'", ",", "$", "batchId", ")", ";", "}", ")", ";", "return", "$", "this", ";", "}" ]

[ "Scope", "the", "query", "for", "the", "given", "batch", "ID", "." ]

[ "protected", "function", "whereBeforeSequence", "(", "$", "query", ",", "EntryQueryOptions", "$", "options", ")", "{", "$", "query", "->", "when", "(", "$", "options", "->", "beforeSequence", ",", "function", "(", "$", "query", ",", "$", "beforeSequence", ")", "{", "return", "$", "query", "->", "where", "(", "'sequence'", ",", "'<'", ",", "$", "beforeSequence", ")", ";", "}", ")", ";", "return", "$", "this", ";", "}" ]

[ "Scope", "the", "query", "for", "the", "given", "pagination", "options", "." ]

[ "protected", "function", "filter", "(", "$", "query", ",", "EntryQueryOptions", "$", "options", ")", "{", "if", "(", "$", "options", "->", "familyHash", "||", "$", "options", "->", "tag", "||", "$", "options", "->", "batchId", ")", "{", "return", "$", "this", ";", "}", "$", "query", "->", "where", "(", "'should_display_on_index'", ",", "true", ")", ";", "return", "$", "this", ";", "}" ]

[ "Scope", "the", "query", "for", "the", "given", "display", "options", "." ]

[ "protected", "function", "registerTelescopeServiceProvider", "(", ")", "{", "$", "namespace", "=", "str_replace_last", "(", "'\\\\'", ",", "''", ",", "$", "this", "->", "getAppNamespace", "(", ")", ")", ";", "$", "appConfig", "=", "file_get_contents", "(", "config_path", "(", "'app.php'", ")", ")", ";", "if", "(", "Str", "::", "contains", "(", "$", "appConfig", ",", "$", "namespace", ".", "'\\\\Providers\\\\TelescopeServiceProvider::class'", ")", ")", "{", "return", ";", "}", "$", "lineEndingCount", "=", "[", "\"\\r\\n\"", "=>", "substr_count", "(", "$", "appConfig", ",", "\"\\r\\n\"", ")", ",", "\"\\r\"", "=>", "substr_count", "(", "$", "appConfig", ",", "\"\\r\"", ")", ",", "\"\\n\"", "=>", "substr_count", "(", "$", "appConfig", ",", "\"\\n\"", ")", ",", "]", ";", "$", "eol", "=", "array_keys", "(", "$", "lineEndingCount", ",", "max", "(", "$", "lineEndingCount", ")", ")", "[", "0", "]", ";", "file_put_contents", "(", "config_path", "(", "'app.php'", ")", ",", "str_replace", "(", "\"{$namespace}\\\\Providers\\EventServiceProvider::class,\"", ".", "$", "eol", ",", "\"{$namespace}\\\\Providers\\EventServiceProvider::class,\"", ".", "$", "eol", ".", "\" {$namespace}\\Providers\\TelescopeServiceProvider::class,\"", ".", "$", "eol", ",", "$", "appConfig", ")", ")", ";", "file_put_contents", "(", "app_path", "(", "'Providers/TelescopeServiceProvider.php'", ")", ",", "str_replace", "(", "\"namespace App\\Providers;\"", ",", "\"namespace {$namespace}\\Providers;\"", ",", "file_get_contents", "(", "app_path", "(", "'Providers/TelescopeServiceProvider.php'", ")", ")", ")", ")", ";", "}" ]

[ "Register", "the", "Telescope", "service", "provider", "in", "the", "application", "configuration", "file", "." ]

[ "public", "function", "find", "(", "$", "id", ")", ":", "EntryResult", "{", "$", "entry", "=", "EntryModel", "::", "on", "(", "$", "this", "->", "connection", ")", "->", "whereUuid", "(", "$", "id", ")", "->", "firstOrFail", "(", ")", ";", "$", "tags", "=", "$", "this", "->", "table", "(", "'telescope_entries_tags'", ")", "->", "where", "(", "'entry_uuid'", ",", "$", "id", ")", "->", "pluck", "(", "'tag'", ")", "->", "all", "(", ")", ";", "return", "new", "EntryResult", "(", "$", "entry", "->", "uuid", ",", "null", ",", "$", "entry", "->", "batch_id", ",", "$", "entry", "->", "type", ",", "$", "entry", "->", "family_hash", ",", "$", "entry", "->", "content", ",", "$", "entry", "->", "created_at", ",", "$", "tags", ")", ";", "}" ]

[ "Find", "the", "entry", "with", "the", "given", "ID", "." ]

[ "public", "function", "get", "(", "$", "type", ",", "EntryQueryOptions", "$", "options", ")", "{", "return", "EntryModel", "::", "on", "(", "$", "this", "->", "connection", ")", "->", "withTelescopeOptions", "(", "$", "type", ",", "$", "options", ")", "->", "take", "(", "$", "options", "->", "limit", ")", "->", "orderByDesc", "(", "'sequence'", ")", "->", "get", "(", ")", "->", "reject", "(", "function", "(", "$", "entry", ")", "{", "return", "!", "is_array", "(", "$", "entry", "->", "content", ")", ";", "}", ")", "->", "map", "(", "function", "(", "$", "entry", ")", "{", "return", "new", "EntryResult", "(", "$", "entry", "->", "uuid", ",", "$", "entry", "->", "sequence", ",", "$", "entry", "->", "batch_id", ",", "$", "entry", "->", "type", ",", "$", "entry", "->", "family_hash", ",", "$", "entry", "->", "content", ",", "$", "entry", "->", "created_at", ",", "[", "]", ")", ";", "}", ")", "->", "values", "(", ")", ";", "}" ]

[ "Return", "all", "the", "entries", "of", "a", "given", "type", "." ]

[ "public", "function", "store", "(", "Collection", "$", "entries", ")", "{", "if", "(", "$", "entries", "->", "isEmpty", "(", ")", ")", "{", "return", ";", "}", "[", "$", "exceptions", ",", "$", "entries", "]", "=", "$", "entries", "->", "partition", "->", "isException", "(", ")", ";", "$", "this", "->", "storeExceptions", "(", "$", "exceptions", ")", ";", "$", "table", "=", "$", "this", "->", "table", "(", "'telescope_entries'", ")", ";", "$", "entries", "->", "chunk", "(", "$", "this", "->", "chunkSize", ")", "->", "each", "(", "function", "(", "$", "chunked", ")", "use", "(", "$", "table", ")", "{", "$", "table", "->", "insert", "(", "$", "chunked", "->", "map", "(", "function", "(", "$", "entry", ")", "{", "$", "entry", "->", "content", "=", "json_encode", "(", "$", "entry", "->", "content", ")", ";", "return", "$", "entry", "->", "toArray", "(", ")", ";", "}", ")", "->", "toArray", "(", ")", ")", ";", "}", ")", ";", "$", "this", "->", "storeTags", "(", "$", "entries", "->", "pluck", "(", "'tags'", ",", "'uuid'", ")", ")", ";", "}" ]

[ "Store", "the", "given", "array", "of", "entries", "." ]

[ "protected", "function", "storeExceptions", "(", "Collection", "$", "exceptions", ")", "{", "$", "this", "->", "table", "(", "'telescope_entries'", ")", "->", "insert", "(", "$", "exceptions", "->", "map", "(", "function", "(", "$", "exception", ")", "{", "$", "occurrences", "=", "$", "this", "->", "table", "(", "'telescope_entries'", ")", "->", "where", "(", "'type'", ",", "EntryType", "::", "EXCEPTION", ")", "->", "where", "(", "'family_hash'", ",", "$", "exception", "->", "familyHash", "(", ")", ")", "->", "count", "(", ")", ";", "$", "this", "->", "table", "(", "'telescope_entries'", ")", "->", "where", "(", "'type'", ",", "EntryType", "::", "EXCEPTION", ")", "->", "where", "(", "'family_hash'", ",", "$", "exception", "->", "familyHash", "(", ")", ")", "->", "update", "(", "[", "'should_display_on_index'", "=>", "false", "]", ")", ";", "return", "array_merge", "(", "$", "exception", "->", "toArray", "(", ")", ",", "[", "'family_hash'", "=>", "$", "exception", "->", "familyHash", "(", ")", ",", "'content'", "=>", "json_encode", "(", "array_merge", "(", "$", "exception", "->", "content", ",", "[", "'occurrences'", "=>", "$", "occurrences", "+", "1", "]", ")", ")", ",", "]", ")", ";", "}", ")", "->", "toArray", "(", ")", ")", ";", "$", "this", "->", "storeTags", "(", "$", "exceptions", "->", "pluck", "(", "'tags'", ",", "'uuid'", ")", ")", ";", "}" ]

[ "Store", "the", "given", "array", "of", "exception", "entries", "." ]

[ "protected", "function", "storeTags", "(", "$", "results", ")", "{", "$", "this", "->", "table", "(", "'telescope_entries_tags'", ")", "->", "insert", "(", "$", "results", "->", "flatMap", "(", "function", "(", "$", "tags", ",", "$", "uuid", ")", "{", "return", "collect", "(", "$", "tags", ")", "->", "map", "(", "function", "(", "$", "tag", ")", "use", "(", "$", "uuid", ")", "{", "return", "[", "'entry_uuid'", "=>", "$", "uuid", ",", "'tag'", "=>", "$", "tag", ",", "]", ";", "}", ")", ";", "}", ")", "->", "all", "(", ")", ")", ";", "}" ]

[ "Store", "the", "tags", "for", "the", "given", "entries", "." ]

[ "public", "function", "update", "(", "Collection", "$", "updates", ")", "{", "foreach", "(", "$", "updates", "as", "$", "update", ")", "{", "$", "entry", "=", "$", "this", "->", "table", "(", "'telescope_entries'", ")", "->", "where", "(", "'uuid'", ",", "$", "update", "->", "uuid", ")", "->", "where", "(", "'type'", ",", "$", "update", "->", "type", ")", "->", "first", "(", ")", ";", "if", "(", "!", "$", "entry", ")", "{", "continue", ";", "}", "$", "content", "=", "json_encode", "(", "array_merge", "(", "json_decode", "(", "$", "entry", "->", "content", ",", "true", ")", "?", ":", "[", "]", ",", "$", "update", "->", "changes", ")", ")", ";", "$", "this", "->", "table", "(", "'telescope_entries'", ")", "->", "where", "(", "'uuid'", ",", "$", "update", "->", "uuid", ")", "->", "where", "(", "'type'", ",", "$", "update", "->", "type", ")", "->", "update", "(", "[", "'content'", "=>", "$", "content", "]", ")", ";", "$", "this", "->", "updateTags", "(", "$", "update", ")", ";", "}", "}" ]

[ "Store", "the", "given", "entry", "updates", "." ]

[ "protected", "function", "updateTags", "(", "$", "entry", ")", "{", "if", "(", "!", "empty", "(", "$", "entry", "->", "tagsChanges", "[", "'added'", "]", ")", ")", "{", "$", "this", "->", "table", "(", "'telescope_entries_tags'", ")", "->", "insert", "(", "collect", "(", "$", "entry", "->", "tagsChanges", "[", "'added'", "]", ")", "->", "map", "(", "function", "(", "$", "tag", ")", "use", "(", "$", "entry", ")", "{", "return", "[", "'entry_uuid'", "=>", "$", "entry", "->", "uuid", ",", "'tag'", "=>", "$", "tag", ",", "]", ";", "}", ")", "->", "toArray", "(", ")", ")", ";", "}", "collect", "(", "$", "entry", "->", "tagsChanges", "[", "'removed'", "]", ")", "->", "each", "(", "function", "(", "$", "tag", ")", "use", "(", "$", "entry", ")", "{", "$", "this", "->", "table", "(", "'telescope_entries_tags'", ")", "->", "where", "(", "[", "'entry_uuid'", "=>", "$", "entry", "->", "uuid", ",", "'tag'", "=>", "$", "tag", ",", "]", ")", "->", "delete", "(", ")", ";", "}", ")", ";", "}" ]

[ "Update", "tags", "of", "the", "given", "entry", "." ]

[ "public", "function", "isMonitoring", "(", "array", "$", "tags", ")", "{", "if", "(", "is_null", "(", "$", "this", "->", "monitoredTags", ")", ")", "{", "$", "this", "->", "loadMonitoredTags", "(", ")", ";", "}", "return", "count", "(", "array_intersect", "(", "$", "tags", ",", "$", "this", "->", "monitoredTags", ")", ")", ">", "0", ";", "}" ]

[ "Determine", "if", "any", "of", "the", "given", "tags", "are", "currently", "being", "monitored", "." ]

[ "public", "function", "monitor", "(", "array", "$", "tags", ")", "{", "$", "tags", "=", "array_diff", "(", "$", "tags", ",", "$", "this", "->", "monitoring", "(", ")", ")", ";", "if", "(", "empty", "(", "$", "tags", ")", ")", "{", "return", ";", "}", "$", "this", "->", "table", "(", "'telescope_monitoring'", ")", "->", "insert", "(", "collect", "(", "$", "tags", ")", "->", "mapWithKeys", "(", "function", "(", "$", "tag", ")", "{", "return", "[", "'tag'", "=>", "$", "tag", "]", ";", "}", ")", "->", "all", "(", ")", ")", ";", "}" ]

[ "Begin", "monitoring", "the", "given", "list", "of", "tags", "." ]

[ "protected", "static", "function", "registerWatchers", "(", "$", "app", ")", "{", "foreach", "(", "config", "(", "'telescope.watchers'", ")", "as", "$", "key", "=>", "$", "watcher", ")", "{", "if", "(", "is_string", "(", "$", "key", ")", "&&", "$", "watcher", "===", "false", ")", "{", "continue", ";", "}", "if", "(", "is_array", "(", "$", "watcher", ")", "&&", "!", "(", "$", "watcher", "[", "'enabled'", "]", "??", "true", ")", ")", "{", "continue", ";", "}", "$", "watcher", "=", "$", "app", "->", "make", "(", "is_string", "(", "$", "key", ")", "?", "$", "key", ":", "$", "watcher", ",", "[", "'options'", "=>", "is_array", "(", "$", "watcher", ")", "?", "$", "watcher", ":", "[", "]", ",", "]", ")", ";", "static", "::", "$", "watchers", "[", "]", "=", "get_class", "(", "$", "watcher", ")", ";", "$", "watcher", "->", "register", "(", "$", "app", ")", ";", "}", "}" ]

[ "Register", "the", "configured", "Telescope", "watchers", "." ]

[ "public", "function", "isReportableException", "(", ")", "{", "$", "handler", "=", "app", "(", "ExceptionHandler", "::", "class", ")", ";", "return", "method_exists", "(", "$", "handler", ",", "'shouldReport'", ")", "?", "$", "handler", "->", "shouldReport", "(", "$", "this", "->", "exception", ")", ":", "true", ";", "}" ]

[ "Determine", "if", "the", "incoming", "entry", "is", "a", "reportable", "exception", "." ]

[ "public", "function", "recordGateCheck", "(", "?", "Authenticatable", "$", "user", ",", "$", "ability", ",", "$", "result", ",", "$", "arguments", ")", "{", "if", "(", "!", "Telescope", "::", "isRecording", "(", ")", "||", "$", "this", "->", "shouldIgnore", "(", "$", "ability", ")", ")", "{", "return", ";", "}", "$", "caller", "=", "$", "this", "->", "getCallerFromStackTrace", "(", ")", ";", "Telescope", "::", "recordGate", "(", "IncomingEntry", "::", "make", "(", "[", "'ability'", "=>", "$", "ability", ",", "'result'", "=>", "$", "result", "?", "'allowed'", ":", "'denied'", ",", "'arguments'", "=>", "$", "this", "->", "formatArguments", "(", "$", "arguments", ")", ",", "'file'", "=>", "$", "caller", "[", "'file'", "]", ",", "'line'", "=>", "$", "caller", "[", "'line'", "]", ",", "]", ")", ")", ";", "return", "$", "result", ";", "}" ]

[ "Record", "a", "gate", "check", "." ]

[ "private", "function", "formatArguments", "(", "$", "arguments", ")", "{", "return", "collect", "(", "$", "arguments", ")", "->", "map", "(", "function", "(", "$", "argument", ")", "{", "return", "$", "argument", "instanceof", "Model", "?", "FormatModel", "::", "given", "(", "$", "argument", ")", ":", "$", "argument", ";", "}", ")", "->", "toArray", "(", ")", ";", "}" ]

[ "Format", "the", "given", "arguments", "." ]

[ "public", "function", "recordMail", "(", "MessageSent", "$", "event", ")", "{", "if", "(", "!", "Telescope", "::", "isRecording", "(", ")", ")", "{", "return", ";", "}", "Telescope", "::", "recordMail", "(", "IncomingEntry", "::", "make", "(", "[", "'mailable'", "=>", "$", "this", "->", "getMailable", "(", "$", "event", ")", ",", "'queued'", "=>", "$", "this", "->", "getQueuedStatus", "(", "$", "event", ")", ",", "'from'", "=>", "$", "event", "->", "message", "->", "getFrom", "(", ")", ",", "'replyTo'", "=>", "$", "event", "->", "message", "->", "getReplyTo", "(", ")", ",", "'to'", "=>", "$", "event", "->", "message", "->", "getTo", "(", ")", ",", "'cc'", "=>", "$", "event", "->", "message", "->", "getCc", "(", ")", ",", "'bcc'", "=>", "$", "event", "->", "message", "->", "getBcc", "(", ")", ",", "'subject'", "=>", "$", "event", "->", "message", "->", "getSubject", "(", ")", ",", "'html'", "=>", "$", "event", "->", "message", "->", "getBody", "(", ")", ",", "'raw'", "=>", "$", "event", "->", "message", "->", "toString", "(", ")", ",", "]", ")", "->", "tags", "(", "$", "this", "->", "tags", "(", "$", "event", "->", "message", ",", "$", "event", "->", "data", ")", ")", ")", ";", "}" ]

[ "Record", "a", "mail", "message", "was", "sent", "." ]

[ "protected", "function", "getQueuedStatus", "(", "$", "event", ")", "{", "if", "(", "isset", "(", "$", "event", "->", "data", "[", "'__laravel_notification_queued'", "]", ")", ")", "{", "return", "$", "event", "->", "data", "[", "'__laravel_notification_queued'", "]", ";", "}", "return", "$", "event", "->", "data", "[", "'__telescope_queued'", "]", "??", "false", ";", "}" ]

[ "Determine", "whether", "the", "mailable", "was", "queued", "." ]

[ "private", "function", "tags", "(", "$", "message", ",", "$", "data", ")", "{", "return", "array_merge", "(", "array_keys", "(", "$", "message", "->", "getTo", "(", ")", "?", ":", "[", "]", ")", ",", "array_keys", "(", "$", "message", "->", "getCc", "(", ")", "?", ":", "[", "]", ")", ",", "array_keys", "(", "$", "message", "->", "getBcc", "(", ")", "?", ":", "[", "]", ")", ",", "$", "data", "[", "'__telescope'", "]", "??", "[", "]", ")", ";", "}" ]

[ "Extract", "the", "tags", "from", "the", "message", "." ]

[ "public", "function", "show", "(", "EntriesRepository", "$", "storage", ",", "$", "id", ")", "{", "return", "response", "(", "$", "storage", "->", "find", "(", "$", "id", ")", "->", "content", "[", "'raw'", "]", ",", "200", ",", "[", "'Content-Type'", "=>", "'message/rfc822'", ",", "'Content-Disposition'", "=>", "'attachment; filename=\"mail-'", ".", "$", "id", ".", "'.eml\"'", ",", "]", ")", ";", "}" ]

[ "Download", "the", "Eml", "content", "of", "the", "email", "." ]

[ "public", "function", "recordAction", "(", "$", "event", ",", "$", "data", ")", "{", "if", "(", "!", "Telescope", "::", "isRecording", "(", ")", "||", "!", "$", "this", "->", "shouldRecord", "(", "$", "event", ")", ")", "{", "return", ";", "}", "$", "model", "=", "FormatModel", "::", "given", "(", "$", "data", "[", "0", "]", ")", ";", "$", "changes", "=", "$", "data", "[", "0", "]", "->", "getChanges", "(", ")", ";", "Telescope", "::", "recordModelEvent", "(", "IncomingEntry", "::", "make", "(", "array_filter", "(", "[", "'action'", "=>", "$", "this", "->", "action", "(", "$", "event", ")", ",", "'model'", "=>", "$", "model", ",", "'changes'", "=>", "empty", "(", "$", "changes", ")", "?", "null", ":", "$", "changes", ",", "]", ")", ")", "->", "tags", "(", "[", "$", "model", "]", ")", ")", ";", "}" ]

[ "Record", "an", "action", "." ]

[ "public", "function", "recordCommand", "(", "CommandStarting", "$", "event", ")", "{", "if", "(", "!", "Telescope", "::", "isRecording", "(", ")", "||", "$", "event", "->", "command", "!==", "'schedule:run'", "&&", "$", "event", "->", "command", "!==", "'schedule:finish'", ")", "{", "return", ";", "}", "collect", "(", "app", "(", "Schedule", "::", "class", ")", "->", "events", "(", ")", ")", "->", "each", "(", "function", "(", "$", "event", ")", "{", "$", "event", "->", "then", "(", "function", "(", ")", "use", "(", "$", "event", ")", "{", "Telescope", "::", "recordScheduledCommand", "(", "IncomingEntry", "::", "make", "(", "[", "'command'", "=>", "$", "event", "instanceof", "CallbackEvent", "?", "'Closure'", ":", "$", "event", "->", "command", ",", "'description'", "=>", "$", "event", "->", "description", ",", "'expression'", "=>", "$", "event", "->", "expression", ",", "'timezone'", "=>", "$", "event", "->", "timezone", ",", "'user'", "=>", "$", "event", "->", "user", ",", "'output'", "=>", "$", "this", "->", "getEventOutput", "(", "$", "event", ")", ",", "]", ")", ")", ";", "}", ")", ";", "}", ")", ";", "}" ]

[ "Record", "a", "scheduled", "command", "was", "executed", "." ]

[ "protected", "function", "getEventOutput", "(", "Event", "$", "event", ")", "{", "if", "(", "!", "$", "event", "->", "output", "||", "$", "event", "->", "output", "===", "$", "event", "->", "getDefaultOutput", "(", ")", "||", "$", "event", "->", "shouldAppendOutput", "||", "!", "file_exists", "(", "$", "event", "->", "output", ")", ")", "{", "return", "''", ";", "}", "return", "trim", "(", "file_get_contents", "(", "$", "event", "->", "output", ")", ")", ";", "}" ]

[ "Get", "the", "output", "for", "the", "scheduled", "event", "." ]

[ "protected", "static", "function", "storeEntriesAfterWorkerLoop", "(", "$", "app", ")", "{", "$", "app", "[", "'events'", "]", "->", "listen", "(", "JobProcessing", "::", "class", ",", "function", "(", ")", "{", "static", "::", "startRecording", "(", ")", ";", "static", "::", "$", "processingJobs", "[", "]", "=", "true", ";", "}", ")", ";", "$", "app", "[", "'events'", "]", "->", "listen", "(", "JobProcessed", "::", "class", ",", "function", "(", "$", "event", ")", "use", "(", "$", "app", ")", "{", "static", "::", "storeIfDoneProcessingJob", "(", "$", "event", ",", "$", "app", ")", ";", "}", ")", ";", "$", "app", "[", "'events'", "]", "->", "listen", "(", "JobFailed", "::", "class", ",", "function", "(", "$", "event", ")", "use", "(", "$", "app", ")", "{", "static", "::", "storeIfDoneProcessingJob", "(", "$", "event", ",", "$", "app", ")", ";", "}", ")", ";", "$", "app", "[", "'events'", "]", "->", "listen", "(", "JobExceptionOccurred", "::", "class", ",", "function", "(", ")", "{", "array_pop", "(", "static", "::", "$", "processingJobs", ")", ";", "}", ")", ";", "}" ]

[ "Store", "entries", "after", "the", "queue", "worker", "loops", "." ]

[ "protected", "static", "function", "storeIfDoneProcessingJob", "(", "$", "event", ",", "$", "app", ")", "{", "array_pop", "(", "static", "::", "$", "processingJobs", ")", ";", "if", "(", "empty", "(", "static", "::", "$", "processingJobs", ")", ")", "{", "static", "::", "store", "(", "$", "app", "[", "EntriesRepository", "::", "class", "]", ")", ";", "if", "(", "$", "event", "->", "connectionName", "!==", "'sync'", ")", "{", "static", "::", "stopRecording", "(", ")", ";", "}", "}", "}" ]

[ "Store", "the", "recorded", "entries", "if", "totally", "done", "processing", "the", "current", "job", "." ]

[ "public", "function", "recordNotification", "(", "NotificationSent", "$", "event", ")", "{", "if", "(", "!", "Telescope", "::", "isRecording", "(", ")", ")", "{", "return", ";", "}", "Telescope", "::", "recordNotification", "(", "IncomingEntry", "::", "make", "(", "[", "'notification'", "=>", "get_class", "(", "$", "event", "->", "notification", ")", ",", "'queued'", "=>", "in_array", "(", "ShouldQueue", "::", "class", ",", "class_implements", "(", "$", "event", "->", "notification", ")", ")", ",", "'notifiable'", "=>", "$", "this", "->", "formatNotifiable", "(", "$", "event", "->", "notifiable", ")", ",", "'channel'", "=>", "$", "event", "->", "channel", ",", "'response'", "=>", "$", "event", "->", "response", ",", "]", ")", "->", "tags", "(", "$", "this", "->", "tags", "(", "$", "event", ")", ")", ")", ";", "}" ]

[ "Record", "a", "new", "notification", "message", "was", "sent", "." ]

[ "private", "function", "tags", "(", "$", "event", ")", "{", "return", "array_merge", "(", "[", "$", "this", "->", "formatNotifiable", "(", "$", "event", "->", "notifiable", ")", ",", "]", ",", "ExtractTags", "::", "from", "(", "$", "event", "->", "notification", ")", ")", ";", "}" ]

[ "Extract", "the", "tags", "for", "the", "given", "event", "." ]

[ "private", "function", "formatNotifiable", "(", "$", "notifiable", ")", "{", "if", "(", "$", "notifiable", "instanceof", "Model", ")", "{", "return", "FormatModel", "::", "given", "(", "$", "notifiable", ")", ";", "}", "elseif", "(", "$", "notifiable", "instanceof", "AnonymousNotifiable", ")", "{", "return", "'Anonymous:'", ".", "implode", "(", "','", ",", "$", "notifiable", "->", "routes", ")", ";", "}", "return", "get_class", "(", "$", "notifiable", ")", ";", "}" ]

[ "Format", "the", "given", "notifiable", "into", "a", "tag", "." ]

[ "public", "static", "function", "get", "(", "Throwable", "$", "exception", ")", "{", "return", "collect", "(", "explode", "(", "\"\\n\"", ",", "file_get_contents", "(", "$", "exception", "->", "getFile", "(", ")", ")", ")", ")", "->", "slice", "(", "$", "exception", "->", "getLine", "(", ")", "-", "10", ",", "20", ")", "->", "mapWithKeys", "(", "function", "(", "$", "value", ",", "$", "key", ")", "{", "return", "[", "$", "key", "+", "1", "=>", "$", "value", "]", ";", "}", ")", "->", "all", "(", ")", ";", "}" ]

[ "Get", "the", "exception", "code", "context", "for", "the", "given", "exception", "." ]

[ "public", "function", "recordLog", "(", "MessageLogged", "$", "event", ")", "{", "if", "(", "!", "Telescope", "::", "isRecording", "(", ")", "||", "$", "this", "->", "shouldIgnore", "(", "$", "event", ")", ")", "{", "return", ";", "}", "Telescope", "::", "recordLog", "(", "IncomingEntry", "::", "make", "(", "[", "'level'", "=>", "$", "event", "->", "level", ",", "'message'", "=>", "$", "event", "->", "message", ",", "'context'", "=>", "Arr", "::", "except", "(", "$", "event", "->", "context", ",", "[", "'telescope'", "]", ")", ",", "]", ")", "->", "tags", "(", "$", "this", "->", "tags", "(", "$", "event", ")", ")", ")", ";", "}" ]

[ "Record", "a", "message", "was", "logged", "." ]

[ "public", "static", "function", "fromRequest", "(", "Request", "$", "request", ")", "{", "return", "(", "new", "static", ")", "->", "batchId", "(", "$", "request", "->", "batch_id", ")", "->", "uuids", "(", "$", "request", "->", "uuids", ")", "->", "beforeSequence", "(", "$", "request", "->", "before", ")", "->", "tag", "(", "$", "request", "->", "tag", ")", "->", "familyHash", "(", "$", "request", "->", "family_hash", ")", "->", "limit", "(", "$", "request", "->", "take", "??", "50", ")", ";", "}" ]

[ "Create", "new", "entry", "query", "options", "from", "the", "incoming", "request", "." ]

[ "public", "function", "recordRequest", "(", "RequestHandled", "$", "event", ")", "{", "if", "(", "!", "Telescope", "::", "isRecording", "(", ")", ")", "{", "return", ";", "}", "Telescope", "::", "recordRequest", "(", "IncomingEntry", "::", "make", "(", "[", "'uri'", "=>", "str_replace", "(", "$", "event", "->", "request", "->", "root", "(", ")", ",", "''", ",", "$", "event", "->", "request", "->", "fullUrl", "(", ")", ")", "?", ":", "'/'", ",", "'method'", "=>", "$", "event", "->", "request", "->", "method", "(", ")", ",", "'controller_action'", "=>", "optional", "(", "$", "event", "->", "request", "->", "route", "(", ")", ")", "->", "getActionName", "(", ")", ",", "'middleware'", "=>", "array_values", "(", "optional", "(", "$", "event", "->", "request", "->", "route", "(", ")", ")", "->", "gatherMiddleware", "(", ")", "??", "[", "]", ")", ",", "'headers'", "=>", "$", "this", "->", "headers", "(", "$", "event", "->", "request", "->", "headers", "->", "all", "(", ")", ")", ",", "'payload'", "=>", "$", "this", "->", "payload", "(", "$", "this", "->", "input", "(", "$", "event", "->", "request", ")", ")", ",", "'session'", "=>", "$", "this", "->", "payload", "(", "$", "this", "->", "sessionVariables", "(", "$", "event", "->", "request", ")", ")", ",", "'response_status'", "=>", "$", "event", "->", "response", "->", "getStatusCode", "(", ")", ",", "'response'", "=>", "$", "this", "->", "response", "(", "$", "event", "->", "response", ")", ",", "'duration'", "=>", "defined", "(", "'LARAVEL_START'", ")", "?", "floor", "(", "(", "microtime", "(", "true", ")", "-", "LARAVEL_START", ")", "*", "1000", ")", ":", "null", ",", "]", ")", ")", ";", "}" ]

[ "Record", "an", "incoming", "HTTP", "request", "." ]

[ "protected", "function", "headers", "(", "$", "headers", ")", "{", "$", "headers", "=", "collect", "(", "$", "headers", ")", "->", "map", "(", "function", "(", "$", "header", ")", "{", "return", "$", "header", "[", "0", "]", ";", "}", ")", "->", "toArray", "(", ")", ";", "return", "$", "this", "->", "hideParameters", "(", "$", "headers", ",", "Telescope", "::", "$", "hiddenRequestHeaders", ")", ";", "}" ]

[ "Format", "the", "given", "headers", "." ]

[ "protected", "function", "hideParameters", "(", "$", "data", ",", "$", "hidden", ")", "{", "foreach", "(", "$", "hidden", "as", "$", "parameter", ")", "{", "if", "(", "Arr", "::", "get", "(", "$", "data", ",", "$", "parameter", ")", ")", "{", "Arr", "::", "set", "(", "$", "data", ",", "$", "parameter", ",", "'********'", ")", ";", "}", "}", "return", "$", "data", ";", "}" ]

[ "Hide", "the", "given", "parameters", "." ]

[ "private", "function", "input", "(", "Request", "$", "request", ")", "{", "$", "files", "=", "$", "request", "->", "files", "->", "all", "(", ")", ";", "array_walk_recursive", "(", "$", "files", ",", "function", "(", "&", "$", "file", ")", "{", "$", "file", "=", "[", "'name'", "=>", "$", "file", "->", "getClientOriginalName", "(", ")", ",", "'size'", "=>", "$", "file", "->", "isFile", "(", ")", "?", "(", "$", "file", "->", "getSize", "(", ")", "/", "1000", ")", ".", "'KB'", ":", "'0'", ",", "]", ";", "}", ")", ";", "return", "array_replace_recursive", "(", "$", "request", "->", "input", "(", ")", ",", "$", "files", ")", ";", "}" ]

[ "Extract", "the", "input", "from", "the", "given", "request", "." ]

[ "protected", "function", "response", "(", "Response", "$", "response", ")", "{", "$", "content", "=", "$", "response", "->", "getContent", "(", ")", ";", "if", "(", "is_string", "(", "$", "content", ")", "&&", "is_array", "(", "json_decode", "(", "$", "content", ",", "true", ")", ")", "&&", "json_last_error", "(", ")", "===", "JSON_ERROR_NONE", ")", "{", "return", "$", "this", "->", "contentWithinLimits", "(", "$", "content", ")", "?", "$", "this", "->", "hideParameters", "(", "json_decode", "(", "$", "content", ",", "true", ")", ",", "Telescope", "::", "$", "hiddenResponseParameters", ")", ":", "'Purged By Telescope'", ";", "}", "if", "(", "$", "response", "instanceof", "RedirectResponse", ")", "{", "return", "'Redirected to '", ".", "$", "response", "->", "getTargetUrl", "(", ")", ";", "}", "if", "(", "$", "response", "instanceof", "IlluminateResponse", "&&", "$", "response", "->", "getOriginalContent", "(", ")", "instanceof", "View", ")", "{", "return", "[", "'view'", "=>", "$", "response", "->", "getOriginalContent", "(", ")", "->", "getPath", "(", ")", ",", "'data'", "=>", "$", "this", "->", "extractDataFromView", "(", "$", "response", "->", "getOriginalContent", "(", ")", ")", ",", "]", ";", "}", "return", "'HTML Response'", ";", "}" ]

[ "Format", "the", "given", "response", "object", "." ]

[ "protected", "function", "extractDataFromView", "(", "$", "view", ")", "{", "return", "collect", "(", "$", "view", "->", "getData", "(", ")", ")", "->", "map", "(", "function", "(", "$", "value", ")", "{", "if", "(", "$", "value", "instanceof", "Model", ")", "{", "return", "FormatModel", "::", "given", "(", "$", "value", ")", ";", "}", "elseif", "(", "is_object", "(", "$", "value", ")", ")", "{", "return", "[", "'class'", "=>", "get_class", "(", "$", "value", ")", ",", "'properties'", "=>", "json_decode", "(", "json_encode", "(", "$", "value", ")", ",", "true", ")", ",", "]", ";", "}", "else", "{", "return", "json_decode", "(", "json_encode", "(", "$", "value", ")", ",", "true", ")", ";", "}", "}", ")", "->", "toArray", "(", ")", ";", "}" ]

[ "Extract", "the", "data", "from", "the", "given", "view", "in", "array", "form", "." ]

[ "public", "function", "recordCommand", "(", "CommandFinished", "$", "event", ")", "{", "if", "(", "!", "Telescope", "::", "isRecording", "(", ")", "||", "$", "this", "->", "shouldIgnore", "(", "$", "event", ")", ")", "{", "return", ";", "}", "Telescope", "::", "recordCommand", "(", "IncomingEntry", "::", "make", "(", "[", "'command'", "=>", "$", "event", "->", "command", "??", "$", "event", "->", "input", "->", "getArguments", "(", ")", "[", "'command'", "]", "??", "'default'", ",", "'exit_code'", "=>", "$", "event", "->", "exitCode", ",", "'arguments'", "=>", "$", "event", "->", "input", "->", "getArguments", "(", ")", ",", "'options'", "=>", "$", "event", "->", "input", "->", "getOptions", "(", ")", ",", "]", ")", ")", ";", "}" ]

[ "Record", "an", "Artisan", "command", "was", "executed", "." ]

[ "public", "function", "recordCacheHit", "(", "CacheHit", "$", "event", ")", "{", "if", "(", "!", "Telescope", "::", "isRecording", "(", ")", "||", "$", "this", "->", "shouldIgnore", "(", "$", "event", ")", ")", "{", "return", ";", "}", "Telescope", "::", "recordCache", "(", "IncomingEntry", "::", "make", "(", "[", "'type'", "=>", "'hit'", ",", "'key'", "=>", "$", "event", "->", "key", ",", "'value'", "=>", "$", "event", "->", "value", ",", "]", ")", ")", ";", "}" ]

[ "Record", "a", "cache", "key", "was", "found", "." ]

[ "public", "function", "recordCacheMissed", "(", "CacheMissed", "$", "event", ")", "{", "if", "(", "!", "Telescope", "::", "isRecording", "(", ")", "||", "$", "this", "->", "shouldIgnore", "(", "$", "event", ")", ")", "{", "return", ";", "}", "Telescope", "::", "recordCache", "(", "IncomingEntry", "::", "make", "(", "[", "'type'", "=>", "'missed'", ",", "'key'", "=>", "$", "event", "->", "key", ",", "]", ")", ")", ";", "}" ]

[ "Record", "a", "missing", "cache", "key", "." ]

[ "public", "function", "recordKeyWritten", "(", "KeyWritten", "$", "event", ")", "{", "if", "(", "!", "Telescope", "::", "isRecording", "(", ")", "||", "$", "this", "->", "shouldIgnore", "(", "$", "event", ")", ")", "{", "return", ";", "}", "Telescope", "::", "recordCache", "(", "IncomingEntry", "::", "make", "(", "[", "'type'", "=>", "'set'", ",", "'key'", "=>", "$", "event", "->", "key", ",", "'value'", "=>", "$", "event", "->", "value", ",", "'expiration'", "=>", "$", "this", "->", "formatExpiration", "(", "$", "event", ")", ",", "]", ")", ")", ";", "}" ]

[ "Record", "a", "cache", "key", "was", "updated", "." ]

[ "public", "function", "user", "(", "$", "user", ")", "{", "$", "this", "->", "user", "=", "$", "user", ";", "$", "this", "->", "content", "=", "array_merge", "(", "$", "this", "->", "content", ",", "[", "'user'", "=>", "[", "'id'", "=>", "$", "user", "->", "getAuthIdentifier", "(", ")", ",", "'name'", "=>", "$", "user", "->", "name", "??", "null", ",", "'email'", "=>", "$", "user", "->", "email", "??", "null", ",", "]", ",", "]", ")", ";", "$", "this", "->", "tags", "(", "[", "'Auth:'", ".", "$", "user", "->", "getAuthIdentifier", "(", ")", "]", ")", ";", "return", "$", "this", ";", "}" ]

[ "Set", "the", "currently", "authenticated", "user", "." ]

[ "public", "function", "tags", "(", "array", "$", "tags", ")", "{", "$", "this", "->", "tags", "=", "array_unique", "(", "array_merge", "(", "$", "this", "->", "tags", ",", "$", "tags", ")", ")", ";", "return", "$", "this", ";", "}" ]

[ "Merge", "tags", "into", "the", "entry", "s", "existing", "tags", "." ]

[ "public", "function", "hasMonitoredTag", "(", ")", "{", "if", "(", "!", "empty", "(", "$", "this", "->", "tags", ")", ")", "{", "return", "app", "(", "EntriesRepository", "::", "class", ")", "->", "isMonitoring", "(", "$", "this", "->", "tags", ")", ";", "}", "return", "false", ";", "}" ]

[ "Determine", "if", "the", "incoming", "entry", "has", "a", "monitored", "tag", "." ]

[ "public", "function", "toArray", "(", ")", "{", "return", "[", "'uuid'", "=>", "$", "this", "->", "uuid", ",", "'batch_id'", "=>", "$", "this", "->", "batchId", ",", "'type'", "=>", "$", "this", "->", "type", ",", "'content'", "=>", "$", "this", "->", "content", ",", "'created_at'", "=>", "$", "this", "->", "recordedAt", "->", "toDateTimeString", "(", ")", ",", "]", ";", "}" ]

[ "Get", "an", "array", "representation", "of", "the", "entry", "for", "storage", "." ]

[ "public", "function", "assignEntryPointFromBatch", "(", "array", "$", "batch", ")", "{", "$", "entryPoint", "=", "collect", "(", "$", "batch", ")", "->", "first", "(", "function", "(", "$", "entry", ")", "{", "return", "in_array", "(", "$", "entry", "->", "type", ",", "[", "EntryType", "::", "REQUEST", ",", "EntryType", "::", "JOB", ",", "EntryType", "::", "COMMAND", "]", ")", ";", "}", ")", ";", "if", "(", "!", "$", "entryPoint", ")", "{", "return", ";", "}", "$", "this", "->", "content", "=", "array_merge", "(", "$", "this", "->", "content", ",", "[", "'entry_point_type'", "=>", "$", "entryPoint", "->", "type", ",", "'entry_point_uuid'", "=>", "$", "entryPoint", "->", "uuid", ",", "'entry_point_description'", "=>", "$", "this", "->", "entryPointDescription", "(", "$", "entryPoint", ")", ",", "]", ")", ";", "}" ]

[ "Assign", "entry", "point", "parameters", "from", "the", "given", "batch", "entries", "." ]

[ "private", "function", "entryPointDescription", "(", "$", "entryPoint", ")", "{", "switch", "(", "$", "entryPoint", "->", "type", ")", "{", "case", "EntryType", "::", "REQUEST", ":", "return", "$", "entryPoint", "->", "content", "[", "'method'", "]", ".", "' '", ".", "$", "entryPoint", "->", "content", "[", "'uri'", "]", ";", "case", "EntryType", "::", "JOB", ":", "return", "$", "entryPoint", "->", "content", "[", "'name'", "]", ";", "case", "EntryType", "::", "COMMAND", ":", "return", "$", "entryPoint", "->", "content", "[", "'command'", "]", ";", "}", "return", "''", ";", "}" ]

[ "Description", "for", "the", "entry", "point", "." ]

[ "public", "function", "jsonSerialize", "(", ")", "{", "return", "[", "'id'", "=>", "$", "this", "->", "id", ",", "'sequence'", "=>", "$", "this", "->", "sequence", ",", "'batch_id'", "=>", "$", "this", "->", "batchId", ",", "'type'", "=>", "$", "this", "->", "type", ",", "'content'", "=>", "$", "this", "->", "content", ",", "'tags'", "=>", "$", "this", "->", "tags", ",", "'family_hash'", "=>", "$", "this", "->", "familyHash", ",", "'created_at'", "=>", "$", "this", "->", "createdAt", "->", "toDateTimeString", "(", ")", ",", "]", ";", "}" ]

[ "Get", "the", "array", "representation", "of", "the", "entry", "." ]

[ "public", "function", "collect", "(", ")", ":", "GitInfo", "{", "$", "branch", "=", "$", "this", "->", "collectBranch", "(", ")", ";", "$", "commit", "=", "$", "this", "->", "collectCommit", "(", ")", ";", "$", "remotes", "=", "$", "this", "->", "collectRemotes", "(", ")", ";", "return", "new", "GitInfo", "(", "$", "branch", ",", "$", "commit", ",", "$", "remotes", ")", ";", "}" ]

[ "Collect", "git", "repository", "info", "." ]

[ "public", "static", "function", "parse", "(", "string", "$", "msg", ")", ":", "Message", "{", "$", "obj", "=", "new", "self", ";", "$", "parts", "=", "explode", "(", "\"\\r\\n\"", ",", "$", "msg", ")", ";", "$", "obj", "->", "body", "=", "MessageBody", "::", "parse", "(", "array_pop", "(", "$", "parts", ")", ")", ";", "foreach", "(", "$", "parts", "as", "$", "line", ")", "{", "if", "(", "$", "line", ")", "{", "$", "pair", "=", "explode", "(", "': '", ",", "$", "line", ")", ";", "$", "obj", "->", "headers", "[", "$", "pair", "[", "0", "]", "]", "=", "$", "pair", "[", "1", "]", ";", "}", "}", "return", "$", "obj", ";", "}" ]

[ "Parses", "a", "message" ]

[ "protected", "function", "resolveName", "(", "Name", "$", "name", ",", "$", "type", ")", "{", "$", "resolvedName", "=", "$", "this", "->", "nameContext", "->", "getResolvedName", "(", "$", "name", ",", "$", "type", ")", ";", "if", "(", "null", "!==", "$", "resolvedName", ")", "{", "$", "name", "->", "setAttribute", "(", "'resolvedName'", ",", "$", "resolvedName", "->", "toString", "(", ")", ")", ";", "}", "return", "$", "name", ";", "}" ]

[ "Resolve", "name", "according", "to", "name", "resolver", "options", "." ]

[ "private", "static", "function", "streamForParent", "(", "array", "$", "sockets", ")", "{", "list", "(", "$", "for_read", ",", "$", "for_write", ")", "=", "$", "sockets", ";", "// The parent will not use the write channel, so it", "// must be closed to prevent deadlock.", "fclose", "(", "$", "for_write", ")", ";", "// stream_select will be used to read multiple streams, so these", "// must be set to non-blocking mode.", "if", "(", "!", "stream_set_blocking", "(", "$", "for_read", ",", "false", ")", ")", "{", "error_log", "(", "'unable to set read stream to non-blocking'", ")", ";", "exit", "(", "self", "::", "EXIT_FAILURE", ")", ";", "}", "return", "$", "for_read", ";", "}" ]

[ "Prepare", "the", "socket", "pair", "to", "be", "used", "in", "a", "parent", "process", "and", "return", "the", "stream", "the", "parent", "will", "use", "to", "read", "results", "." ]

[ "private", "function", "readResultsFromChildren", "(", ")", "{", "// Create an array of all active streams, indexed by", "// resource id.", "$", "streams", "=", "[", "]", ";", "foreach", "(", "$", "this", "->", "read_streams", "as", "$", "stream", ")", "{", "$", "streams", "[", "intval", "(", "$", "stream", ")", "]", "=", "$", "stream", ";", "}", "// Create an array for the content received on each stream,", "// indexed by resource id.", "$", "content", "=", "array_fill_keys", "(", "array_keys", "(", "$", "streams", ")", ",", "''", ")", ";", "// Read the data off of all the stream.", "while", "(", "count", "(", "$", "streams", ")", ">", "0", ")", "{", "$", "needs_read", "=", "array_values", "(", "$", "streams", ")", ";", "$", "needs_write", "=", "null", ";", "$", "needs_except", "=", "null", ";", "// Wait for data on at least one stream.", "$", "num", "=", "stream_select", "(", "$", "needs_read", ",", "$", "needs_write", ",", "$", "needs_except", ",", "null", "/* no timeout */", ")", ";", "if", "(", "$", "num", "===", "false", ")", "{", "error_log", "(", "'unable to select on read stream'", ")", ";", "exit", "(", "self", "::", "EXIT_FAILURE", ")", ";", "}", "// For each stream that was ready, read the content.", "foreach", "(", "$", "needs_read", "as", "$", "file", ")", "{", "$", "buffer", "=", "fread", "(", "$", "file", ",", "1024", ")", ";", "if", "(", "$", "buffer", ")", "{", "$", "content", "[", "intval", "(", "$", "file", ")", "]", ".=", "$", "buffer", ";", "}", "// If the stream has closed, stop trying to select on it.", "if", "(", "feof", "(", "$", "file", ")", ")", "{", "fclose", "(", "$", "file", ")", ";", "unset", "(", "$", "streams", "[", "intval", "(", "$", "file", ")", "]", ")", ";", "}", "}", "}", "// Unmarshal the content into its original form.", "return", "array_values", "(", "array_map", "(", "/**\n * @param string $data\n *\n * @return array\n */", "function", "(", "$", "data", ")", "{", "/** @var array */", "$", "result", "=", "unserialize", "(", "$", "data", ")", ";", "/** @psalm-suppress DocblockTypeContradiction */", "if", "(", "!", "\\", "is_array", "(", "$", "result", ")", ")", "{", "error_log", "(", "'Child terminated without returning a serialized array - response type='", ".", "gettype", "(", "$", "result", ")", ")", ";", "$", "this", "->", "did_have_error", "=", "true", ";", "}", "return", "$", "result", ";", "}", ",", "$", "content", ")", ")", ";", "}" ]

[ "Read", "the", "results", "that", "each", "child", "process", "has", "serialized", "on", "their", "write", "streams", ".", "The", "results", "are", "returned", "in", "an", "array", "one", "for", "each", "worker", ".", "The", "order", "of", "the", "results", "is", "not", "maintained", "." ]

[ "public", "function", "wait", "(", ")", ":", "array", "{", "// Read all the streams from child processes into an array.", "$", "content", "=", "$", "this", "->", "readResultsFromChildren", "(", ")", ";", "// Wait for all children to return", "foreach", "(", "$", "this", "->", "child_pid_list", "as", "$", "child_pid", ")", "{", "$", "process_lookup", "=", "posix_kill", "(", "$", "child_pid", ",", "0", ")", ";", "$", "status", "=", "0", ";", "if", "(", "$", "process_lookup", ")", "{", "/**\n * @psalm-suppress UndefinedConstant - does not exist on windows\n * @psalm-suppress MixedArgument\n */", "posix_kill", "(", "$", "child_pid", ",", "SIGALRM", ")", ";", "if", "(", "pcntl_waitpid", "(", "$", "child_pid", ",", "$", "status", ")", "<", "0", ")", "{", "error_log", "(", "posix_strerror", "(", "posix_get_last_error", "(", ")", ")", ")", ";", "}", "}", "// Check to see if the child died a graceful death", "if", "(", "pcntl_wifsignaled", "(", "$", "status", ")", ")", "{", "$", "return_code", "=", "pcntl_wexitstatus", "(", "$", "status", ")", ";", "$", "term_sig", "=", "pcntl_wtermsig", "(", "$", "status", ")", ";", "/**\n * @psalm-suppress UndefinedConstant - does not exist on windows\n */", "if", "(", "$", "term_sig", "!==", "SIGALRM", ")", "{", "$", "this", "->", "did_have_error", "=", "true", ";", "error_log", "(", "\"Child terminated with return code $return_code and signal $term_sig\"", ")", ";", "}", "}", "}", "return", "$", "content", ";", "}" ]

[ "Wait", "for", "all", "child", "processes", "to", "complete" ]

[ "protected", "function", "traverseNode", "(", "Node", "$", "node", ")", ":", "Node", "{", "foreach", "(", "$", "node", "->", "getSubNodeNames", "(", ")", "as", "$", "name", ")", "{", "$", "subNode", "=", "&", "$", "node", "->", "$", "name", ";", "if", "(", "\\", "is_array", "(", "$", "subNode", ")", ")", "{", "$", "subNode", "=", "$", "this", "->", "traverseArray", "(", "$", "subNode", ")", ";", "if", "(", "$", "this", "->", "stopTraversal", ")", "{", "break", ";", "}", "}", "elseif", "(", "$", "subNode", "instanceof", "Node", ")", "{", "$", "traverseChildren", "=", "true", ";", "foreach", "(", "$", "this", "->", "visitors", "as", "$", "visitor", ")", "{", "$", "return", "=", "$", "visitor", "->", "enterNode", "(", "$", "subNode", ",", "$", "traverseChildren", ")", ";", "if", "(", "null", "!==", "$", "return", ")", "{", "if", "(", "$", "return", "instanceof", "Node", ")", "{", "$", "subNode", "=", "$", "return", ";", "}", "elseif", "(", "self", "::", "DONT_TRAVERSE_CHILDREN", "===", "$", "return", ")", "{", "$", "traverseChildren", "=", "false", ";", "}", "elseif", "(", "self", "::", "STOP_TRAVERSAL", "===", "$", "return", ")", "{", "$", "this", "->", "stopTraversal", "=", "true", ";", "break", "2", ";", "}", "else", "{", "throw", "new", "\\", "LogicException", "(", "'enterNode() returned invalid value of type '", ".", "gettype", "(", "$", "return", ")", ")", ";", "}", "}", "}", "if", "(", "$", "traverseChildren", ")", "{", "$", "subNode", "=", "$", "this", "->", "traverseNode", "(", "$", "subNode", ")", ";", "if", "(", "$", "this", "->", "stopTraversal", ")", "{", "break", ";", "}", "}", "foreach", "(", "$", "this", "->", "visitors", "as", "$", "visitor", ")", "{", "$", "return", "=", "$", "visitor", "->", "leaveNode", "(", "$", "subNode", ")", ";", "if", "(", "null", "!==", "$", "return", ")", "{", "if", "(", "$", "return", "instanceof", "Node", ")", "{", "$", "subNode", "=", "$", "return", ";", "}", "elseif", "(", "self", "::", "STOP_TRAVERSAL", "===", "$", "return", ")", "{", "$", "this", "->", "stopTraversal", "=", "true", ";", "break", "2", ";", "}", "elseif", "(", "\\", "is_array", "(", "$", "return", ")", ")", "{", "throw", "new", "\\", "LogicException", "(", "'leaveNode() may only return an array '", ".", "'if the parent structure is an array'", ")", ";", "}", "else", "{", "throw", "new", "\\", "LogicException", "(", "'leaveNode() returned invalid value of type '", ".", "gettype", "(", "$", "return", ")", ")", ";", "}", "}", "}", "}", "}", "return", "$", "node", ";", "}" ]

[ "Recursively", "traverse", "a", "node", "." ]

[ "public", "static", "function", "getFQCLNFromNameObject", "(", "PhpParser", "\\", "Node", "\\", "Name", "$", "class_name", ",", "Aliases", "$", "aliases", ")", "{", "/** @var string|null */", "$", "resolved_name", "=", "$", "class_name", "->", "getAttribute", "(", "'resolvedName'", ")", ";", "if", "(", "$", "resolved_name", ")", "{", "return", "$", "resolved_name", ";", "}", "if", "(", "$", "class_name", "instanceof", "PhpParser", "\\", "Node", "\\", "Name", "\\", "FullyQualified", ")", "{", "return", "implode", "(", "'\\\\'", ",", "$", "class_name", "->", "parts", ")", ";", "}", "if", "(", "in_array", "(", "$", "class_name", "->", "parts", "[", "0", "]", ",", "[", "'self'", ",", "'static'", ",", "'parent'", "]", ",", "true", ")", ")", "{", "return", "$", "class_name", "->", "parts", "[", "0", "]", ";", "}", "return", "Type", "::", "getFQCLNFromString", "(", "implode", "(", "'\\\\'", ",", "$", "class_name", "->", "parts", ")", ",", "$", "aliases", ")", ";", "}" ]

[ "Gets", "the", "fully", "-", "qualified", "class", "name", "from", "a", "Name", "object" ]

[ "public", "static", "function", "getTypeFromValue", "(", "$", "value", ")", "{", "switch", "(", "gettype", "(", "$", "value", ")", ")", "{", "case", "'boolean'", ":", "if", "(", "$", "value", ")", "{", "return", "Type", "::", "getTrue", "(", ")", ";", "}", "return", "Type", "::", "getFalse", "(", ")", ";", "case", "'integer'", ":", "return", "Type", "::", "getInt", "(", "false", ",", "$", "value", ")", ";", "case", "'double'", ":", "return", "Type", "::", "getFloat", "(", "$", "value", ")", ";", "case", "'string'", ":", "return", "Type", "::", "getString", "(", "$", "value", ")", ";", "case", "'array'", ":", "return", "Type", "::", "getArray", "(", ")", ";", "case", "'NULL'", ":", "return", "Type", "::", "getNull", "(", ")", ";", "default", ":", "return", "Type", "::", "getMixed", "(", ")", ";", "}", "}" ]

[ "Gets", "the", "Psalm", "type", "from", "a", "particular", "value" ]

[ "public", "static", "function", "afterStatementAnalysis", "(", "PhpParser", "\\", "Node", "\\", "Stmt", "$", "stmt", ",", "Context", "$", "context", ",", "StatementsSource", "$", "statements_source", ",", "Codebase", "$", "codebase", ",", "array", "&", "$", "file_replacements", "=", "[", "]", ")", "{", "if", "(", "$", "stmt", "instanceof", "PhpParser", "\\", "Node", "\\", "Stmt", "\\", "Echo_", ")", "{", "foreach", "(", "$", "stmt", "->", "exprs", "as", "$", "expr", ")", "{", "if", "(", "!", "isset", "(", "$", "expr", "->", "inferredType", ")", "||", "$", "expr", "->", "inferredType", "->", "hasMixed", "(", ")", ")", "{", "if", "(", "IssueBuffer", "::", "accepts", "(", "new", "ArgumentTypeCoercion", "(", "'Echo requires an unescaped string, '", ".", "$", "expr", "->", "inferredType", ".", "' provided'", ",", "new", "CodeLocation", "(", "$", "statements_source", ",", "$", "expr", ")", ",", "'echo'", ")", ",", "$", "statements_source", "->", "getSuppressedIssues", "(", ")", ")", ")", "{", "// keep soldiering on", "}", "continue", ";", "}", "$", "types", "=", "$", "expr", "->", "inferredType", "->", "getTypes", "(", ")", ";", "foreach", "(", "$", "types", "as", "$", "type", ")", "{", "if", "(", "$", "type", "instanceof", "\\", "Psalm", "\\", "Type", "\\", "Atomic", "\\", "TString", "&&", "!", "$", "type", "instanceof", "\\", "Psalm", "\\", "Type", "\\", "Atomic", "\\", "TLiteralString", "&&", "!", "$", "type", "instanceof", "\\", "Psalm", "\\", "Type", "\\", "Atomic", "\\", "THtmlEscapedString", ")", "{", "if", "(", "IssueBuffer", "::", "accepts", "(", "new", "ArgumentTypeCoercion", "(", "'Echo requires an unescaped string, '", ".", "$", "expr", "->", "inferredType", ".", "' provided'", ",", "new", "CodeLocation", "(", "$", "statements_source", ",", "$", "expr", ")", ",", "'echo'", ")", ",", "$", "statements_source", "->", "getSuppressedIssues", "(", ")", ")", ")", "{", "// keep soldiering on", "}", "}", "}", "}", "}", "}" ]

[ "Called", "after", "a", "statement", "has", "been", "checked" ]

[ "private", "function", "fileExistsForClassLike", "(", "ClassLikes", "$", "classlikes", ",", "$", "fq_class_name", ")", "{", "$", "fq_class_name_lc", "=", "strtolower", "(", "$", "fq_class_name", ")", ";", "if", "(", "isset", "(", "$", "this", "->", "classlike_files", "[", "$", "fq_class_name_lc", "]", ")", ")", "{", "return", "true", ";", "}", "if", "(", "$", "fq_class_name", "===", "'self'", ")", "{", "return", "false", ";", "}", "if", "(", "isset", "(", "$", "this", "->", "existing_classlikes_lc", "[", "$", "fq_class_name_lc", "]", ")", ")", "{", "throw", "new", "\\", "InvalidArgumentException", "(", "'Why are you asking about a builtin class?'", ")", ";", "}", "$", "composer_file_path", "=", "$", "this", "->", "config", "->", "getComposerFilePathForClassLike", "(", "$", "fq_class_name", ")", ";", "if", "(", "$", "composer_file_path", "&&", "file_exists", "(", "$", "composer_file_path", ")", ")", "{", "if", "(", "$", "this", "->", "debug_output", ")", "{", "echo", "'Using composer to locate file for '", ".", "$", "fq_class_name", ".", "\"\\n\"", ";", "}", "$", "classlikes", "->", "addFullyQualifiedClassLikeName", "(", "$", "fq_class_name_lc", ",", "realpath", "(", "$", "composer_file_path", ")", ")", ";", "return", "true", ";", "}", "$", "old_level", "=", "error_reporting", "(", ")", ";", "if", "(", "!", "$", "this", "->", "debug_output", ")", "{", "error_reporting", "(", "E_ERROR", ")", ";", "}", "try", "{", "if", "(", "$", "this", "->", "debug_output", ")", "{", "echo", "'Using reflection to locate file for '", ".", "$", "fq_class_name", ".", "\"\\n\"", ";", "}", "/** @psalm-suppress TypeCoercion */", "$", "reflected_class", "=", "new", "\\", "ReflectionClass", "(", "$", "fq_class_name", ")", ";", "}", "catch", "(", "\\", "Throwable", "$", "e", ")", "{", "error_reporting", "(", "$", "old_level", ")", ";", "// do not cache any results here (as case-sensitive filenames can screw things up)", "return", "false", ";", "}", "error_reporting", "(", "$", "old_level", ")", ";", "/** @psalm-suppress MixedMethodCall due to Reflection class weirdness */", "$", "file_path", "=", "(", "string", ")", "$", "reflected_class", "->", "getFileName", "(", ")", ";", "// if the file was autoloaded but exists in evaled code only, return false", "if", "(", "!", "file_exists", "(", "$", "file_path", ")", ")", "{", "return", "false", ";", "}", "$", "new_fq_class_name", "=", "$", "reflected_class", "->", "getName", "(", ")", ";", "if", "(", "strtolower", "(", "$", "new_fq_class_name", ")", "!==", "strtolower", "(", "$", "fq_class_name", ")", ")", "{", "$", "classlikes", "->", "addClassAlias", "(", "$", "new_fq_class_name", ",", "strtolower", "(", "$", "fq_class_name", ")", ")", ";", "$", "fq_class_name_lc", "=", "strtolower", "(", "$", "new_fq_class_name", ")", ";", "}", "$", "fq_class_name", "=", "$", "new_fq_class_name", ";", "$", "classlikes", "->", "addFullyQualifiedClassLikeName", "(", "$", "fq_class_name_lc", ")", ";", "if", "(", "$", "reflected_class", "->", "isInterface", "(", ")", ")", "{", "$", "classlikes", "->", "addFullyQualifiedInterfaceName", "(", "$", "fq_class_name", ",", "$", "file_path", ")", ";", "}", "elseif", "(", "$", "reflected_class", "->", "isTrait", "(", ")", ")", "{", "$", "classlikes", "->", "addFullyQualifiedTraitName", "(", "$", "fq_class_name", ",", "$", "file_path", ")", ";", "}", "else", "{", "$", "classlikes", "->", "addFullyQualifiedClassName", "(", "$", "fq_class_name", ",", "$", "file_path", ")", ";", "}", "return", "true", ";", "}" ]

[ "Checks", "whether", "a", "class", "exists", "and", "if", "it", "does", "then", "records", "what", "file", "it", "s", "in", "for", "later", "checking" ]

[ "public", "static", "function", "isContainedByInPhp", "(", "Type", "\\", "Union", "$", "input_type", "=", "null", ",", "Type", "\\", "Union", "$", "container_type", ")", "{", "if", "(", "!", "$", "input_type", ")", "{", "return", "false", ";", "}", "if", "(", "$", "input_type", "->", "getId", "(", ")", "===", "$", "container_type", "->", "getId", "(", ")", ")", "{", "return", "true", ";", "}", "if", "(", "$", "input_type", "->", "isNullable", "(", ")", "&&", "!", "$", "container_type", "->", "isNullable", "(", ")", ")", "{", "return", "false", ";", "}", "$", "input_type_not_null", "=", "clone", "$", "input_type", ";", "$", "input_type_not_null", "->", "removeType", "(", "'null'", ")", ";", "$", "container_type_not_null", "=", "clone", "$", "container_type", ";", "$", "container_type_not_null", "->", "removeType", "(", "'null'", ")", ";", "if", "(", "$", "input_type_not_null", "->", "getId", "(", ")", "===", "$", "container_type_not_null", "->", "getId", "(", ")", ")", "{", "return", "true", ";", "}", "if", "(", "$", "input_type_not_null", "->", "hasArray", "(", ")", "&&", "$", "container_type_not_null", "->", "hasType", "(", "'iterable'", ")", ")", "{", "return", "true", ";", "}", "return", "false", ";", "}" ]

[ "Used", "for", "comparing", "signature", "typehints", "uses", "PHP", "s", "light", "contravariance", "rules" ]

[ "public", "static", "function", "isSimplyContainedBy", "(", "Type", "\\", "Union", "$", "input_type", ",", "Type", "\\", "Union", "$", "container_type", ")", "{", "if", "(", "$", "input_type", "->", "getId", "(", ")", "===", "$", "container_type", "->", "getId", "(", ")", ")", "{", "return", "true", ";", "}", "if", "(", "$", "input_type", "->", "isNullable", "(", ")", "&&", "!", "$", "container_type", "->", "isNullable", "(", ")", ")", "{", "return", "false", ";", "}", "$", "input_type_not_null", "=", "clone", "$", "input_type", ";", "$", "input_type_not_null", "->", "removeType", "(", "'null'", ")", ";", "$", "container_type_not_null", "=", "clone", "$", "container_type", ";", "$", "container_type_not_null", "->", "removeType", "(", "'null'", ")", ";", "return", "(", "bool", ")", "array_intersect_key", "(", "$", "input_type_not_null", "->", "getTypes", "(", ")", ",", "$", "container_type_not_null", "->", "getTypes", "(", ")", ")", ";", "}" ]

[ "Used", "for", "comparing", "docblock", "types", "to", "signature", "types", "before", "we", "know", "about", "all", "types" ]

[ "protected", "function", "fillJenkins", "(", ")", ":", "self", "{", "if", "(", "isset", "(", "$", "this", "->", "env", "[", "'JENKINS_URL'", "]", ")", "&&", "isset", "(", "$", "this", "->", "env", "[", "'BUILD_NUMBER'", "]", ")", ")", "{", "$", "this", "->", "readEnv", "[", "'CI_BUILD_NUMBER'", "]", "=", "$", "this", "->", "env", "[", "'BUILD_NUMBER'", "]", ";", "$", "this", "->", "readEnv", "[", "'CI_BUILD_URL'", "]", "=", "$", "this", "->", "env", "[", "'JENKINS_URL'", "]", ";", "$", "this", "->", "env", "[", "'CI_NAME'", "]", "=", "'jenkins'", ";", "// backup", "$", "this", "->", "readEnv", "[", "'BUILD_NUMBER'", "]", "=", "$", "this", "->", "env", "[", "'BUILD_NUMBER'", "]", ";", "$", "this", "->", "readEnv", "[", "'JENKINS_URL'", "]", "=", "$", "this", "->", "env", "[", "'JENKINS_URL'", "]", ";", "$", "this", "->", "readEnv", "[", "'CI_NAME'", "]", "=", "$", "this", "->", "env", "[", "'CI_NAME'", "]", ";", "}", "return", "$", "this", ";", "}" ]

[ "Fill", "Jenkins", "environment", "variables", "." ]

[ "protected", "function", "fillScrutinizer", "(", ")", ":", "self", "{", "if", "(", "isset", "(", "$", "this", "->", "env", "[", "'SCRUTINIZER'", "]", ")", "&&", "$", "this", "->", "env", "[", "'SCRUTINIZER'", "]", ")", "{", "$", "this", "->", "readEnv", "[", "'CI_JOB_ID'", "]", "=", "$", "this", "->", "env", "[", "'SCRUTINIZER_INSPECTION_UUID'", "]", ";", "$", "this", "->", "readEnv", "[", "'CI_BRANCH'", "]", "=", "$", "this", "->", "env", "[", "'SCRUTINIZER_BRANCH'", "]", ";", "$", "this", "->", "readEnv", "[", "'CI_PR_NUMBER'", "]", "=", "$", "this", "->", "env", "[", "'SCRUTINIZER_PR_NUMBER'", "]", "??", "''", ";", "// backup", "$", "this", "->", "readEnv", "[", "'CI_NAME'", "]", "=", "'Scrutinizer'", ";", "$", "repo_slug", "=", "(", "string", ")", "$", "this", "->", "env", "[", "'SCRUTINIZER_PROJECT'", "]", "??", "''", ";", "if", "(", "$", "repo_slug", ")", "{", "$", "slug_parts", "=", "explode", "(", "'/'", ",", "$", "repo_slug", ")", ";", "if", "(", "$", "this", "->", "readEnv", "[", "'CI_PR_NUMBER'", "]", ")", "{", "$", "this", "->", "readEnv", "[", "'CI_PR_REPO_OWNER'", "]", "=", "$", "slug_parts", "[", "1", "]", ";", "$", "this", "->", "readEnv", "[", "'CI_PR_REPO_NAME'", "]", "=", "$", "slug_parts", "[", "2", "]", ";", "}", "else", "{", "$", "this", "->", "readEnv", "[", "'CI_REPO_OWNER'", "]", "=", "$", "slug_parts", "[", "1", "]", ";", "$", "this", "->", "readEnv", "[", "'CI_REPO_NAME'", "]", "=", "$", "slug_parts", "[", "2", "]", ";", "}", "}", "}", "return", "$", "this", ";", "}" ]

[ "Fill", "Scrutinizer", "environment", "variables", "." ]

[ "public", "static", "function", "checkStatic", "(", "$", "method_id", ",", "$", "self_call", ",", "$", "is_context_dynamic", ",", "Codebase", "$", "codebase", ",", "CodeLocation", "$", "code_location", ",", "array", "$", "suppressed_issues", ",", "&", "$", "is_dynamic_this_method", "=", "false", ")", "{", "$", "codebase_methods", "=", "$", "codebase", "->", "methods", ";", "if", "(", "$", "method_id", "===", "'Closure::fromcallable'", ")", "{", "return", "true", ";", "}", "$", "original_method_id", "=", "$", "method_id", ";", "$", "method_id", "=", "$", "codebase_methods", "->", "getDeclaringMethodId", "(", "$", "method_id", ")", ";", "if", "(", "!", "$", "method_id", ")", "{", "throw", "new", "\\", "LogicException", "(", "'Declaring method for '", ".", "$", "original_method_id", ".", "' should not be null'", ")", ";", "}", "$", "storage", "=", "$", "codebase_methods", "->", "getStorage", "(", "$", "method_id", ")", ";", "if", "(", "!", "$", "storage", "->", "is_static", ")", "{", "if", "(", "$", "self_call", ")", "{", "if", "(", "!", "$", "is_context_dynamic", ")", "{", "if", "(", "IssueBuffer", "::", "accepts", "(", "new", "NonStaticSelfCall", "(", "'Method '", ".", "$", "codebase_methods", "->", "getCasedMethodId", "(", "$", "method_id", ")", ".", "' is not static, but is called '", ".", "'using self::'", ",", "$", "code_location", ")", ",", "$", "suppressed_issues", ")", ")", "{", "return", "false", ";", "}", "}", "else", "{", "$", "is_dynamic_this_method", "=", "true", ";", "}", "}", "else", "{", "if", "(", "IssueBuffer", "::", "accepts", "(", "new", "InvalidStaticInvocation", "(", "'Method '", ".", "$", "codebase_methods", "->", "getCasedMethodId", "(", "$", "method_id", ")", ".", "' is not static, but is called '", ".", "'statically'", ",", "$", "code_location", ")", ",", "$", "suppressed_issues", ")", ")", "{", "return", "false", ";", "}", "}", "}", "return", "true", ";", "}" ]

[ "Determines", "whether", "a", "given", "method", "is", "static", "or", "not" ]

[ "public", "static", "function", "simplifyCNF", "(", "array", "$", "clauses", ")", "{", "$", "cloned_clauses", "=", "[", "]", ";", "// avoid strict duplicates", "foreach", "(", "$", "clauses", "as", "$", "clause", ")", "{", "$", "unique_clause", "=", "clone", "$", "clause", ";", "foreach", "(", "$", "unique_clause", "->", "possibilities", "as", "$", "var_id", "=>", "$", "possibilities", ")", "{", "if", "(", "count", "(", "$", "possibilities", ")", ")", "{", "$", "unique_clause", "->", "possibilities", "[", "$", "var_id", "]", "=", "array_unique", "(", "$", "possibilities", ")", ";", "}", "}", "$", "cloned_clauses", "[", "$", "clause", "->", "getHash", "(", ")", "]", "=", "$", "unique_clause", ";", "}", "// remove impossible types", "foreach", "(", "$", "cloned_clauses", "as", "$", "clause_a", ")", "{", "if", "(", "count", "(", "$", "clause_a", "->", "possibilities", ")", "!==", "1", "||", "count", "(", "array_values", "(", "$", "clause_a", "->", "possibilities", ")", "[", "0", "]", ")", "!==", "1", ")", "{", "continue", ";", "}", "if", "(", "!", "$", "clause_a", "->", "reconcilable", "||", "$", "clause_a", "->", "wedge", ")", "{", "continue", ";", "}", "$", "clause_var", "=", "array_keys", "(", "$", "clause_a", "->", "possibilities", ")", "[", "0", "]", ";", "$", "only_type", "=", "array_pop", "(", "array_values", "(", "$", "clause_a", "->", "possibilities", ")", "[", "0", "]", ")", ";", "$", "negated_clause_type", "=", "self", "::", "negateType", "(", "$", "only_type", ")", ";", "foreach", "(", "$", "cloned_clauses", "as", "$", "clause_b", ")", "{", "if", "(", "$", "clause_a", "===", "$", "clause_b", "||", "!", "$", "clause_b", "->", "reconcilable", "||", "$", "clause_b", "->", "wedge", ")", "{", "continue", ";", "}", "if", "(", "isset", "(", "$", "clause_b", "->", "possibilities", "[", "$", "clause_var", "]", ")", "&&", "in_array", "(", "$", "negated_clause_type", ",", "$", "clause_b", "->", "possibilities", "[", "$", "clause_var", "]", ",", "true", ")", ")", "{", "$", "clause_b", "->", "possibilities", "[", "$", "clause_var", "]", "=", "array_filter", "(", "$", "clause_b", "->", "possibilities", "[", "$", "clause_var", "]", ",", "/**\n * @param string $possible_type\n *\n * @return bool\n */", "function", "(", "$", "possible_type", ")", "use", "(", "$", "negated_clause_type", ")", "{", "return", "$", "possible_type", "!==", "$", "negated_clause_type", ";", "}", ")", ";", "if", "(", "count", "(", "$", "clause_b", "->", "possibilities", "[", "$", "clause_var", "]", ")", "===", "0", ")", "{", "unset", "(", "$", "clause_b", "->", "possibilities", "[", "$", "clause_var", "]", ")", ";", "$", "clause_b", "->", "impossibilities", "=", "null", ";", "}", "}", "}", "}", "$", "deduped_clauses", "=", "[", "]", ";", "// avoid strict duplicates", "foreach", "(", "$", "cloned_clauses", "as", "$", "clause", ")", "{", "$", "deduped_clauses", "[", "$", "clause", "->", "getHash", "(", ")", "]", "=", "clone", "$", "clause", ";", "}", "$", "deduped_clauses", "=", "array_filter", "(", "$", "deduped_clauses", ",", "/**\n * @return bool\n */", "function", "(", "Clause", "$", "clause", ")", "{", "return", "count", "(", "$", "clause", "->", "possibilities", ")", "||", "$", "clause", "->", "wedge", ";", "}", ")", ";", "$", "simplified_clauses", "=", "[", "]", ";", "foreach", "(", "$", "deduped_clauses", "as", "$", "clause_a", ")", "{", "$", "is_redundant", "=", "false", ";", "foreach", "(", "$", "deduped_clauses", "as", "$", "clause_b", ")", "{", "if", "(", "$", "clause_a", "===", "$", "clause_b", "||", "!", "$", "clause_b", "->", "reconcilable", "||", "$", "clause_b", "->", "wedge", "||", "$", "clause_a", "->", "wedge", ")", "{", "continue", ";", "}", "if", "(", "$", "clause_a", "->", "contains", "(", "$", "clause_b", ")", ")", "{", "$", "is_redundant", "=", "true", ";", "break", ";", "}", "}", "if", "(", "!", "$", "is_redundant", ")", "{", "$", "simplified_clauses", "[", "]", "=", "$", "clause_a", ";", "}", "}", "return", "$", "simplified_clauses", ";", "}" ]

[ "This", "is", "a", "very", "simple", "simplification", "heuristic", "for", "CNF", "formulae", "." ]

[ "public", "static", "function", "getTruthsFromFormula", "(", "array", "$", "clauses", ",", "array", "&", "$", "cond_referenced_var_ids", "=", "[", "]", ")", "{", "$", "truths", "=", "[", "]", ";", "if", "(", "empty", "(", "$", "clauses", ")", ")", "{", "return", "[", "]", ";", "}", "foreach", "(", "$", "clauses", "as", "$", "clause", ")", "{", "if", "(", "!", "$", "clause", "->", "reconcilable", ")", "{", "continue", ";", "}", "foreach", "(", "$", "clause", "->", "possibilities", "as", "$", "var", "=>", "$", "possible_types", ")", "{", "// if there's only one possible type, return it", "if", "(", "count", "(", "$", "clause", "->", "possibilities", ")", "===", "1", "&&", "count", "(", "$", "possible_types", ")", "===", "1", ")", "{", "if", "(", "isset", "(", "$", "truths", "[", "$", "var", "]", ")", ")", "{", "$", "truths", "[", "$", "var", "]", "[", "]", "=", "[", "array_pop", "(", "$", "possible_types", ")", "]", ";", "}", "else", "{", "$", "truths", "[", "$", "var", "]", "=", "[", "[", "array_pop", "(", "$", "possible_types", ")", "]", "]", ";", "}", "}", "elseif", "(", "count", "(", "$", "clause", "->", "possibilities", ")", "===", "1", ")", "{", "// if there's only one active clause, return all the non-negation clause members ORed together", "$", "things_that_can_be_said", "=", "array_filter", "(", "$", "possible_types", ",", "/**\n * @param string $possible_type\n *\n * @return bool\n *\n * @psalm-suppress MixedOperand\n */", "function", "(", "$", "possible_type", ")", "{", "return", "$", "possible_type", "[", "0", "]", "!==", "'!'", ";", "}", ")", ";", "if", "(", "$", "things_that_can_be_said", "&&", "count", "(", "$", "things_that_can_be_said", ")", "===", "count", "(", "$", "possible_types", ")", ")", "{", "$", "things_that_can_be_said", "=", "array_unique", "(", "$", "things_that_can_be_said", ")", ";", "if", "(", "$", "clause", "->", "generated", "&&", "count", "(", "$", "possible_types", ")", ">", "1", ")", "{", "unset", "(", "$", "cond_referenced_var_ids", "[", "$", "var", "]", ")", ";", "}", "/** @var array<int, string> $things_that_can_be_said */", "$", "truths", "[", "$", "var", "]", "=", "[", "$", "things_that_can_be_said", "]", ";", "}", "}", "}", "}", "return", "$", "truths", ";", "}" ]

[ "Look", "for", "clauses", "with", "only", "one", "possible", "value" ]

[ "public", "function", "publishDiagnostics", "(", "string", "$", "uri", ",", "array", "$", "diagnostics", ")", ":", "Promise", "{", "return", "$", "this", "->", "handler", "->", "notify", "(", "'textDocument/publishDiagnostics'", ",", "[", "'uri'", "=>", "$", "uri", ",", "'diagnostics'", "=>", "$", "diagnostics", "]", ")", ";", "}" ]

[ "Diagnostics", "notification", "are", "sent", "from", "the", "server", "to", "the", "client", "to", "signal", "results", "of", "validation", "runs", "." ]

[ "public", "function", "xcontent", "(", "TextDocumentIdentifier", "$", "textDocument", ")", ":", "Promise", "{", "return", "call", "(", "/**\n * @return \\Generator<int, mixed, mixed, TextDocumentItem>\n */", "function", "(", ")", "use", "(", "$", "textDocument", ")", "{", "$", "result", "=", "yield", "$", "this", "->", "handler", "->", "request", "(", "'textDocument/xcontent'", ",", "[", "'textDocument'", "=>", "$", "textDocument", "]", ")", ";", "/** @var TextDocumentItem */", "return", "$", "this", "->", "mapper", "->", "map", "(", "$", "result", ",", "new", "TextDocumentItem", ")", ";", "}", ")", ";", "}" ]

[ "The", "content", "request", "is", "sent", "from", "a", "server", "to", "a", "client", "to", "request", "the", "current", "content", "of", "a", "text", "document", "identified", "by", "the", "URI" ]

[ "public", "function", "getFirstAppearance", "(", "$", "var_id", ")", "{", "return", "isset", "(", "$", "this", "->", "all_vars", "[", "$", "var_id", "]", ")", "?", "$", "this", "->", "all_vars", "[", "$", "var_id", "]", ":", "null", ";", "}" ]

[ "The", "first", "appearance", "of", "the", "variable", "in", "this", "set", "of", "statements", "being", "evaluated" ]

[ "public", "function", "propertyExists", "(", "string", "$", "property_id", ",", "bool", "$", "read_mode", ",", "StatementsSource", "$", "source", "=", "null", ",", "Context", "$", "context", "=", "null", ",", "CodeLocation", "$", "code_location", "=", "null", ")", "{", "// remove trailing backslash if it exists", "$", "property_id", "=", "preg_replace", "(", "'/^\\\\\\\\/'", ",", "''", ",", "$", "property_id", ")", ";", "list", "(", "$", "fq_class_name", ",", "$", "property_name", ")", "=", "explode", "(", "'::$'", ",", "$", "property_id", ")", ";", "if", "(", "$", "this", "->", "property_existence_provider", "->", "has", "(", "$", "fq_class_name", ")", ")", "{", "$", "property_exists", "=", "$", "this", "->", "property_existence_provider", "->", "doesPropertyExist", "(", "$", "fq_class_name", ",", "$", "property_name", ",", "$", "read_mode", ",", "$", "source", ",", "$", "context", ",", "$", "code_location", ")", ";", "if", "(", "$", "property_exists", "!==", "null", ")", "{", "return", "$", "property_exists", ";", "}", "}", "$", "class_storage", "=", "$", "this", "->", "classlike_storage_provider", "->", "get", "(", "$", "fq_class_name", ")", ";", "if", "(", "isset", "(", "$", "class_storage", "->", "declaring_property_ids", "[", "$", "property_name", "]", ")", ")", "{", "$", "declaring_property_class", "=", "$", "class_storage", "->", "declaring_property_ids", "[", "$", "property_name", "]", ";", "if", "(", "$", "context", "&&", "$", "context", "->", "calling_method_id", ")", "{", "$", "this", "->", "file_reference_provider", "->", "addMethodReferenceToClassMember", "(", "$", "context", "->", "calling_method_id", ",", "strtolower", "(", "$", "declaring_property_class", ")", ".", "'::$'", ".", "$", "property_name", ")", ";", "}", "elseif", "(", "$", "source", ")", "{", "$", "this", "->", "file_reference_provider", "->", "addFileReferenceToClassMember", "(", "$", "source", "->", "getFilePath", "(", ")", ",", "strtolower", "(", "$", "declaring_property_class", ")", ".", "'::$'", ".", "$", "property_name", ")", ";", "}", "if", "(", "$", "this", "->", "collect_locations", "&&", "$", "code_location", ")", "{", "$", "this", "->", "file_reference_provider", "->", "addCallingLocationForClassProperty", "(", "$", "code_location", ",", "strtolower", "(", "$", "declaring_property_class", ")", ".", "'::$'", ".", "$", "property_name", ")", ";", "}", "return", "true", ";", "}", "if", "(", "$", "context", "&&", "$", "context", "->", "calling_method_id", ")", "{", "$", "this", "->", "file_reference_provider", "->", "addMethodReferenceToMissingClassMember", "(", "$", "context", "->", "calling_method_id", ",", "strtolower", "(", "$", "fq_class_name", ")", ".", "'::$'", ".", "$", "property_name", ")", ";", "}", "elseif", "(", "$", "source", ")", "{", "$", "this", "->", "file_reference_provider", "->", "addFileReferenceToMissingClassMember", "(", "$", "source", "->", "getFilePath", "(", ")", ",", "strtolower", "(", "$", "fq_class_name", ")", ".", "'::$'", ".", "$", "property_name", ")", ";", "}", "return", "false", ";", "}" ]

[ "Whether", "or", "not", "a", "given", "property", "exists" ]

[ "public", "function", "update", "(", "Context", "$", "start_context", ",", "Context", "$", "end_context", ",", "$", "has_leaving_statements", ",", "array", "$", "vars_to_update", ",", "array", "&", "$", "updated_vars", ")", "{", "foreach", "(", "$", "start_context", "->", "vars_in_scope", "as", "$", "var_id", "=>", "$", "old_type", ")", "{", "// this is only true if there was some sort of type negation", "if", "(", "in_array", "(", "$", "var_id", ",", "$", "vars_to_update", ",", "true", ")", ")", "{", "// if we're leaving, we're effectively deleting the possibility of the if types", "$", "new_type", "=", "!", "$", "has_leaving_statements", "&&", "$", "end_context", "->", "hasVariable", "(", "$", "var_id", ")", "?", "$", "end_context", "->", "vars_in_scope", "[", "$", "var_id", "]", ":", "null", ";", "$", "existing_type", "=", "isset", "(", "$", "this", "->", "vars_in_scope", "[", "$", "var_id", "]", ")", "?", "$", "this", "->", "vars_in_scope", "[", "$", "var_id", "]", ":", "null", ";", "if", "(", "!", "$", "existing_type", ")", "{", "if", "(", "$", "new_type", ")", "{", "$", "this", "->", "vars_in_scope", "[", "$", "var_id", "]", "=", "clone", "$", "new_type", ";", "$", "updated_vars", "[", "$", "var_id", "]", "=", "true", ";", "}", "continue", ";", "}", "// if the type changed within the block of statements, process the replacement", "// also never allow ourselves to remove all types from a union", "if", "(", "(", "!", "$", "new_type", "||", "!", "$", "old_type", "->", "equals", "(", "$", "new_type", ")", ")", "&&", "(", "$", "new_type", "||", "count", "(", "$", "existing_type", "->", "getTypes", "(", ")", ")", ">", "1", ")", ")", "{", "$", "existing_type", "->", "substitute", "(", "$", "old_type", ",", "$", "new_type", ")", ";", "if", "(", "$", "new_type", "&&", "$", "new_type", "->", "from_docblock", ")", "{", "$", "existing_type", "->", "setFromDocblock", "(", ")", ";", "}", "$", "updated_vars", "[", "$", "var_id", "]", "=", "true", ";", "}", "}", "}", "}" ]

[ "Updates", "the", "parent", "context", "looking", "at", "the", "changes", "within", "a", "block", "and", "then", "applying", "those", "changes", "where", "necessary", "to", "the", "parent", "context" ]

[ "public", "static", "function", "getConfigForPath", "(", "$", "path", ",", "$", "base_dir", ",", "$", "output_format", ")", "{", "$", "config_path", "=", "self", "::", "locateConfigFile", "(", "$", "path", ")", ";", "if", "(", "!", "$", "config_path", ")", "{", "if", "(", "$", "output_format", "===", "ProjectAnalyzer", "::", "TYPE_CONSOLE", ")", "{", "exit", "(", "'Could not locate a config XML file in path '", ".", "$", "path", ".", "'. Have you run \\'psalm --init\\' ?'", ".", "PHP_EOL", ")", ";", "}", "throw", "new", "ConfigException", "(", "'Config not found for path '", ".", "$", "path", ")", ";", "}", "return", "self", "::", "loadFromXMLFile", "(", "$", "config_path", ",", "$", "base_dir", ")", ";", "}" ]

[ "Gets", "a", "Config", "object", "from", "an", "XML", "file", "." ]

[ "public", "static", "function", "locateConfigFile", "(", "string", "$", "path", ")", "{", "$", "dir_path", "=", "realpath", "(", "$", "path", ")", ";", "if", "(", "$", "dir_path", "===", "false", ")", "{", "throw", "new", "ConfigException", "(", "'Config not found for path '", ".", "$", "path", ")", ";", "}", "if", "(", "!", "is_dir", "(", "$", "dir_path", ")", ")", "{", "$", "dir_path", "=", "dirname", "(", "$", "dir_path", ")", ";", "}", "do", "{", "$", "maybe_path", "=", "$", "dir_path", ".", "DIRECTORY_SEPARATOR", ".", "Config", "::", "DEFAULT_FILE_NAME", ";", "if", "(", "file_exists", "(", "$", "maybe_path", ")", "||", "file_exists", "(", "$", "maybe_path", ".=", "'.dist'", ")", ")", "{", "return", "$", "maybe_path", ";", "}", "$", "dir_path", "=", "dirname", "(", "$", "dir_path", ")", ";", "}", "while", "(", "dirname", "(", "$", "dir_path", ")", "!==", "$", "dir_path", ")", ";", "return", "null", ";", "}" ]

[ "Searches", "up", "a", "folder", "hierarchy", "for", "the", "most", "immediate", "config", "." ]

[ "public", "static", "function", "loadFromXMLFile", "(", "$", "file_path", ",", "$", "base_dir", ")", "{", "$", "file_contents", "=", "file_get_contents", "(", "$", "file_path", ")", ";", "if", "(", "$", "file_contents", "===", "false", ")", "{", "throw", "new", "\\", "InvalidArgumentException", "(", "'Cannot open '", ".", "$", "file_path", ")", ";", "}", "try", "{", "$", "config", "=", "self", "::", "loadFromXML", "(", "$", "base_dir", ",", "$", "file_contents", ")", ";", "$", "config", "->", "hash", "=", "sha1", "(", "$", "file_contents", ")", ";", "}", "catch", "(", "ConfigException", "$", "e", ")", "{", "throw", "new", "ConfigException", "(", "'Problem parsing '", ".", "$", "file_path", ".", "\":\\n\"", ".", "' '", ".", "$", "e", "->", "getMessage", "(", ")", ")", ";", "}", "return", "$", "config", ";", "}" ]

[ "Creates", "a", "new", "config", "object", "from", "the", "file" ]

[ "private", "static", "function", "coalesceReplacements", "(", "array", "$", "diff", ")", "{", "$", "newDiff", "=", "[", "]", ";", "$", "c", "=", "\\", "count", "(", "$", "diff", ")", ";", "for", "(", "$", "i", "=", "0", ";", "$", "i", "<", "$", "c", ";", "$", "i", "++", ")", "{", "$", "diffType", "=", "$", "diff", "[", "$", "i", "]", "->", "type", ";", "if", "(", "$", "diffType", "!==", "DiffElem", "::", "TYPE_REMOVE", ")", "{", "$", "newDiff", "[", "]", "=", "$", "diff", "[", "$", "i", "]", ";", "continue", ";", "}", "$", "j", "=", "$", "i", ";", "while", "(", "$", "j", "<", "$", "c", "&&", "$", "diff", "[", "$", "j", "]", "->", "type", "===", "DiffElem", "::", "TYPE_REMOVE", ")", "{", "$", "j", "++", ";", "}", "$", "k", "=", "$", "j", ";", "while", "(", "$", "k", "<", "$", "c", "&&", "$", "diff", "[", "$", "k", "]", "->", "type", "===", "DiffElem", "::", "TYPE_ADD", ")", "{", "$", "k", "++", ";", "}", "if", "(", "$", "j", "-", "$", "i", "===", "$", "k", "-", "$", "j", ")", "{", "$", "len", "=", "$", "j", "-", "$", "i", ";", "for", "(", "$", "n", "=", "0", ";", "$", "n", "<", "$", "len", ";", "$", "n", "++", ")", "{", "$", "newDiff", "[", "]", "=", "new", "DiffElem", "(", "DiffElem", "::", "TYPE_REPLACE", ",", "$", "diff", "[", "$", "i", "+", "$", "n", "]", "->", "old", ",", "$", "diff", "[", "$", "j", "+", "$", "n", "]", "->", "new", ")", ";", "}", "}", "else", "{", "for", "(", ";", "$", "i", "<", "$", "k", ";", "$", "i", "++", ")", "{", "$", "newDiff", "[", "]", "=", "$", "diff", "[", "$", "i", "]", ";", "}", "}", "/** @psalm-suppress LoopInvalidation */", "$", "i", "=", "$", "k", "-", "1", ";", "}", "return", "$", "newDiff", ";", "}" ]

[ "Coalesce", "equal", "-", "length", "sequences", "of", "remove", "+", "add", "into", "a", "replace", "operation", "." ]

[ "public", "function", "scanFiles", "(", "int", "$", "threads", "=", "1", ")", "{", "$", "has_changes", "=", "$", "this", "->", "scanner", "->", "scanFiles", "(", "$", "this", "->", "classlikes", ",", "$", "threads", ")", ";", "if", "(", "$", "has_changes", ")", "{", "$", "this", "->", "populator", "->", "populateCodebase", "(", "$", "this", ")", ";", "}", "}" ]

[ "Scans", "all", "files", "their", "related", "files" ]

[ "public", "function", "isTypeContainedByType", "(", "Type", "\\", "Union", "$", "input_type", ",", "Type", "\\", "Union", "$", "container_type", ")", ":", "bool", "{", "return", "TypeAnalyzer", "::", "isContainedBy", "(", "$", "this", ",", "$", "input_type", ",", "$", "container_type", ")", ";", "}" ]

[ "Checks", "if", "type", "is", "a", "subtype", "of", "other" ]