AbstractDaftObject::CheckTypeDefinesOwnIdProperties() - Code Metrics - Inspection of "php-cs-fixer" - SignpostMarv/daft-object - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 4b315b...f1f5b9 )

by SignpostMarv

created 2017-09-16 08:44 UTC

CheckTypeDefinesOwnIdProperties() B

↳ Parent: AbstractDaftObject

Complexity

Conditions	7
Paths	6

Size

Total Lines	56
Code Lines	33

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	25
CRAP Score	7.0601

Importance

Changes

Metric	Value
dl	0
loc	56
ccs	25
cts	28
cp	0.8929
rs	7.7489
c	0
b	0
f	0
cc	7
eloc	33
nc	6
nop	1
crap	7.0601

How to fix Long Method

<?php
/**
* Base daft objects.
*
* @author SignpostMarv
*/
declare(strict_types=1);

namespace SignpostMarv\DaftObject;

use TypeError;

/**
* Base daft object.
*/
abstract class AbstractDaftObject implements DaftObject
{
    /**
    * List of properties that can be defined on an implementation.
    *
    * @var string[]
    */
    const PROPERTIES = [];

    /**
    * List of nullable properties that can be defined on an implementation.
    *
    * @var string[]
    */
    const NULLABLE_PROPERTIES = [];

    /**
    * Index of checked types.
    *
    * @see self::CheckTypeDefinesOwnIdProperties()
    *
    * @var bool[]
    */
    private static $checkedTypes = [];

    /**
    * Does some sanity checking.
    *
    * @see DefinesOwnIdPropertiesInterface
    * @see self::CheckTypeDefinesOwnIdProperties()
    *
    * @throws TypeError if static::class was previously determined to be incorrectly implemented
    */
    public function __construct()
    {
        if (
            ($this instanceof DefinesOwnIdPropertiesInterface) &&
            false === self::CheckTypeDefinesOwnIdProperties($this)
        ) {
            throw new IncorrectlyImplementedTypeError(
                get_class($this) . // phpunit coverage does not pick up static::class here
                ' already determined to be incorrectly implemented'
            );
        }
    }

    /**
    * Maps param $property to the getter method.
    *
    * @param string $property the property being retrieved
    *
    * @throws UndefinedPropertyException if a property is undefined
    *
    * @return mixed
    */
    public function __get(string $property)
    {
        $expectedMethod = 'Get' . ucfirst($property);
        if (true !== method_exists($this, $expectedMethod)) {
            throw new UndefinedPropertyException(static::class, $property);
        }

        return $this->$expectedMethod();
    }

    /**
    * Maps param $property to the getter method.
    *
    * @param string $property the property being retrieved
    * @param mixed $v
    *
    * @throws UndefinedPropertyException if a property is undefined
    *
    * @return mixed
    */
    public function __set(string $property, $v)
    {
        $expectedMethod = 'Set' . ucfirst($property);
        if (
            true !== method_exists($this, $expectedMethod)
        ) {
            throw new PropertyNotWriteableException(static::class, $property);
        }

        return $this->$expectedMethod($v);
    }

    /**
    * required to support unset($foo->bar).
    *
    * @param string $property the property being unset
    *
    * @see static::NudgePropertyValue()
    */
    public function __unset(string $property) : void
    {
        $this->NudgePropertyValue($property, null);
    }

    /**
    * List of properties that can be defined on an implementation.
    *
    * @return string[]
    */
    final public static function DaftObjectProperties() : array
    {
        return static::PROPERTIES;
    }

    /**
    * List of nullable properties that can be defined on an implementation.
    *
    * @return string[]
    */
    final public static function DaftObjectNullableProperties() : array
    {
        return static::NULLABLE_PROPERTIES;
    }

    /**
    * Nudge the state of a given property, marking it as dirty.
    *
    * @param string $property property being nudged
    * @param mixed $value value to nudge property with
    *
    * @throws UndefinedPropertyException if $property is not in static::DaftObjectProperties()
    * @throws PropertyNotNullableException if $property is not in static::DaftObjectNullableProperties()
    */
    abstract protected function NudgePropertyValue(
        string $property,
        $value
    ) : void;

    /**
    * Checks if a type correctly defines it's own id.
    *
    * @param DaftObject $object
    *
    * @throws TypeError if $object::DaftObjectIdProperties() does not contain at least one property
    * @throws TypeError if $object::DaftObjectIdProperties() is not string[]
    * @throws UndefinedPropertyException if an id property is not in $object::DaftObjectIdProperties()
    */
    final protected static function CheckTypeDefinesOwnIdProperties(
        DaftObject $object
    ) : bool {
        static $checkedTypes = [];

        if (false === isset($checkedTypes[get_class($object)])) {
            $checkedTypes[get_class($object)] = false;

            if (false === ($object instanceof DefinesOwnIdPropertiesInterface)) {
                throw new IncorrectlyImplementedTypeError(
                    get_class($object) .
                    ' does not implement ' .
                    DefinesOwnIdPropertiesInterface::class
                );
            }

            /**
            * @var DefinesOwnIdPropertiesInterface $object
            */
            $object = $object;


            $properties = $object::DaftObjectIdProperties();

            if (count($properties) < 1) {
                throw new IncorrectlyImplementedTypeError(
                    get_class($object) .
                    '::DaftObjectIdProperties() must return at least one' .
                    ' property'
                );
            }

            foreach ($properties as $property) {
                if (false === is_string($property)) {
                    throw new IncorrectlyImplementedTypeError(
                        get_class($object) .
                        '::DaftObjectIdProperties() does not return string[]'
                    );
                } elseif (
                    false === in_array(
                        $property,
                        $object::DaftObjectProperties(),
                        true
                    )
                ) {
                    throw new UndefinedPropertyException(
                        get_class($object),
                        $property
                    );
                }
            }

            $checkedTypes[get_class($object)] = true;
        }

        return $checkedTypes[get_class($object)];
    }
}


1			<?php
2			/**
3			* Base daft objects.
4			*
5			* @author SignpostMarv
6			*/
7			declare(strict_types=1);
8
9			namespace SignpostMarv\DaftObject;
10
11			use TypeError;
12
13			/**
14			* Base daft object.
15			*/
16			abstract class AbstractDaftObject implements DaftObject
17			{
18			/**
19			* List of properties that can be defined on an implementation.
20			*
21			* @var string[]
22			*/
23			const PROPERTIES = [];
24
25			/**
26			* List of nullable properties that can be defined on an implementation.
27			*
28			* @var string[]
29			*/
30			const NULLABLE_PROPERTIES = [];
31
32			/**
33			* Index of checked types.
34			*
35			* @see self::CheckTypeDefinesOwnIdProperties()
36			*
37			* @var bool[]
38			*/
39			private static $checkedTypes = [];
40
41			/**
42			* Does some sanity checking.
43			*
44			* @see DefinesOwnIdPropertiesInterface
45			* @see self::CheckTypeDefinesOwnIdProperties()
46			*
47			* @throws TypeError if static::class was previously determined to be incorrectly implemented
48			*/
49	40		public function __construct()
50			{
51			if (
52	40		($this instanceof DefinesOwnIdPropertiesInterface) &&
53	32		false === self::CheckTypeDefinesOwnIdProperties($this)
54			) {
55	1		throw new IncorrectlyImplementedTypeError(
56	1		get_class($this) . // phpunit coverage does not pick up static::class here
57	1		' already determined to be incorrectly implemented'
58			);
59			}
60	37		}
61
62			/**
63			* Maps param $property to the getter method.
64			*
65			* @param string $property the property being retrieved
66			*
67			* @throws UndefinedPropertyException if a property is undefined
68			*
69			* @return mixed
70			*/
71	26	View Code Duplication	public function __get(string $property)
72			{
73	26		$expectedMethod = 'Get' . ucfirst($property);
74	26		if (true !== method_exists($this, $expectedMethod)) {
75	1		throw new UndefinedPropertyException(static::class, $property);
76			}
77
78	25		return $this->$expectedMethod();
79			}
80
81			/**
82			* Maps param $property to the getter method.
83			*
84			* @param string $property the property being retrieved
85			* @param mixed $v
86			*
87			* @throws UndefinedPropertyException if a property is undefined
88			*
89			* @return mixed
90			*/
91	13	View Code Duplication	public function __set(string $property, $v)
92			{
93	13		$expectedMethod = 'Set' . ucfirst($property);
94			if (
95	13		true !== method_exists($this, $expectedMethod)
96			) {
97	1		throw new PropertyNotWriteableException(static::class, $property);
98			}
99
100	12		return $this->$expectedMethod($v);
101			}
102
103			/**
104			* required to support unset($foo->bar).
105			*
106			* @param string $property the property being unset
107			*
108			* @see static::NudgePropertyValue()
109			*/
110	8		public function __unset(string $property) : void
111			{
112	8		$this->NudgePropertyValue($property, null);
113	6		}
114
115			/**
116			* List of properties that can be defined on an implementation.
117			*
118			* @return string[]
119			*/
120	6		final public static function DaftObjectProperties() : array
121			{
122	6		return static::PROPERTIES;
123			}
124
125			/**
126			* List of nullable properties that can be defined on an implementation.
127			*
128			* @return string[]
129			*/
130	9		final public static function DaftObjectNullableProperties() : array
131			{
132	9		return static::NULLABLE_PROPERTIES;
133			}
134
135			/**
136			* Nudge the state of a given property, marking it as dirty.
137			*
138			* @param string $property property being nudged
139			* @param mixed $value value to nudge property with
140			*
141			* @throws UndefinedPropertyException if $property is not in static::DaftObjectProperties()
142			* @throws PropertyNotNullableException if $property is not in static::DaftObjectNullableProperties()
143			*/
144			abstract protected function NudgePropertyValue(
145			string $property,
146			$value
147			) : void;
148
149			/**
150			* Checks if a type correctly defines it's own id.
151			*
152			* @param DaftObject $object
153			*
154			* @throws TypeError if $object::DaftObjectIdProperties() does not contain at least one property
155			* @throws TypeError if $object::DaftObjectIdProperties() is not string[]
156			* @throws UndefinedPropertyException if an id property is not in $object::DaftObjectIdProperties()
157			*/
158	33		final protected static function CheckTypeDefinesOwnIdProperties(
159			DaftObject $object
160			) : bool {
161	33		static $checkedTypes = [];
162
163	33		if (false === isset($checkedTypes[get_class($object)])) {
164	8		$checkedTypes[get_class($object)] = false;
165
166	8		if (false === ($object instanceof DefinesOwnIdPropertiesInterface)) {
167	1		throw new IncorrectlyImplementedTypeError(
168	1		get_class($object) .
169			' does not implement ' .
170	1		DefinesOwnIdPropertiesInterface::class
171			);
172			}
173
174			/**
175			* @var DefinesOwnIdPropertiesInterface $object
176			*/
177	7		$object = $object;
			0 ignored issues – show Bug introduced 2017-09-16 08:53 UTC by Report Bug Copy Issue Report Why assign `$object` to itself? This checks looks for cases where a variable has been assigned to itself. This assignement can be removed without consequences. Loading history...
178
179	7		$properties = $object::DaftObjectIdProperties();
180
181	7		if (count($properties) < 1) {
182	1		throw new IncorrectlyImplementedTypeError(
183	1		get_class($object) .
184			'::DaftObjectIdProperties() must return at least one' .
185	1		' property'
186			);
187			}
188
189	6		foreach ($properties as $property) {
190	6		if (false === is_string($property)) {
191	1		throw new IncorrectlyImplementedTypeError(
192	1		get_class($object) .
193	1		'::DaftObjectIdProperties() does not return string[]'
194			);
195			} elseif (
196	5		false === in_array(
197	5		$property,
198	5		$object::DaftObjectProperties(),
199	5		true
200			)
201			) {
202			throw new UndefinedPropertyException(
203			get_class($object),
204			$property
205			);
206			}
207			}
208
209	5		$checkedTypes[get_class($object)] = true;
210			}
211
212	30		return $checkedTypes[get_class($object)];
213			}
214			}
215

SignpostMarv / daft-object

GitHub Access Token became invalid

Push — master ( 4b315b...f1f5b9 )

CheckTypeDefinesOwnIdProperties() B

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like