Yaml::buildArgument() - Code Metrics - Inspection of "add tests to verify new constructors are built cor..." - Innmind/Compose - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( f8d1c0...c6d734 )

by Baptiste

created 2018-01-21 13:22 UTC

Yaml::buildArgument() B

↳ Parent: Yaml

Complexity

Conditions	5
Paths	5

Size

Total Lines	36
Code Lines	21

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	18
CRAP Score	5.0035

Importance

Changes

Metric	Value
dl	0
loc	36
ccs	18
cts	19
cp	0.9474
rs	8.439
c	0
b	0
f	0
cc	5
eloc	21
nc	5
nop	2
crap	5.0035

<?php
declare(strict_types = 1);

namespace Innmind\Compose\Loader;

use Innmind\Compose\{
    Loader,
    Definitions,
    Arguments,
    Definition\Argument,
    Definition\Argument\Types,
    Definition\Name,
    Definition\Service,
    Definition\Service\Arguments as ServiceArguments,
    Definition\Service\Constructors,
    Exception\DomainException
};
use Innmind\Url\PathInterface;
use Innmind\Immutable\{
    Str,
    Stream,
    Map,
    Pair
};
use Symfony\Component\{
    Yaml\Yaml as Lib,
    OptionsResolver\OptionsResolver
};

final class Yaml implements Loader
{
    private const ARGUMENT_PATTERN = '~^(?<optional>\?)?(?<type>.+)( \?\? \$.+)?$~';
    private const ARGUMENT_DEFAULT_PATTERN = '~( \?\? \$(?<default>.+))$~';
    private const SERVICE_NAME = "~^(?<name>[a-zA-Z0-9]+)[\s ](?<constructor>.+)$~"; //split on space or non breaking space

    private $resolver;
    private $types;
    private $arguments;
    private $constructors;

    public function __construct(
        Types $types,
        ServiceArguments $arguments,
        Constructors $constructors
    ) {
        $this->resolver = new OptionsResolver;
        $this->resolver->setRequired(['expose', 'services']);
        $this->resolver->setDefined('arguments');
        $this->resolver->setAllowedTypes('arguments', 'array');
        $this->resolver->setAllowedTypes('expose', 'array');
        $this->resolver->setAllowedTypes('services', 'array');
        $this->resolver->setDefault('arguments', []);
        $this->types = $types;
        $this->arguments = $arguments;
        $this->constructors = $constructors;
    }

    public function __invoke(PathInterface $definition): Definitions
    {
        $data = Lib::parseFile((string) $definition);
        $data = $this->resolver->resolve($data);

        $arguments = $this->buildArguments($data['arguments']);
        $definitions = $this->buildDefinitions(
            Stream::of('string'),
            $data['services']
        );
        $definitions = $this->expose(
            $definitions,
            Map::of(
                'string',
                'string',
                array_values($data['expose']),
                array_keys($data['expose'])
            )
        );

        return new Definitions(
            $arguments,
            ...$definitions->values()
        );
    }

    private function buildArguments(array $definitions): Arguments
    {
        $arguments = [];

        foreach ($definitions as $name => $type) {
            $arguments[] = $this->buildArgument($name, Str::of($type)->trim());
        }

        return new Arguments(...$arguments);
    }

    private function buildArgument(string $name, Str $type): Argument
    {
        if (!$type->matches(self::ARGUMENT_PATTERN)) {
            throw new DomainException;
        }

        $components = $type->capture(self::ARGUMENT_PATTERN);

        $argument = new Argument(
            new Name($name),
            $this->types->load(
                $components
                    ->get('type')
                    ->pregReplace(
                        self::ARGUMENT_DEFAULT_PATTERN,
                        ''
                    )
            )
        );

        if (
            $components->contains('optional') &&
            !$components->get('optional')->empty()
        ) {
            $argument = $argument->makeOptional();
        }

        if ($type->matches(self::ARGUMENT_DEFAULT_PATTERN)) {
            $argument = $argument->defaultsTo(new Name(
                (string) $type
                    ->capture(self::ARGUMENT_DEFAULT_PATTERN)
                    ->get('default')
            ));
        }

        return $argument;
    }

    private function buildDefinitions(Stream $namespace, array $definitions): Map
    {
        $services = new Map('string', Service::class);

        foreach ($definitions as $key => $value) {
            $key = Str::of($key);

            if (!is_array($value)) {
                throw new DomainException;
            }

            if (!$key->matches(self::SERVICE_NAME)) {
                $services = $services->merge(
                    $this->buildDefinitions(
                        $namespace->add((string) $key),
                        $value
                    )
                );

                continue;
            }

            $service = $this->buildService($namespace, $key, $value);
            $services = $services->put(
                (string) $service->name(),
                /** @scrutinizer ignore-type */ (string) $service->name(),
                $service
            );
        }

        return $services;

    }

    private function buildService(
        Stream $namespace,
        Str $name,
        array $arguments
    ): Service {
        $components = $name->capture(self::SERVICE_NAME);

        foreach ($arguments as &$argument) {
            $argument = $this->arguments->load($argument);
        }

        return new Service(
            new Name(
                (string) $namespace
                    ->add((string) $components->get('name'))
                    ->join('.')
            ),
            $this->constructors->load($components->get('constructor')->trim('  ')), //space and non breaking space
            ...$arguments
        );
    }

    private function expose(Map $definitions, Map $expose): Map
    {
        $expose = $expose
            ->foreach(static function(string $service): void {
                if (!Str::of($service)->matches('~^\$~')) {
                    throw new DomainException;
                }
            })
            ->map(static function(string $service, string $alias): Pair {
                return new Pair(
                    (string) Str::of($service)->substring(1), //remove the $ sign
                    $alias
                );
            });

        return $definitions->map(static function(string $name, Service $service) use ($expose): Service {
            if ($expose->contains($name)) {
                $service = $service->exposeAs(new Name(
                    $expose->get($name)
                ));
            }

            return $service;
        });
    }
}


Innmind / Compose

Push — develop ( f8d1c0...c6d734 )

Yaml::buildArgument() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like