Helix\Asana\Base\Data

Complexity

Total Complexity

40

Size/Duplication

Total Lines	305
Duplicated Lines	0 %

Importance

Changes	26
Bugs	1	Features	1

19 Methods

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

<?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);
    }
}