NickLai\AssociativeArray

Complexity

Total Complexity

46

Size/Duplication

Total Lines	340
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

21 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	select()	0	11	2
A	last()	0	7	2
A	make()	0	3	1
B	orderBy()	0	29	7
A	groupBy()	0	16	4
A	getIterator()	0	3	1
A	rightJoin()	0	3	1
A	offsetSet()	0	6	2
A	offsetGet()	0	3	1
A	where()	0	3	1
A	leftJoin()	0	22	5
A	count()	0	3	1
A	getAssociativeRows()	0	11	4
A	innerJoin()	0	14	4
A	first()	0	7	2
A	offsetUnset()	0	3	1
A	avg()	0	4	2
A	offsetExists()	0	3	1
A	sum()	0	3	1
A	toArray()	0	5	2

<?php

/**
 * Associative array class.
 *
 * @author  Nick Lai <resxc13579@gmail.com>
 * @license https://opensource.org/licenses/mit-license.php MIT
 * @link    https://github.com/nick-lai/associative-array
 */

namespace NickLai;

use ArrayAccess;
use ArrayIterator;
use Countable;
use IteratorAggregate;
use Traversable;

class AssociativeArray implements ArrayAccess, Countable, IteratorAggregate
{
    /**
     * The rows contained in the associative array.
     *
     * @var array
     */
    protected $rows = [];

    /**
     * Create a new associative array.
     *
     * @param mixed $rows
     * @return void
     */
    public function __construct($rows = [])
    {
        $this->rows = $this->getAssociativeRows($rows);
    }

    /**
     * Create a new associative array instance.
     *
     * @param mixed $rows
     * @return static
     */
    public static function make($rows = [])
    {
        return new static($rows);
    }

    /**
     * Get rows of selected columns.
     *
     * @param string|array $keys
     * @return static
     */
    public function select($keys)
    {
        if (!is_array($keys)) {
            $keys = (array)$keys;
        }

        $keys = array_flip($keys);

        return new static(array_map(function($row) use ($keys) {
            return array_intersect_key($row, $keys);
        }, $this->rows));
    }

    /**
     * Filter the rows using the given callback.
     *
     * @param callable $callback
     * @return static
     */
    public function where(callable $callback)
    {
        return new static(array_filter($this->rows, $callback, ARRAY_FILTER_USE_BOTH));
    }

    /**
     * Inner join rows
     *
     * @param array $rows
     * @param callable $on
     * @return static
     */
    public function innerJoin($rows, callable $on)
    {
        $result = [];

        foreach ($this->rows as $leftRow) {
            foreach ($rows as $rightRow) {
                if ($on($leftRow, $rightRow)) {
                    $result[] = $leftRow + $rightRow;
                    break;
                }
            }
        }

        return new static($result);
    }

    /**
     * Left join rows
     *
     * @param array $rows
     * @param callable $on
     * @return static
     */
    public function leftJoin($rows, callable $on)
    {
        $nullRightRow = [];

        foreach ((new static($rows))->first() as $key => $value) {
            $nullRightRow[$key] = null;
        }

        $result = [];

        foreach ($this->rows as $leftRow) {
            $row = $leftRow + $nullRightRow;
            foreach ($rows as $rightRow) {
                if ($on($leftRow, $rightRow)) {
                    $row = $leftRow + $rightRow;
                    break;
                }
            }
            $result[] = $row;
        }

        return new static($result);
    }

    /**
     * Right join rows
     *
     * @param array $rows
     * @param callable $on
     * @return static
     */
    public function rightJoin($rows, callable $on)
    {
        return (new static($rows))->leftJoin($this->rows, $on);
    }

    /**
     * Order by keys
     *
     * @param string|array $keys
     * @param string|array $directions
     * @return static
     */
    public function orderBy($keys, $directions = 'asc')
    {
        if (!is_array($keys)) {
            $keys = (array)$keys;
        }

        $i = 0;
        $key2Direction = [];
        $isStringDirections = is_string($directions);

        foreach ($keys as $key) {
            $key2Direction[$key] = $isStringDirections ? $directions : ($directions[$i] ?? 'asc');
            $i++;
        }

        $result = $this->rows;

        usort($result, function($a, $b) use ($keys, $key2Direction) {
            foreach ($keys as $key) {
                if ($cmpVal = $key2Direction[$key] === 'desc'
                        ? $b[$key] <=> $a[$key]
                        : $a[$key] <=> $b[$key]) {
                    return $cmpVal;
                }
            }
            return 0;
        });

        return new static($result);
    }

    /**
     * Groups an associative array by keys.
     *
     * @param array|string $keys
     * @return static
     */
    public function groupBy($keys)
    {
        if (!is_array($keys)) {
            $keys = (array)$keys;
        }

        $result = [];

        foreach ($this->rows as $row) {
            $groupKey = implode(',', array_intersect_key($row, array_flip($keys)));
            if (!isset($result[$groupKey])) {
                $result[$groupKey] = $row;
            }
        }

        return new static(array_values($result));
    }

    /**
     * Return the first row
     *
     * @param mixed $default
     * @return mixed
     */
    public function first($default = null)
    {
        foreach ($this->rows as $row) {
            return $row;
        }

        return $default;
    }

    /**
     * Return the last row
     *
     * @param mixed $default
     * @return mixed
     */
    public function last($default = null)
    {
        foreach (array_reverse($this->rows) as $row) {
            return $row;
        }

        return $default;
    }

    /**
     * Count the number of rows in the associative array.
     *
     * @return int
     */
    public function count()
    {
        return count($this->rows);
    }

    /**
     * Get the sum of a given key.
     *
     * @param string $key
     * @return mixed
     */
    public function sum($key)
    {
        return array_sum(array_column($this->rows, $key));
    }

    /**
     * Get the average value of a given key.
     *
     * @param string $key
     * @return mixed
     */
    public function avg($key)
    {
        $sum = $this->sum($key);
        return $sum ? ($sum / $this->count()) : $sum;
    }

    /**
     * Get the instance as an array.
     *
     * @return array
     */
    public function toArray()
    {
        return array_map(function($row) {
            return $row instanceof self ? $row->toArray() : $row;
        }, $this->rows);
    }

    /**
     * Get an iterator for the rows.
     *
     * @return \ArrayIterator
     */
    public function getIterator()
    {
        return new ArrayIterator($this->rows);
    }

    /**
     * Determine if a row exists at an offset.
     *
     * @param mixed $offset
     * @return bool
     */
    public function offsetExists($offset)
    {
        return array_key_exists($offset, $this->rows);
    }

    /**
     * Get a row at a given offset.
     *
     * @param mixed $offset
     * @return mixed
     */
    public function offsetGet($offset)
    {
        return $this->rows[$offset];
    }

    /**
     * Set the row at a given offset.
     *
     * @param mixed $offset
     * @param mixed $row
     * @return void
     */
    public function offsetSet($offset, $row)
    {
        if (is_null($offset)) {
            $this->rows[] = $row;
        } else {
            $this->rows[$offset] = $row;
        }
    }

    /**
     * Unset the row at a given offset.
     *
     * @param string $offset
     * @return void
     */
    public function offsetUnset($offset)
    {
        unset($this->rows[$offset]);
    }

    /**
     * Results array of rows from associative array or traversable.
     *
     * @param mixed $rows
     * @return array
     */
    protected function getAssociativeRows($rows)
    {
        if (is_array($rows)) {
            return $rows;
        } elseif ($rows instanceof self) {
            return $rows->toArray();
        } elseif ($rows instanceof Traversable) {
            return iterator_to_array($rows);
        }

        return (array)$rows;
    }
}