AbstractArrayBackedDaftObject::NudgePropertyValue() - Code Metrics - Inspection of "splitting exception throwing code for nudge proper..." - SignpostMarv/daft-object - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 5e5df8...1f722b )

by SignpostMarv

created 2017-10-08 12:47 UTC

NudgePropertyValue() A

↳ Parent: AbstractArrayBackedDaftObject

Complexity

Conditions	4
Paths	4

Size

Total Lines	14
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	8
CRAP Score	4

Importance

Changes

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

<?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];
    }

    /**
    * @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) ||
                (
                    isset($this->wormProperties[$property]) &&

                    true === $this->wormProperties[$property]
                )
            )
        ) {
            throw new PropertyNotRewriteableException(
                static::class,
                $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;
        }
    }

    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			* @param mixed $value
251			*
252			* @see AbstractArrayBackedDaftObject::NudgePropertyValue()
253			*/
254	134		private function MaybeThrowOnNudge(string $property, $value) : void
255			{
256	134		if (true !== in_array($property, static::PROPERTIES, true)) {
257	1		throw new UndefinedPropertyException(static::class, $property);
258			} elseif (
259	133		true === is_null($value) &&
260	88		true !== in_array($property, static::NULLABLE_PROPERTIES, true)
261			) {
262	58		throw new PropertyNotNullableException(static::class, $property);
263			} elseif (
264	75		$this instanceof DaftObjectWorm &&
265			(
266	50		$this->HasPropertyChanged($property) \|\|
267			(
268	50		isset($this->wormProperties[$property]) &&
			0 ignored issues – show Bug Best Practice introduced 2017-09-16 09:01 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...
269	2		true === $this->wormProperties[$property]
270			)
271			)
272			) {
273	50		throw new PropertyNotRewriteableException(
274	50		static::class,
275	50		$property
276			);
277			}
278	75		}
279
280			/**
281			* {@inheritdoc}
282			*/
283	134		protected function NudgePropertyValue(string $property, $value) : void
284			{
285	134		$this->MaybeThrowOnNudge($property, $value);
286
287			$isChanged = (
288	75		false === array_key_exists($property, $this->data) \|\|
289	75		$this->data[$property] !== $value
290			);
291
292	75		$this->data[$property] = $value;
293
294	75		if ($isChanged && true !== isset($this->changedProperties[$property])) {
295	75		$this->changedProperties[$property] = true;
296	75		$this->wormProperties[$property] = true;
297			}
298	75		}
299
300	12		private static function ThrowIfJsonDefNotValid(array $array) : array
301			{
302	12		$jsonProps = [];
303
304	12		$jsonDef = static::DaftObjectJsonProperties();
305	12		$nullableProps = static::DaftObjectNullableProperties();
306
307	12		foreach ($jsonDef as $k => $v) {
308	12		$prop = $v;
309	12		if (is_string($k)) {
310	9		$prop = $k;
311			}
312			if (
313			(
314	12		false === isset($array[$prop]) \|\|
315	11		is_null($array[$prop])
316			) &&
317	3		false === in_array($prop, $nullableProps, true)
318			) {
319	1		throw new PropertyNotNullableException(static::class, $prop);
320			}
321
322	11		$jsonProps[] = $prop;
323			}
324
325	11		$out = [];
326
327	11		foreach ($array as $prop => $propVal) {
328			if (
329	11		false === in_array($prop, $jsonProps, true)
330			) {
331	1		throw new PropertyNotJsonDecodableException(
332	1		static::class,
333	1		$prop
334			);
335	11		} elseif (false === is_null($propVal)) {
336	11		if (isset($jsonDef[$prop])) {
337	8		$jsonType = $jsonDef[$prop];
338
339	8		if (false === is_array($propVal)) {
340	2		if ('[]' === mb_substr($jsonType, -2)) {
341	1		throw new PropertyNotJsonDecodableShouldBeArrayException(
342	1		static::class,
343	1		$prop
344			);
345			}
346	1		throw new PropertyNotJsonDecodableShouldBeArrayException(
347	1		$jsonType,
348	1		$prop
349			);
350			}
351			}
352	9		$out[$prop] = $propVal;
353			}
354			}
355
356	8		return $out;
357			}
358
359	5		private static function ThrowIfNotJsonType(string $jsonType) : void
360			{
361	5		if (false === is_a($jsonType, DaftJson::class, true)) {
362	1		throw new ClassDoesNotImplementClassException(
363	1		$jsonType,
364	1		DaftJson::class
365			);
366			}
367	4		}
368
369	3		private static function ArrayToJsonType(
370			string $jsonType,
371			array $propVal,
372			bool $writeAll
373			) : DaftJson {
374			/**
375			* @var DaftJson $jsonType
376			*/
377	3		$jsonType = $jsonType;
378
379	3		return $jsonType::DaftObjectFromJsonArray(
380	3		$propVal,
381	3		$writeAll
382			);
383			}
384
385	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...
386			{
387	60		if (false === is_a(static::class, DaftJson::class, true)) {
388	48		throw new DaftObjectNotDaftJsonBadMethodCallException(
389	48		static::class
390			);
391			}
392	12		}
393			}
394

SignpostMarv / daft-object

GitHub Access Token became invalid

Push — master ( 5e5df8...1f722b )

NudgePropertyValue() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like