Respect\Validation\Factory

Complexity

Total Complexity

34

Size/Duplication

Total Lines	260
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	9

Test Coverage

Coverage

38.64%

Importance

Changes

0

14 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	12	3
A	setDefaultInstance()	0	4	1
A	getDefaultInstance()	0	8	2
A	getNamespaces()	0	4	1
A	rule()	0	4	1
A	exception()	0	7	1
A	message()	0	4	1
C	messages()	0	33	8
A	createMessage()	0	18	1
A	chooseTemplate()	0	17	4
A	getRuleName()	0	6	1
A	getRuleReflection()	0	13	3
A	getExceptionReflection()	0	13	3
A	getReflection()	0	16	4

<?php

/*
 * This file is part of Respect/Validation.
 *
 * (c) Alexandre Gomes Gaigalas <alexandre@gaigalas.net>
 *
 * For the full copyright and license information, please view the "LICENSE.md"
 * file that was distributed with this source code.
 */

namespace Respect\Validation;

use Doctrine\Common\Annotations\Reader;
use Doctrine\Common\Annotations\SimpleAnnotationReader;
use ReflectionClass;
use Respect\Validation\Annotations\Template;
use Respect\Validation\Annotations\Templates;
use Respect\Validation\Exceptions\ComponentException;
use Respect\Validation\Exceptions\ExceptionNotFoundException;
use Respect\Validation\Exceptions\InvalidClassException;
use Respect\Validation\Exceptions\InvalidRuleExceptionException;
use Respect\Validation\Exceptions\RuleNotFoundException;
use Respect\Validation\Exceptions\ValidationException;

/**
 * Factory to create rules.
 *
 * @author Henrique Moody <henriquemoody@gmail.com>
 *
 * @since 0.8.0
 */
final class Factory
{
    /**
     * @var string[]
     */
    private $namespaces;

    /**
     * @var ReflectionClass[]
     */
    private $reflections;

    /**
     * @var Reader
     */
    private $annotationReader;

    /**
     * @var self
     */
    private static $defaultInstance;

    /**
     * Initializes the rule with the defined namespaces.
     *
     * If the default namespace is not in the array, it will be add to the end
     * of the array.
     *
     * @param array $namespaces
     */
    public function __construct(array $namespaces = [])
    {
        if (!in_array(__NAMESPACE__, $namespaces)) {
            $namespaces[] = __NAMESPACE__;
        }

        $this->namespaces = $namespaces;
        $this->annotationReader = new SimpleAnnotationReader();
        foreach ($namespaces as $namespace) {
            $this->annotationReader->addNamespace(rtrim($namespace, '\\').'\\Annotations');
        }
    }

    /**
     * Defines the default instance of the factory.
     *
     * @param Factory $factory
     */
    public static function setDefaultInstance(self $factory)
    {
        self::$defaultInstance = $factory;

It seems like $factory of type object<self> is incompatible with the declared type object<Respect\Validation\Factory> of property $defaultInstance.

    }

    /**
     * Returns the default instance of the factory.
     *
     * @return self
     */
    public static function getDefaultInstance(): self
    {
        if (!self::$defaultInstance instanceof self) {
            self::$defaultInstance = new self();
        }

        return self::$defaultInstance;
    }

    /**
     * Returns a list of namespaces.
     *
     * @return array
     */
    public function getNamespaces(): array
    {
        return $this->namespaces;
    }

    /**
     * Creates a rule based on its name with the defined arguments.
     *
     * @param string $ruleName
     * @param array  $arguments
     *
     * @throws ComponentException When the rule cannot be created
     *
     * @return Rule
     */
    public function rule(string $ruleName, array $arguments = []): Rule
    {
        return $this->getRuleReflection($ruleName)->newInstanceArgs($arguments);
    }

    public function exception(Result $result): ValidationException
    {
        $message = $this->message($result);
        $reflection = $this->getExceptionReflection($message->getRuleName());

        return $reflection->newInstance($message->__toString());
    }

    public function message(Result $result, string $locale = 'en'): Message
    {
        return current($this->messages($result, $locale));
    }

    public function messages(Result $result, string $locale = 'en'): array
    {
        $key = spl_object_hash($result);
        $message = $this->createMessage($result, $locale);
        $messages = [$key => $message];
        foreach ($result as $childKey => $childResult) {
            if (!is_string($childKey)) {
                $childKey = spl_object_hash($childResult);
            }

            $childMessage = $this->createMessage($childResult, $locale);

            if (!$childResult->hasChildren()) {
                $messages[$childKey] = $childMessage;
                continue;
            }

            $messages[$childKey] = $this->messages($childResult);
            if (count($messages[$childKey]) == 1) {
                $messages[$childKey] = current($messages[$childKey]);
            }

            if ($childMessage->isIgnorable()) {
                continue;
            }
        }

        if ($message->isIgnorable() && count($messages) > 1) {
            unset($messages[$key]);
        }

        return $messages;
    }

    private function createMessage(Result $result, string $locale = 'en'): Message

The parameter $locale is not used and could be removed.

    {
        $ruleName = $this->getRuleName($result->getRule());
        $properties = $result->getProperties();
        $reflection = $this->getExceptionReflection($ruleName);

        /* @var Templates $templates */
        $templates = $this->annotationReader->getClassAnnotation($reflection, Templates::class);

        /* @var Template $template */
        $template = $this->chooseTemplate(
            $templates,
            $result->isInverted(),
            $properties['templateId'] ?? Template::STANDARD_ID
        );

        return new Message($ruleName, $template->message, $result->getInput(), $properties, $templates->isIgnorable);
    }

    private function chooseTemplate(Templates $templates, bool $isInverted, string $templateId): Template
    {
        $templatesList = $templates->regular;
        if ($isInverted) {
            $templatesList = $templates->inverted;
        }

        foreach ($templatesList as $template) {
            if ($template->id != $templateId) {
                continue;
            }

            return $template;
        }

        return current($templatesList);
    }

    private function getRuleName(Rule $rule): string
    {
        $reflection = $this->getReflection(get_class($rule));

The call to getReflection() misses a required argument $parentClassName.

        return $reflection->getShortName();
    }

    /**
     * Returns a reflection of a rule based on its name.
     *
     * @throws RuleNotFoundException
     *
     * @param string $ruleName
     *
     * @return ReflectionClass
     */
    private function getRuleReflection(string $ruleName): ReflectionClass
    {
        foreach ($this->getNamespaces() as $namespace) {
            $className = rtrim($namespace, '\\').'\\Rules\\'.ucfirst($ruleName);
            if (!class_exists($className)) {
                continue;
            }

            return $this->getReflection($className, Rule::class);
        }

        throw new RuleNotFoundException(sprintf('Could not find "%s" rule', $ruleName));
    }

    /**
     * Returns a reflection of an exception based on a rule name.
     *
     * @throws ExceptionNotFoundException
     *
     * @param string $ruleName
     *
     * @return ReflectionClass
     */
    private function getExceptionReflection(string $ruleName): ReflectionClass
    {
        foreach ($this->getNamespaces() as $namespace) {
            $className = sprintf('%s\\Exceptions\\%sException', rtrim($namespace, '\\'), $ruleName);
            if (!class_exists($className)) {
                continue;
            }

            return $this->getReflection($className, ValidationException::class);
        }

        throw new ExceptionNotFoundException(sprintf('Could not find "%s" exception', $ruleName));
    }

    /**
     * Creates a ReflectionClass object based on a class name.
     *
     * This method always return the same object for a given class name in order
     * to improve performance. Also checks if the reflection is child of $parentClass
     * and if it is instantiable.
     *
     * @param string $className
     * @param string $parentClassName
     *
     * @return ReflectionClass
     *
     * @throws InvalidClassException When not valid.
     */
    private function getReflection(string $className, string $parentClassName): ReflectionClass
    {
        if (!isset($this->reflections[$className])) {
            $this->reflections[$className] = new ReflectionClass($className);

            if (!$this->reflections[$className]->isInstantiable()) {
                throw new InvalidClassException(sprintf('"%s" is not instantiable', $className));
            }
        }

        if (!$this->reflections[$className]->isSubclassOf($parentClassName)) {
            throw new InvalidClassException(sprintf('"%s" is not subclass of "%s"', $className, $parentClassName));
        }

        return $this->reflections[$className];
    }
}