PropertyAccessor::setNullValue() - Code Metrics - Inspection of "Feature/property access with generics" - spaark/composite-utils - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#7)

by Emily

created 2017-03-18 18:46 UTC

PropertyAccessor::setNullValue() A

↳ Parent: PropertyAccessor

Complexity

Conditions	2
Paths	2

Size

Total Lines	11
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	11
ccs	5
cts	5
cp	1
rs	9.4285
c	0
b	0
f	0
cc	2
eloc	5
nc	2
nop	1
crap	2

<?php
/**
 * This file is part of the Composite Utils package.
 *
 * (c) Emily Shepherd <[email protected]>
 *
 * For the full copyright and license information, please view the
 * LICENSE.md file that was distributed with this source code.
 *
 * @package spaark/composite-utils
 * @author Emily Shepherd <[email protected]>
 * @license MIT
 */

namespace Spaark\CompositeUtils\Service;

use Spaark\CompositeUtils\Model\Reflection\ReflectionComposite;
use Spaark\CompositeUtils\Model\Reflection\ReflectionProperty;
use Spaark\CompositeUtils\Model\Reflection\Type\ObjectType;
use Spaark\CompositeUtils\Model\Reflection\Type\MixedType;
use Spaark\CompositeUtils\Model\Reflection\Type\StringType;
use Spaark\CompositeUtils\Model\Reflection\Type\IntegerType;
use Spaark\CompositeUtils\Model\Reflection\Type\BooleanType;
use Spaark\CompositeUtils\Model\Reflection\Type\CollectionType;
use Spaark\CompositeUtils\Model\Reflection\Type\ScalarType;
use Spaark\CompositeUtils\Model\Reflection\Type\AbstractType;
use Spaark\CompositeUtils\Exception\CannotWritePropertyException;
use Spaark\CompositeUtils\Exception\IllegalPropertyTypeException;
use Spaark\CompositeUtils\Exception\MissingRequiredParameterException;
use Spaark\CompositeUtils\Factory\Reflection\TypeParser;
use Spaark\CompositeUtils\Service\TypeComparator;

/**
 * This class is used to access properties of a composite and enforce
 * data type requirements
 */
class PropertyAccessor extends RawPropertyAccessor
{
    /**
     * Reflection information about the composite being accessed
     *
     * @var ReflectionComposite
     */
    protected $reflect;

    /**
     * Creates the PropertyAccessor for the given object, using the
     * given reflection information
     *
     * @param object $object The object to access
     * @param ReflectionComposite $reflect Reflection information about
     *     the composite
     */
    public function __construct($object, ReflectionComposite $reflect)
    {
        parent::__construct($object);

        $this->reflect = $reflect;
    }

    /**
     * Initializes the given object with the given parameters, enforcing
     * the constructor requirements and auto building any left overs
     */
    public function constructObject(...$args)
    {
        $i = 0;
        foreach ($this->reflect->requiredProperties as $property)
        {
            if (!isset($args[$i]))
            {
                throw new MissingRequiredParameterException
                (
                    get_class($this->object),
                    $property->name
                );
            }

            $this->setAnyValue($property, $args[$i]);

            $i++;
        }

        $building = false;
        foreach ($this->reflect->optionalProperties as $property)
        {
            if ($building)
            {
                $this->buildProperty($property);
            }
            else
            {
                if (isset($args[$i]))
                {
                    $this->setAnyValue($property, $args[$i]);
                    $i++;
                }
                else
                {
                    $building = true;
                    $this->buildProperty($property);
                }
            }
        }

        foreach ($this->reflect->builtProperties as $property)
        {
            $this->buildProperty($property);
        }
    }

    /**
     * Builds a property automatically
     *
     * @param ReflectionProperty $property The property to build
     */
    protected function buildProperty(ReflectionProperty $property)
    {
        if (!$property->type instanceof ObjectType)
        {
            $this->setAnyValue($property, 0);
        }
        elseif ($property->builtInConstructor)
        {
            $class = (string)$property->type->classname;
            $this->setRawValue($property->name, new $class());
        }
    }

    /**
     * Returns the value of the property
     *
     * @param string $property The name of the property to get
     * @return mixed The value of the property
     */
    public function getValue(string $property)
    {
        return $this->getRawValue($property);
    }

    /**
     * Sets the value of a property, enforcing datatype requirements
     *
     * @param string $property The name of the property to set
     * @param mixed $value The value to set
     */
    public function setValue(string $property, $value)
    {
        if (!$this->reflect->properties->containsKey($property))
function acceptsInteger($int) { }

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

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);
        {
            throw new CannotWritePropertyException
            (
                get_class($this->object), $property
            );
        }

        $this->setAnyValue
        (
            $this->reflect->properties[$property],
            $value
        );
    }

    /**
     * Sets the value of a property, enforcing datatype requirements
     *
     * @param ReflectionProperty $property The property to set
     * @param mixed $value The value to set
     */
    protected function setAnyValue(ReflectionProperty $property, $value)
    {
        $valueType = (new TypeParser())->parseFromType($value);
        $comparator = new TypeComparator();

        if ($comparator->compatible($property->type, $valueType))
        {
            $this->setRawValue($property->name, $value);
        }
        elseif ($property->type instanceof ScalarType)
        {
            $this->setScalarValue($property, $valueType, $value);

        }
        else
        {
            $this->throwError($property, $valueType);
        }
    }

    /**
     * Attempts to set a property which expects a scalar value
     *
     * @param ReflectionProperty $property The property to set
     * @param ScalarType $valueType The scalar type
     * @param mixed $value The value to set
     */
    private function setScalarValue
    (
        ReflectionProperty $property,
        ScalarType $valueType,
        $value
    )
    {
        $method = '__to' . $valueType;

        if (is_scalar($value))
        {
            $this->setRawValue
            (
                $property->name,
                $property->type->cast($value)
abstract class User
{
    /** @return string */
    abstract public function getPassword();
}

class MyUser extends User
{
    public function getPassword()
    {
        // return something
    }

    public function getDisplayName()
    {
        // return some name.
    }
}

class AuthSystem
{
    public function authenticate(User $user)
    {
        $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName()));
        // do something.
    }
}
            );
        }
        elseif (is_object($value) && method_exists([$value, $method]))
        {
            $this->setScalarValue
            (
                $property,
                $valueType,
                $value->$method()
            );
        }
        else
        {
            $this->throwError($property, $valueType);
        }
    }

    /**
     * Throws an IlleglPropertyTypeException
     *
     * @param ReflectionProperty $property The property being set
     * @param AbstractType $valueType The value being set
     */
    private function throwError
    (
        ReflectionProperty $property,
        AbstractType $valueType
    )
    {
        throw new IllegalPropertyTypeException
        (
            get_class($this->object),
            $property->name,
            $property->type,
            $valueType
        );
    }
}


1		<?php
2		/**
3		* This file is part of the Composite Utils package.
4		*
5		* (c) Emily Shepherd <[email protected]>
6		*
7		* For the full copyright and license information, please view the
8		* LICENSE.md file that was distributed with this source code.
9		*
10		* @package spaark/composite-utils
11		* @author Emily Shepherd <[email protected]>
12		* @license MIT
13		*/
14
15		namespace Spaark\CompositeUtils\Service;
16
17		use Spaark\CompositeUtils\Model\Reflection\ReflectionComposite;
18		use Spaark\CompositeUtils\Model\Reflection\ReflectionProperty;
19		use Spaark\CompositeUtils\Model\Reflection\Type\ObjectType;
20		use Spaark\CompositeUtils\Model\Reflection\Type\MixedType;
21		use Spaark\CompositeUtils\Model\Reflection\Type\StringType;
22		use Spaark\CompositeUtils\Model\Reflection\Type\IntegerType;
23		use Spaark\CompositeUtils\Model\Reflection\Type\BooleanType;
24		use Spaark\CompositeUtils\Model\Reflection\Type\CollectionType;
25		use Spaark\CompositeUtils\Model\Reflection\Type\ScalarType;
26		use Spaark\CompositeUtils\Model\Reflection\Type\AbstractType;
27		use Spaark\CompositeUtils\Exception\CannotWritePropertyException;
28		use Spaark\CompositeUtils\Exception\IllegalPropertyTypeException;
29		use Spaark\CompositeUtils\Exception\MissingRequiredParameterException;
30		use Spaark\CompositeUtils\Factory\Reflection\TypeParser;
31		use Spaark\CompositeUtils\Service\TypeComparator;
32
33		/**
34		* This class is used to access properties of a composite and enforce
35		* data type requirements
36		*/
37		class PropertyAccessor extends RawPropertyAccessor
38		{
39		/**
40		* Reflection information about the composite being accessed
41		*
42		* @var ReflectionComposite
43		*/
44		protected $reflect;
45
46		/**
47		* Creates the PropertyAccessor for the given object, using the
48		* given reflection information
49		*
50		* @param object $object The object to access
51		* @param ReflectionComposite $reflect Reflection information about
52		* the composite
53		*/
54	28	public function __construct($object, ReflectionComposite $reflect)
55		{
56	28	parent::__construct($object);
57
58	28	$this->reflect = $reflect;
59	28	}
60
61		/**
62		* Initializes the given object with the given parameters, enforcing
63		* the constructor requirements and auto building any left overs
64		*/
65	11	public function constructObject(...$args)
66		{
67	11	$i = 0;
68	11	foreach ($this->reflect->requiredProperties as $property)
69		{
70	11	if (!isset($args[$i]))
71		{
72	2	throw new MissingRequiredParameterException
73		(
74	2	get_class($this->object),
75	2	$property->name
76		);
77		}
78
79	9	$this->setAnyValue($property, $args[$i]);
80
81	9	$i++;
82		}
83
84	9	$building = false;
85	9	foreach ($this->reflect->optionalProperties as $property)
86		{
87	4	if ($building)
88		{
89	2	$this->buildProperty($property);
90		}
91		else
92		{
93	4	if (isset($args[$i]))
94		{
95	2	$this->setAnyValue($property, $args[$i]);
96	2	$i++;
97		}
98		else
99		{
100	2	$building = true;
101	2	$this->buildProperty($property);
102		}
103		}
104		}
105
106	9	foreach ($this->reflect->builtProperties as $property)
107		{
108	4	$this->buildProperty($property);
109		}
110	9	}
111
112		/**
113		* Builds a property automatically
114		*
115		* @param ReflectionProperty $property The property to build
116		*/
117	4	protected function buildProperty(ReflectionProperty $property)
118		{
119	4	if (!$property->type instanceof ObjectType)
120		{
121	3	$this->setAnyValue($property, 0);
122		}
123	3	elseif ($property->builtInConstructor)
124		{
125	2	$class = (string)$property->type->classname;
126	2	$this->setRawValue($property->name, new $class());
127		}
128	4	}
129
130		/**
131		* Returns the value of the property
132		*
133		* @param string $property The name of the property to get
134		* @return mixed The value of the property
135		*/
136	6	public function getValue(string $property)
137		{
138	6	return $this->getRawValue($property);
139		}
140
141		/**
142		* Sets the value of a property, enforcing datatype requirements
143		*
144		* @param string $property The name of the property to set
145		* @param mixed $value The value to set
146		*/
147	9	public function setValue(string $property, $value)
148		{
149	9	if (!$this->reflect->properties->containsKey($property))
		0 ignored issues – show Documentation introduced 2017-02-15 22:55 UTC by Report Bug Copy Issue Report `$property` is of type `string`, but the function expects a `object<Spaark\CompositeU...del\Collection\KeyType>`. 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...
150		{
151		throw new CannotWritePropertyException
152		(
153		get_class($this->object), $property
154		);
155		}
156
157	9	$this->setAnyValue
158		(
159	9	$this->reflect->properties[$property],
160		$value
161		);
162	5	}
163
164		/**
165		* Sets the value of a property, enforcing datatype requirements
166		*
167		* @param ReflectionProperty $property The property to set
168		* @param mixed $value The value to set
169		*/
170	15	protected function setAnyValue(ReflectionProperty $property, $value)
171		{
172	15	$valueType = (new TypeParser())->parseFromType($value);
173	15	$comparator = new TypeComparator();
174
175	15	if ($comparator->compatible($property->type, $valueType))
176		{
177	13	$this->setRawValue($property->name, $value);
178		}
179	5	elseif ($property->type instanceof ScalarType)
180		{
181	4	$this->setScalarValue($property, $valueType, $value);
		0 ignored issues – show Compatibility introduced 2017-03-12 20:08 UTC by Report Bug Copy Issue Report `$valueType` of type `object<Spaark\CompositeU...tion\Type\AbstractType>` is not a sub-type of `object<Spaark\CompositeU...ection\Type\ScalarType>`. It seems like you assume a child class of the class `Spaark\CompositeUtils\Mo...ction\Type\AbstractType` to be always present. This check looks for parameters that are defined as one type in their type hint or doc comment but seem to be used as a narrower type, i.e an implementation of an interface or a subclass. Consider changing the type of the parameter or doing an instanceof check before assuming your parameter is of the expected type. Loading history...
182		}
183		else
184		{
185	1	$this->throwError($property, $valueType);
186		}
187	14	}
188
189		/**
190		* Attempts to set a property which expects a scalar value
191		*
192		* @param ReflectionProperty $property The property to set
193		* @param ScalarType $valueType The scalar type
194		* @param mixed $value The value to set
195		*/
196	4	private function setScalarValue
197		(
198		ReflectionProperty $property,
199		ScalarType $valueType,
200		$value
201		)
202		{
203	4	$method = '__to' . $valueType;
204
205	4	if (is_scalar($value))
206		{
207	4	$this->setRawValue
208		(
209	4	$property->name,
210	4	$property->type->cast($value)
		0 ignored issues – show Bug introduced 2017-03-12 20:08 UTC by Report Bug Copy Issue Report It seems like you code against a specific sub-type and not the parent class `Spaark\CompositeUtils\Mo...ction\Type\AbstractType` as the method `cast()` does only exist in the following sub-classes of `Spaark\CompositeUtils\Mo...ction\Type\AbstractType`: `Spaark\CompositeUtils\Mo...ection\Type\BooleanType`, `Spaark\CompositeUtils\Mo...flection\Type\FloatType`, `Spaark\CompositeUtils\Mo...ection\Type\IntegerType`, `Spaark\CompositeUtils\Mo...lection\Type\ScalarType`, `Spaark\CompositeUtils\Mo...lection\Type\StringType`. Maybe you want to `instanceof` check for one of these explicitly? Let’s take a look at an example: abstract class User { /** @return string / abstract public function getPassword(); } class MyUser extends User { public function getPassword() { // return something } public function getDisplayName() { // return some name. } } class AuthSystem { public function authenticate(User $user) { $this->logger->info(sprintf('Authenticating %s.', $user->getDisplayName())); // do something. } } In the above example, the authenticate() method works fine as long as you just pass instances of MyUser. However, if you now also want to pass a different sub-classes of User which does not have a getDisplayName() method, the code will break. Available Fixes Change the type-hint for the parameter: class AuthSystem { public function authenticate(MyUser $user) { / ... / } } Add an additional type-check: class AuthSystem { public function authenticate(User $user) { if ($user instanceof MyUser) { $this->logger->info(/* ... /); } // or alternatively if ( ! $user instanceof MyUser) { throw new \LogicException( '$user must be an instance of MyUser, ' .'other instances are not supported.' ); } } } Note:* PHP Analyzer uses reverse abstract interpretation to narrow down the types inside the if block in such a case. Add the method to the parent class: abstract class User { /** @return string / abstract public function getPassword(); /* @return string */ abstract public function getDisplayName(); } Loading history...
211		);
212		}
213		elseif (is_object($value) && method_exists([$value, $method]))
214		{
215		$this->setScalarValue
216		(
217		$property,
218		$valueType,
219		$value->$method()
220		);
221		}
222		else
223		{
224		$this->throwError($property, $valueType);
225		}
226	4	}
227
228		/**
229		* Throws an IlleglPropertyTypeException
230		*
231		* @param ReflectionProperty $property The property being set
232		* @param AbstractType $valueType The value being set
233		*/
234	1	private function throwError
235		(
236		ReflectionProperty $property,
237		AbstractType $valueType
238		)
239		{
240	1	throw new IllegalPropertyTypeException
241		(
242	1	get_class($this->object),
243	1	$property->name,
244	1	$property->type,
245		$valueType
246		);
247		}
248		}
249

spaark / composite-utils

Pull Request — master (#7)

PropertyAccessor::setNullValue() A

Complexity

Size

Duplication

Code Coverage

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like