League\Csv\Query

Complexity

Total Complexity

39

Size/Duplication

Total Lines	349
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	4

Importance

Changes	6
Bugs	0	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__set()	0	4	1
A	__unset()	0	4	1
A	addHeaders()	0	15	3
A	__invoke()	0	12	2
B	assertValidKeys()	0	10	5
A	execute()	0	18	3
A	useMBStringConverter()	0	5	3
A	stripBOM()	0	12	2
A	setOffset()	0	12	2
A	setLimit()	0	12	2
A	addSortBy()	0	7	1
A	addFilter()	0	7	1
A	applyBOMStripping()	0	8	3
A	getStripBOMIterator()	0	19	4
A	applyIteratorFilter()	0	8	1
A	applyIteratorSortBy()	0	20	4
A	convertToUtf8()	0	12	1

<?php
/**
* This file is part of the League.csv library
*
* @license http://opensource.org/licenses/MIT
* @link https://github.com/thephpleague/csv/
* @version 8.1.1
* @package League.csv
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace League\Csv;

use ArrayIterator;
use CallbackFilterIterator;
use InvalidArgumentException;
use Iterator;
use League\Csv\Config\Validator;
use LimitIterator;

/**
 * A simple Query class to fetch rows against a Csv file object
 *
 * @package League.csv
 * @since  4.2.1
 *
 */
class Query
{
    use Validator;

    /**
     * Callables to filter the iterator
     *
     * @var callable[]
     */
    protected $filters = [];

    /**
     * Callables to sort the iterator
     *
     * @var callable[]
     */
    protected $sort_by = [];

    /**
     * iterator Offset
     *
     * @var int
     */
    protected $offset = 0;

    /**
     * iterator maximum length
     *
     * @var int
     */
    protected $limit = -1;

    /**
     * Stripping BOM status
     *
     * @var bool
     */
    protected $strip_BOM = true;

    /**
     * Offset of Header keys
     *
     * @var array|int
     */
    protected $headers = 0;

    /**
     * @inheritdoc
     */
    public function __set($property, $value)
    {
        throw new InvalidArgumentException(sprintf('%s is an undefined property', $property));
    }

    /**
     * @inheritdoc
     */
    public function __unset($property)
    {
        throw new InvalidArgumentException(sprintf('%s is an undefined property', $property));
    }

    /**
     * Add Headers
     *
     * @param string[]|int $headers
     */
    public function addHeaders($headers)
    {
        if (!is_array($headers)) {
            $headers = $this->validateInteger($headers, 0, 'the row index must be a positive integer, 0 or a non empty array');
        }

        if ($headers === $this->headers) {
            return $this;
        }

        $clone = clone $this;
        $clone->headers = $headers;

        return $clone;
    }

    /**
     * Returns a Record object
     *
     * @return Records
     */
    public function __invoke(AbstractCsv $csv)
    {
        $headers = $this->headers;
        if (!is_array($headers)) {
            $it = (new static())->setOffset($headers)->setLimit(1)->execute($csv);
            $it->rewind();
            $headers = (array) $it->current();
        }
        $this->assertValidKeys($headers);

        return new Records($this->execute($csv), $headers);
    }

    /**
     * Validates the array to be used by the fetchAssoc method
     *
     * @param array $keys

There is no parameter named $keys. Was it maybe removed?

     *
     * @throws InvalidArgumentException If the submitted array fails the assertion
     *
     * @return array
     */
    protected function assertValidKeys(array $headers)
    {
        $is_valid_keys = function ($value) {
            return is_scalar($value) || (is_object($value) && method_exists($value, '__toString'));
        };

        if (empty($headers) || $headers !== array_unique(array_filter($headers, $is_valid_keys))) {
            throw new InvalidArgumentException('Use a flat array with unique string values');
        }
    }

    /**
     * Returns the CSV Iterator
     *
     * @return Iterator
     */
    protected function execute(AbstractCsv $csv)
    {
        $input_encoding = $csv->getInputEncoding();
        $use_converter = $this->useMBStringConverter($csv);
        $normalizedCsv = function ($row) {
            return is_array($row) && $row != [null];
        };
        array_unshift($this->filters, $normalizedCsv);
        $iterator = $this->applyBOMStripping($csv);
        $iterator = $this->applyIteratorFilter($iterator);
        $iterator = $this->applyIteratorSortBy($iterator);
        $iterator = new LimitIterator($iterator, $this->offset, $this->limit);

        if (!$use_converter) {
            return $iterator;
        }
        return $this->convertToUtf8($iterator, $input_encoding);
    }

    protected function useMBStringConverter(AbstractCsv $csv)
    {
        return !('UTF-8' === $csv->getInputEncoding()
            || ($csv->isActiveStreamFilter() && STREAM_FILTER_READ === $csv->getStreamFilterMode()));
    }

    /**
     * Stripping BOM setter
     *
     * @param bool $status
     *
     * @return static
     */
    public function stripBOM($status)
    {
        $status = (bool) $status;
        if ($status === $this->strip_BOM) {
            return $this;
        }

        $clone = clone $this;
        $clone->strip_BOM = $status;

        return $clone;
    }

    /**
     * Set LimitIterator Offset
     *
     * @param $offset
     *
     * @return static
     */
    public function setOffset($offset)
    {
        $offset = $this->validateInteger($offset, 0, 'the offset must be a positive integer or 0');
        if ($offset === $this->offset) {
            return $this;
        }

        $clone = clone $this;
        $clone->offset = $offset;

        return $clone;
    }

    /**
     * Set LimitIterator Count
     *
     * @param int $limit
     *
     * @return static
     */
    public function setLimit($limit)
    {
        $limit = $this->validateInteger($limit, -1, 'the limit must an integer greater or equals to -1');
        if ($limit === $this->limit) {
            return $this;
        }

        $clone = clone $this;
        $clone->limit = $limit;

        return $clone;
    }

    /**
     * Set an Iterator sorting callable function
     *
     * @param callable $callable
     *
     * @return static
     */
    public function addSortBy(callable $callable)
    {
        $clone = clone $this;
        $clone->sort_by[] = $callable;

        return $clone;
    }

    /**
     * Set the Iterator filter method
     *
     * @param callable $callable
     *
     * @return static
     */
    public function addFilter(callable $callable)
    {
        $clone = clone $this;
        $clone->filters[] = $callable;

        return $clone;
    }

    /**
     * Remove the BOM sequence from the CSV
     *
     * @param AbstractCsv $csv
     *
     * @return Iterator
     */
    protected function applyBOMStripping(AbstractCsv $csv)
    {
        if ($this->strip_BOM && '' != $csv->getInputBOM()) {
            return $this->getStripBOMIterator($csv);
        }

        return $csv->getIterator();
    }

    /**
     * Return the Iterator without the BOM sequence
     *
     * @param AbstractCsv $csv
     *
     * @return Iterator
     */
    protected function getStripBOMIterator(AbstractCsv $csv)
    {
        $bom_length = mb_strlen($csv->getInputBOM());
        $enclosure = $csv->getEnclosure();
        $strip_BOM = function ($row, $index) use ($bom_length, $enclosure) {
            if (0 != $index) {
                return $row;
            }

            $row[0] = mb_substr($row[0], $bom_length);
            if ($row[0][0] === $enclosure && mb_substr($row[0], -1, 1) === $enclosure) {
                $row[0] = mb_substr($row[0], 1, -1);
            }

            return $row;
        };

        return new MapIterator($csv->getIterator(), $strip_BOM);
    }

    /**
    * Filter the Iterator
    *
    * @param Iterator $iterator
    *
    * @return Iterator
    */
    protected function applyIteratorFilter(Iterator $iterator)
    {
        $reducer = function ($iterator, $callable) {
            return new CallbackFilterIterator($iterator, $callable);
        };

        return array_reduce($this->filters, $reducer, $iterator);
    }

    /**
    * Sort the Iterator
    *
    * @param Iterator $iterator
    *
    * @return Iterator
    */
    protected function applyIteratorSortBy(Iterator $iterator)
    {
        if (!$this->sort_by) {

The expression $this->sort_by of type 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.

            return $iterator;
        }

        $obj = new ArrayIterator(iterator_to_array($iterator));
        $obj->uasort(function ($row_a, $row_b) {
            $res = 0;
            foreach ($this->sort_by as $compare) {
                if (0 !== ($res = call_user_func($compare, $row_a, $row_b))) {
                    break;
                }
            }

            return $res;
        });

        return $obj;
    }

    /**
     * Convert Iterator to UTF-8 if needed
     *
     * @param string   $input_encoding
     * @param Iterator $iterator
     *
     * @return Iterator
     */
    protected function convertToUtf8(Iterator $iterator, $input_encoding)
    {
        $convert_cell = function ($value) use ($input_encoding) {
            return mb_convert_encoding($value, 'UTF-8', $input_encoding);
        };

        $convert_row = function ($row) use ($convert_cell) {
            return array_map($convert_cell, (array) $row);
        };

        return new MapIterator($iterator, $convert_row);
    }
}