AbstractArrayBackedDaftObject::DaftObjectFromJsonTypeArray() - Code Metrics - Inspection of "avoid calling array_keys()" - SignpostMarv/daft-object - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 064842...663d76 )

by SignpostMarv

created 2017-10-08 11:47 UTC

DaftObjectFromJsonTypeArray() B

↳ Parent: AbstractArrayBackedDaftObject

Complexity

Conditions	3
Paths	2

Size

Total Lines	25
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	10
CRAP Score	3.1105

Importance

Changes

Metric	Value
dl	0
loc	25
ccs	10
cts	13
cp	0.7692
rs	8.8571
c	0
b	0
f	0
cc	3
eloc	12
nc	2
nop	4
crap	3.1105

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

        $out = new static($in, $writeAll);

        if ( ! ($out instanceof DaftJson)) { // here to trick phpstan
            exit;
        }

        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
    {
        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
            );
        }

        $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	22		final public static function DaftObjectFromJsonArray(
132			array $array,
133			bool $writeAll = false
134			) : DaftJson {
135	22		static::ThrowIfNotDaftJson();
136	6		$array = static::ThrowIfJsonDefNotValid($array);
137	6		$in = [];
138
139	6		$jsonDef = static::DaftObjectJsonProperties();
140
141	6		foreach (array_keys($array) as $prop) {
142	6		if (isset($jsonDef[$prop])) {
143	3		$jsonType = $jsonDef[$prop];
144
145	3		if ('[]' === mb_substr($jsonType, -2)) {
146	1		$in[$prop] = static::DaftObjectFromJsonTypeArray(
147	1		mb_substr($jsonType, 0, -2),
148	1		$prop,
149	1		$array[$prop],
150	1		$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	6		$out = new static($in, $writeAll);
165
166	6		if ( ! ($out instanceof DaftJson)) { // here to trick phpstan
167			exit;
168			}
169
170	6		return $out;
171			}
172
173	22		public static function DaftObjectFromJsonString(string $string) : DaftJson
174			{
175	22		static::ThrowIfNotDaftJson();
176
177	6		return static::DaftObjectFromJsonArray(json_decode($string, true));
178			}
179
180			/**
181			* @param mixed $propVal
182			*
183			* @return DaftJson
184			*/
185	2		protected static function DaftObjectFromJsonType(
186			string $jsonType,
187			array $propVal,
188			bool $writeAll
189			) {
190	2		static::ThrowIfNotJsonType($jsonType);
191
192	2		return static::ArrayToJsonType($jsonType, $propVal, $writeAll);
193			}
194
195			/**
196			* @return DaftJson[]
197			*/
198	1		protected static function DaftObjectFromJsonTypeArray(
199			string $jsonType,
200			string $prop,
201			array $propVal,
202			bool $writeAll
203			) : array {
204	1		static::ThrowIfNotJsonType($jsonType);
205
206	1		$out = [];
207
208	1		foreach ($propVal as $val) {
209	1		if (false === is_array($val)) {
210			throw new PropertyNotJsonDecodableShouldBeArrayException(
211			$jsonType,
212			$prop
213			);
214			}
215	1		$out[] = static::ArrayToJsonType(
216	1		$jsonType,
217	1		$val,
218	1		$writeAll
219			);
220			}
221
222	1		return $out;
223			}
224
225			/**
226			* Retrieve a property from data.
227			*
228			* @param string $property the property being retrieved
229			*
230			* @throws PropertyNotNullableException if value is not set and $property is not listed as nullabe
231			*
232			* @return mixed the property value
233			*/
234	44		protected function RetrievePropertyValueFromData(string $property)
235			{
236			if (
237	44		false === array_key_exists($property, $this->data) &&
238	5		false === in_array($property, static::NULLABLE_PROPERTIES, true)
239			) {
240	1		throw new PropertyNotNullableException(static::class, $property);
241			} elseif (
242	43		in_array($property, static::NULLABLE_PROPERTIES, true)
243			) {
244	33		return $this->data[$property] ?? null;
245			}
246
247	43		return $this->data[$property];
248			}
249
250			/**
251			* {@inheritdoc}
252			*/
253	134		protected function NudgePropertyValue(string $property, $value) : void
254			{
255	134		if (true !== in_array($property, static::PROPERTIES, true)) {
256	1		throw new UndefinedPropertyException(static::class, $property);
257			} elseif (
258	133		true === is_null($value) &&
259	88		true !== in_array($property, static::NULLABLE_PROPERTIES, true)
260			) {
261	58		throw new PropertyNotNullableException(static::class, $property);
262			} elseif (
263	75		$this instanceof DaftObjectWorm &&
264			(
265	50		$this->HasPropertyChanged($property) \|\|
266			(
267	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...
268	2		true === $this->wormProperties[$property]
269			)
270			)
271			) {
272	50		throw new PropertyNotRewriteableException(
273	50		static::class,
274	50		$property
275			);
276			}
277
278			$isChanged = (
279	75		false === array_key_exists($property, $this->data) \|\|
280	75		$this->data[$property] !== $value
281			);
282
283	75		$this->data[$property] = $value;
284
285	75		if ($isChanged && true !== isset($this->changedProperties[$property])) {
286	75		$this->changedProperties[$property] = true;
287	75		$this->wormProperties[$property] = true;
288			}
289	75		}
290
291	6		private static function ThrowIfJsonDefNotValid(array $array) : array
292			{
293	6		$jsonProps = [];
294
295	6		$jsonDef = static::DaftObjectJsonProperties();
296	6		$nullableProps = static::DaftObjectNullableProperties();
297
298	6		foreach ($jsonDef as $k => $v) {
299	6		$prop = $v;
300	6		if (is_string($k)) {
301	3		$prop = $k;
302			}
303			if (
304			(
305	6		false === isset($array[$prop]) \|\|
306	6		is_null($array[$prop])
307			) &&
308	2		false === in_array($prop, $nullableProps, true)
309			) {
310			throw new PropertyNotNullableException(static::class, $prop);
311			}
312
313	6		$jsonProps[] = $prop;
314			}
315
316	6		$out = [];
317
318	6		foreach ($array as $prop => $propVal) {
319			if (
320	6		false === in_array($prop, $jsonProps, true)
321			) {
322			throw new PropertyNotJsonDecodableException(
323			static::class,
324			$prop
325			);
326	6		} elseif (false === is_null($propVal)) {
327	6		if (isset($jsonDef[$prop])) {
328	3		$jsonType = $jsonDef[$prop];
329
330	3		if (false === is_array($propVal)) {
331			if ('[]' === mb_substr($jsonType, -2)) {
332			throw new PropertyNotJsonDecodableShouldBeArrayException(
333			static::class,
334			$prop
335			);
336			}
337			throw new PropertyNotJsonDecodableShouldBeArrayException(
338			$jsonType,
339			$prop
340			);
341			}
342			}
343	6		$out[$prop] = $propVal;
344			}
345			}
346
347	6		return $out;
348			}
349
350	3		private static function ThrowIfNotJsonType(string $jsonType) : void
351			{
352	3		if (false === is_a($jsonType, DaftJson::class, true)) {
353			throw new ClassDoesNotImplementClassException(
354			$jsonType,
355			DaftJson::class
356			);
357			}
358	3		}
359
360	3		private static function ArrayToJsonType(
361			string $jsonType,
362			array $propVal,
363			bool $writeAll
364			) : DaftJson {
365			/**
366			* @var DaftJson $jsonType
367			*/
368	3		$jsonType = $jsonType;
369
370	3		return $jsonType::DaftObjectFromJsonArray(
371	3		$propVal,
372	3		$writeAll
373			);
374			}
375
376	54	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...
377			{
378	54		if (false === is_a(static::class, DaftJson::class, true)) {
379	48		throw new DaftObjectNotDaftJsonBadMethodCallException(
380	48		static::class
381			);
382			}
383	6		}
384			}
385

SignpostMarv / daft-object

GitHub Access Token became invalid

Push — master ( 064842...663d76 )

DaftObjectFromJsonTypeArray() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like