DoctrineRequirementsProvider::processRow() - Code Metrics - Inspection of "wip" - larriereguichet/colonel-smoker-bundle - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — feature/html-code-handler ( 0406d3...1467c9 )

by Arnaud

created 2019-04-04 21:23 UTC

DoctrineRequirementsProvider::processRow() A

↳ Parent: DoctrineRequirementsProvider

Complexity

Conditions	4
Paths	4

Size

Total Lines	25
Code Lines	16

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	4
eloc	16
nc	4
nop	4
dl	0
loc	25
rs	9.7333
c	0
b	0
f	0

<?php

namespace LAG\SmokerBundle\Bridge\Doctrine\ORM\RequirementsProvider;

use LAG\SmokerBundle\Bridge\Doctrine\ORM\DataProvider\DoctrineDataProviderInterface;
use LAG\SmokerBundle\Exception\Exception;
use LAG\SmokerBundle\Exception\Url\UnsupportedUrlException;
use LAG\SmokerBundle\Url\Requirements\Mapping\MappingResolverInterface;
use LAG\SmokerBundle\Url\Requirements\Provider\RequirementsProviderInterface;
use Symfony\Component\OptionsResolver\OptionsResolver;
use Symfony\Component\PropertyAccess\PropertyAccess;
use Symfony\Component\Routing\Route;
use Symfony\Component\Routing\RouterInterface;
use Traversable;

class DoctrineRequirementsProvider implements RequirementsProviderInterface
{
    private $name = 'default';

    /**
     * @var RouterInterface
     */
    protected $router;

    /**
     * @var MappingResolverInterface
     */
    protected $mappingResolver;

    /**
     * @var DoctrineDataProviderInterface
     */
    protected $dataProvider;

    /**
     * RequirementsProvider constructor.
     *
     * @param MappingResolverInterface      $mappingResolver
     * @param RouterInterface               $router
     * @param DoctrineDataProviderInterface $dataProvider
     */
    public function __construct(
        MappingResolverInterface $mappingResolver,
        RouterInterface $router,
        DoctrineDataProviderInterface $dataProvider
    ) {
        $this->mappingResolver = $mappingResolver;
        $this->router = $router;
        $this->dataProvider = $dataProvider;
    }

    /**
     * {@inheritdoc}
     */
    public function getName(): string
    {
        return $this->name;
    }

    /**
     * {@inheritdoc}
     */
    public function supports(string $routeName): bool
    {
        $mapping = $this->mappingResolver->resolve($routeName);

        if ([] === $mapping) {
            return false;
        }

        return $this->name === $mapping['provider'];
    }

    /**
     * {@inheritdoc}
     */
    public function getRequirementsData(string $routeName, array $options = []): Traversable
    {
        $options = $this->resolveOptions($options);
        $mapping = $this->mappingResolver->resolve($routeName);

        if ([] === $mapping) {
            throw new UnsupportedUrlException($routeName, $this->name);
        }

        if ($this->name !== $mapping['provider']) {
            throw new Exception('The provider "'.$this->name.'" does not support the route "'.$routeName.'"');
        }

        if (!key_exists('where', $mapping['options'])) {
            $mapping['options']['where'] = [];
        }
        // Allow optional dynamic criteria to find specific entities
        $mapping['options']['where'] = array_merge($mapping['options']['where'], $options['where']);

        $entities = $this
            ->dataProvider
            ->getData($mapping['entity'], $mapping['options'])
        ;
        $route = $this
            ->router
            ->getRouteCollection()
            ->get($routeName)
        ;

        foreach ($entities as $row) {
            $values = $this->processRow($row, $routeName, $route, $mapping);

            yield $values;
        }
    }

    /**
     * @inheritDoc
     */
    public function getRequirements(string $routeName): array
    {
        $route = $this
            ->router
            ->getRouteCollection()
            ->get($routeName)
        ;
        $requirements = $route->getRequirements();

        if (0 === count($requirements)) {
            $matches = [];
            preg_match_all('/{(.*?)}/', $route->getPath(), $matches);

            $requirements = array_flip($matches[1]);
        }

        return $requirements;
    }

    /**
     * @param array $row
     * @param string $routeName
     * @param Route $route
     * @param array $mapping
     *
     * @return array
     *
     * @throws Exception
     */
    private function processRow(array $row, string $routeName, Route $route, array $mapping): array
    private function processRow(array $row, string $routeName, /** @scrutinizer ignore-unused */ Route $route, array $mapping): array
    {
        $requirements = $this->getRequirements($routeName);
        $entity = $row[0];
        $values = [];
        $accessor = PropertyAccess::createPropertyAccessor();

        foreach ($requirements as $name => $requirement) {
            if (!key_exists($name, $mapping['requirements'])) {
                throw new Exception(sprintf(
                    'The requirement "%s" for the route "%s" is not provided',
                    $name,
                    $routeName
                ));
            }
            $property = $mapping['requirements'][$name];

            if ('@' === substr($property, 0, 1)) {
                $values[$name] = substr($property, 1);
            } else {
                $values[$name] = $accessor->getValue($entity, $property);
            }
        }

        return $values;
    }

    private function resolveOptions(array $options): array
    {
        $resolver = new OptionsResolver();
        $resolver
            ->setDefaults([
                'where' => [],
            ])
            ->setAllowedTypes('where', 'array')
        ;

        return $resolver->resolve($options);
    }
}


larriereguichet / colonel-smoker-bundle

Push — feature/html-code-handler ( 0406d3...1467c9 )

DoctrineRequirementsProvider::processRow() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like