Data::_hydrate() - Code Metrics - hfw/asana - Measure and Improve Code Quality continuously with Scrutinizer

Data::_hydrate() A
last analyzed 2020-11-23 04:28 UTC

↳ Parent: Data

Complexity

Conditions	5
Paths	4

Size

Total Lines	15
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	5
eloc	8
nc	4
nop	2
dl	0
loc	15
rs	9.6111
c	0
b	0
f	0

<?php

namespace Helix\Asana\Base;

use Helix\Asana\Api;
use JsonSerializable;
use Serializable;

/**
 * A data object with support for annotated magic methods.
 */
class Data implements JsonSerializable, Serializable {

    /**
     * Sub-element hydration specs.
     *
     * - `field => class` for a nullable instance
     * - `field => [class]` for an array of instances
     *
     * The classes specified here should be the field's base class (identity) from this library.
     *
     * Do not use this to map to extensions. Extend and override {@link Api::factory()} to do that.
     *
     * @see _setField()
     *
     * @var array
     */
    protected const MAP = [];

    /**
     * @var Api
     */
    protected $api;

    /**
     * @var array|Data[]|AbstractEntity[]
     */
    protected $data = [];

    /**
     * @var bool[]
     */
    protected $diff = [];

    /**
     * @param Api|Data $caller
     * @param array $data
     */
    public function __construct ($caller, array $data = []) {
        if ($caller instanceof self) {
            $this->api = $caller->api;
        }
        else {
            assert($caller instanceof Api);
            /** @var Api $caller */
            $this->api = $caller;
        }
        $this->_setData($data);
    }

    /**
     * Magic method handler.
     *
     * @see _get()
     * @see _has()
     * @see _is()
     * @see _select()
     * @see _set()
     *
     * @param string $method
     * @param array $args
     * @return mixed
     */
    public function __call (string $method, array $args) {
        static $magic = [];
        if (!$call =& $magic[$method]) {
            preg_match('/^(get|has|is|select|set)(.+)$/', $method, $call);
            if ('_select' !== $call[1] = '_' . $call[1]) { // _select() calls getters
                $call[2] = preg_replace_callback('/[A-Z]/', function(array $match) {
                    return '_' . strtolower($match[0]);
                }, lcfirst($call[2]));
            }
        }
        return $this->{$call[1]}($call[2], ...$args);
    }

    /**
     * @return array
     * @internal pool, `var_export()`
     */
    final public function __debugInfo (): array {
        return $this->data;
    }

    /**
     * @param $field
     * @return null|Data|mixed
     * @internal for `array_column()`
     */
    final public function __get ($field) {
        return $this->_get($field);
    }

    /**
     * @param $field
     * @return bool
     * @internal for `array_column()`
     */
    final public function __isset ($field) {
        return true; // fields may be lazy-loaded or coalesced to null.
    }

    /**
     * Magic method: `getField()`
     *
     * @see __call()
     *
     * @param string $field
     * @return mixed
     */
    protected function _get (string $field) {
        return $this->data[$field] ?? null;
    }

    /**
     * Magic method: `hasField()`
     *
     * Whether a countable field has anything in it,
     * or casts a scalar field to boolean.
     *
     * @see __call()
     *
     * @param string $field
     * @return bool
     */
    protected function _has (string $field): bool {
        $value = $this->_get($field);
        if (isset($value)) {
            if (is_countable($value)) {
                return count($value) > 0;
            }
            return (bool)$value;
        }
        return false;
    }

    /**
     * A factory that also hydrates / caches entities.
     *
     * @param string $class
     * @param mixed $item
     * @return mixed
     */
    protected function _hydrate (string $class, $item) {
        if (!isset($item) or $item instanceof self) {
            return $item;
        }
        // hydrate entities
        if (is_subclass_of($class, AbstractEntity::class)) {
            if (is_string($item)) { // convert gids to lazy stubs
                $item = ['gid' => $item];
            }
            return $this->api->getPool()->get($item['gid'], $this, function() use ($class, $item) {
                return $this->api->factory($this, $class, $item);
            });
        }
        // hydrate simple
        return $this->api->factory($this, $class, $item);
    }

    /**
     * Magic method: `isField()`
     *
     * Boolean casts a scalar field.
     *
     * Do not use this for countable fields, use `hasField()` instead.
     *
     * @see __call()
     *
     * @param string $field
     * @return bool
     */
    protected function _is (string $field): bool {
        return (bool)$this->_get($field);
    }

    /**
     * Magic method: `selectField(callable $filter)`
     *
     * Where `Field` has an accessor at `getField()`, either real or magic.
     *
     * This can also be used to select from an arbitrary iterable.
     *
     * @see __call()
     *
     * @param string|iterable $subject
     * @param callable $filter `fn( Data $object ): bool`
     * @param array $args
     * @return array
     */
    protected function _select ($subject, callable $filter, ...$args) {
        if (is_string($subject)) {
            $subject = $this->{'get' . $subject}(...$args) ?? [];
        }
        $selected = [];
        foreach ($subject as $item) {
            if (call_user_func($filter, $item)) {
                $selected[] = $item;
            }
        }
        return $selected;
    }

    /**
     * Magic method: `setField(mixed $value)`
     *
     * @see __call()
     *
     * @param string $field
     * @param mixed $value
     * @return $this
     */
    protected function _set (string $field, $value) {
        $this->data[$field] = $value;
        $this->diff[$field] = true;
        return $this;
    }

    /**
     * Clears all diffs and sets all data, hydrating mapped fields.
     *
     * @param array $data
     */
    protected function _setData (array $data): void {
        $this->data = $this->diff = [];
        foreach ($data as $field => $value) {
            $this->_setField($field, $value);
        }
    }

    /**
     * Sets a value, hydrating if mapped, and clears the diff.
     *
     * @param string $field
     * @param mixed $value
     */
    protected function _setField (string $field, $value): void {
        if (isset(static::MAP[$field])) {
            $class = static::MAP[$field];
            if (is_array($class)) {
                $value = array_map(function($each) use ($class) {
                    return $this->_hydrate($class[0], $each);
                }, $value);
            }
            elseif (isset($value)) {
                $value = $this->_hydrate($class, $value);
            }
        }
        $this->data[$field] = $value;
        unset($this->diff[$field]);
    }

    /**
     * Whether the instance has changes.
     *
     * @return bool
     */
    final public function isDiff (): bool {
        return (bool)$this->diff;
    }

    /**
     * @return array
     */
    public function jsonSerialize (): array {
        $data = $this->toArray();
        ksort($data);
        return $data;
    }

    /**
     * Dehydrated JSON encode.
     *
     * @return string
     */
    public function serialize (): string {
        return json_encode($this, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE);
    }

    /**
     * Dehydrated data.
     *
     * @param bool $diff
     * @return array
     */
    public function toArray (bool $diff = false): array {
        $dehydrate = function($each) use (&$dehydrate, $diff) {
            // convert entities to gids
            if ($each instanceof AbstractEntity and $each->hasGid()) {
                return $each->getGid();
            }
            // convert other data to arrays.
            elseif ($each instanceof self) {
                return $each->toArray($diff);
            }
            // dehydrate normal arrays.
            elseif (is_array($each)) {
                return array_map($dehydrate, $each);
            }
            // return as-is
            return $each;
        };
        if ($diff) {
            return array_map($dehydrate, array_intersect_key($this->data, $this->diff));
        }
        return array_map($dehydrate, $this->data);
    }

    /**
     * @param $serialized
     */
    public function unserialize ($serialized): void {
        $this->data = json_decode($serialized, true);
    }
}

1			<?php
2
3			namespace Helix\Asana\Base;
4
5			use Helix\Asana\Api;
6			use JsonSerializable;
7			use Serializable;
8
9			/**
10			* A data object with support for annotated magic methods.
11			*/
12			class Data implements JsonSerializable, Serializable {
13
14			/**
15			* Sub-element hydration specs.
16			*
17			* - `field => class` for a nullable instance
18			* - `field => [class]` for an array of instances
19			*
20			* The classes specified here should be the field's base class (identity) from this library.
21			*
22			* Do not use this to map to extensions. Extend and override {@link Api::factory()} to do that.
23			*
24			* @see _setField()
25			*
26			* @var array
27			*/
28			protected const MAP = [];
29
30			/**
31			* @var Api
32			*/
33			protected $api;
34
35			/**
36			* @var array\|Data[]\|AbstractEntity[]
37			*/
38			protected $data = [];
39
40			/**
41			* @var bool[]
42			*/
43			protected $diff = [];
44
45			/**
46			* @param Api\|Data $caller
47			* @param array $data
48			*/
49			public function __construct ($caller, array $data = []) {
50			if ($caller instanceof self) {
51			$this->api = $caller->api;
52			}
53			else {
54			assert($caller instanceof Api);
55			/** @var Api $caller */
56			$this->api = $caller;
57			}
58			$this->_setData($data);
59			}
60
61			/**
62			* Magic method handler.
63			*
64			* @see _get()
65			* @see _has()
66			* @see _is()
67			* @see _select()
68			* @see _set()
69			*
70			* @param string $method
71			* @param array $args
72			* @return mixed
73			*/
74			public function __call (string $method, array $args) {
75			static $magic = [];
76			if (!$call =& $magic[$method]) {
77			preg_match('/^(get\|has\|is\|select\|set)(.+)$/', $method, $call);
78			if ('_select' !== $call[1] = '_' . $call[1]) { // _select() calls getters
79			$call[2] = preg_replace_callback('/[A-Z]/', function(array $match) {
80			return '_' . strtolower($match[0]);
81			}, lcfirst($call[2]));
82			}
83			}
84			return $this->{$call[1]}($call[2], ...$args);
85			}
86
87			/**
88			* @return array
89			* @internal pool, `var_export()`
90			*/
91			final public function __debugInfo (): array {
92			return $this->data;
93			}
94
95			/**
96			* @param $field
97			* @return null\|Data\|mixed
98			* @internal for `array_column()`
99			*/
100			final public function __get ($field) {
101			return $this->_get($field);
102			}
103
104			/**
105			* @param $field
106			* @return bool
107			* @internal for `array_column()`
108			*/
109			final public function __isset ($field) {
110			return true; // fields may be lazy-loaded or coalesced to null.
111			}
112
113			/**
114			* Magic method: `getField()`
115			*
116			* @see __call()
117			*
118			* @param string $field
119			* @return mixed
120			*/
121			protected function _get (string $field) {
122			return $this->data[$field] ?? null;
123			}
124
125			/**
126			* Magic method: `hasField()`
127			*
128			* Whether a countable field has anything in it,
129			* or casts a scalar field to boolean.
130			*
131			* @see __call()
132			*
133			* @param string $field
134			* @return bool
135			*/
136			protected function _has (string $field): bool {
137			$value = $this->_get($field);
138			if (isset($value)) {
139			if (is_countable($value)) {
140			return count($value) > 0;
141			}
142			return (bool)$value;
143			}
144			return false;
145			}
146
147			/**
148			* A factory that also hydrates / caches entities.
149			*
150			* @param string $class
151			* @param mixed $item
152			* @return mixed
153			*/
154			protected function _hydrate (string $class, $item) {
155			if (!isset($item) or $item instanceof self) {
156			return $item;
157			}
158			// hydrate entities
159			if (is_subclass_of($class, AbstractEntity::class)) {
160			if (is_string($item)) { // convert gids to lazy stubs
161			$item = ['gid' => $item];
162			}
163			return $this->api->getPool()->get($item['gid'], $this, function() use ($class, $item) {
164			return $this->api->factory($this, $class, $item);
165			});
166			}
167			// hydrate simple
168			return $this->api->factory($this, $class, $item);
169			}
170
171			/**
172			* Magic method: `isField()`
173			*
174			* Boolean casts a scalar field.
175			*
176			* Do not use this for countable fields, use `hasField()` instead.
177			*
178			* @see __call()
179			*
180			* @param string $field
181			* @return bool
182			*/
183			protected function _is (string $field): bool {
184			return (bool)$this->_get($field);
185			}
186
187			/**
188			* Magic method: `selectField(callable $filter)`
189			*
190			* Where `Field` has an accessor at `getField()`, either real or magic.
191			*
192			* This can also be used to select from an arbitrary iterable.
193			*
194			* @see __call()
195			*
196			* @param string\|iterable $subject
197			* @param callable $filter `fn( Data $object ): bool`
198			* @param array $args
199			* @return array
200			*/
201			protected function _select ($subject, callable $filter, ...$args) {
202			if (is_string($subject)) {
203			$subject = $this->{'get' . $subject}(...$args) ?? [];
204			}
205			$selected = [];
206			foreach ($subject as $item) {
207			if (call_user_func($filter, $item)) {
208			$selected[] = $item;
209			}
210			}
211			return $selected;
212			}
213
214			/**
215			* Magic method: `setField(mixed $value)`
216			*
217			* @see __call()
218			*
219			* @param string $field
220			* @param mixed $value
221			* @return $this
222			*/
223			protected function _set (string $field, $value) {
224			$this->data[$field] = $value;
225			$this->diff[$field] = true;
226			return $this;
227			}
228
229			/**
230			* Clears all diffs and sets all data, hydrating mapped fields.
231			*
232			* @param array $data
233			*/
234			protected function _setData (array $data): void {
235			$this->data = $this->diff = [];
236			foreach ($data as $field => $value) {
237			$this->_setField($field, $value);
238			}
239			}
240
241			/**
242			* Sets a value, hydrating if mapped, and clears the diff.
243			*
244			* @param string $field
245			* @param mixed $value
246			*/
247			protected function _setField (string $field, $value): void {
248			if (isset(static::MAP[$field])) {
249			$class = static::MAP[$field];
250			if (is_array($class)) {
251			$value = array_map(function($each) use ($class) {
252			return $this->_hydrate($class[0], $each);
253			}, $value);
254			}
255			elseif (isset($value)) {
256			$value = $this->_hydrate($class, $value);
257			}
258			}
259			$this->data[$field] = $value;
260			unset($this->diff[$field]);
261			}
262
263			/**
264			* Whether the instance has changes.
265			*
266			* @return bool
267			*/
268			final public function isDiff (): bool {
269			return (bool)$this->diff;
270			}
271
272			/**
273			* @return array
274			*/
275			public function jsonSerialize (): array {
276			$data = $this->toArray();
277			ksort($data);
278			return $data;
279			}
280
281			/**
282			* Dehydrated JSON encode.
283			*
284			* @return string
285			*/
286			public function serialize (): string {
287			return json_encode($this, JSON_PRETTY_PRINT \| JSON_UNESCAPED_SLASHES \| JSON_UNESCAPED_UNICODE);
288			}
289
290			/**
291			* Dehydrated data.
292			*
293			* @param bool $diff
294			* @return array
295			*/
296			public function toArray (bool $diff = false): array {
297			$dehydrate = function($each) use (&$dehydrate, $diff) {
298			// convert entities to gids
299			if ($each instanceof AbstractEntity and $each->hasGid()) {
300			return $each->getGid();
301			}
302			// convert other data to arrays.
303			elseif ($each instanceof self) {
304			return $each->toArray($diff);
305			}
306			// dehydrate normal arrays.
307			elseif (is_array($each)) {
308			return array_map($dehydrate, $each);
309			}
310			// return as-is
311			return $each;
312			};
313			if ($diff) {
314			return array_map($dehydrate, array_intersect_key($this->data, $this->diff));
315			}
316			return array_map($dehydrate, $this->data);
317			}
318
319			/**
320			* @param $serialized
321			*/
322			public function unserialize ($serialized): void {
323			$this->data = json_decode($serialized, true);
324			}
325			}

hfw / asana

Data::_hydrate() A last analyzed 2020-11-23 04:28 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Data::_hydrate() A
last analyzed 2020-11-23 04:28 UTC