Spiral\Http\Request\InputBag

Complexity

Total Complexity

22

Size/Duplication

Total Lines	172
Duplicated Lines	0 %

Importance

Changes	1
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	count()	0	3	1
A	offsetSet()	0	3	1
A	has()	0	9	2
A	get()	0	6	2
A	all()	0	6	2
A	offsetUnset()	0	3	1
A	fetch()	0	9	2
A	getIterator()	0	3	1
A	dotGet()	0	21	6
A	__debugInfo()	0	3	1
A	offsetExists()	0	3	1
A	offsetGet()	0	3	1

<?php

/**
 * Spiral Framework.
 *
 * @license   MIT
 * @author    Anton Titov (Wolfy-J)
 */

declare(strict_types=1);

namespace Spiral\Http\Request;

use Spiral\Http\Exception\DotNotFoundException;
use Spiral\Http\Exception\InputException;

/**
 * Generic data accessor, used to read properties of active request. Input bags provide ability to
 * isolate request parts using given prefix.
 */
class InputBag implements \Countable, \IteratorAggregate, \ArrayAccess
{
    /** @var array */
    private $data = [];

    /** @var string */
    private $prefix = '';

    /**
     * @param array  $data
     * @param string $prefix
     */
    public function __construct(array $data, string $prefix = '')
    {
        $this->data = $data;
        $this->prefix = $prefix;
    }

    /**
     * @return array
     */
    public function __debugInfo()
    {
        return $this->all();
    }

    /**
     * {@inheritdoc}
     */
    public function count(): int
    {
        return count($this->all());
    }

    /**
     * @return array
     */
    public function all(): array
    {
        try {
            return $this->dotGet('');
        } catch (DotNotFoundException $e) {
            return [];
        }
    }

    /**
     * {@inheritdoc}
     */
    public function getIterator(): \Traversable
    {
        return new \ArrayIterator($this->all());
    }

    /**
     * Fetch only specified keys from property values. Missed values can be filled with defined
     * filler. Only one variable layer can be fetched (no dot notation).
     *
     * @param array $keys
     * @param bool  $fill Fill missing key with filler value.
     * @param mixed $filler
     * @return array
     */
    public function fetch(array $keys, bool $fill = false, $filler = null)
    {
        $result = array_intersect_key($this->all(), array_flip($keys));
        ;
        if (!$fill) {
            return $result;
        }

        return $result + array_fill_keys($keys, $filler);
    }

    /**
     * {@inheritdoc}
     */
    public function offsetExists($offset)
    {
        return $this->has($offset);
    }

    /**
     * Check if field presented (can be empty) by it's name. Dot notation allowed.
     *
     * @param string $name
     * @return bool
     */
    public function has(string $name): bool
    {
        try {
            $this->dotGet($name);
        } catch (DotNotFoundException $e) {
            return false;
        }

        return true;
    }

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

    /**
     * Get property or return default value. Dot notation allowed.
     *
     * @param string $name
     * @param mixed  $default
     * @return mixed
     */
    public function get(string $name, $default = null)
    {
        try {
            return $this->dotGet($name);
        } catch (DotNotFoundException $e) {
            return $default;
        }
    }

    /**
     * {@inheritdoc}
     *
     * @throws InputException
     */
    public function offsetSet($offset, $value): void
    {
        throw new InputException('InputBag is immutable');
    }

    /**
     * {@inheritdoc}
     *
     * @throws InputException
     */
    public function offsetUnset($offset): void
    {
        throw new InputException('InputBag is immutable');
    }

    /**
     * Get element using dot notation.
     *
     * @param string $name
     * @return mixed|null
     *
     * @throws DotNotFoundException
     */
    private function dotGet(string $name)
    {
        $data = $this->data;

        //Generating path relative to a given name and prefix
        $path = (!empty($this->prefix) ? $this->prefix . '.' : '') . $name;
        if (empty($path)) {
            return $data;
        }

        $path = explode('.', rtrim($path, '.'));

        foreach ($path as $step) {
            if (!is_array($data) || !array_key_exists($step, $data)) {
                throw new DotNotFoundException("Unable to find requested element '{$name}'");
            }

            $data = &$data[$step];
        }

        return $data;
    }
}