AbstractArrayBackedDaftObject::ArrayToJsonType() - Code Metrics - Inspection of "further deferring nullable property tests" - SignpostMarv/daft-object - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( ae7dcc...317cba )

by SignpostMarv

created 2017-10-08 15:46 UTC

AbstractArrayBackedDaftObject::ArrayToJsonType() A

↳ Parent: AbstractArrayBackedDaftObject

Complexity

Conditions	1
Paths	1

Size

Total Lines	13
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	1

Importance

Changes

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

<?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::DaftObjectJsonPropertyNames() as $property) {
            $val = $this->DoGetSet(
                $property,
                false,
                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));
    }

    public function DaftObjectWormPropertyWritten(string $property) : bool
    {
        $wormProperties = $this->wormProperties;

        return
            ($this instanceof DaftObjectWorm) &&
            (
                $this->HasPropertyChanged($property) ||
                false === empty($wormProperties[$property])
            );
    }

    /**
    * @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->DaftObjectWormPropertyWritten($property)) {
            throw new PropertyNotRewriteableException(
                static::class,
                $property
            );
        }
    }

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

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


        $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	188		public function __construct(array $data = [], bool $writeAll = false)
41			{
42	188		parent::__construct();
43
44	186		if (true === $writeAll) {
45	61		foreach ($data as $k => $v) {
46	61		$this->__set($k, $v);
47			}
48			} else {
49	127		foreach ($data as $k => $v) {
50	66		$this->data[$k] = $v;
51			}
52			}
53	184		}
54
55			/**
56			* {@inheritdoc}
57			*/
58	31		public function __isset(string $property) : bool
59			{
60			return
61	31		in_array($property, static::PROPERTIES, true) &&
62	31		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::DaftObjectJsonPropertyNames() as $property) {
108	6		$val = $this->DoGetSet(
109	6		$property,
110	6		false,
111	6		NotPublicGetterPropertyException::class
112			);
113
114	6		if (false === is_null($val)) {
115	6		$out[$property] = $val;
116			}
117			}
118
119	6		return $out;
120			}
121
122			/**
123			* {@inheritdoc}
124			*/
125	28		final public static function DaftObjectFromJsonArray(
126			array $array,
127			bool $writeAll = false
128			) : DaftJson {
129	28		static::ThrowIfNotDaftJson();
130	12		$array = static::ThrowIfJsonDefNotValid($array);
131	9		$in = [];
132
133	9		$jsonDef = static::DaftObjectJsonProperties();
134
135	9		foreach (array_keys($array) as $prop) {
136	8		if (isset($jsonDef[$prop])) {
137	5		$jsonType = $jsonDef[$prop];
138
139	5		if ('[]' === mb_substr($jsonType, -2)) {
140	3		$in[$prop] = static::DaftObjectFromJsonTypeArray(
141	3		mb_substr($jsonType, 0, -2),
142	3		$prop,
143	3		$array[$prop],
144	3		$writeAll
145			);
146			} else {
147	2		$in[$prop] = static::DaftObjectFromJsonType(
148	2		$jsonType,
149	2		$array[$prop],
150	2		$writeAll
151			);
152			}
153			} else {
154	6		$in[$prop] = $array[$prop];
155			}
156			}
157
158			/**
159			* @var DaftJson $out
160			*/
161	7		$out = new static($in, $writeAll);
162
163	7		return $out;
164			}
165
166	22		public static function DaftObjectFromJsonString(string $string) : DaftJson
167			{
168	22		static::ThrowIfNotDaftJson();
169
170	6		return static::DaftObjectFromJsonArray(json_decode($string, true));
171			}
172
173	75		public function DaftObjectWormPropertyWritten(string $property) : bool
174			{
175	75		$wormProperties = $this->wormProperties;
176
177			return
178	75		($this instanceof DaftObjectWorm) &&
179			(
180	50		$this->HasPropertyChanged($property) \|\|
181	75		false === empty($wormProperties[$property])
182			);
183			}
184
185			/**
186			* @param mixed $propVal
187			*
188			* @return DaftJson
189			*/
190	2		protected static function DaftObjectFromJsonType(
191			string $jsonType,
192			array $propVal,
193			bool $writeAll
194			) {
195	2		static::ThrowIfNotJsonType($jsonType);
196
197	2		return static::ArrayToJsonType($jsonType, $propVal, $writeAll);
198			}
199
200			/**
201			* @return DaftJson[]
202			*/
203	3		protected static function DaftObjectFromJsonTypeArray(
204			string $jsonType,
205			string $prop,
206			array $propVal,
207			bool $writeAll
208			) : array {
209	3		static::ThrowIfNotJsonType($jsonType);
210
211	2		$out = [];
212
213	2		foreach ($propVal as $val) {
214	2		if (false === is_array($val)) {
215	1		throw new PropertyNotJsonDecodableShouldBeArrayException(
216	1		$jsonType,
217	1		$prop
218			);
219			}
220	1		$out[] = static::ArrayToJsonType(
221	1		$jsonType,
222	1		$val,
223	1		$writeAll
224			);
225			}
226
227	1		return $out;
228			}
229
230			/**
231			* Retrieve a property from data.
232			*
233			* @param string $property the property being retrieved
234			*
235			* @throws PropertyNotNullableException if value is not set and $property is not listed as nullabe
236			*
237			* @return mixed the property value
238			*/
239	45		protected function RetrievePropertyValueFromData(string $property)
240			{
241			if (
242	45		false === array_key_exists($property, $this->data) &&
243	6		false === in_array($property, static::NULLABLE_PROPERTIES, true)
244			) {
245	2		throw new PropertyNotNullableException(static::class, $property);
246			} elseif (
247	43		in_array($property, static::NULLABLE_PROPERTIES, true)
248			) {
249	33		return $this->data[$property] ?? null;
250			}
251
252	43		return $this->data[$property];
253			}
254
255			/**
256			* {@inheritdoc}
257			*/
258	134		protected function NudgePropertyValue(string $property, $value) : void
259			{
260	134		$this->MaybeThrowOnNudge($property, $value);
261
262			$isChanged = (
263	75		false === array_key_exists($property, $this->data) \|\|
264	75		$this->data[$property] !== $value
265			);
266
267	75		$this->data[$property] = $value;
268
269	75		if ($isChanged && true !== isset($this->changedProperties[$property])) {
270	75		$this->changedProperties[$property] = true;
271	75		$this->wormProperties[$property] = true;
272			}
273	75		}
274
275			/**
276			* @param mixed $value
277			*
278			* @see AbstractArrayBackedDaftObject::NudgePropertyValue()
279			*/
280	134		private function MaybeThrowOnNudge(string $property, $value) : void
281			{
282	134		if (true !== in_array($property, static::PROPERTIES, true)) {
283	1		throw new UndefinedPropertyException(static::class, $property);
284			} elseif (
285	133		true === is_null($value) &&
286	88		true !== in_array($property, static::NULLABLE_PROPERTIES, true)
287			) {
288	58		throw new PropertyNotNullableException(static::class, $property);
289	75		} elseif ($this->DaftObjectWormPropertyWritten($property)) {
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 = static::DaftObjectJsonPropertyNames();
300
301	12		$jsonDef = static::DaftObjectJsonProperties();
302	12		$nullableProps = static::DaftObjectNullableProperties();
			0 ignored issues – show Unused Code introduced 2017-10-08 15:48 UTC by Report Bug Copy Issue Report The assignment to `$nullableProps` is dead and can be removed. Loading history...
303
304	12		$out = [];
305
306	12		foreach ($array as $prop => $propVal) {
307			if (
308	12		false === in_array($prop, $jsonProps, true)
309			) {
310	1		throw new PropertyNotJsonDecodableException(
311	1		static::class,
312	1		$prop
313			);
314	12		} elseif (false === is_null($propVal)) {
315	11		if (isset($jsonDef[$prop])) {
316	8		$jsonType = $jsonDef[$prop];
317
318	8		if (false === is_array($propVal)) {
319	2		if ('[]' === mb_substr($jsonType, -2)) {
320	1		throw new PropertyNotJsonDecodableShouldBeArrayException(
321	1		static::class,
322	1		$prop
323			);
324			}
325	1		throw new PropertyNotJsonDecodableShouldBeArrayException(
326	1		$jsonType,
327	1		$prop
328			);
329			}
330			}
331	9		$out[$prop] = $propVal;
332			}
333			}
334
335	9		return $out;
336			}
337
338	5		private static function ThrowIfNotJsonType(string $jsonType) : void
339			{
340	5		if (false === is_a($jsonType, DaftJson::class, true)) {
341	1		throw new ClassDoesNotImplementClassException(
342	1		$jsonType,
343	1		DaftJson::class
344			);
345			}
346	4		}
347
348	3		private static function ArrayToJsonType(
349			string $jsonType,
350			array $propVal,
351			bool $writeAll
352			) : DaftJson {
353			/**
354			* @var DaftJson $jsonType
355			*/
356	3		$jsonType = $jsonType;
357
358	3		return $jsonType::DaftObjectFromJsonArray(
359	3		$propVal,
360	3		$writeAll
361			);
362			}
363
364	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...
365			{
366	60		if (false === is_a(static::class, DaftJson::class, true)) {
367	48		throw new DaftObjectNotDaftJsonBadMethodCallException(
368	48		static::class
369			);
370			}
371	12		}
372			}
373

SignpostMarv / daft-object

GitHub Access Token became invalid

Push — master ( ae7dcc...317cba )

AbstractArrayBackedDaftObject::ArrayToJsonType() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like