AbstractArrayBackedDaftObject::MaybeThrowOnNudge() - Code Metrics - Inspection of "reducing two checks to a single check" - SignpostMarv/daft-object - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 1f722b...57520b )

by SignpostMarv

created 2017-10-08 12:52 UTC

AbstractArrayBackedDaftObject::MaybeThrowOnNudge() B

↳ Parent: AbstractArrayBackedDaftObject

Complexity

Conditions	7
Paths	1

Size

Total Lines	19
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	12
CRAP Score	7

Importance

Changes

Metric	Value
dl	0
loc	19
ccs	12
cts	12
cp	1
rs	8.2222
c	0
b	0
f	0
cc	7
eloc	13
nc	1
nop	2
crap	7

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

namespace SignpostMarv\DaftObject;

/**
* Array-backed daft objects.
*/
abstract class AbstractArrayBackedDaftObject extends AbstractDaftObject implements DaftObjectCreatedByArray
{
    /**
    * data for this instance.
    *
    * @var array
    */
    private $data = [];

    /**
    * List of changed properties.
    *
    * @var bool[]
    */
    private $changedProperties = [];

    /**
    * List of changed properties, for write-once read-many.
    *
    * @var bool[]
    */
    private $wormProperties = [];

    /**
    * {@inheritdoc}
    */
    public function __construct(array $data = [], bool $writeAll = false)
    {
        parent::__construct();

        if (true === $writeAll) {
            foreach ($data as $k => $v) {
                $this->__set($k, $v);
            }
        } else {
            foreach ($data as $k => $v) {
                $this->data[$k] = $v;
            }
        }
    }

    /**
    * {@inheritdoc}
    */
    public function __isset(string $property) : bool
    {
        return
            in_array($property, static::PROPERTIES, true) &&
            isset($this->data, $this->data[$property]);
    }

    /**
    * {@inheritdoc}
    */
    public function ChangedProperties() : array
    {
        /**
        * @var string[] $out
        */
        $out = array_keys($this->changedProperties);

        return $out;
    }

    /**
    * {@inheritdoc}
    */
    public function MakePropertiesUnchanged(string ...$properties) : void
    {
        foreach ($properties as $property) {
            unset($this->changedProperties[$property]);
        }
    }

    /**
    * {@inheritdoc}
    */
    public function HasPropertyChanged(string $property) : bool
    {
        return
            isset($this->changedProperties[$property]) &&
            true === $this->changedProperties[$property];
    }

    /**
    * {@inheritdoc}
    */
    public function jsonSerialize() : array
    {
        static::ThrowIfNotDaftJson();

        $out = [];

        foreach (static::DaftObjectJsonProperties() as $k => $v) {
            $property = $v;
            if (is_string($k)) {
                $property = $k;
            }

            $val = $this->DoGetSet(
                $property,
                'Get' . ucfirst($property),
                PropertyNotReadableException::class,
                NotPublicGetterPropertyException::class
            );

            if (false === is_null($val)) {
                $out[$property] = $val;
            }
        }

        return $out;
    }

    /**
    * {@inheritdoc}
    */
    final public static function DaftObjectFromJsonArray(
        array $array,
        bool $writeAll = false
    ) : DaftJson {
        static::ThrowIfNotDaftJson();
        $array = static::ThrowIfJsonDefNotValid($array);
        $in = [];

        $jsonDef = static::DaftObjectJsonProperties();

        foreach (array_keys($array) as $prop) {
            if (isset($jsonDef[$prop])) {
                $jsonType = $jsonDef[$prop];

                if ('[]' === mb_substr($jsonType, -2)) {
                    $in[$prop] = static::DaftObjectFromJsonTypeArray(
                        mb_substr($jsonType, 0, -2),
                        $prop,
                        $array[$prop],
                        $writeAll
                    );
                } else {
                    $in[$prop] = static::DaftObjectFromJsonType(
                        $jsonType,
                        $array[$prop],
                        $writeAll
                    );
                }
            } else {
                $in[$prop] = $array[$prop];
            }
        }

        /**
        * @var DaftJson $out
        */
        $out = new static($in, $writeAll);

        return $out;
    }

    public static function DaftObjectFromJsonString(string $string) : DaftJson
    {
        static::ThrowIfNotDaftJson();

        return static::DaftObjectFromJsonArray(json_decode($string, true));
    }

    /**
    * @param mixed $propVal
    *
    * @return DaftJson
    */
    protected static function DaftObjectFromJsonType(
        string $jsonType,
        array $propVal,
        bool $writeAll
    ) {
        static::ThrowIfNotJsonType($jsonType);

        return static::ArrayToJsonType($jsonType, $propVal, $writeAll);
    }

    /**
    * @return DaftJson[]
    */
    protected static function DaftObjectFromJsonTypeArray(
        string $jsonType,
        string $prop,
        array $propVal,
        bool $writeAll
    ) : array {
        static::ThrowIfNotJsonType($jsonType);

        $out = [];

        foreach ($propVal as $val) {
            if (false === is_array($val)) {
                throw new PropertyNotJsonDecodableShouldBeArrayException(
                    $jsonType,
                    $prop
                );
            }
            $out[] = static::ArrayToJsonType(
                $jsonType,
                $val,
                $writeAll
            );
        }

        return $out;
    }

    /**
    * Retrieve a property from data.
    *
    * @param string $property the property being retrieved
    *
    * @throws PropertyNotNullableException if value is not set and $property is not listed as nullabe
    *
    * @return mixed the property value
    */
    protected function RetrievePropertyValueFromData(string $property)
    {
        if (
            false === array_key_exists($property, $this->data) &&
            false === in_array($property, static::NULLABLE_PROPERTIES, true)
        ) {
            throw new PropertyNotNullableException(static::class, $property);
        } elseif (
            in_array($property, static::NULLABLE_PROPERTIES, true)
        ) {
            return $this->data[$property] ?? null;
        }

        return $this->data[$property];
    }

    /**
    * {@inheritdoc}
    */
    protected function NudgePropertyValue(string $property, $value) : void
    {
        $this->MaybeThrowOnNudge($property, $value);

        $isChanged = (
            false === array_key_exists($property, $this->data) ||
            $this->data[$property] !== $value
        );

        $this->data[$property] = $value;

        if ($isChanged && true !== isset($this->changedProperties[$property])) {
            $this->changedProperties[$property] = true;
            $this->wormProperties[$property] = true;
        }
    }

    /**
    * @param mixed $value
    *
    * @see AbstractArrayBackedDaftObject::NudgePropertyValue()
    */
    private function MaybeThrowOnNudge(string $property, $value) : void
    {
        if (true !== in_array($property, static::PROPERTIES, true)) {
            throw new UndefinedPropertyException(static::class, $property);
        } elseif (
            true === is_null($value) &&
            true !== in_array($property, static::NULLABLE_PROPERTIES, true)
        ) {
            throw new PropertyNotNullableException(static::class, $property);
        } elseif (
            $this instanceof DaftObjectWorm &&
            (
                $this->HasPropertyChanged($property) ||
                false === empty($this->wormProperties[$property])

            )
        ) {
            throw new PropertyNotRewriteableException(
                static::class,
                $property
            );
        }
    }

    private static function ThrowIfJsonDefNotValid(array $array) : array
    {
        $jsonProps = [];

        $jsonDef = static::DaftObjectJsonProperties();
        $nullableProps = static::DaftObjectNullableProperties();

        foreach ($jsonDef as $k => $v) {
            $prop = $v;
            if (is_string($k)) {
                $prop = $k;
            }
            if (
                (
                    false === isset($array[$prop]) ||
                    is_null($array[$prop])
                ) &&
                false === in_array($prop, $nullableProps, true)
            ) {
                throw new PropertyNotNullableException(static::class, $prop);
            }

            $jsonProps[] = $prop;
        }

        $out = [];

        foreach ($array as $prop => $propVal) {
            if (
                false === in_array($prop, $jsonProps, true)
            ) {
                throw new PropertyNotJsonDecodableException(
                    static::class,
                    $prop
                );
            } elseif (false === is_null($propVal)) {
                if (isset($jsonDef[$prop])) {
                    $jsonType = $jsonDef[$prop];

                    if (false === is_array($propVal)) {
                        if ('[]' === mb_substr($jsonType, -2)) {
                            throw new PropertyNotJsonDecodableShouldBeArrayException(
                                static::class,
                                $prop
                            );
                        }
                        throw new PropertyNotJsonDecodableShouldBeArrayException(
                            $jsonType,
                            $prop
                        );
                    }
                }
                $out[$prop] = $propVal;
            }
        }

        return $out;
    }

    private static function ThrowIfNotJsonType(string $jsonType) : void
    {
        if (false === is_a($jsonType, DaftJson::class, true)) {
            throw new ClassDoesNotImplementClassException(
                $jsonType,
                DaftJson::class
            );
        }
    }

    private static function ArrayToJsonType(
        string $jsonType,
        array $propVal,
        bool $writeAll
    ) : DaftJson {
        /**
        * @var DaftJson $jsonType
        */
        $jsonType = $jsonType;

        return $jsonType::DaftObjectFromJsonArray(
            $propVal,
            $writeAll
        );
    }

    private static function ThrowIfNotDaftJson() : void

    {
        if (false === is_a(static::class, DaftJson::class, true)) {
            throw new DaftObjectNotDaftJsonBadMethodCallException(
                static::class
            );
        }
    }
}


1			<?php
2			/**
3			* Base daft objects.
4			*
5			* @author SignpostMarv
6			*/
7			declare(strict_types=1);
8
9			namespace SignpostMarv\DaftObject;
10
11			/**
12			* Array-backed daft objects.
13			*/
14			abstract class AbstractArrayBackedDaftObject extends AbstractDaftObject implements DaftObjectCreatedByArray
15			{
16			/**
17			* data for this instance.
18			*
19			* @var array
20			*/
21			private $data = [];
22
23			/**
24			* List of changed properties.
25			*
26			* @var bool[]
27			*/
28			private $changedProperties = [];
29
30			/**
31			* List of changed properties, for write-once read-many.
32			*
33			* @var bool[]
34			*/
35			private $wormProperties = [];
36
37			/**
38			* {@inheritdoc}
39			*/
40	189		public function __construct(array $data = [], bool $writeAll = false)
41			{
42	189		parent::__construct();
43
44	187		if (true === $writeAll) {
45	60		foreach ($data as $k => $v) {
46	60		$this->__set($k, $v);
47			}
48			} else {
49	129		foreach ($data as $k => $v) {
50	68		$this->data[$k] = $v;
51			}
52			}
53	185		}
54
55			/**
56			* {@inheritdoc}
57			*/
58	33		public function __isset(string $property) : bool
59			{
60			return
61	33		in_array($property, static::PROPERTIES, true) &&
62	33		isset($this->data, $this->data[$property]);
63			}
64
65			/**
66			* {@inheritdoc}
67			*/
68	29		public function ChangedProperties() : array
69			{
70			/**
71			* @var string[] $out
72			*/
73	29		$out = array_keys($this->changedProperties);
74
75	29		return $out;
76			}
77
78			/**
79			* {@inheritdoc}
80			*/
81	33		public function MakePropertiesUnchanged(string ...$properties) : void
82			{
83	33		foreach ($properties as $property) {
84	33		unset($this->changedProperties[$property]);
85			}
86	33		}
87
88			/**
89			* {@inheritdoc}
90			*/
91	82		public function HasPropertyChanged(string $property) : bool
92			{
93			return
94	82		isset($this->changedProperties[$property]) &&
95	82		true === $this->changedProperties[$property];
96			}
97
98			/**
99			* {@inheritdoc}
100			*/
101	22		public function jsonSerialize() : array
102			{
103	22		static::ThrowIfNotDaftJson();
104
105	6		$out = [];
106
107	6		foreach (static::DaftObjectJsonProperties() as $k => $v) {
108	6		$property = $v;
109	6		if (is_string($k)) {
110	3		$property = $k;
111			}
112
113	6		$val = $this->DoGetSet(
114	6		$property,
115	6		'Get' . ucfirst($property),
116	6		PropertyNotReadableException::class,
117	6		NotPublicGetterPropertyException::class
118			);
119
120	6		if (false === is_null($val)) {
121	6		$out[$property] = $val;
122			}
123			}
124
125	6		return $out;
126			}
127
128			/**
129			* {@inheritdoc}
130			*/
131	28		final public static function DaftObjectFromJsonArray(
132			array $array,
133			bool $writeAll = false
134			) : DaftJson {
135	28		static::ThrowIfNotDaftJson();
136	12		$array = static::ThrowIfJsonDefNotValid($array);
137	8		$in = [];
138
139	8		$jsonDef = static::DaftObjectJsonProperties();
140
141	8		foreach (array_keys($array) as $prop) {
142	8		if (isset($jsonDef[$prop])) {
143	5		$jsonType = $jsonDef[$prop];
144
145	5		if ('[]' === mb_substr($jsonType, -2)) {
146	3		$in[$prop] = static::DaftObjectFromJsonTypeArray(
147	3		mb_substr($jsonType, 0, -2),
148	3		$prop,
149	3		$array[$prop],
150	3		$writeAll
151			);
152			} else {
153	2		$in[$prop] = static::DaftObjectFromJsonType(
154	2		$jsonType,
155	2		$array[$prop],
156	2		$writeAll
157			);
158			}
159			} else {
160	6		$in[$prop] = $array[$prop];
161			}
162			}
163
164			/**
165			* @var DaftJson $out
166			*/
167	6		$out = new static($in, $writeAll);
168
169	6		return $out;
170			}
171
172	22		public static function DaftObjectFromJsonString(string $string) : DaftJson
173			{
174	22		static::ThrowIfNotDaftJson();
175
176	6		return static::DaftObjectFromJsonArray(json_decode($string, true));
177			}
178
179			/**
180			* @param mixed $propVal
181			*
182			* @return DaftJson
183			*/
184	2		protected static function DaftObjectFromJsonType(
185			string $jsonType,
186			array $propVal,
187			bool $writeAll
188			) {
189	2		static::ThrowIfNotJsonType($jsonType);
190
191	2		return static::ArrayToJsonType($jsonType, $propVal, $writeAll);
192			}
193
194			/**
195			* @return DaftJson[]
196			*/
197	3		protected static function DaftObjectFromJsonTypeArray(
198			string $jsonType,
199			string $prop,
200			array $propVal,
201			bool $writeAll
202			) : array {
203	3		static::ThrowIfNotJsonType($jsonType);
204
205	2		$out = [];
206
207	2		foreach ($propVal as $val) {
208	2		if (false === is_array($val)) {
209	1		throw new PropertyNotJsonDecodableShouldBeArrayException(
210	1		$jsonType,
211	1		$prop
212			);
213			}
214	1		$out[] = static::ArrayToJsonType(
215	1		$jsonType,
216	1		$val,
217	1		$writeAll
218			);
219			}
220
221	1		return $out;
222			}
223
224			/**
225			* Retrieve a property from data.
226			*
227			* @param string $property the property being retrieved
228			*
229			* @throws PropertyNotNullableException if value is not set and $property is not listed as nullabe
230			*
231			* @return mixed the property value
232			*/
233	44		protected function RetrievePropertyValueFromData(string $property)
234			{
235			if (
236	44		false === array_key_exists($property, $this->data) &&
237	5		false === in_array($property, static::NULLABLE_PROPERTIES, true)
238			) {
239	1		throw new PropertyNotNullableException(static::class, $property);
240			} elseif (
241	43		in_array($property, static::NULLABLE_PROPERTIES, true)
242			) {
243	33		return $this->data[$property] ?? null;
244			}
245
246	43		return $this->data[$property];
247			}
248
249			/**
250			* {@inheritdoc}
251			*/
252	134		protected function NudgePropertyValue(string $property, $value) : void
253			{
254	134		$this->MaybeThrowOnNudge($property, $value);
255
256			$isChanged = (
257	75		false === array_key_exists($property, $this->data) \|\|
258	75		$this->data[$property] !== $value
259			);
260
261	75		$this->data[$property] = $value;
262
263	75		if ($isChanged && true !== isset($this->changedProperties[$property])) {
264	75		$this->changedProperties[$property] = true;
265	75		$this->wormProperties[$property] = true;
266			}
267	75		}
268
269			/**
270			* @param mixed $value
271			*
272			* @see AbstractArrayBackedDaftObject::NudgePropertyValue()
273			*/
274	134		private function MaybeThrowOnNudge(string $property, $value) : void
275			{
276	134		if (true !== in_array($property, static::PROPERTIES, true)) {
277	1		throw new UndefinedPropertyException(static::class, $property);
278			} elseif (
279	133		true === is_null($value) &&
280	88		true !== in_array($property, static::NULLABLE_PROPERTIES, true)
281			) {
282	58		throw new PropertyNotNullableException(static::class, $property);
283			} elseif (
284	75		$this instanceof DaftObjectWorm &&
285			(
286	50		$this->HasPropertyChanged($property) \|\|
287	50		false === empty($this->wormProperties[$property])
			0 ignored issues – show Bug Best Practice introduced 2017-10-08 12:54 UTC by Report Bug Copy Issue Report The property `wormProperties` does not exist on `SignpostMarv\DaftObject\DaftObjectWorm`. Since you implemented `__get`, consider adding a @property annotation. Loading history...
288			)
289			) {
290	50		throw new PropertyNotRewriteableException(
291	50		static::class,
292	50		$property
293			);
294			}
295	75		}
296
297	12		private static function ThrowIfJsonDefNotValid(array $array) : array
298			{
299	12		$jsonProps = [];
300
301	12		$jsonDef = static::DaftObjectJsonProperties();
302	12		$nullableProps = static::DaftObjectNullableProperties();
303
304	12		foreach ($jsonDef as $k => $v) {
305	12		$prop = $v;
306	12		if (is_string($k)) {
307	9		$prop = $k;
308			}
309			if (
310			(
311	12		false === isset($array[$prop]) \|\|
312	11		is_null($array[$prop])
313			) &&
314	3		false === in_array($prop, $nullableProps, true)
315			) {
316	1		throw new PropertyNotNullableException(static::class, $prop);
317			}
318
319	11		$jsonProps[] = $prop;
320			}
321
322	11		$out = [];
323
324	11		foreach ($array as $prop => $propVal) {
325			if (
326	11		false === in_array($prop, $jsonProps, true)
327			) {
328	1		throw new PropertyNotJsonDecodableException(
329	1		static::class,
330	1		$prop
331			);
332	11		} elseif (false === is_null($propVal)) {
333	11		if (isset($jsonDef[$prop])) {
334	8		$jsonType = $jsonDef[$prop];
335
336	8		if (false === is_array($propVal)) {
337	2		if ('[]' === mb_substr($jsonType, -2)) {
338	1		throw new PropertyNotJsonDecodableShouldBeArrayException(
339	1		static::class,
340	1		$prop
341			);
342			}
343	1		throw new PropertyNotJsonDecodableShouldBeArrayException(
344	1		$jsonType,
345	1		$prop
346			);
347			}
348			}
349	9		$out[$prop] = $propVal;
350			}
351			}
352
353	8		return $out;
354			}
355
356	5		private static function ThrowIfNotJsonType(string $jsonType) : void
357			{
358	5		if (false === is_a($jsonType, DaftJson::class, true)) {
359	1		throw new ClassDoesNotImplementClassException(
360	1		$jsonType,
361	1		DaftJson::class
362			);
363			}
364	4		}
365
366	3		private static function ArrayToJsonType(
367			string $jsonType,
368			array $propVal,
369			bool $writeAll
370			) : DaftJson {
371			/**
372			* @var DaftJson $jsonType
373			*/
374	3		$jsonType = $jsonType;
375
376	3		return $jsonType::DaftObjectFromJsonArray(
377	3		$propVal,
378	3		$writeAll
379			);
380			}
381
382	60	View Code Duplication	private static function ThrowIfNotDaftJson() : void
			0 ignored issues – show Duplication introduced 2017-10-04 21:37 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
383			{
384	60		if (false === is_a(static::class, DaftJson::class, true)) {
385	48		throw new DaftObjectNotDaftJsonBadMethodCallException(
386	48		static::class
387			);
388			}
389	12		}
390			}
391

SignpostMarv / daft-object

GitHub Access Token became invalid

Push — master ( 1f722b...57520b )

AbstractArrayBackedDaftObject::MaybeThrowOnNudge() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like