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

Completed

Push — master ( 47155b...fea8ac )

by SignpostMarv

created 2018-05-17 23:27 UTC

GenerateDaftObjectFromJsonArrayClosure() B

↳ Parent: AbstractArrayBackedDaftObject

Complexity

Conditions	3
Paths	1

Size

Total Lines	26
Code Lines	13

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	12
CRAP Score	3

Importance

Changes

Metric	Value
cc	3
eloc	13
nc	1
nop	2
dl	0
loc	26
ccs	12
cts	12
cp	1
crap	3
rs	8.8571
c	0
b	0
f	0

<?php
/**
* Base daft objects.
*
* @author SignpostMarv
*/
declare(strict_types=1);

namespace SignpostMarv\DaftObject;

use Closure;

/**
* Array-backed daft objects.
*/
abstract class AbstractArrayBackedDaftObject extends AbstractDaftObject implements DaftObjectCreatedByArray
{
    /**
    * data for this instance.
    *
    * @var array<string, mixed>
    */
    private $data = [];

    /**
    * List of changed properties.
    *
    * @var array<string, bool>
    */
    private $changedProperties = [];

    /**
    * List of changed properties, for write-once read-many.
    *
    * @var array<string, bool>
    */
    private $wormProperties = [];

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

    public function __isset(string $property) : bool
    {
        return
            in_array($property, static::PROPERTIES, true) &&
            isset($this->data, $this->data[$property]);
    }

    public function ChangedProperties() : array
    {
        return array_keys($this->changedProperties);
    }

    public function MakePropertiesUnchanged(string ...$properties) : void
    {
        foreach ($properties as $property) {
            unset($this->changedProperties[$property]);
        }
    }

    public function HasPropertyChanged(string $property) : bool
    {
        return
            isset($this->changedProperties[$property]) &&
            true === $this->changedProperties[$property];
    }

    public function jsonSerialize() : array
    {
        static::ThrowIfNotDaftJson();

        $out = [];

        foreach (static::DaftObjectJsonPropertyNames() as $property) {
            $val = $this->DoGetSet($property, false);

            if (false === is_null($val)) {
                $out[$property] = $val;
            }
        }

        return $out;
    }

    final public static function DaftObjectFromJsonArray(
        array $array,
        bool $writeAll = false
    ) : DaftJson {
        static::ThrowIfNotDaftJson();
        $array = static::ThrowIfJsonDefNotValid($array);
        $props = array_keys($array);
        $mapper = static::DaftJsonClosure($array, $writeAll);

        /**
        * @var DaftJson $out
        */
        $out = new static(array_combine($props, array_map($mapper, $props)), $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])
            );
    }

    final protected static function DaftJsonClosure(array $array, bool $writeAll) : Closure
    {
        $jsonDef = static::DaftObjectJsonProperties();

        return
            /**
            * @return mixed
            */
            function (string $prop) use ($array, $jsonDef, $writeAll) {
                $jsonType = $jsonDef[$prop] ?? null;

                if ( ! is_string($jsonType)) {
                    return $array[$prop];
                }

                return static::DaftJsonFromJsonType($jsonType, $prop, $array[$prop], $writeAll);
            };
    }

    /**
    * @return array<int, DaftJson>|DaftJson
    */
    final protected static function DaftJsonFromJsonType(
        string $jsonType,
        string $prop,
        array $propVal,
        bool $writeAll
    ) {
        if ('[]' === mb_substr($jsonType, -2)) {
            $jsonType = mb_substr($jsonType, 0, -2);

            return static::DaftObjectFromJsonTypeArray($jsonType, $prop, $propVal, $writeAll);
        }

        return static::DaftObjectFromJsonType($jsonType, $propVal, $writeAll);
    }

    /**
    * @param array<string, mixed> $propVal
    *
    * @return DaftJson
    */
    protected static function DaftObjectFromJsonType(string $type, array $propVal, bool $writeAll)
    {
        static::ThrowIfNotJsonType($type);

        return static::ArrayToJsonType($type, $propVal, $writeAll);
    }

    /**
    * @return array<int, 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];
    }

    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 $type, string $prop) : void
    {
        if ('[]' === mb_substr($type, -2)) {
            throw new PropertyNotJsonDecodableShouldBeArrayException(static::class, $prop);
        }
        throw new PropertyNotJsonDecodableShouldBeArrayException($type, $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 $type, array $value, bool $writeAll) : DaftJson
    {
        /**
        * @var DaftJson $type
        */
        $type = $type;

        return $type::DaftObjectFromJsonArray($value, $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		use Closure;
12
13		/**
14		* Array-backed daft objects.
15		*/
16		abstract class AbstractArrayBackedDaftObject extends AbstractDaftObject implements DaftObjectCreatedByArray
17		{
18		/**
19		* data for this instance.
20		*
21		* @var array<string, mixed>
22		*/
23		private $data = [];
24
25		/**
26		* List of changed properties.
27		*
28		* @var array<string, bool>
29		*/
30		private $changedProperties = [];
31
32		/**
33		* List of changed properties, for write-once read-many.
34		*
35		* @var array<string, bool>
36		*/
37		private $wormProperties = [];
38
39	376	public function __construct(array $data = [], bool $writeAll = false)
40		{
41	376	parent::__construct();
42
43	372	if (true === $writeAll) {
44	122	foreach ($data as $k => $v) {
45	122	$this->__set($k, $v);
46		}
47		} else {
48	254	foreach ($data as $k => $v) {
49	132	$this->data[$k] = $v;
50		}
51		}
52	368	}
53
54	62	public function __isset(string $property) : bool
55		{
56		return
57	62	in_array($property, static::PROPERTIES, true) &&
58	62	isset($this->data, $this->data[$property]);
59		}
60
61	58	public function ChangedProperties() : array
62		{
63	58	return array_keys($this->changedProperties);
64		}
65
66	66	public function MakePropertiesUnchanged(string ...$properties) : void
67		{
68	66	foreach ($properties as $property) {
69	66	unset($this->changedProperties[$property]);
70		}
71	66	}
72
73	164	public function HasPropertyChanged(string $property) : bool
74		{
75		return
76	164	isset($this->changedProperties[$property]) &&
77	164	true === $this->changedProperties[$property];
78		}
79
80	44	public function jsonSerialize() : array
81		{
82	44	static::ThrowIfNotDaftJson();
83
84	12	$out = [];
85
86	12	foreach (static::DaftObjectJsonPropertyNames() as $property) {
87	12	$val = $this->DoGetSet($property, false);
88
89	12	if (false === is_null($val)) {
90	12	$out[$property] = $val;
91		}
92		}
93
94	12	return $out;
95		}
96
97	56	final public static function DaftObjectFromJsonArray(
98		array $array,
99		bool $writeAll = false
100		) : DaftJson {
101	56	static::ThrowIfNotDaftJson();
102	24	$array = static::ThrowIfJsonDefNotValid($array);
103	18	$props = array_keys($array);
104	18	$mapper = static::DaftJsonClosure($array, $writeAll);
105
106		/**
107		* @var DaftJson $out
108		*/
109	18	$out = new static(array_combine($props, array_map($mapper, $props)), $writeAll);
110
111	14	return $out;
112		}
113
114	44	public static function DaftObjectFromJsonString(string $string) : DaftJson
115		{
116	44	static::ThrowIfNotDaftJson();
117
118	12	return static::DaftObjectFromJsonArray(json_decode($string, true));
119		}
120
121	150	public function DaftObjectWormPropertyWritten(string $property) : bool
122		{
123	150	$wormProperties = $this->wormProperties;
124
125		return
126	150	($this instanceof DaftObjectWorm) &&
127		(
128	100	$this->HasPropertyChanged($property) \|\|
129	150	false === empty($wormProperties[$property])
130		);
131		}
132
133	18	final protected static function DaftJsonClosure(array $array, bool $writeAll) : Closure
134		{
135	18	$jsonDef = static::DaftObjectJsonProperties();
136
137		return
138		/**
139		* @return mixed
140		*/
141		function (string $prop) use ($array, $jsonDef, $writeAll) {
142	16	$jsonType = $jsonDef[$prop] ?? null;
143
144	16	if ( ! is_string($jsonType)) {
145	12	return $array[$prop];
146		}
147
148	10	return static::DaftJsonFromJsonType($jsonType, $prop, $array[$prop], $writeAll);
149	18	};
150		}
151
152		/**
153		* @return array<int, DaftJson>\|DaftJson
154		*/
155	10	final protected static function DaftJsonFromJsonType(
156		string $jsonType,
157		string $prop,
158		array $propVal,
159		bool $writeAll
160		) {
161	10	if ('[]' === mb_substr($jsonType, -2)) {
162	6	$jsonType = mb_substr($jsonType, 0, -2);
163
164	6	return static::DaftObjectFromJsonTypeArray($jsonType, $prop, $propVal, $writeAll);
165		}
166
167	4	return static::DaftObjectFromJsonType($jsonType, $propVal, $writeAll);
168		}
169
170		/**
171		* @param array<string, mixed> $propVal
172		*
173		* @return DaftJson
174		*/
175	4	protected static function DaftObjectFromJsonType(string $type, array $propVal, bool $writeAll)
176		{
177	4	static::ThrowIfNotJsonType($type);
178
179	4	return static::ArrayToJsonType($type, $propVal, $writeAll);
180		}
181
182		/**
183		* @return array<int, DaftJson>
184		*/
185	6	protected static function DaftObjectFromJsonTypeArray(
186		string $jsonType,
187		string $prop,
188		array $propVal,
189		bool $writeAll
190		) : array {
191	6	static::ThrowIfNotJsonType($jsonType);
192
193	4	$out = [];
194
195	4	foreach ($propVal as $val) {
196	4	if (false === is_array($val)) {
197	2	throw new PropertyNotJsonDecodableShouldBeArrayException($jsonType, $prop);
198		}
199	2	$out[] = static::ArrayToJsonType($jsonType, $val, $writeAll);
200		}
201
202	2	return $out;
203		}
204
205		/**
206		* Retrieve a property from data.
207		*
208		* @param string $property the property being retrieved
209		*
210		* @throws PropertyNotNullableException if value is not set and $property is not listed as nullabe
211		*
212		* @return mixed the property value
213		*/
214	90	protected function RetrievePropertyValueFromData(string $property)
215		{
216		if (
217	90	false === array_key_exists($property, $this->data) &&
218	90	false === in_array($property, static::NULLABLE_PROPERTIES, true)
219		) {
220	4	throw new PropertyNotNullableException(static::class, $property);
221		} elseif (
222	86	in_array($property, static::NULLABLE_PROPERTIES, true)
223		) {
224	66	return $this->data[$property] ?? null;
225		}
226
227	86	return $this->data[$property];
228		}
229
230	268	protected function NudgePropertyValue(string $property, $value) : void
231		{
232	268	$this->MaybeThrowOnNudge($property, $value);
233
234		$isChanged = (
235	150	false === array_key_exists($property, $this->data) \|\|
236	150	$this->data[$property] !== $value
237		);
238
239	150	$this->data[$property] = $value;
240
241	150	if ($isChanged && true !== isset($this->changedProperties[$property])) {
242	150	$this->changedProperties[$property] = true;
243	150	$this->wormProperties[$property] = true;
244		}
245	150	}
246
247		/**
248		* @param mixed $value
249		*
250		* @see AbstractArrayBackedDaftObject::NudgePropertyValue()
251		*/
252	268	private function MaybeThrowOnNudge(string $property, $value) : void
253		{
254	268	if (true !== in_array($property, static::PROPERTIES, true)) {
255	2	throw new UndefinedPropertyException(static::class, $property);
256		} elseif (
257	266	true === is_null($value) &&
258	266	true !== in_array($property, static::NULLABLE_PROPERTIES, true)
259		) {
260	116	throw new PropertyNotNullableException(static::class, $property);
261	150	} elseif ($this->DaftObjectWormPropertyWritten($property)) {
262	100	throw new PropertyNotRewriteableException(static::class, $property);
263		}
264	150	}
265
266	24	private static function ThrowIfJsonDefNotValid(array $array) : array
267		{
268	24	$jsonProps = static::DaftObjectJsonPropertyNames();
269
270	24	$jsonDef = static::DaftObjectJsonProperties();
271
272	24	$out = [];
273
274	24	foreach ($array as $prop => $propVal) {
275	24	if (false === in_array($prop, $jsonProps, true)) {
276	2	throw new PropertyNotJsonDecodableException(static::class, $prop);
277	24	} elseif (false === is_null($propVal)) {
278	22	if (isset($jsonDef[$prop])) {
279	16	$jsonType = $jsonDef[$prop];
280
281	16	if (false === is_array($propVal)) {
282	4	static::ThrowBecauseArrayJsonTypeNotValid($jsonType, $prop);
283		}
284		}
285	20	$out[$prop] = $propVal;
286		}
287		}
288
289	18	return $out;
290		}
291
292	4	private static function ThrowBecauseArrayJsonTypeNotValid(string $type, string $prop) : void
293		{
294	4	if ('[]' === mb_substr($type, -2)) {
295	2	throw new PropertyNotJsonDecodableShouldBeArrayException(static::class, $prop);
296		}
297	2	throw new PropertyNotJsonDecodableShouldBeArrayException($type, $prop);
298		}
299
300	10	private static function ThrowIfNotJsonType(string $jsonType) : void
301		{
302	10	if (false === is_a($jsonType, DaftJson::class, true)) {
303	2	throw new ClassDoesNotImplementClassException($jsonType, DaftJson::class);
304		}
305	8	}
306
307	6	private static function ArrayToJsonType(string $type, array $value, bool $writeAll) : DaftJson
308		{
309		/**
310		* @var DaftJson $type
311		*/
312	6	$type = $type;
313
314	6	return $type::DaftObjectFromJsonArray($value, $writeAll);
315		}
316		}
317

SignpostMarv / daft-object

GitHub Access Token became invalid

Push — master ( 47155b...fea8ac )

GenerateDaftObjectFromJsonArrayClosure() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like