Validator::__construct() - Code Metrics - Dgame/php-object - Measure and Improve Code Quality continuously with Scrutinizer

Validator::__construct() A
last analyzed 2019-07-31 20:31 UTC

↳ Parent: Validator

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

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

<?php

namespace Dgame\Object;

use Dgame\Type\TypeFactory;
use ReflectionMethod;
use ReflectionParameter;
use Throwable;

/**
 * Class Validator
 * @package Dgame\Object
 */
final class Validator
{
    /**
     * @var ObjectFacade
     */
    private $facade;

    /**
     * Validator constructor.
     *
     * @param ObjectFacade $facade
     */
    public function __construct(ObjectFacade $facade)
    {
        $this->facade = $facade;
    }

    /**
     * @param ObjectFacade $facade
     *
     * @return Validator

     */
    public static function new(ObjectFacade $facade): self
    {
        return new self($facade);
    }

    /**
     * @param ReflectionMethod $method
     * @param mixed            $value
     *
     * @return bool
     */
    public function isValidSetterMethod(ReflectionMethod $method, $value): bool
    {
        if (!$method->isPublic()) {
            return false;
        }

        if ($method->getNumberOfParameters() === 0) {
            return true;
        }

        if ($method->getNumberOfRequiredParameters() > 1) {
            return false;
        }

        if ($value === null) {
            return $method->getParameters()[0]->allowsNull();
        }

        return $this->isValidParameterValue($method->getParameters()[0], $value);
    }

    /**
     * @param ReflectionParameter $parameter
     * @param mixed               $value
     *
     * @return bool
     */
    public function isValidParameterValue(ReflectionParameter $parameter, $value): bool
    {
        return !$parameter->hasType() || TypeFactory::reflection($parameter)->accept($value);
    }

    /**
     * @param ReflectionMethod $method
     *
     * @return bool
     */
    public function isValidGetterMethod(ReflectionMethod $method): bool
    {
        if (!$method->isPublic()) {
            return false;
        }

        try {
            $value = $method->invoke($this->facade->getObject());
        } catch (Throwable $t) {
            return false;
        }

        $returnType = $method->getReturnType();

        return $value !== null || $returnType === null || $returnType->allowsNull();
    }

    /**
     * @param ReflectionMethod $method
     * @param array            ...$args
     *
     * @return bool
     */

    public function areValidMethodArguments(ReflectionMethod $method, ...$args): bool
    {
        if (!$method->isPublic()) {
            return false;
        }

        if (count($args) < $method->getNumberOfRequiredParameters()) {
            return false;
        }

        return $this->validateMethodArguments($method, ...$args);
    }

    /**
     * @param ReflectionMethod $method
     * @param array            ...$args
     *
     * @return bool
     */

    private function validateMethodArguments(ReflectionMethod $method, ...$args): bool
    {
        $parameters = $method->getParameters();
        foreach ($args as $i => $arg) {
            if (!array_key_exists($i, $parameters)) {
                break;
            }

            if ($arg === null && !$parameters[$i]->allowsNull()) {
                return false;
            }

            if (!$this->isValidParameterValue($parameters[$i], $arg)) {
                return false;
            }
        }

        return true;
    }
}



1		<?php
2
3		namespace Dgame\Object;
4
5		use Dgame\Type\TypeFactory;
6		use ReflectionMethod;
7		use ReflectionParameter;
8		use Throwable;
9
10		/**
11		* Class Validator
12		* @package Dgame\Object
13		*/
14		final class Validator
15		{
16		/**
17		* @var ObjectFacade
18		*/
19		private $facade;
20
21		/**
22		* Validator constructor.
23		*
24		* @param ObjectFacade $facade
25		*/
26	4	public function __construct(ObjectFacade $facade)
27		{
28	4	$this->facade = $facade;
29	4	}
30
31		/**
32		* @param ObjectFacade $facade
33		*
34		* @return Validator
		0 ignored issues – show Documentation introduced 2017-04-30 20:50 UTC by Report Bug Copy Issue Report Should the return type not be `\self`? This check compares the return type specified in the `@return` annotation of a function or method doc comment with the types returned by the function and raises an issue if they mismatch. Loading history...
35		*/
36	4	public static function new(ObjectFacade $facade): self
37		{
38	4	return new self($facade);
39		}
40
41		/**
42		* @param ReflectionMethod $method
43		* @param mixed $value
44		*
45		* @return bool
46	3	*/
47		public function isValidSetterMethod(ReflectionMethod $method, $value): bool
48	3	{
49		if (!$method->isPublic()) {
50		return false;
51		}
52
53		if ($method->getNumberOfParameters() === 0) {
54		return true;
55		}
56	2
57		if ($method->getNumberOfRequiredParameters() > 1) {
58	2	return false;
59		}
60
61		if ($value === null) {
62		return $method->getParameters()[0]->allowsNull();
63		}
64
65		return $this->isValidParameterValue($method->getParameters()[0], $value);
66		}
67	1
68		/**
69	1	* @param ReflectionParameter $parameter
70		* @param mixed $value
71		*
72		* @return bool
73	1	*/
74	1	public function isValidParameterValue(ReflectionParameter $parameter, $value): bool
75		{
76		return !$parameter->hasType() \|\| TypeFactory::reflection($parameter)->accept($value);
77	1	}
78
79		/**
80		* @param ReflectionMethod $method
81	1	*
82	1	* @return bool
83		*/
84		public function isValidGetterMethod(ReflectionMethod $method): bool
85	1	{
86		if (!$method->isPublic()) {
87		return false;
88		}
89
90		try {
91		$value = $method->invoke($this->facade->getObject());
92		} catch (Throwable $t) {
93		return false;
94	1	}
95
96	1	$returnType = $method->getReturnType();
97
98		return $value !== null \|\| $returnType === null \|\| $returnType->allowsNull();
99		}
100
101		/**
102		* @param ReflectionMethod $method
103		* @param array ...$args
104	2	*
105		* @return bool
106	2	*/
		0 ignored issues – show Documentation introduced 2017-04-30 20:50 UTC by Report Bug Copy Issue Report Consider making the type for parameter `$args` a bit more specific; maybe use `array[]`. Loading history...
107		public function areValidMethodArguments(ReflectionMethod $method, ...$args): bool
108		{
109		if (!$method->isPublic()) {
110	2	return false;
111		}
112	2
113		if (count($args) < $method->getNumberOfRequiredParameters()) {
114		return false;
115		}
116
117		return $this->validateMethodArguments($method, ...$args);
118		}
119
120		/**
121		* @param ReflectionMethod $method
122		* @param array ...$args
123		*
124		* @return bool
125		*/
		0 ignored issues – show Documentation introduced 2017-04-30 20:50 UTC by Report Bug Copy Issue Report Consider making the type for parameter `$args` a bit more specific; maybe use `array[]`. Loading history...
126		private function validateMethodArguments(ReflectionMethod $method, ...$args): bool
127		{
128		$parameters = $method->getParameters();
129		foreach ($args as $i => $arg) {
130		if (!array_key_exists($i, $parameters)) {
131		break;
132		}
133
134		if ($arg === null && !$parameters[$i]->allowsNull()) {
135		return false;
136		}
137
138		if (!$this->isValidParameterValue($parameters[$i], $arg)) {
139		return false;
140		}
141		}
142
143		return true;
144		}
145		}
146
147

Dgame / php-object

Validator::__construct() A last analyzed 2019-07-31 20:31 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Validator::__construct() A
last analyzed 2019-07-31 20:31 UTC