Respect\Validation\Factory

Complexity

Total Complexity

15

Size/Duplication

Total Lines	103
Duplicated Lines	0 %

Test Coverage

Coverage

92.86%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	exception()	0	20	4
A	rule()	0	17	4
A	getDefaultInstance()	0	7	2
A	setDefaultInstance()	0	3	1
A	getRulePrefixes()	0	3	1
A	filterRulePrefix()	0	6	1
A	appendRulePrefix()	0	3	1
A	prependRulePrefix()	0	3	1

<?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.
 */

declare(strict_types=1);

namespace Respect\Validation;

use function Respect\Stringifier\stringify;

The function Respect\Stringifier\stringify was not found. Maybe you did not declare it correctly or list all dependencies?

use ReflectionClass;
use ReflectionObject;
use Respect\Validation\Exceptions\ComponentException;
use Respect\Validation\Exceptions\ValidationException;

class Factory
{
    /**
     * Default instance of the Factory.
     *
     * @var Factory
     */
    protected static $defaultInstance;

    /**
     * @var string[]
     */
    protected $rulePrefixes = ['Respect\\Validation\\Rules\\'];

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

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

        return self::$defaultInstance;
    }

    /**
     * @return array
     */
    public function getRulePrefixes(): array
    {
        return $this->rulePrefixes;
    }

    private function filterRulePrefix(string $rulePrefix): string
    {
        $namespaceSeparator = '\\';
        $rulePrefix = rtrim($rulePrefix, $namespaceSeparator);

        return $rulePrefix.$namespaceSeparator;
    }

    public function appendRulePrefix(string $rulePrefix): void
    {
        array_push($this->rulePrefixes, $this->filterRulePrefix($rulePrefix));
    }

    public function prependRulePrefix(string $rulePrefix): void
    {
        array_unshift($this->rulePrefixes, $this->filterRulePrefix($rulePrefix));
    }

    public function rule(string $ruleName, array $arguments = []): Validatable
    {
        foreach ($this->getRulePrefixes() as $prefix) {
            $className = $prefix.ucfirst($ruleName);
            if (!class_exists($className)) {
                continue;
            }

            $reflection = new ReflectionClass($className);
            if (!$reflection->isSubclassOf(Validatable::class)) {
                throw new ComponentException(sprintf('"%s" is not a valid respect rule', $className));
            }

            return $reflection->newInstanceArgs($arguments);
        }

        throw new ComponentException(sprintf('"%s" is not a valid rule name', $ruleName));
    }

    public function exception(Validatable $validatable, $input, array $extraParams = []): ValidationException
    {
        $reflection = new ReflectionObject($validatable);

        $exceptionName = str_replace('\\Rules\\', '\\Exceptions\\', $reflection->getName()).'Exception';
        $exception = new $exceptionName();

        $params = ['input' => $input] + $extraParams;
        foreach ($reflection->getProperties() as $property) {
            $property->setAccessible(true);
            $params += [$property->getName() => $property->getValue($validatable)];
        }

        $name = $validatable->getName() ?: stringify($input);
        $exception->configure($name, $params);
        if (isset($params['template'])) {
            $exception->setTemplate($params['template']);
        }

        return $exception;
    }
}