Data::getDiff() - Code Metrics - Inspection of "Data -> _getPatch() renamed to getDiff() and made..." - hfw/asana - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( 22dd1f...d25a5e )

by y

created 2020-05-06 06:05 UTC

Data::getDiff() A

↳ Parent: Data

Complexity

Conditions	5
Paths	1

Size

Total Lines	18
Code Lines	9

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	5
eloc	9
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	18
rs	9.6111

<?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 {

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

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

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

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

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

    public function __debugInfo (): array {
        return $this->data;
    }

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

    /**
     * Sub-element hydration specs.
     *
     * - `data key => class` for an instance
     * - `data key => [class]` for an array of instances
     *
     * @return array
     */
    protected function _getMap (): array {
        return [];
    }

    /**
     * @param string|string[] $class
     * @param null|self|array $value
     * @return null|Data|Data[]
     */
    protected function _getMapped ($class, $value) {
        // use empty|Data|Data[] as-is
        if (!$value or $value instanceof self or current($value) instanceof self) {
            return $value;
        }
        // hydrate
        $isArray = is_array($class);
        $class = $isArray ? $class[0] : $class;
        $hydrate = function($each) use ($class) {
            // hydrate AbstractEntity
            if (is_subclass_of($class, AbstractEntity::class)) {
                // hydrate using data[]
                if (is_array($each)) {
                    return $this->api->getCache()->get($each['gid'], $this, function() use ($class, $each) {
                        return $this->factory($class, $each);
                    });
                }
                // hydrate a stub with gid (lazy-loader)
                return $this->api->getCache()->get($each, $this, function() use ($class, $each) {
                    return $this->factory($class, ['gid' => $each]);
                });
            }
            // hydrate Data
            return $this->factory($class, $each);
        };
        return $isArray ? array_map($hydrate, $value) : $hydrate($value);
    }

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

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

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

    /**
     * Sets all data and clears the diff. Hydrates mapped fields.
     *
     * @param array $data
     * @return $this
     */
    protected function _setData (array $data) {
        $map = $this->_getMap();
        /** @var null|self|array $value */
        foreach (array_intersect_key($data, $map) as $key => $value) {
            $data[$key] = $this->_getMapped($map[$key], $value);
        }
        $this->data = $data;
        $this->diff = [];
        return $this;
    }

    /**
     * Helper, forwards to the API.
     *
     * @param string $class
     * @param array $data
     * @return mixed
     */
    final protected function factory (string $class, array $data = []) {
        return $this->api->factory($class, $this, $data);
    }

    /**
     * Constructs and returns an array for Asana using diffs.
     *
     * @return array
     */
    public function getDiff (): array {
        $convert = function($each) use (&$convert) {
            // convert existing entities to gids
            if ($each instanceof AbstractEntity and $each->hasGid()) {
                return $each->getGid();
            }
            // convert data objects and new entities to arrays
            elseif ($each instanceof self) {
                return $each->getDiff();
            }
            // convert arrays
            elseif (is_array($each)) {
                return array_map($convert, $each);
            }
            // return as-is
            return $each;
        };
        return array_map($convert, array_intersect_key($this->data, $this->diff));
    }

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

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

    /**
     * Helper, forwards to the API.
     *
     * @see Api::load()
     *
     * @param string $class
     * @param string $path
     * @param array $query
     * @return null|mixed|AbstractEntity
     */
    final protected function load (string $class, string $path, array $query = []) {
        return $this->api->load($class, $this, $path, $query);
    }

    /**
     * Helper, forwards to the API.
     *
     * @see Api::loadAll()
     *
     * @param string $class
     * @param string $path
     * @param array $query
     * @param int $pages
     * @return array|AbstractEntity[]
     */
    final protected function loadAll (string $class, string $path, array $query = [], int $pages = 0) {
        return $this->api->loadAll($class, $this, $path, $query, $pages);
    }

    /**
     * Caution: Serialization does not preserve the Api instance, and data will be dehydrated.
     *
     * The Api factory must be used to hydrate a usable instance.
     *
     * @return string
     */
    public function serialize (): string {
        return serialize($this->toArray());
    }

    /**
     * Returns the instance's data, dehydrated.
     *
     * @return array
     */
    public function toArray (): array {
        if (!$this->api) {
            return $this->data;
        }
        $dehydrate = function($each) use (&$dehydrate) {
            if ($each instanceof AbstractEntity and $each->hasGid()) {
                return $each->getGid();
            }
            elseif ($each instanceof self) {
                return $each->toArray();
            }
            elseif (is_array($each)) {
                return array_map($dehydrate, $each);
            }
            return $each;
        };
        return array_map($dehydrate, $this->data);
    }

    /**
     * Caution: Serialization does not preserve the Api instance, and data will be dehydrated.
     *
     * The Api factory must be used to construct/hydrate a usable instance.
     *
     * @param $serialized
     */
    public function unserialize ($serialized): void {
        $this->data = unserialize($serialized);
    }
}

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			* @var Api
16			*/
17			protected $api;
18
19			/**
20			* @var array\|Data[]
21			*/
22			protected $data = [];
23
24			/**
25			* @var bool[]
26			*/
27			protected $diff = [];
28
29			/**
30			* @param Api\|Data $caller
31			* @param array $data
32			*/
33			public function __construct ($caller, array $data = []) {
34			$this->api = $caller instanceof self ? $caller->api : $caller;
35			$this->_setData($data);
36			}
37
38			/**
39			* Magic method handler.
40			*
41			* @see _get()
42			* @see _has()
43			* @see _is()
44			* @see _set()
45			* @param string $method
46			* @param array $args
47			* @return mixed
48			*/
49			public function __call (string $method, array $args) {
50			static $cache = [];
51			if (!$call =& $cache[$method]) {
52			preg_match('/^(get\|has\|is\|set)(.+)$/', $method, $call);
53			$call[1] = '_' . $call[1];
54			$call[2] = preg_replace_callback('/[A-Z]/', function(array $match) {
55			return '_' . strtolower($match[0]);
56			}, lcfirst($call[2]));
57			}
58			return $this->{$call[1]}($call[2], ...$args);
59			}
60
61			public function __debugInfo (): array {
62			return $this->data;
63			}
64
65			/**
66			* Magic method: `getField()`
67			*
68			* @see __call()
69			*
70			* @param string $key
71			* @return mixed
72			*/
73			protected function _get (string $key) {
74			return $this->data[$key] ?? null;
75			}
76
77			/**
78			* Sub-element hydration specs.
79			*
80			* - `data key => class` for an instance
81			* - `data key => [class]` for an array of instances
82			*
83			* @return array
84			*/
85			protected function _getMap (): array {
86			return [];
87			}
88
89			/**
90			* @param string\|string[] $class
91			* @param null\|self\|array $value
92			* @return null\|Data\|Data[]
93			*/
94			protected function _getMapped ($class, $value) {
95			// use empty\|Data\|Data[] as-is
96			if (!$value or $value instanceof self or current($value) instanceof self) {
97			return $value;
98			}
99			// hydrate
100			$isArray = is_array($class);
101			$class = $isArray ? $class[0] : $class;
102			$hydrate = function($each) use ($class) {
103			// hydrate AbstractEntity
104			if (is_subclass_of($class, AbstractEntity::class)) {
105			// hydrate using data[]
106			if (is_array($each)) {
107			return $this->api->getCache()->get($each['gid'], $this, function() use ($class, $each) {
108			return $this->factory($class, $each);
109			});
110			}
111			// hydrate a stub with gid (lazy-loader)
112			return $this->api->getCache()->get($each, $this, function() use ($class, $each) {
113			return $this->factory($class, ['gid' => $each]);
114			});
115			}
116			// hydrate Data
117			return $this->factory($class, $each);
118			};
119			return $isArray ? array_map($hydrate, $value) : $hydrate($value);
120			}
121
122			/**
123			* Magic method: `hasField()`
124			*
125			* Whether a scalar field is set, or a countable field has anything in it.
126			*
127			* @see __call()
128			*
129			* @param string $key
130			* @return bool
131			*/
132			protected function _has (string $key): bool {
133			$value = $this->_get($key);
134			if (isset($value)) {
135			if (is_countable($value)) {
136			return count($value) > 0;
137			}
138			return true;
139			}
140			return false;
141			}
142
143			/**
144			* Magic method: `isField()`
145			*
146			* The boolean state of a scalar field.
147			*
148			* Do not use this for countable fields, use `hasField()` instead.
149			*
150			* @see __call()
151			*
152			* @param string $key
153			* @return bool
154			*/
155			protected function _is (string $key): bool {
156			return !empty($this->_get($key));
157			}
158
159			/**
160			* Magic method: `setField(mixed $value)`
161			*
162			* @see __call()
163			*
164			* @param string $key
165			* @param mixed $value
166			* @return $this
167			*/
168			protected function _set (string $key, $value) {
169			$this->data[$key] = $value;
170			$this->diff[$key] = true;
171			return $this;
172			}
173
174			/**
175			* Sets all data and clears the diff. Hydrates mapped fields.
176			*
177			* @param array $data
178			* @return $this
179			*/
180			protected function _setData (array $data) {
181			$map = $this->_getMap();
182			/** @var null\|self\|array $value */
183			foreach (array_intersect_key($data, $map) as $key => $value) {
184			$data[$key] = $this->_getMapped($map[$key], $value);
185			}
186			$this->data = $data;
187			$this->diff = [];
188			return $this;
189			}
190
191			/**
192			* Helper, forwards to the API.
193			*
194			* @param string $class
195			* @param array $data
196			* @return mixed
197			*/
198			final protected function factory (string $class, array $data = []) {
199			return $this->api->factory($class, $this, $data);
200			}
201
202			/**
203			* Constructs and returns an array for Asana using diffs.
204			*
205			* @return array
206			*/
207			public function getDiff (): array {
208			$convert = function($each) use (&$convert) {
209			// convert existing entities to gids
210			if ($each instanceof AbstractEntity and $each->hasGid()) {
211			return $each->getGid();
212			}
213			// convert data objects and new entities to arrays
214			elseif ($each instanceof self) {
215			return $each->getDiff();
216			}
217			// convert arrays
218			elseif (is_array($each)) {
219			return array_map($convert, $each);
220			}
221			// return as-is
222			return $each;
223			};
224			return array_map($convert, array_intersect_key($this->data, $this->diff));
225			}
226
227			/**
228			* Whether the instance has changes.
229			*
230			* @return bool
231			*/
232			final public function isDiff (): bool {
233			return (bool)$this->diff;
234			}
235
236			/**
237			* @see toArray()
238			* @return array
239			*/
240			public function jsonSerialize (): array {
241			return $this->toArray();
242			}
243
244			/**
245			* Helper, forwards to the API.
246			*
247			* @see Api::load()
248			*
249			* @param string $class
250			* @param string $path
251			* @param array $query
252			* @return null\|mixed\|AbstractEntity
253			*/
254			final protected function load (string $class, string $path, array $query = []) {
255			return $this->api->load($class, $this, $path, $query);
256			}
257
258			/**
259			* Helper, forwards to the API.
260			*
261			* @see Api::loadAll()
262			*
263			* @param string $class
264			* @param string $path
265			* @param array $query
266			* @param int $pages
267			* @return array\|AbstractEntity[]
268			*/
269			final protected function loadAll (string $class, string $path, array $query = [], int $pages = 0) {
270			return $this->api->loadAll($class, $this, $path, $query, $pages);
271			}
272
273			/**
274			* Caution: Serialization does not preserve the Api instance, and data will be dehydrated.
275			*
276			* The Api factory must be used to hydrate a usable instance.
277			*
278			* @return string
279			*/
280			public function serialize (): string {
281			return serialize($this->toArray());
282			}
283
284			/**
285			* Returns the instance's data, dehydrated.
286			*
287			* @return array
288			*/
289			public function toArray (): array {
290			if (!$this->api) {
291			return $this->data;
292			}
293			$dehydrate = function($each) use (&$dehydrate) {
294			if ($each instanceof AbstractEntity and $each->hasGid()) {
295			return $each->getGid();
296			}
297			elseif ($each instanceof self) {
298			return $each->toArray();
299			}
300			elseif (is_array($each)) {
301			return array_map($dehydrate, $each);
302			}
303			return $each;
304			};
305			return array_map($dehydrate, $this->data);
306			}
307
308			/**
309			* Caution: Serialization does not preserve the Api instance, and data will be dehydrated.
310			*
311			* The Api factory must be used to construct/hydrate a usable instance.
312			*
313			* @param $serialized
314			*/
315			public function unserialize ($serialized): void {
316			$this->data = unserialize($serialized);
317			}
318			}

hfw / asana

Push — master ( 22dd1f...d25a5e )

Data::getDiff() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like