Helix\Asana\Base\Data

Complexity

Total Complexity

50

Size/Duplication

Total Lines	398
Duplicated Lines	0 %

Importance

Changes	33
Bugs	1	Features	1

22 Methods

Rating	Name	Duplication	Size	Complexity
A	_loadAll()	0	2	1
A	toArray()	0	13	5
A	_load()	0	2	1
C	_setMapped()	0	44	12
A	_loadEach()	0	2	1
A	isDiff()	0	5	2
A	_factory()	0	2	1
A	__debugInfo()	0	2	1
A	_is()	0	2	1
A	getDiff()	0	18	5
A	_has()	0	9	3
A	__isset()	0	2	1
A	__call()	0	10	2
A	unserialize()	0	4	1
A	_set()	0	4	1
A	__get()	0	2	1
A	_select()	0	11	4
A	_get()	0	2	1
A	serialize()	0	2	1
A	__construct()	0	3	2
A	_setData()	0	4	2
A	jsonSerialize()	0	4	1

<?php

namespace Helix\Asana\Base;

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

/**
 * 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
     * - `* => class` to wildcard all fields as nullable instances
     *
     * The map supports polymorphic entity hydration via `*` indirection.
     *
     * ```
     * field => * or [*],
     * field* => [
     *      entity::TYPE => entity::class,
     *      entity::TYPE => entity::class
     * ],
     * ```
     *
     * 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 {@see Api::factory()} to do that.
     *
     * @see _setData()
     * @see _setMapped()
     *
     * @var array
     */
    protected const MAP = [];

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

    /**
     * This is only provided for use by functions like `array_column()`.
     *
     * @param $field
     * @return null|Data|mixed
     */
    final public function __get ($field) {
        return $this->_get($field);
    }

    /**
     * This is only provided for use by functions like `array_column()`.
     *
     * Always returns `true`, since fields that are not set can be lazy-loaded.
     *
     * @param $field
     * @return bool
     */
    final public function __isset ($field) {
        return true;
    }

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

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

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

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

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

    /**
     * Magic method: `selectField(callable $filter)`
     *
     * This can also be used to select from an arbitrary array.
     *
     * @see __call()
     *
     * @param string|iterable $subject
     * @param callable $filter `fn( Data $object ): bool`
     * @return array
     */
    protected function _select ($subject, callable $filter) {
        if (!is_iterable($subject)) {
            $subject = $this->_get($subject) ?? [];

It seems like $subject can also be of type iterable; however, parameter $field of Helix\Asana\Base\Data::_get() does only seem to accept string, maybe add an additional type check?

        }
        $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->_setMapped($field, $value);
        }
    }

    /**
     * Sets a value, hydrating if mapped, and clears the diff.
     *
     * @param string $field
     * @param mixed $value
     */
    protected function _setMapped (string $field, $value): void {
        unset($this->diff[$field]);

        // use value as-is?
        if (
            !isset(static::MAP[$field]) && !isset(static::MAP['*']) // unmapped
            or empty($value)                                        // null or []
            or $value instanceof self                               // Data-ish
            or is_array($value) && current($value) instanceof self  // Data[]-ish
        ) {
            $this->data[$field] = $value;
            return;
        }

        // otherwise the field is mapped.
        $class = static::MAP[$field] ?? static::MAP['*'];
        if ($isList = is_array($class)) {
            $class = $class[0];
        }
        // polymorphic
        if ($class === '*') {
            $class = static::MAP["{$field}*"][$value['resource_type']];
        }

        $hydrate = function($data) use ($class) {
            // hydrate AbstractEntity
            if (is_subclass_of($class, AbstractEntity::class)) {
                // convert gids to data stubs. a lazy-loader will be returned.
                if (is_scalar($data)) {
                    $data = ['gid' => $data];
                }
                return $this->api->getCache()->get($data['gid'], $this, function() use ($class, $data) {
                    return $this->_factory($class, $data);
                });
            }
            // hydrate Data
            return $this->_factory($class, $data);
        };

        if ($isList) {
            $this->data[$field] = array_map($hydrate, $value);
        }
        else {
            $this->data[$field] = $hydrate($value);
        }
    }

    /**
     * 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.
     *
     * @param string null $field

Are you sure the doc-type for parameter $string is correct as it would always require null to be passed?

     * @return bool
     */
    final public function isDiff (string $field = null): bool {
        if ($field) {
            return isset($this->diff[$field]);
        }
        return (bool)$this->diff;
    }

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

    /**
     * Returns a serialized representation of the instance's dehydrated data.
     *
     * @return string
     */
    public function serialize (): string {
        return json_encode($this, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES | JSON_UNESCAPED_UNICODE);
    }

    /**
     * Returns a dehydrated copy of the instance's data.
     *
     * @return array
     */
    public function toArray (): array {
        return array_map($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;
        }, $this->data);
    }

    /**
     * Sets the dehydrated data and uses the default {@see Api} instance.
     *
     * @param $serialized
     */
    public function unserialize ($serialized): void {
        $this->api = Api::getDefault();
        $data = json_decode($serialized, true);
        $this->_setData($data);
    }
}