Bouhnosaure\Dogecoin\ResponseArrayTrait

Complexity

Total Complexity

38

Size/Duplication

Total Lines	300
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

100%

Importance

Changes

0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	get()	0	14	3
A	exists()	0	8	1
A	has()	0	8	1
A	first()	0	10	2
A	last()	0	10	2
A	contains()	0	4	1
A	key()	0	7	1
A	keys()	0	4	1
A	values()	0	4	1
B	random()	0	23	5
A	count()	0	18	4
A	flatten()	0	13	2
A	sum()	0	4	1
A	__invoke()	0	4	1
B	constructKey()	0	12	5
C	parseKey()	0	32	7

<?php

namespace Bouhnosaure\Dogecoin;

trait ResponseArrayTrait
{
    /**
     * Gets data by using key with dotted notation.
     *
     * @param string|null $key
     *
     * @return mixed
     */
    public function get($key = null)
    {
        $key = $this->constructKey($key);

        if (is_null($key)) {
            return $this->result();

It seems like result() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        }

        return $this->parseKey($key, function ($part, $result) {
            if (isset($result[$part])) {
                return $result[$part];
            }
        });
    }

    /**
     * Checks if key exists.
     *
     * @param string|null $key
     *
     * @return bool
     */
    public function exists($key = null)
    {
        $key = $this->constructKey($key);

        return $this->parseKey($key, function ($part, $result) {
            return array_key_exists($part, $result);
        });
    }

    /**
     * Checks if key exists and not null.
     *
     * @param string|null $key
     *
     * @return bool
     */
    public function has($key = null)
    {
        $key = $this->constructKey($key);

        return $this->parseKey($key, function ($part, $result) {
            return isset($result[$part]);
        });
    }

    /**
     * Gets first element.
     *
     * @return mixed
     */
    public function first()
    {
        $value = $this->get();

        if (is_array($value)) {
            return reset($value);
        }

        return $value;
    }

    /**
     * Gets last element.
     *
     * @return mixed
     */
    public function last()
    {
        $value = $this->get();

        if (is_array($value)) {
            return end($value);
        }

        return $value;
    }

    /**
     * Checks if response contains value.
     *
     * @param mixed $value
     *
     * @return bool
     */
    public function contains($value)
    {
        return in_array($value, $this->result());

It seems like result() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Set current key.
     *
     * @param string|null $key
     *
     * @return static
     */
    public function key($key = null)
    {
        $new = clone $this;
        $new->current = $key;

The property current does not exist. Did you maybe forget to declare it?

        return $new;
    }

    /**
     * Gets response keys.
     *
     * @return array
     */
    public function keys()
    {
        return array_keys($this->result());

It seems like result() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Gets response values.
     *
     * @return array
     */
    public function values()
    {
        return array_values($this->result());

It seems like result() must be provided by classes using this trait. How about adding it as abstract method to this trait?

    }

    /**
     * Gets random value.
     *
     * @param int         $number
     * @param string|null $key
     *
     * @return mixed
     */
    public function random($number = 1, $key = null)
    {
        $value = $this->get($key);

        if (is_array($value)) {
            $keys = array_keys($value);
            $keysLength = count($keys);

            shuffle($keys);

            if ($number > $keysLength) {
                $number = $keysLength;
            }

            for ($result = [], $count = 0; $count < $number; $count++) {
                $result[$keys[$count]] = $value[$keys[$count]];
            }

            return count($result) > 1 ? $result : current($result);
        }

        return $value;
    }

    /**
     * Counts response items.
     *
     * @param string|null $key
     *
     * @return int
     */
    public function count($key = null)
    {
        if (is_null($this->constructKey($key))) {
            return count($this->result());

It seems like result() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        }

        if (!$this->exists($key)) {
            return 0;
        }

        $value = $this->get($key);

        if (is_array($value)) {
            return count($value);
        }

        return 1;
    }

    /**
     * Flattens multi-dimensional array.
     *
     * @param string|null $key
     *
     * @return array
     */
    public function flatten($key = null)
    {
        $array = new \RecursiveIteratorIterator(
            new \RecursiveArrayIterator((array) $this->get($key))
        );

        $tmp = [];
        foreach ($array as $value) {
            $tmp[] = $value;
        }

        return $tmp;
    }

    /**
     * Gets sum of values.
     *
     * @param string|null $key
     *
     * @return float
     */
    public function sum($key = null)
    {
        return array_sum($this->flatten($key));
    }

    /**
     * Get response item by key.
     *
     * @param string|null $key
     *
     * @return mixed
     */
    public function __invoke($key = null)
    {
        return $this->key($key);
    }

    /**
     * Constructs full key.
     *
     * @param string|null $key
     *
     * @return string|null
     */
    protected function constructKey($key = null)
    {
        if (!is_null($key) && !is_null($this->current)) {
            return $this->current.'.'.$key;
        }

        if (is_null($key) && !is_null($this->current)) {
            return $this->current;
        }

        return $key;
    }

    /**
     * Parses dotted notation.
     *
     * @param string     $key
     * @param callable   $callback
     * @param array|null $result
     *
     * @return mixed
     */
    protected function parseKey($key, callable $callback, $result = null)
    {
        $parts = explode('.', trim($key, '.'));
        $result = $result ?: $this->result();

It seems like result() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        foreach ($parts as $index => $part) {
            if ($part == '*') {
                $sub = [];

                foreach (array_keys($result) as $subKey) {
                    $path = $subKey;

                    if (isset($parts[$index + 1])) {
                        $pathParts = array_slice($parts, $index + 1);
                        $path .= '.'.implode('.', $pathParts);
                    }

                    $sub[$subKey] = $this->parseKey($path, $callback, $result);
                }

                return $sub;
            }

            if (!$return = $callback($part, $result)) {
                return $return;
            }

            $result = $result[$part];
        }

        return $return;

The variable $return does not seem to be defined for all execution paths leading up to this point.

    }
}