AbstractArrayBackedDaftObject::ArrayToJsonType() - Code Metrics - Inspection of "adjusting indentation" - SignpostMarv/daft-object - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 90f6c1...b2131c )

by SignpostMarv

created 2017-10-08 10:55 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::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();

        $in = [];

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

        $jsonProps = [];

        foreach ($jsonDef as $k => $v) {
            if (is_string($k)) {
                $jsonProps[] = $k;
            } else {
                $jsonProps[] = $v;
            }
        }

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

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

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

                    $in[$prop] = static::DaftObjectFromJsonTypeArray(
                        mb_substr($jsonType, 0, -2),
                        $prop,
                        $array[$prop],
                        $writeAll
                    );
                } elseif (false === is_array($array[$prop])) {
                    throw new PropertyNotJsonDecodableShouldBeArrayException(
                        (string) $jsonType,
                        $prop
                    );
                } 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|DaftJson[]
    */
    protected static function DaftObjectFromJsonType(
        string $jsonType,
        array $propVal,
        bool $writeAll
    ) {
        static::ThrowIfNotJsonType($jsonType);

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

    }

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

SignpostMarv / daft-object

GitHub Access Token became invalid

Push — master ( 90f6c1...b2131c )

AbstractArrayBackedDaftObject::ArrayToJsonType() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like