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

Data::toArray() A
last analyzed 2021-08-07 23:39 UTC

↳ Parent: Data

Complexity

Conditions	2
Paths	1

Size

Total Lines	8
Code Lines	5

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
eloc	5
c	1
b	0
f	0
nc	1
nop	0
dl	0
loc	8
rs	10

<?php

namespace Helix\Shopify\Base;

use Base\Data\JsonSerializableTrait;
use Base\Data\MagicMethodTrait;
use Helix\Shopify\Api;
use Helix\Shopify\Api\Pool;
use JsonSerializable;
use Serializable;

/**
 * A data-object supporting annotated magic access.
 */
class Data extends \Base\Data implements JsonSerializable, Serializable
{

    use MagicMethodTrait;
    use JsonSerializableTrait;

    /**
     * @var array
     */
    const MAP = [];

    /**
     * Fields always added to diffs.
     *
     * @var string[]
     */
    const PATCH = [];

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

    /**
     * @var Pool
     */
    protected $pool;

    /**
     * @param mixed $caller
     * @return Api
     * @internal
     */
    final protected static function _getApi($caller)
    {
        if ($caller instanceof self) {
            return $caller->api;
        }
        assert($caller instanceof Api);
        return $caller;
    }

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

    /**
     * @param string $method
     * @param array $args
     * @return mixed
     */
    public function __call(string $method, array $args)
    {
        static $magic = [];
        if (!$call =& $magic[$method]) {
            preg_match('/^([a-z]+)(.+)$/', $method, $call);
            $call[1] = '_' . $call[1];
            if ($call[1] !== '_select') { // _select() calls getters
                $call[2] = preg_replace_callback('/[A-Z]/', function (array $match) {
                    return '_' . lcfirst($match[0]);
                }, lcfirst($call[2]));
            }
        }
        return $this->{$call[1]}($call[2], ...$args);
    }

    /**
     * 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 ids to lazy stubs
                $item = ['id' => $item];
            }
            return $this->pool->get($item['id'], $this, function () use ($class, $item) {
                return $this->api->factory($this, $class, $item);
            });
        }
        // hydrate simple
        return $this->api->factory($this, $class, $item);
    }

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

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

    /**
     * Sets a value, hydrating if mapped, and clears the diff.
     *
     * @param string $field
     * @param mixed $value
     * @return $this
     */
    protected function _setField(string $field, $value)
    {
        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]);
        return $this;
    }

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

    /**
     * @return array
     */
    public function toArray(): array
    {
        return array_map(function ($value) {
            if ($value instanceof self) {
                return $value->toArray();
            }
            return $value;
        }, $this->data);
    }

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

1			<?php
2
3			namespace Helix\Shopify\Base;
4
5			use Base\Data\JsonSerializableTrait;
6			use Base\Data\MagicMethodTrait;
7			use Helix\Shopify\Api;
8			use Helix\Shopify\Api\Pool;
9			use JsonSerializable;
10			use Serializable;
11
12			/**
13			* A data-object supporting annotated magic access.
14			*/
15			class Data extends \Base\Data implements JsonSerializable, Serializable
16			{
17
18			use MagicMethodTrait;
19			use JsonSerializableTrait;
20
21			/**
22			* @var array
23			*/
24			const MAP = [];
25
26			/**
27			* Fields always added to diffs.
28			*
29			* @var string[]
30			*/
31			const PATCH = [];
32
33			/**
34			* @var Api
35			*/
36			protected $api;
37
38			/**
39			* @var Pool
40			*/
41			protected $pool;
42
43			/**
44			* @param mixed $caller
45			* @return Api
46			* @internal
47			*/
48			final protected static function _getApi($caller)
49			{
50			if ($caller instanceof self) {
51			return $caller->api;
52			}
53			assert($caller instanceof Api);
54			return $caller;
55			}
56
57			/**
58			* @param Api\|Data $caller
59			* @param array $data
60			*/
61			public function __construct($caller, array $data = [])
62			{
63			parent::__construct();
64			$this->api = self::_getApi($caller);
65			$this->pool = $this->api->getPool();
66			$this->_setData($data);
67			}
68
69			/**
70			* @param string $method
71			* @param array $args
72			* @return mixed
73			*/
74			public function __call(string $method, array $args)
75			{
76			static $magic = [];
77			if (!$call =& $magic[$method]) {
78			preg_match('/^([a-z]+)(.+)$/', $method, $call);
79			$call[1] = '_' . $call[1];
80			if ($call[1] !== '_select') { // _select() calls getters
81			$call[2] = preg_replace_callback('/[A-Z]/', function (array $match) {
82			return '_' . lcfirst($match[0]);
83			}, lcfirst($call[2]));
84			}
85			}
86			return $this->{$call[1]}($call[2], ...$args);
87			}
88
89			/**
90			* A factory that also hydrates / caches entities.
91			*
92			* @param string $class
93			* @param mixed $item
94			* @return mixed
95			*/
96			protected function _hydrate(string $class, $item)
97			{
98			if (!isset($item) or $item instanceof self) {
99			return $item;
100			}
101			// hydrate entities
102			if (is_subclass_of($class, AbstractEntity::class)) {
103			if (is_string($item)) { // convert ids to lazy stubs
104			$item = ['id' => $item];
105			}
106			return $this->pool->get($item['id'], $this, function () use ($class, $item) {
107			return $this->api->factory($this, $class, $item);
108			});
109			}
110			// hydrate simple
111			return $this->api->factory($this, $class, $item);
112			}
113
114			/**
115			* Magic method: `selectField(callable $filter)`
116			*
117			* Where `Field` has an accessor at `getField()`, either real or magic.
118			*
119			* This can also be used to select from an arbitrary iterable.
120			*
121			* @see __call()
122			*
123			* @param string\|iterable $subject
124			* @param callable $filter `fn( Data $object ): bool`
125			* @param array $args
126			* @return array
127			*/
128			protected function _select($subject, callable $filter, ...$args)
129			{
130			if (is_string($subject)) {
131			$subject = $this->{'get' . $subject}(...$args) ?? [];
132			}
133			$selected = [];
134			foreach ($subject as $item) {
135			if (call_user_func($filter, $item)) {
136			$selected[] = $item;
137			}
138			}
139			return $selected;
140			}
141
142			/**
143			* Clears all diffs and sets all data, hydrating mapped fields.
144			*
145			* @param array $data
146			* @return $this
147			*/
148			protected function _setData(array $data)
149			{
150			$this->data = $this->diff = [];
151			foreach ($data as $field => $value) {
152			$this->_setField($field, $value);
153			}
154			return $this;
155			}
156
157			/**
158			* Sets a value, hydrating if mapped, and clears the diff.
159			*
160			* @param string $field
161			* @param mixed $value
162			* @return $this
163			*/
164			protected function _setField(string $field, $value)
165			{
166			if (isset(static::MAP[$field])) {
167			$class = static::MAP[$field];
168			if (is_array($class)) {
169			$value = array_map(function ($each) use ($class) {
170			return $this->_hydrate($class[0], $each);
171			}, $value);
172			} elseif (isset($value)) {
173			$value = $this->_hydrate($class, $value);
174			}
175			}
176			$this->data[$field] = $value;
177			unset($this->diff[$field]);
178			return $this;
179			}
180
181			/**
182			* Dehydrated JSON encode.
183			*
184			* @return string
185			*/
186			public function serialize(): string
187			{
188			return json_encode($this, JSON_PRETTY_PRINT \| JSON_UNESCAPED_SLASHES \| JSON_UNESCAPED_UNICODE);
189			}
190
191			/**
192			* @return array
193			*/
194			public function toArray(): array
195			{
196			return array_map(function ($value) {
197			if ($value instanceof self) {
198			return $value->toArray();
199			}
200			return $value;
201			}, $this->data);
202			}
203
204			/**
205			* @param $serialized
206			*/
207			public function unserialize($serialized): void
208			{
209			$this->data = json_decode($serialized, true);
210			}
211			}

hfw / shopify

Data::toArray() A last analyzed 2021-08-07 23:39 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Data::toArray() A
last analyzed 2021-08-07 23:39 UTC