_id stringlengths 2 7 | title stringlengths 3 151 | partition stringclasses 3
values | text stringlengths 33 8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q14000 | ExtractsMailableTags.registerMailableTagExtractor | train | protected static function registerMailableTagExtractor()
{
Mailable::buildViewDataUsing(function ($mailable) {
return [
'__telescope' => ExtractTags::from($mailable), | php | {
"resource": ""
} |
q14001 | QueryWatcher.recordQuery | train | public function recordQuery(QueryExecuted $event)
{
if (! Telescope::isRecording()) {
return;
}
$time = $event->time;
$caller = $this->getCallerFromStackTrace();
Telescope::recordQuery(IncomingEntry::make([
| php | {
"resource": ""
} |
q14002 | RecordingController.toggle | train | public function toggle()
{
if ($this->cache->get('telescope:pause-recording')) {
$this->cache->forget('telescope:pause-recording');
} else {
| php | {
"resource": ""
} |
q14003 | EventWatcher.recordEvent | train | public function recordEvent($eventName, $payload)
{
if (! Telescope::isRecording() || $this->shouldIgnore($eventName)) {
return;
}
$formattedPayload = $this->extractPayload($eventName, $payload);
Telescope::recordEvent(IncomingEntry::make([
'name' => $eventName,
| php | {
"resource": ""
} |
q14004 | EventWatcher.extractPayload | train | protected function extractPayload($eventName, $payload)
{
if (class_exists($eventName) && isset($payload[0]) && is_object($payload[0])) {
return ExtractProperties::from($payload[0]);
}
return collect($payload)->map(function ($value) {
return is_object($value) | php | {
"resource": ""
} |
q14005 | EventWatcher.formatListeners | train | protected function formatListeners($eventName)
{
return collect(app('events')->getListeners($eventName))
->map(function ($listener) {
$listener = (new ReflectionFunction($listener))
->getStaticVariables()['listener'];
if (is_string($listener)) {
return Str::contains($listener, '@') ? $listener : $listener.'@handle';
} elseif (is_array($listener)) {
return get_class($listener[0]).'@'.$listener[1];
}
return $this->formatClosureListener($listener);
})->reject(function ($listener) | php | {
"resource": ""
} |
q14006 | EventWatcher.formatClosureListener | train | protected function formatClosureListener(Closure $listener)
{
$listener = new ReflectionFunction($listener);
return sprintf('Closure at %s[%s:%s]',
| php | {
"resource": ""
} |
q14007 | Telescope.start | train | public static function start($app)
{
if (! config('telescope.enabled')) {
return;
}
static::registerWatchers($app);
static::registerMailableTagExtractor();
| php | {
"resource": ""
} |
q14008 | Telescope.runningApprovedArtisanCommand | train | protected static function runningApprovedArtisanCommand($app)
{
return $app->runningInConsole() && ! in_array(
$_SERVER['argv'][1] ?? null,
array_merge([
// 'migrate',
'migrate:rollback',
'migrate:fresh',
// 'migrate:refresh',
'migrate:reset',
'migrate:install',
'package:discover',
| php | {
"resource": ""
} |
q14009 | Telescope.withoutRecording | train | public static function withoutRecording($callback)
{
$shouldRecord = static::$shouldRecord;
static::$shouldRecord = false;
| php | {
"resource": ""
} |
q14010 | Telescope.record | train | protected static function record(string $type, IncomingEntry $entry)
{
if (! static::isRecording()) {
return;
}
$entry->type($type)->tags(
static::$tagUsing ? call_user_func(static::$tagUsing, $entry) : []
);
try {
if (Auth::hasUser()) {
$entry->user(Auth::user());
}
} catch (Throwable $e) {
// Do nothing.
}
| php | {
"resource": ""
} |
q14011 | Telescope.catch | train | public static function catch($e, $tags = [])
{
if ($e instanceof Throwable && ! $e instanceof Exception) {
$e = new FatalThrowableError($e);
}
| php | {
"resource": ""
} |
q14012 | Telescope.store | train | public static function store(EntriesRepository $storage)
{
if (empty(static::$entriesQueue) && empty(static::$updatesQueue)) {
return;
}
if (! collect(static::$filterBatchUsing)->every->__invoke(collect(static::$entriesQueue))) {
static::flushEntries();
}
| php | {
"resource": ""
} |
q14013 | Telescope.collectEntries | train | protected static function collectEntries($batchId)
{
return collect(static::$entriesQueue)
->each(function ($entry) use ($batchId) {
$entry->batchId($batchId);
| php | {
"resource": ""
} |
q14014 | Telescope.collectUpdates | train | protected static function collectUpdates($batchId)
{
return collect(static::$updatesQueue)
| php | {
"resource": ""
} |
q14015 | TelescopeServiceProvider.registerStorageDriver | train | protected function registerStorageDriver()
{
$driver = config('telescope.driver');
| php | {
"resource": ""
} |
q14016 | TelescopeServiceProvider.registerDatabaseDriver | train | 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)
| php | {
"resource": ""
} |
q14017 | EntryController.status | train | protected function status()
{
if (! config('telescope.enabled', false)) {
return 'disabled';
}
if (cache('telescope:pause-recording', false)) {
return 'paused';
}
$watcher = config('telescope.watchers.'.$this->watcher()); | php | {
"resource": ""
} |
q14018 | ExceptionWatcher.recordException | train | 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(),
| php | {
"resource": ""
} |
q14019 | JobWatcher.recordJob | train | public function recordJob($connection, $queue, array $payload)
{
if (! Telescope::isRecording()) {
return;
}
$content = array_merge([
'status' => 'pending',
], $this->defaultJobData($connection, $queue, $payload, $this->data($payload)));
| php | {
"resource": ""
} |
q14020 | JobWatcher.recordProcessedJob | train | public function recordProcessedJob(JobProcessed $event)
{
if (! Telescope::isRecording()) {
return;
}
$uuid = $event->job->payload()['telescope_uuid'] ?? null;
if (! $uuid) {
return;
| php | {
"resource": ""
} |
q14021 | JobWatcher.recordFailedJob | train | 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' => [
| php | {
"resource": ""
} |
q14022 | JobWatcher.defaultJobData | train | protected function defaultJobData($connection, $queue, array $payload, array $data)
{
return [
'connection' => $connection,
'queue' => $queue,
'name' => $payload['displayName'],
| php | {
"resource": ""
} |
q14023 | TelescopeApplicationServiceProvider.authorization | train | protected function authorization()
{
$this->gate();
Telescope::auth(function ($request) {
return app()->environment('local') ||
| php | {
"resource": ""
} |
q14024 | EntryUpdate.addTags | train | public function addTags(array $tags)
{
$this->tagsChanges['added'] = array_unique(
| php | {
"resource": ""
} |
q14025 | EntryUpdate.removeTags | train | public function removeTags(array $tags)
{
$this->tagsChanges['removed'] = array_unique(
| php | {
"resource": ""
} |
q14026 | RedisWatcher.recordCommand | train | public function recordCommand(CommandExecuted $event)
{
if (! Telescope::isRecording() || $this->shouldIgnore($event)) {
return;
}
Telescope::recordRedis(IncomingEntry::make([ | php | {
"resource": ""
} |
q14027 | RedisWatcher.formatCommand | train | 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}";
| php | {
"resource": ""
} |
q14028 | ExtractTags.from | train | public static function from($target)
{
if ($tags = static::explicitTags([$target])) {
return $tags;
}
| php | {
"resource": ""
} |
q14029 | ExtractTags.fromArray | train | 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(); | php | {
"resource": ""
} |
q14030 | ExtractTags.tagsForListener | train | protected static function tagsForListener($job)
{
return collect(
[static::extractListener($job), static::extractEvent($job),
])->map(function ($job) {
| php | {
"resource": ""
} |
q14031 | ExtractTags.targetsFor | train | protected static function targetsFor($job)
{
switch (true) {
case $job instanceof BroadcastEvent:
return [$job->event];
case $job instanceof CallQueuedListener:
| php | {
"resource": ""
} |
q14032 | ExtractTags.modelsFor | train | 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];
| php | {
"resource": ""
} |
q14033 | ExtractTags.extractEvent | train | protected static function extractEvent($job)
{
return isset($job->data[0]) && is_object($job->data[0])
| php | {
"resource": ""
} |
q14034 | ExtractProperties.from | train | 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)];
| php | {
"resource": ""
} |
q14035 | EntryModel.scopeWithTelescopeOptions | train | public function scopeWithTelescopeOptions($query, $type, EntryQueryOptions $options)
{
$this->whereType($query, $type)
->whereBatchId($query, $options)
->whereTag($query, $options)
->whereFamilyHash($query, | php | {
"resource": ""
} |
q14036 | EntryModel.whereBatchId | train | protected function whereBatchId($query, EntryQueryOptions $options)
{
$query->when($options->batchId, function | php | {
"resource": ""
} |
q14037 | EntryModel.whereBeforeSequence | train | protected function whereBeforeSequence($query, EntryQueryOptions $options)
{
$query->when($options->beforeSequence, function | php | {
"resource": ""
} |
q14038 | EntryModel.filter | train | protected function filter($query, EntryQueryOptions $options)
{
if ($options->familyHash || $options->tag || $options->batchId) | php | {
"resource": ""
} |
q14039 | InstallCommand.registerTelescopeServiceProvider | train | 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"), | php | {
"resource": ""
} |
q14040 | DatabaseEntriesRepository.find | train | 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(
| php | {
"resource": ""
} |
q14041 | DatabaseEntriesRepository.get | train | 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,
| php | {
"resource": ""
} |
q14042 | DatabaseEntriesRepository.store | train | 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) {
| php | {
"resource": ""
} |
q14043 | DatabaseEntriesRepository.storeExceptions | train | 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]);
| php | {
"resource": ""
} |
q14044 | DatabaseEntriesRepository.storeTags | train | protected function storeTags($results)
{
$this->table('telescope_entries_tags')->insert($results->flatMap(function ($tags, $uuid) {
return collect($tags)->map(function ($tag) use ($uuid) {
return [
| php | {
"resource": ""
} |
q14045 | DatabaseEntriesRepository.update | train | 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
| php | {
"resource": ""
} |
q14046 | DatabaseEntriesRepository.updateTags | train | 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,
];
| php | {
"resource": ""
} |
q14047 | DatabaseEntriesRepository.isMonitoring | train | public function isMonitoring(array $tags)
{
if (is_null($this->monitoredTags)) {
| php | {
"resource": ""
} |
q14048 | DatabaseEntriesRepository.monitor | train | public function monitor(array $tags)
{
$tags = array_diff($tags, $this->monitoring());
if (empty($tags)) {
return;
}
$this->table('telescope_monitoring')
->insert(collect($tags)
| php | {
"resource": ""
} |
q14049 | RegistersWatchers.registerWatchers | train | 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'] ?? | php | {
"resource": ""
} |
q14050 | IncomingExceptionEntry.isReportableException | train | public function isReportableException()
{
$handler = app(ExceptionHandler::class);
return method_exists($handler, 'shouldReport')
| php | {
"resource": ""
} |
q14051 | GateWatcher.recordGateCheck | train | public function recordGateCheck(?Authenticatable $user, $ability, $result, $arguments)
{
if (! Telescope::isRecording() || $this->shouldIgnore($ability)) {
return;
}
$caller = $this->getCallerFromStackTrace();
Telescope::recordGate(IncomingEntry::make([
'ability' => $ability,
| php | {
"resource": ""
} |
q14052 | GateWatcher.formatArguments | train | private function formatArguments($arguments)
{
return collect($arguments)->map(function ($argument) {
return $argument instanceof Model | php | {
"resource": ""
} |
q14053 | MailWatcher.recordMail | train | 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(),
| php | {
"resource": ""
} |
q14054 | MailWatcher.getQueuedStatus | train | protected function getQueuedStatus($event)
{
if (isset($event->data['__laravel_notification_queued'])) {
| php | {
"resource": ""
} |
q14055 | MailWatcher.tags | train | private function tags($message, $data)
{
return array_merge(
array_keys($message->getTo() ?: []),
array_keys($message->getCc() ?: []),
| php | {
"resource": ""
} |
q14056 | MailEmlController.show | train | public function show(EntriesRepository $storage, $id)
{
return response($storage->find($id)->content['raw'], 200, [
'Content-Type' => 'message/rfc822',
| php | {
"resource": ""
} |
q14057 | ModelWatcher.recordAction | train | 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' => | php | {
"resource": ""
} |
q14058 | ScheduleWatcher.recordCommand | train | 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, | php | {
"resource": ""
} |
q14059 | ScheduleWatcher.getEventOutput | train | protected function getEventOutput(Event $event)
{
if (! $event->output ||
$event->output === $event->getDefaultOutput() ||
$event->shouldAppendOutput ||
| php | {
"resource": ""
} |
q14060 | ListensForStorageOpportunities.storeEntriesAfterWorkerLoop | train | 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);
});
| php | {
"resource": ""
} |
q14061 | ListensForStorageOpportunities.storeIfDoneProcessingJob | train | protected static function storeIfDoneProcessingJob($event, $app)
{
array_pop(static::$processingJobs);
if (empty(static::$processingJobs)) {
static::store($app[EntriesRepository::class]);
| php | {
"resource": ""
} |
q14062 | NotificationWatcher.recordNotification | train | public function recordNotification(NotificationSent $event)
{
if (! Telescope::isRecording()) {
return;
}
Telescope::recordNotification(IncomingEntry::make([
'notification' => get_class($event->notification), | php | {
"resource": ""
} |
q14063 | NotificationWatcher.tags | train | private function tags($event)
{
return array_merge([
$this->formatNotifiable($event->notifiable),
| php | {
"resource": ""
} |
q14064 | NotificationWatcher.formatNotifiable | train | private function formatNotifiable($notifiable)
{
if ($notifiable instanceof Model) {
return FormatModel::given($notifiable);
} elseif ($notifiable instanceof AnonymousNotifiable) {
| php | {
"resource": ""
} |
q14065 | ExceptionContext.get | train | public static function get(Throwable $exception)
{
return collect(explode("\n", file_get_contents($exception->getFile())))
->slice($exception->getLine() - 10, 20)
| php | {
"resource": ""
} |
q14066 | LogWatcher.recordLog | train | public function recordLog(MessageLogged $event)
{
if (! Telescope::isRecording() || $this->shouldIgnore($event)) {
return;
}
Telescope::recordLog(
IncomingEntry::make([
'level' => $event->level,
| php | {
"resource": ""
} |
q14067 | EntryQueryOptions.fromRequest | train | public static function fromRequest(Request $request)
{
return (new static)
->batchId($request->batch_id)
->uuids($request->uuids)
->beforeSequence($request->before)
| php | {
"resource": ""
} |
q14068 | RequestWatcher.recordRequest | train | 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()),
| php | {
"resource": ""
} |
q14069 | RequestWatcher.headers | train | protected function headers($headers)
{
$headers = collect($headers)->map(function ($header) {
| php | {
"resource": ""
} |
q14070 | RequestWatcher.hideParameters | train | protected function hideParameters($data, $hidden)
{
foreach ($hidden as $parameter) {
if (Arr::get($data, $parameter)) {
| php | {
"resource": ""
} |
q14071 | RequestWatcher.input | train | private function input(Request $request)
{
$files = $request->files->all();
array_walk_recursive($files, function (&$file) {
$file = [
'name' => $file->getClientOriginalName(),
| php | {
"resource": ""
} |
q14072 | RequestWatcher.response | train | 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();
}
| php | {
"resource": ""
} |
q14073 | RequestWatcher.extractDataFromView | train | protected function extractDataFromView($view)
{
return collect($view->getData())->map(function ($value) {
if ($value instanceof Model) {
return FormatModel::given($value);
} | php | {
"resource": ""
} |
q14074 | CommandWatcher.recordCommand | train | public function recordCommand(CommandFinished $event)
{
if (! Telescope::isRecording() || $this->shouldIgnore($event)) {
return;
}
Telescope::recordCommand(IncomingEntry::make([
| php | {
"resource": ""
} |
q14075 | CacheWatcher.recordCacheHit | train | public function recordCacheHit(CacheHit $event)
{
if (! Telescope::isRecording() || $this->shouldIgnore($event)) {
return;
}
Telescope::recordCache(IncomingEntry::make([
| php | {
"resource": ""
} |
q14076 | CacheWatcher.recordCacheMissed | train | public function recordCacheMissed(CacheMissed $event)
{
if (! Telescope::isRecording() || $this->shouldIgnore($event)) {
| php | {
"resource": ""
} |
q14077 | CacheWatcher.recordKeyWritten | train | public function recordKeyWritten(KeyWritten $event)
{
if (! Telescope::isRecording() || $this->shouldIgnore($event)) {
return;
}
Telescope::recordCache(IncomingEntry::make([
'type' => 'set',
| php | {
"resource": ""
} |
q14078 | IncomingEntry.user | train | public function user($user)
{
$this->user = $user;
$this->content = array_merge($this->content, [
'user' => [
'id' => $user->getAuthIdentifier(),
'name' => $user->name ?? null,
| php | {
"resource": ""
} |
q14079 | IncomingEntry.tags | train | public function tags(array $tags)
{
$this->tags | php | {
"resource": ""
} |
q14080 | IncomingEntry.hasMonitoredTag | train | public function hasMonitoredTag()
{
if (! empty($this->tags)) {
| php | {
"resource": ""
} |
q14081 | IncomingEntry.toArray | train | public function toArray()
{
return [
'uuid' => $this->uuid,
'batch_id' => $this->batchId,
'type' => $this->type,
| php | {
"resource": ""
} |
q14082 | IncomingDumpEntry.assignEntryPointFromBatch | train | public function assignEntryPointFromBatch(array $batch)
{
$entryPoint = collect($batch)->first(function ($entry) {
return in_array($entry->type, [EntryType::REQUEST, EntryType::JOB, EntryType::COMMAND]);
| php | {
"resource": ""
} |
q14083 | IncomingDumpEntry.entryPointDescription | train | private function entryPointDescription($entryPoint)
{
switch ($entryPoint->type) {
case EntryType::REQUEST:
return $entryPoint->content['method'].' '.$entryPoint->content['uri'];
| php | {
"resource": ""
} |
q14084 | EntryResult.jsonSerialize | train | public function jsonSerialize()
{
return [
'id' => $this->id,
'sequence' => $this->sequence,
'batch_id' => $this->batchId,
'type' => $this->type,
'content' => $this->content,
| php | {
"resource": ""
} |
q14085 | GitInfoCollector.collect | train | public function collect() : GitInfo
{
$branch = $this->collectBranch();
$commit = $this->collectCommit();
| php | {
"resource": ""
} |
q14086 | Message.parse | train | 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) {
| php | {
"resource": ""
} |
q14087 | SimpleNameResolver.resolveName | train | protected function resolveName(Name $name, $type) {
$resolvedName = $this->nameContext->getResolvedName($name, $type);
if (null !== $resolvedName) {
| php | {
"resource": ""
} |
q14088 | Pool.streamForParent | train | 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.
| php | {
"resource": ""
} |
q14089 | Pool.readResultsFromChildren | train | 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(
| php | {
"resource": ""
} |
q14090 | Pool.wait | train | 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) {
/**
* @psalm-suppress UndefinedConstant - does not exist on windows
* @psalm-suppress MixedArgument
*/
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);
| php | {
"resource": ""
} |
q14091 | CustomTraverser.traverseNode | train | 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;
}
| php | {
"resource": ""
} |
q14092 | ClassLikeAnalyzer.getFQCLNFromNameObject | train | 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 | php | {
"resource": ""
} |
q14093 | ClassLikeAnalyzer.getTypeFromValue | train | 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':
| php | {
"resource": ""
} |
q14094 | EchoChecker.afterStatementAnalysis | train | 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()
| php | {
"resource": ""
} |
q14095 | Scanner.fileExistsForClassLike | train | 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);
}
| php | {
"resource": ""
} |
q14096 | TypeAnalyzer.isContainedByInPhp | train | 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');
| php | {
"resource": ""
} |
q14097 | TypeAnalyzer.isSimplyContainedBy | train | 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 | php | {
"resource": ""
} |
q14098 | BuildInfoCollector.fillJenkins | train | 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
| php | {
"resource": ""
} |
q14099 | BuildInfoCollector.fillScrutinizer | train | 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);
| php | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.