Factory::setDefaultInstance() - Code Metrics - Inspection of "New Concrete API" - Respect/Validation - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#678)

by Henrique

created 2017-10-25 07:27 UTC

Factory::setDefaultInstance() A

↳ Parent: Factory

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	4
c	0
b	0
f	0
ccs	3
cts	3
cp	1
rs	10
cc	1
eloc	2
nc	1
nop	1
crap	1

<?php

/*
 * This file is part of Respect/Validation.
 *
 * (c) Alexandre Gomes Gaigalas <[email protected]>
 *
 * 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\SimpleAnnotationReader;
use ReflectionClass;
use Respect\Validation\Annotations\Template;
use Respect\Validation\Annotations\Templates;
use Respect\Validation\Exceptions\ComponentException;
use Respect\Validation\Exceptions\InvalidRuleException;
use Respect\Validation\Exceptions\RuleNotFoundException;
use Respect\Validation\Message\Formatter;

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

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

    /**
     * @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;
    }

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

    }

    /**
     * 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
    {
        foreach ($this->getNamespaces() as $namespace) {
            $className = rtrim($namespace, '\\').'\\Rules\\'.ucfirst($ruleName);
            if (!class_exists($className)) {
                continue;
            }

            $reflection = $this->getReflection($className);

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

            if (!$reflection->isInstantiable()) {
                throw new InvalidRuleException(sprintf('"%s" is not instantiable', $className));
            }

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

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

    private function getMessage(ReflectionClass $reflection, Result $result): string
    {
        $reader = new SimpleAnnotationReader();
        $reader->addNamespace('Respect\\Validation\\Annotations');

        $templates = $reader->getClassAnnotation($reflection, Templates::class);

        $template = $this->chooseTemplate($templates, $result);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        $formatter = new Formatter(2, 3);

        return $formatter->create($result->getInput(), $result->getProperties(), $template->message);
    }

    public function exception(Result $result)
    {
        $exceptionName = str_replace('Rule', 'Exception', get_class($result->getRule())).'Exception';

        $reflection = $this->getReflection($exceptionName);
        $message = $this->getMessage($reflection, $result);

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

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

        $templateId = 'standard';
        $properties = $result->getProperties();
        if (isset($properties['templateId'])) {
            $templateId = $properties['templateId'];
        }

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

            return $template;
        }

        return current($templateLists);

    }

    /**
     * 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.
     *
     * @param string $className
     *
     * @return ReflectionClass
     */
    private function getReflection(string $className): ReflectionClass
    {
        if (!isset($this->reflections[$className])) {
            $this->reflections[$className] = new ReflectionClass($className);
        }

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


1		<?php
2
3		/*
4		* This file is part of Respect/Validation.
5		*
6		* (c) Alexandre Gomes Gaigalas <[email protected]>
7		*
8		* For the full copyright and license information, please view the "LICENSE.md"
9		* file that was distributed with this source code.
10		*/
11
12		namespace Respect\Validation;
13
14		use Doctrine\Common\Annotations\SimpleAnnotationReader;
15		use ReflectionClass;
16		use Respect\Validation\Annotations\Template;
17		use Respect\Validation\Annotations\Templates;
18		use Respect\Validation\Exceptions\ComponentException;
19		use Respect\Validation\Exceptions\InvalidRuleException;
20		use Respect\Validation\Exceptions\RuleNotFoundException;
21		use Respect\Validation\Message\Formatter;
22
23		/**
24		* Factory to create rules.
25		*
26		* @author Henrique Moody <[email protected]>
27		*
28		* @since 0.8.0
29		*/
30		final class Factory
31		{
32		/**
33		* @var string[]
34		*/
35		private $namespaces;
36
37		/**
38		* @var ReflectionClass[]
39		*/
40		private $reflections;
41
42		/**
43		* @var self
44		*/
45		private static $defaultInstance;
46
47		/**
48		* Initializes the rule with the defined namespaces.
49		*
50		* If the default namespace is not in the array, it will be add to the end
51		* of the array.
52		*
53		* @param array $namespaces
54		*/
55	11	public function __construct(array $namespaces = [])
56		{
57	11	if (!in_array(__NAMESPACE__, $namespaces)) {
58	9	$namespaces[] = __NAMESPACE__;
59		}
60
61	11	$this->namespaces = $namespaces;
62	11	}
63
64		/**
65		* Defines the default instance of the factory.
66		*
67		* @param Factory $factory
68		*/
69	1	public static function setDefaultInstance(self $factory)
70		{
71	1	self::$defaultInstance = $factory;
		0 ignored issues – show Documentation Bug introduced 2017-02-27 21:28 UTC by Report Bug Copy Issue Report It seems like `$factory` of type `object<self>` is incompatible with the declared type `object<Respect\Validation\Factory>` of property `$defaultInstance`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
72	1	}
73
74		/**
75		* Returns the default instance of the factory.
76		*
77		* @return self
78		*/
79	2	public static function getDefaultInstance(): self
80		{
81	2	if (!self::$defaultInstance instanceof self) {
82	1	self::$defaultInstance = new self();
83		}
84
85	2	return self::$defaultInstance;
86		}
87
88		/**
89		* Returns a list of namespaces.
90		*
91		* @return array
92		*/
93	9	public function getNamespaces(): array
94		{
95	9	return $this->namespaces;
96		}
97
98		/**
99		* Creates a rule based on its name with the defined arguments.
100		*
101		* @param string $ruleName
102		* @param array $arguments
103		*
104		* @throws ComponentException When the rule cannot be created
105		*
106		* @return Rule
107		*/
108	6	public function rule(string $ruleName, array $arguments = []): Rule
109		{
110	6	foreach ($this->getNamespaces() as $namespace) {
111	6	$className = rtrim($namespace, '\\').'\\Rules\\'.ucfirst($ruleName);
112	6	if (!class_exists($className)) {
113	1	continue;
114		}
115
116	5	$reflection = $this->getReflection($className);
117
118	5	if (!$reflection->isSubclassOf(Rule::class)) {
119	1	throw new InvalidRuleException(sprintf('"%s" is not a valid rule', $className));
120		}
121
122	4	if (!$reflection->isInstantiable()) {
123	1	throw new InvalidRuleException(sprintf('"%s" is not instantiable', $className));
124		}
125
126	3	return $reflection->newInstanceArgs($arguments);
127		}
128
129	1	throw new RuleNotFoundException(sprintf('Could not find "%s" rule', $ruleName));
130		}
131
132		private function getMessage(ReflectionClass $reflection, Result $result): string
133		{
134		$reader = new SimpleAnnotationReader();
135		$reader->addNamespace('Respect\\Validation\\Annotations');
136
137		$templates = $reader->getClassAnnotation($reflection, Templates::class);
138
139		$template = $this->chooseTemplate($templates, $result);
		0 ignored issues – show Documentation introduced 2017-10-16 19:42 UTC by Report Bug Copy Issue Report `$templates` is of type `object\|null`, but the function expects a `object<Respect\Validation\Annotations\Templates>`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
140
141		$formatter = new Formatter(2, 3);
142
143		return $formatter->create($result->getInput(), $result->getProperties(), $template->message);
144		}
145
146		public function exception(Result $result)
147		{
148		$exceptionName = str_replace('Rule', 'Exception', get_class($result->getRule())).'Exception';
149
150		$reflection = $this->getReflection($exceptionName);
151		$message = $this->getMessage($reflection, $result);
152
153		return $reflection->newInstance($message);
154		}
155
156		private function chooseTemplate(Templates $templates, Result $result): Template
157		{
158		$templatesList = $templates->regular;
159		if ($result->isInverted()) {
160		$templatesList = $templates->inverted;
161		}
162
163		$templateId = 'standard';
164		$properties = $result->getProperties();
165		if (isset($properties['templateId'])) {
166		$templateId = $properties['templateId'];
167		}
168
169		foreach ($templatesList as $template) {
170		if ($template->id != $templateId) {
171		continue;
172		}
173
174		return $template;
175		}
176
177		return current($templateLists);
		0 ignored issues – show Bug introduced 2017-10-16 19:42 UTC by Report Bug Copy Issue Report The variable `$templateLists` does not exist. Did you mean `$templatesList`? This check looks for variables that are accessed but have not been defined. It raises an issue if it finds another variable that has a similar name. The variable may have been renamed without also renaming all references. Loading history...
178		}
179
180		/**
181		* Creates a ReflectionClass object based on a class name.
182		*
183		* This method always return the same object for a given class name in order
184		* to improve performance.
185		*
186		* @param string $className
187		*
188		* @return ReflectionClass
189		*/
190	5	private function getReflection(string $className): ReflectionClass
191		{
192	5	if (!isset($this->reflections[$className])) {
193	5	$this->reflections[$className] = new ReflectionClass($className);
194		}
195
196	5	return $this->reflections[$className];
197		}
198		}
199

Respect / Validation

Scrutinizer GitHub App not installed

Pull Request — master (#678)

Factory::setDefaultInstance() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like