Tuum\Form\Data\AbstractData

Complexity

Total Complexity

31

Size/Duplication

Total Lines	223
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes	1
Bugs	1	Features	0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	5	2
A	forge()	0	4	1
A	__get()	0	4	1
A	get()	0	6	1
A	ifExists()	0	7	2
A	exists()	0	14	4
A	raw()	0	11	3
A	parseRaw()	0	10	2
B	recurseGet()	0	16	6
A	extractKey()	0	6	2
A	getIterator()	0	8	2
A	offsetExists()	0	4	1
A	offsetGet()	0	4	1
A	offsetSet()	0	4	1
A	offsetUnset()	0	6	2

<?php
namespace Tuum\Form\Data;

use Traversable;

abstract class AbstractData implements \ArrayAccess, \IteratorAggregate
{
    /**
     * @var array|object
     */
    protected $data = [];

    /**
     * @var callable|Escape
     */
    protected $escape;

    /**
     * @ param Message $message
     *
     * @param array|object  $data
     * @param null|callable $escape
     */
    public function __construct($data = [], $escape = null)
    {
        $this->data   = $data;
        $this->escape = $escape ?: ['Tuum\Form\Data\Escape', 'htmlSafe'];
    }

    /**
     * @param array|object  $data
     * @param null|callable $escape
     * @return static
     */
    public static function forge($data = [], $escape = null)
    {
        return new static($data, $escape);
    }

    /**
     * accessing data as property. returns escaped value.
     *
     * @param string $key
     * @return mixed
     */
    public function __get($key)
    {
        return $this->get($key);
    }

    /**
     * get an escaped value.
     *
     * @param string     $key
     * @param null|mixed $default
     * @return mixed
     */
    public function get($key, $default = null)
    {
        $value  = $this->raw($key, $default);
        $escape = $this->escape;
        return $escape($value);
    }

    /**
     * @param string $name
     * @param string|null $value
     * @param string $string
     * @return string
     */
    public function ifExists($name, $value, $string)
    {
        if ($this->exists($name, $value)) {
            return $string;
        }
        return '';
    }

    /**
     * @param string $name
     * @param string $value
     * @return bool
     */
    public function exists($name, $value = null)
    {
        $found = $this->raw($name);
        if (is_null($found)) {
            return false;
        }
        if (!is_null($value)) {
            if (is_array($found)) {
                return in_array($value, $found);
            }
            return (string)$value === (string)$found;
        }
        return true;
    }

    /**
     * get a raw value.
     *
     * @param string     $key
     * @param null|mixed $default
     * @return mixed
     */
    public function raw($key, $default = null)
    {
        if (strpos($key, '[') === false) {
            return Accessor::get($this->data, $key, $default);
        }
        $found = $this->parseRaw($key);
        if (!is_null($found)) {
            return $found;
        }
        return $default;
    }

    /**
     * get a raw value for form element array name (with []).
     *
     * @param string $key
     * @return null|mixed
     */
    private function parseRaw($key)
    {
        $key = str_replace('[]', '', $key);
        parse_str($key, $levels);
        if (is_null($levels)) {
            return null;
        }
        $inputs = $this->data;
        return $this->recurseGet($levels, $inputs);
    }

    /**
     * gets a value from $input array.
     *
     * returns null if not found. or
     * returns an empty space if key is set but has not real value.
     *
     * @param array $levels
     * @param mixed $inputs
     * @return mixed
     */
    private function recurseGet($levels, $inputs)
    {
        if (!is_array($levels)) {
            if (is_null($inputs) || $inputs === false) {
                $inputs = '';
            }
            return $inputs;
        }
        foreach($levels as $key => $next) {
            if (Accessor::has($inputs, $key)) {
                return $this->recurseGet($next, Accessor::get($inputs, $key));
            }
            break;
        }
        return null;
    }

    /**
     * returns new Data object populated with its data[$key].
     *
     * @param string $key
     * @return static
     */
    public function extractKey($key)
    {
        $self       = clone($this);
        $self->data = Accessor::get($this->data, $key) ?: [];
        return $self;
    }

    /**
     * Retrieve an external iterator
     *
     * @return Traversable
     */
    public function getIterator()
    {
        $data = $this->data;
        foreach ($this->data as $key => $val) {
            $data[$key] = $this->extractKey($key);
        }
        return new \ArrayIterator($data);
    }

    /**
     * @param mixed $offset
     * @return bool
     */
    public function offsetExists($offset)
    {
        return array_key_exists($offset, $this->data);
    }

    /**
     * @param mixed
     * @return mixed
     */
    public function offsetGet($offset)
    {
        return $this->get($offset);
    }

    /**
     * @param mixed $offset
     * @param mixed $value
     * @return void
     */
    public function offsetSet($offset, $value)
    {
        $this->data[$offset] = $value;
    }

    /**
     * @param mixed $offset
     * @return void
     */
    public function offsetUnset($offset)
    {
        if ($this->offsetExists($offset)) {
            unset($this->data[$offset]);
        }
    }

}