Helix\Asana\Base\Data

Complexity

Total Complexity

43

Size/Duplication

Total Lines	323
Duplicated Lines	0 %

Importance

Changes	29
Bugs	1	Features	1

20 Methods

Rating	Name	Duplication	Size	Complexity
A	toArray()	0	17	6
B	_setMapped()	0	31	10
A	isDiff()	0	2	1
A	loadAll()	0	2	1
A	__debugInfo()	0	2	1
A	factory()	0	2	1
A	_is()	0	2	1
A	_has()	0	9	3
A	__isset()	0	2	1
A	getDiff()	0	18	5
A	__call()	0	10	2
A	unserialize()	0	3	1
A	load()	0	2	1
A	_set()	0	4	1
A	__get()	0	2	1
A	_get()	0	2	1
A	serialize()	0	2	1
A	__construct()	0	3	2
A	_setData()	0	4	2
A	jsonSerialize()	0	2	1

<?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.
     *
     * - `data key => class` for a nullable instance
     * - `data key => [class]` for an array of instances
     *
     * @return array
     */
    protected static $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|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 $key
     * @return null|Data|mixed
     */
    final public function __get ($key) {
        return $this->_get($key);
    }

    /**
     * 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 $key
     * @return bool
     */
    final public function __isset ($key) {
        return true;
    }

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

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

    /**
     * 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 $key => $value) {
            $this->_setMapped($key, $value);
        }
    }

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

        // use unmapped values, null, [], Data, and Data[] as-is
        if (
            !$class = static::$map[$key] ?? null
            or $value === null
            or $value === []
            or $value instanceof self
            or current($value) instanceof self
        ) {
            $this->data[$key] = $value;
            return;
        }

        // otherwise hydrate the mapped value
        $isList = is_array($class); // whether the field is mapped as a list
        $class = $isList ? $class[0] : $class;
        $hydrate = function($each) use ($class) {
            // hydrate AbstractEntity
            if (is_subclass_of($class, AbstractEntity::class)) {
                // convert gids to data array stubs. a lazy-loader will be returned.
                $each = is_array($each) ? $each : ['gid' => $each];
                return $this->api->getCache()->get($each['gid'], $this, function() use ($class, $each) {
                    return $this->factory($class, $each);
                });
            }
            // hydrate Data
            return $this->factory($class, $each);
        };
        $this->data[$key] = $isList ? array_map($hydrate, $value) : $hydrate($value);
    }

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

    /**
     * Returns a serialized representation of the instance's dehydrated data.
     *
     * @return string
     */
    public function serialize (): string {
        return serialize($this->toArray());
    }

    /**
     * Returns a dehydrated copy of the instance's data.
     *
     * @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);
    }

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