Beispiel #1
0
 public function __construct(MapInterface $factories)
 {
     if ((string) $factories->keyType() !== 'string' || (string) $factories->valueType() !== HeaderFactoryInterface::class) {
         throw new InvalidArgumentException();
     }
     $this->factories = $factories;
 }
Beispiel #2
0
 /**
  * Build a new type instance of the wished type
  *
  * @param string $type
  * @param MapInterface<scalar, variable> $config
  *
  * @return TypeInterface
  */
 public function build(string $type, MapInterface $config) : TypeInterface
 {
     if ((string) $config->keyType() !== 'scalar' || (string) $config->valueType() !== 'variable') {
         throw new InvalidArgumentException();
     }
     return call_user_func([$this->types->get($type), 'fromConfig'], $config, $this);
 }
Beispiel #3
0
 public function __construct(MapInterface $directories)
 {
     if ((string) $directories->keyType() !== 'string' || (string) $directories->valueType() !== Directory::class) {
         throw new InvalidArgumentException();
     }
     $this->directories = $directories;
     $this->cache = new Map('string', HttpResource::class);
 }
Beispiel #4
0
 public function __construct(MapInterface $formats)
 {
     if ((string) $formats->keyType() !== 'string' || (string) $formats->valueType() !== Format::class || $formats->size() === 0) {
         throw new InvalidArgumentException();
     }
     $this->formats = $formats;
     $this->negotiator = new Negotiator();
 }
 /**
  * {@inheritdoc}
  */
 public function build(ServerRequestInterface $request, Reference $from, MapInterface $tos) : MapInterface
 {
     if ((string) $tos->keyType() !== Reference::class || (string) $tos->valueType() !== MapInterface::class) {
         throw new InvalidArgumentException();
     }
     return $this->builders->reduce(new Map('string', HeaderInterface::class), function (MapInterface $carry, LinkBuilderInterface $builder) use($request, $from, $tos) : MapInterface {
         return $carry->merge($builder->build($request, $from, $tos));
     });
 }
Beispiel #6
0
 public function __construct(string $name, MapInterface $children, MapInterface $definitions)
 {
     if ((string) $children->keyType() !== 'string' || (string) $children->valueType() !== self::class || (string) $definitions->keyType() !== 'string' || (string) $definitions->valueType() !== HttpResource::class) {
         throw new InvalidArgumentException();
     }
     $this->name = $name;
     $this->children = $children;
     $this->definitions = $definitions;
 }
Beispiel #7
0
 public function __construct(MapInterface $headers)
 {
     if ((string) $headers->keyType() !== 'string' || (string) $headers->valueType() !== HeaderInterface::class) {
         throw new InvalidArgumentException();
     }
     $this->headers = $headers->map(function (string $name, HeaderInterface $header) {
         return new Pair((string) (new Str($name))->toLower(), $header);
     });
 }
Beispiel #8
0
 /**
  * {@inheritdoc}
  */
 public static function fromConfig(MapInterface $config, Types $types) : TypeInterface
 {
     if ((string) $config->keyType() !== 'scalar' || (string) $config->valueType() !== 'variable') {
         throw new InvalidArgumentException();
     }
     $type = new self();
     $type->innerKey = $config->get('inner');
     $type->inner = $types->build($config->get('inner'), $config->remove('inner'));
     return $type;
 }
Beispiel #9
0
 /**
  * {@inheritdoc}
  */
 public static function fromConfig(MapInterface $config, Types $types) : TypeInterface
 {
     if ((string) $config->keyType() !== 'scalar' || (string) $config->valueType() !== 'variable') {
         throw new InvalidArgumentException();
     }
     $type = new self();
     if ($config->contains('format')) {
         $type->format = (string) $config->get('format');
     }
     return $type;
 }
Beispiel #10
0
 public function __construct(string $topLevel, string $subType, string $suffix, MapInterface $parameters)
 {
     if ((string) $parameters->keyType() !== 'string' || (string) $parameters->valueType() !== ParameterInterface::class) {
         throw new InvalidArgumentException();
     }
     if (!self::topLevels()->contains($topLevel)) {
         throw new InvalidTopLevelTypeException();
     }
     $this->topLevel = $topLevel;
     $this->subType = $subType;
     $this->suffix = $suffix;
     $this->parameters = $parameters;
 }
Beispiel #11
0
 public function __construct(UrlInterface $url, string $rel, MapInterface $parameters)
 {
     if (empty($rel) || (string) $parameters->keyType() !== 'string' || (string) $parameters->valueType() !== ParameterInterface::class) {
         throw new InvalidArgumentException();
     }
     $this->url = $url;
     $this->rel = $rel;
     $this->parameters = $parameters;
     $parameters = $parameters->values()->join(';');
     $parameters = $parameters->length() > 0 ? $parameters->prepend(';') : $parameters;
     $link = (new Str('<%s>; rel="%s"'))->sprintf((string) $url, $rel);
     parent::__construct((string) $link->append((string) $parameters));
 }
Beispiel #12
0
 public function __construct(string $type, string $subType, MapInterface $parameters)
 {
     $media = (new Str('%s/%s'))->sprintf($type, $subType);
     if (!$media->match('~^\\*/\\*$~') && !$media->match('~^[\\w\\-.]+/\\*$~') && !$media->match('~^[\\w\\-.]+/[\\w\\-.]+$~')) {
         throw new InvalidArgumentException();
     }
     if ((string) $parameters->keyType() !== 'string' || (string) $parameters->valueType() !== ParameterInterface::class) {
         throw new InvalidArgumentException();
     }
     $this->type = $type;
     $this->subType = $subType;
     $this->parameters = $parameters;
     $parameters = $parameters->values()->join(';');
     $parameters = $parameters->length() > 0 ? $parameters->prepend(';') : $parameters;
     parent::__construct((string) $media->append((string) $parameters));
 }
Beispiel #13
0
 /**
  * @param MapInterface<int, NodeInterface> $nodes
  */
 public function __invoke(MapInterface $nodes) : NodeInterface
 {
     if ((string) $nodes->keyType() !== 'int' || (string) $nodes->valueType() !== NodeInterface::class) {
         throw new InvalidArgumentException();
     }
     if ($nodes->size() === 1) {
         if (!$nodes->current()->hasChildren()) {
             return $nodes->current();
         }
         try {
             return $this($nodes->current()->children());
         } catch (ContentTooDispersedException $e) {
             return $nodes->current();
         }
     }
     $dispersion = $nodes->reduce([], function (array $dispersion, int $position, NodeInterface $node) : array {
         $text = (new Text())($node);
         $text = new Str($text);
         $dispersion[$position] = $text->wordCount();
         return $dispersion;
     });
     $quantile = new Quantile($dispersion);
     $lookup = [];
     //select qartiles that have more words than the average nodes
     for ($i = 1; $i < 5; $i++) {
         $diff = $quantile->quartile($i)->value() - $quantile->quartile($i - 1)->value();
         if ($diff >= $quantile->mean()) {
             $lookup[] = $i;
         }
     }
     if (empty($lookup)) {
         throw new ContentTooDispersedException();
     }
     //select the minimum amount of words that needs to be in nodes
     $min = $quantile->quartile(min($lookup))->value();
     $nodes = $nodes->filter(function (int $position) use($min, $dispersion) : bool {
         return $dispersion[$position] >= $min;
     });
     return $this($nodes);
 }
Beispiel #14
0
 /**
  * {@inheritdoc}
  */
 public function merge(MapInterface $map) : MapInterface
 {
     if (!$this->keyType()->equals($map->keyType()) || !$this->valueType()->equals($map->valueType())) {
         throw new InvalidArgumentException('The 2 maps does not reference the same types');
     }
     $newMap = clone $this;
     $map->foreach(function ($key, $value) use(&$newMap) {
         $newMap = $newMap->put($key, $value);
     });
     return $newMap;
 }