/** * Parse each product in the response and add it to the rich response. * * @param SearchResponse $searchResponse * @param array $body */ protected function parseProducts(SearchResponse $searchResponse, array $body) { $factory = new SearchProductFactory(); $searchResponse->setSearchProducts(Std::map(function ($rawProduct) use($factory) { return $factory->makeFromArray($rawProduct); }, Arr::dotGet($body, 'searchCatalogs.result', []))); }
/** * Render the object into a string. * * @return mixed */ public function render() { return (new Table(['class' => 'table'], [new TableHeader([], new TableRow([], Std::map(function ($columnLabel) { return new TableHeaderCell([], $columnLabel); }, $this->headerLabels))), new TableBody([], Std::map(function ($row) { return new TableRow([], Std::map(function ($cell) { return new TableCell([], $cell); }, $row)); }, $this->rows))]))->render(); }
/** * Generate a URL for a path inside the dashboard. * * @param string $path * @param array $parameters * @param null|bool $secure * * @return string */ public function url($path = '', $parameters = [], $secure = null) { $queryString = ''; if (count($parameters)) { $queryString = '?' . implode('&', Std::map(function ($value, $name) { return urlencode($name) . '=' . urlencode($value); }, $parameters)); } return url($this->basePath . $path, [], $secure) . $queryString; }
/** * Parse category mappings. * * @param GetAsinCategoriesResponse $categoriesResponse * @param array $body */ protected function parseMappings(GetAsinCategoriesResponse $categoriesResponse, array $body) { $factory = new CategoryMappingFactory(); $categoriesResponse->setCategoryMappings(Std::map(function ($rawMapping) use($factory, $categoriesResponse) { $mapping = $factory->makeFromArray($rawMapping); if ($mapping->isMainCategory()) { $categoriesResponse->setMainCategory($mapping); } return $mapping; }, $body['categoryMappings'])); }
/** * Build an instance of an Impersonator included common dependencies * defined in the map returned by getCommonProvisions(). * * @return Impersonator * @throws LackOfCoffeeException */ public function impersonatorWithCommon() { $impersonator = $this->impersonator(); Std::map(function ($value, $key) use($impersonator) { if (is_array($value) || $value instanceof Closure) { $impersonator->mock($key, $value); return; } $impersonator->provide($value); }, $this->getCommonProvisions()); return $impersonator; }
/** * Get all migrations. * * @param StructuredStatusInterface $status * * @return Card */ public function getAll(StructuredStatusInterface $status) { $report = $status->generateReport(); $idle = $report->getIdle(); $unknown = $report->getUnknown(); $ran = $report->getRan(); return new Card([], [new CardHeader([], 'All Migrations'), new SimpleTable(['-', 'Status', 'Name'], Std::map(function ($name) use($idle, $unknown, $ran) { if (in_array($name, $idle)) { return [new Italic(['class' => ['fa', 'fa-circle-o', 'text-warning']]), 'Pending', $name]; } elseif (in_array($name, $unknown)) { return [new Italic(['class' => ['fa', 'fa-times-circle', 'text-danger']]), 'Exotic', $name]; } elseif (in_array($name, $ran)) { return [new Italic(['class' => ['fa', 'fa-check-circle', 'text-success']]), 'Ran', $name]; } return [new Italic(['class' => ['fa', 'fa-circle-o']]), '???', $name]; }, Std::concat($report->getMigrations(), $report->getUnknown())))]); }
/** * Render the object into a string. * * @return mixed */ public function render() { return new Div([], Std::map(function (Alert $alert) { $classes = ['alert']; switch ($alert->getType()) { case Alert::TYPE_SUCCESS: $classes[] = 'alert-success'; break; case Alert::TYPE_WARNING: $classes[] = 'alert-warning'; break; case Alert::TYPE_INFO: $classes[] = 'alert-info'; break; case Alert::TYPE_ERROR: $classes[] = 'alert-danger'; break; } return new Div(['class' => $classes], $alert->getContent()); }, $this->alerts)); }
/** * Get an array representation of this object. * * @return array */ public function toArray() { return RamlUtils::filterEmptyValues(['example' => $this->example, 'schema' => $this->schema, 'formParameters' => Std::map(function (RamlParameter $parameter) { return $parameter->toArray(); }, $this->formParameters)]); }
/** * Generate a raml file describing the application. * * @param ApplicationManifestInterface $manifest * @param RamlEncoderOptions $options * * @return string */ public function encode(ApplicationManifestInterface $manifest, RamlEncoderOptions $options = null) { $options = Std::coalesceThunk($options, function () use($manifest) { if ($manifest->hasProperty('ramlEncoderOptions')) { return $manifest->getProperty('ramlEncoderOptions'); } return RamlEncoderOptions::defaultOptions(); }); $root = ['title' => $manifest->getName(), 'version' => $manifest->getCurrentVersion(), 'mediaType' => 'application/json', 'baseUri' => $manifest->getBaseUri()]; if (count($manifest->getProse())) { foreach ($manifest->getProse() as $title => $content) { $root['documentation'][] = ['title' => $title, 'content' => $content]; } } foreach ($manifest->getApiResources() as $resource) { $path = $resource->getPrefix(); if ($path == '') { $path = '/'; } if (Arr::has($root, $path)) { $root[$path] = Arr::merge($root[$path], $this->encodeResource($resource, $options)); continue; } $root[$path] = $this->encodeResource($resource, $options); } if ($options !== null) { $root['securitySchemes'] = Std::map(function ($scheme) { $result = []; foreach ($scheme as $key => $property) { $result[$key] = $property->toArray(); } return $result; }, $options->getSecuritySchemes()); } $yaml = yaml_emit(RamlUtils::filterEmptyValues($root)); return str_replace("---\n", "#%RAML 0.8\n", $yaml); }
/** * Render the sidebar for this module. * * If null is returned, we won't display one. * * @param ConferenceContext $context * * @return SafeHtmlWrapper */ public function renderSidebar(ConferenceContext $context) { return Html::safe((new UnorderedList(['class' => 'nav nav-pills nav-stacked'], Std::map(function (Method $method, $methodName) use($context) { return new ListItem(['class' => 'nav-item'], [new Anchor(['href' => $context->method($this->getName(), $methodName), 'class' => 'nav-link'], Std::coalesce($method->getLabel(), $methodName))]); }, Std::filter(function (Method $method) { return !$method->isHidden(); }, $this->getMethods()))))->render()); }
/** * Render all router patterns. * * @param Router $router * * @return Table */ protected function renderPatterns(Router $router) { return new Table(['class' => 'table'], [new TableHeader([], new TableRow([], [new TableHeaderCell([], 'Key'), new TableHeaderCell([], 'Pattern')])), new TableBody([], Std::map(function ($pattern, $key) { return new TableRow([], [new TableCell([], $key), new TableCell([], new PreformattedText(['class' => 'pre-scrollable'], $pattern))]); }, $router->getPatterns()))]); }
/** * Generate the model. * * @throws LackOfCoffeeException * @return Model */ public function make() { // Make model instance $model = $this->getModelInstance(true); $filling = TransformPipeline::define()->inline(function ($input) { return array_merge($input, $this->overrides); })->inline(function ($input) { return Std::map(function ($value) { return Std::value($value); }, $input); })->run($this->getMapping()); Std::each(function ($value, $key) use(&$model) { $model->{$key} = $value; }, $filling); Std::each(function ($relation, $name) use(&$model) { if (!$this->isBelongsTo($name)) { return; } $model->{$name}()->associate($this->generateRelation($name)); }, $this->relations); $model->save(); Std::each(function ($relation, $name) use(&$model) { if ($this->isBelongsTo($name)) { return; } $related = $this->generateRelation($name); if (is_array($related)) { $model->{$name}()->saveMany($related); } else { $model->{$name}()->save($related); } }, $this->relations); return $model; }
/** * Get an array representation of this object. * * @return array */ public function toArray() { return Std::map(function (RamlBody $body) { return $body->toArray(); }, $this->bodyTypes); }
/** * Render the object into a string. * * @return mixed */ public function render() { return new Div([], Std::map(function ($content, $term) { return new Row([], [new Column(['medium' => 4], new Bold([], $term . ':')), new Column(['medium' => 8], $content)]); }, $this->descriptions)); }
/** * Get an array representation of this object. * * @return array */ public function toArray() { return Std::map(function (RamlResponse $response) { return $response->toArray(); }, $this->responses); }
/** * Get problematic modules. * * @param DashboardInterface $dashboard * * @return Div */ public function getIssues(DashboardInterface $dashboard) { $exceptions = Std::map(function (Exception $exception, $moduleName) { return new Div([], [new Div(['class' => 'card card-inverted'], [new CardBlock([], [new HeaderSix(['class' => 'text-muted'], $moduleName), new Bold([], get_class($exception) . ': '), $exception->getMessage(), new Div(['class' => 'collapse p-t', 'id' => 'stack'], new PreformattedText(['class' => 'pre-scrollable'], $exception->getTraceAsString()))]), new Div(['class' => 'card-footer text-muted'], [new Row([], [new Column(['medium' => 6], [basename($exception->getFile()) . ':' . $exception->getLine()]), new Column(['medium' => 6, 'class' => 'text-xs-right'], new Button(['href' => '#', 'class' => ['btn', 'btn-sm', 'btn-primary-outline'], 'data-toggle' => 'collapse', 'data-target' => '#stack', 'aria-expanded' => 'false', 'aria-controls' => '#stack'], 'Toggle stacktrace'))])])])]); }, $dashboard->getFailedModules()); return new Div([], [new Div(['class' => 'card'], [new Div(['class' => 'card-header'], 'Module issues'), new Div(['class' => 'card-block'], ['Below you will find a list of all the modules that ', 'failed to load. If one or more failed to load, it is ', 'not necessarily a bad thing. If you do not intend to ', 'use the component covered by the module, you may ', 'safely ignore it.'])]), new HorizontalLine([]), new Div([], Std::firstBias(count($dashboard->getFailedModules()) > 0, $exceptions, function () { return new Card(['class' => 'card card-block text-center'], ['All modules seem fine!']); }))]); }
/** * Get the type of each field. * * @return array */ public function getTypes() { if ($this->spec instanceof Spec) { return Std::map(function ($field) { if ($field instanceof AbstractConstraint) { return $field->toString(); } return implode(' ^ ', Std::map(function ($innerField) { if ($innerField instanceof Spec) { return '{spec}'; } elseif ($innerField instanceof AbstractConstraint) { return $innerField->toString(); } return '{???}'; }, $field)); }, $this->spec->getConstraints()); } return []; }
/** * Render a table showing jobs. * * @param Paginator $jobs * * @return mixed */ protected function renderJobsTable(Paginator $jobs) { return Std::firstBias(count($jobs->items()) > 0, function () use($jobs) { return new SimpleTable(['ID', 'Task', 'State', 'Runs', 'Created At', 'Duration'], Std::map(function (Job $job) { return [$job->id, $job->state, $job->task, $job->attempts, $job->created_at->toDayDateTimeString(), $job->getExecutionTime()]; }, $jobs->items())); }, function () { return new CardBlock(['class' => 'card-block text-center'], [new Paragraph([], [new Italic(['class' => 'fa fa-4x fa-search text-light'])]), 'No jobs found matching the specified criteria.']); }); }
/** * @param Spec $spec * @param string $field * * @return TableRow */ protected function renderConstraint(Spec $spec, $field) { $constraints = $spec->getConstraints(); $defaults = $spec->getDefaults(); $default = ''; if (array_key_exists($field, $defaults)) { $default = $defaults[$field]; } $constraint = $constraints[$field]; if ($constraint instanceof AbstractConstraint) { return new TableRow([], [new TableCell([], $field), new TableCell([], $constraint->toString()), new TableCell([], (string) $default)]); } return new TableRow([], [new TableCell([], $field), new TableCell([], Std::map(function (AbstractConstraint $constraint) { return $constraint->toString() . ', '; }, $constraint)), new TableCell([], (string) $default)]); }
public function benchMap() { Std::map(function ($value, $key) { return $value . ' ' . $key; }, $this->keyValueArray); }
/** * Get an array representation of this object. * * @return array */ public function toArray() { return RamlUtils::filterEmptyValues(['description' => $this->description, 'type' => $this->type, 'describedBy' => RamlUtils::filterEmptyValues(['headers' => Std::map(function (RamlParameter $header) { return $header->toArray(); }, $this->headers), 'queryParameters' => Std::map(function (RamlParameter $query) { return $query->toArray(); }, $this->queryParameters), 'responses' => $this->responses ? $this->responses->toArray() : null]), 'settings' => $this->settings]); }
/** * Apply a function to this functor. * * @param callable $closure * * @return FunctorInterface */ public function fmap(callable $closure) { return static::of(Std::map($closure, $this->value)); }
public function testMap() { $doubler = function ($item) { return $item * 2; }; $list = new SplDoublyLinkedList(); $list->push(1); $list->push(3); $list->push(4); $list->push(5); $this->assertEqualsMatrix([[[2, 6, 8, 10], Std::map($doubler, [1, 3, 4, 5])], [[2, 6, 8, 10], Std::map($doubler, $list)]]); }