AbstractArrayBackedDaftObject::ThrowIfNotDaftJson() - Code Metrics - Inspection of "php-cs-fixer" - SignpostMarv/daft-object - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 68f23c...d0216f )

by SignpostMarv

created 2017-10-08 17:04 UTC

AbstractArrayBackedDaftObject::ThrowIfNotDaftJson() A

↳ Parent: Project

Complexity

Conditions	2
Paths	1

Size

Total Lines	5
Code Lines	3

Duplication

Lines	5
Ratio	100 %

Code Coverage

Tests	4
CRAP Score	2

Importance

Changes

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

<?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();

        $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)) {
                        static::ThrowBecauseArrayJsonTypeNotValid(
                            $jsonType,
                            $prop
                        );
                    }
                }
                $out[$prop] = $propVal;
            }
        }

        return $out;
    }

    private static function ThrowBecauseArrayJsonTypeNotValid(
        string $jsonType,
        string $prop
    ) : void {
        if ('[]' === mb_substr($jsonType, -2)) {
            throw new PropertyNotJsonDecodableShouldBeArrayException(
                static::class,
                $prop
            );
        }
        throw new PropertyNotJsonDecodableShouldBeArrayException(
            $jsonType,
            $prop
        );
    }

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


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
303	12	$out = [];
304
305	12	foreach ($array as $prop => $propVal) {
306		if (
307	12	false === in_array($prop, $jsonProps, true)
308		) {
309	1	throw new PropertyNotJsonDecodableException(
310	1	static::class,
311	1	$prop
312		);
313	12	} elseif (false === is_null($propVal)) {
314	11	if (isset($jsonDef[$prop])) {
315	8	$jsonType = $jsonDef[$prop];
316
317	8	if (false === is_array($propVal)) {
318	2	static::ThrowBecauseArrayJsonTypeNotValid(
319	2	$jsonType,
320	2	$prop
321		);
322		}
323		}
324	9	$out[$prop] = $propVal;
325		}
326		}
327
328	9	return $out;
329		}
330
331	2	private static function ThrowBecauseArrayJsonTypeNotValid(
332		string $jsonType,
333		string $prop
334		) : void {
335	2	if ('[]' === mb_substr($jsonType, -2)) {
336	1	throw new PropertyNotJsonDecodableShouldBeArrayException(
337	1	static::class,
338	1	$prop
339		);
340		}
341	1	throw new PropertyNotJsonDecodableShouldBeArrayException(
342	1	$jsonType,
343	1	$prop
344		);
345		}
346
347	5	private static function ThrowIfNotJsonType(string $jsonType) : void
348		{
349	5	if (false === is_a($jsonType, DaftJson::class, true)) {
350	1	throw new ClassDoesNotImplementClassException(
351	1	$jsonType,
352	1	DaftJson::class
353		);
354		}
355	4	}
356
357	3	private static function ArrayToJsonType(
358		string $jsonType,
359		array $propVal,
360		bool $writeAll
361		) : DaftJson {
362		/**
363		* @var DaftJson $jsonType
364		*/
365	3	$jsonType = $jsonType;
366
367	3	return $jsonType::DaftObjectFromJsonArray(
368	3	$propVal,
369	3	$writeAll
370		);
371		}
372		}
373

SignpostMarv / daft-object

GitHub Access Token became invalid

Push — master ( 68f23c...d0216f )

AbstractArrayBackedDaftObject::ThrowIfNotDaftJson() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like