R2\Helpers\ArrayRecordset

Complexity

Total Complexity

18

Size/Duplication

Total Lines	161
Duplicated Lines	0 %

Importance

Changes	2
Bugs	0	Features	0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	orderBy()	0	13	3
A	data()	0	4	1
A	__construct()	0	5	1
A	value()	0	4	1
A	groupBy()	0	10	2
A	first()	0	4	1
A	pluck()	0	13	3
A	orderByCallable()	0	4	1
A	get()	0	15	5

<?php

namespace R2\Helpers;

use Spatie\Macroable\Macroable;

class ArrayRecordset
{
    const CASE_SENSITIVE = 1;
    const PRESERVE_KEYS = 2;

    /** @var string */
    protected $name = 'Recordset';

    use Macroable;

    /** @var array */
    protected $data;

    /** @var int */
    protected $options;

    /** @var callable[] */
    protected $comparators;

    /**
     * Chain constructor.
     *
     * @param array $data
     */
    public function __construct(array $data = [], int $options = 0)
    {
        $this->data = $data;
        $this->options = $options;
        $this->comparators = [];
    }

    /**
     * Set source data.
     *
     * @param array $data
     * @return self
     */
    public function data(array $data = []): self
    {
        $this->data = $data;
        return $this;
    }

    /**
     * Simple sort.
     *
     * @param string $field
     * @param string $direction
     * @return self
     */
    public function orderBy(string $field, string $direction = 'asc'): self
    {
        $sign = strtolower($direction) === 'asc' ? 1 : -1;
        if ($this->options & self::CASE_SENSITIVE) {
            $this->comparators[] = function ($a, $b) use ($field, $sign) {
                return strnatcmp($a[$field], $b[$field]) * $sign;
            };
        } else {
            $this->comparators[] = function ($a, $b) use ($field, $sign) {
                return strnatcasecmp($a[$field], $b[$field]) * $sign;
            };
        }
        return $this;
    }

    /**
     * Sort by arbitrary function applicable for PHP usort().
     *
     * @param callable $func
     * @return self
     */
    public function orderByCallable(callable $func): self
    {
        $this->comparators[] = $func;
        return $this;
    }

    /**
     * Group by field.
     * It cause additional dimension of array. Should be called right before the get() or first() call.
     *
     * @param string $field
     * @return self
     */
    public function groupBy(string $field): self
    {
        $grouped = [];
        foreach ($this->get() as $item) {
            $key = $item[$field];
            $grouped[$key][] = $item;
        }
        $this->data = $grouped;
        $this->comparators = [];
        return $this;
    }

    /**
     * Get result array.
     *
     * @return array
     */
    public function get(): array
    {
        if ($this->comparators) {

The expression $this->comparators of type array<mixed,callable> is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

            $sort = $this->options & self::PRESERVE_KEYS ? 'uasort' : 'usort';
            $sort($this->data, function ($a, $b) {
                foreach ($this->comparators as $f) {
                    $result = $f($a, $b);
                    if ($result !== 0) {
                        return $result;
                    }
                }
                return 0;
            });
        }
        return $this->data;
    }

    /**
     * Get first record only.
     *
     * @return array
     */
    public function first(): array
    {
        $result = $this->get();
        return reset($result);
    }

    /**
     * Get first given field value of first record only.
     *
     * @param string $field
     * @return mixed
     */
    public function value(string $field)
    {
        $result = $this->get();
        return reset($result)[$field];
    }

    /**
     * Plucka n array of values.
     *
     * @param mixed      $value
     * @param mixed|null $key
     * @return array
     */
    public function pluck($value, $key = null): array
    {
        $results = [];
        foreach ($this->get() as $item) {
            $itemValue = $item[$value];
            if (is_null($key)) {
                $results[] = $itemValue;
            } else {
                $itemKey = $item[$key];
                $results[$itemKey] = $itemValue;
            }
        }
        return $results;
    }
}