Statement::computeHeader() - Code Metrics - Inspection of "Implementing 9.0 Public API" - thephpleague/csv - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#210)

by ignace nyamagana

created 2017-02-03 14:11 UTC

Statement::computeHeader() B

↳ Parent: Statement

Complexity

Conditions	4
Paths	4

Size

Total Lines	24
Code Lines	15

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	15
CRAP Score	4

Importance

Changes

Metric	Value
dl	0
loc	24
ccs	15
cts	15
cp	1
rs	8.6845
c	0
b	0
f	0
cc	4
eloc	15
nc	4
nop	1
crap	4

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

namespace League\Csv;

use ArrayIterator;
use CallbackFilterIterator;
use Iterator;
use League\Csv\Config\ValidatorTrait;
use LimitIterator;
use SplFileObject;

/**
 *  A trait to manage filtering a CSV
 *
 * @package League.csv
 * @since  9.0.0
 *
 */
class Statement
{
    use ValidatorTrait;

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

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

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

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

    /**
     * CSV headers
     *
     * @var string[]
     */
    protected $header = [];

    /**
     * Set LimitIterator Offset
     *
     * @param $offset
     *
     * @return self
     */
    public function offset(int $offset = 0): self
    {
        $offset = $this->filterInteger($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 self
     */
    public function limit(int $limit = -1): self
    {
        $limit = $this->filterInteger($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 self
     */
    public function orderBy(callable $callable): self
    {
        $clone = clone $this;
        $clone->order_by[] = $callable;

        return $clone;
    }

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

        return $clone;
    }

    /**
     * Set the headers to be used by the RecordSet object
     *
     * @param string[] $header
     *
     * @return self
     */
    public function header(array $header): self
    {
        $header = $this->filterHeader($header);
        if ($header === $this->header) {
            return $this;
        }

        $clone = clone $this;
        $clone->header = $header;

        return $clone;
    }

    /**
     * Returns the inner CSV Document Iterator object
     *
     * @return RecordSet
     */
    public function process(Reader $reader)
    {
        $csv = $reader->getDocument();
        $csv->setFlags(SplFileObject::READ_CSV | SplFileObject::READ_AHEAD | SplFileObject::SKIP_EMPTY);
        $csv->setCsvControl($reader->getDelimiter(), $reader->getEnclosure(), $reader->getEscape());
        $header = $this->header;
        if (empty($header)) {
            $header = $this->computeHeader($reader);
        }

        $normalized = function ($row) {
            return is_array($row) && $row != [null];
        };

        $iterator = $this->stripBOM(
            new CallbackFilterIterator($csv, $normalized),
            $reader->getInputBOM(),
            $reader->getEnclosure()
        );
        $iterator = $this->combineHeader($iterator, $header);
        $iterator = $this->filterRecords($iterator);
        $iterator = $this->orderRecords($iterator);

        return new RecordSet(new LimitIterator($iterator, $this->offset, $this->limit), $header);
    }

    /**
     * Set the computed RecordSet headers
     *
     * @param Reader $reader The CSV document Reader object
     *
     * @throws Exception If the header is not found
     *
     * @return string[]
     */
    protected function computeHeader(Reader $reader)
    {
        $offset = $reader->getHeaderOffset();
        if (null === $offset) {
            return [];
        }

        $csv = $reader->getDocument();
        $csv->seek($offset);
        $header = $csv->current();
        if (empty($header)) {
            throw new Exception('The header record specified by `Reader::setHeaderOffset` does not exist or is empty');
        }

        if (0 === $offset) {
            $header = $this->removeBOM($header, mb_strlen($reader->getInputBOM()), $reader->getEnclosure());
        }
        $header = $this->filterHeader($header);
        array_unshift($this->where, function ($row, $index) use ($offset) {
            return $index !== $offset;
        });

        return $header;
    }

    /**
     * Remove the BOM sequence from the CSV
     *
     * @param Iterator $iterator
     *
     * @return Iterator
     */
    protected function stripBOM(Iterator $iterator, string $bom, string $enclosure): Iterator
    {
        if ('' == $bom) {
            return $iterator;
        }

        $bom_length = mb_strlen($bom);
        $strip_bom = function ($row, $index) use ($bom_length, $enclosure) {
            if (0 != $index || !is_array($row)) {
                return $row;
            }

            return $this->removeBOM($row, $bom_length, $enclosure);
        };

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

    /**
     * Add the CSV header if present
     *
     * @param Iterator $iterator
     * @param string[] $header
     *
     * @return Iterator
     */
    protected function combineHeader(Iterator $iterator, array $header): Iterator
    {
        if (empty($header)) {
            return $iterator;
        }

        $header_count = count($header);
        $combine = function (array $row) use ($header_count, $header) {
            if ($header_count != count($row)) {
                $row = array_slice(array_pad($row, $header_count, null), 0, $header_count);
            }

            return array_combine($header, $row);
        };

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

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

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

    /**
    * Sort the Iterator
    *
    * @param Iterator $iterator
    *
    * @return Iterator
    */
    protected function orderRecords(Iterator $iterator): Iterator
    {
        if (empty($this->order_by)) {
            return $iterator;
        }

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

            return $res;
        });

        return $obj;
    }
}


1		<?php
2		/**
3		* This file is part of the League.csv library
4		*
5		* @license http://opensource.org/licenses/MIT
6		* @link https://github.com/thephpleague/csv/
7		* @version 9.0.0
8		* @package League.csv
9		*
10		* For the full copyright and license information, please view the LICENSE
11		* file that was distributed with this source code.
12		*/
13		declare(strict_types=1);
14
15		namespace League\Csv;
16
17		use ArrayIterator;
18		use CallbackFilterIterator;
19		use Iterator;
20		use League\Csv\Config\ValidatorTrait;
21		use LimitIterator;
22		use SplFileObject;
23
24		/**
25		* A trait to manage filtering a CSV
26		*
27		* @package League.csv
28		* @since 9.0.0
29		*
30		*/
31		class Statement
32		{
33		use ValidatorTrait;
34
35		/**
36		* Callables to filter the iterator
37		*
38		* @var callable[]
39		*/
40		protected $where = [];
41
42		/**
43		* Callables to sort the iterator
44		*
45		* @var callable[]
46		*/
47		protected $order_by = [];
48
49		/**
50		* iterator Offset
51		*
52		* @var int
53		*/
54		protected $offset = 0;
55
56		/**
57		* iterator maximum length
58		*
59		* @var int
60		*/
61		protected $limit = -1;
62
63		/**
64		* CSV headers
65		*
66		* @var string[]
67		*/
68		protected $header = [];
69
70		/**
71		* Set LimitIterator Offset
72		*
73		* @param $offset
74		*
75		* @return self
76		*/
77	12	public function offset(int $offset = 0): self
78		{
79	12	$offset = $this->filterInteger($offset, 0, 'the offset must be a positive integer or 0');
80	12	if ($offset === $this->offset) {
81	2	return $this;
82		}
83
84	10	$clone = clone $this;
85	10	$clone->offset = $offset;
86
87	10	return $clone;
88		}
89
90		/**
91		* Set LimitIterator Count
92		*
93		* @param int $limit
94		*
95		* @return self
96		*/
97	14	public function limit(int $limit = -1): self
98		{
99	14	$limit = $this->filterInteger($limit, -1, 'the limit must an integer greater or equals to -1');
100	12	if ($limit === $this->limit) {
101	2	return $this;
102		}
103
104	10	$clone = clone $this;
105	10	$clone->limit = $limit;
106
107	10	return $clone;
108		}
109
110		/**
111		* Set an Iterator sorting callable function
112		*
113		* @param callable $callable
114		*
115		* @return self
116		*/
117	2	public function orderBy(callable $callable): self
118		{
119	2	$clone = clone $this;
120	2	$clone->order_by[] = $callable;
121
122	2	return $clone;
123		}
124
125		/**
126		* Set the Iterator filter method
127		*
128		* @param callable $callable
129		*
130		* @return self
131		*/
132	2	public function where(callable $callable): self
133		{
134	2	$clone = clone $this;
135	2	$clone->where[] = $callable;
136
137	2	return $clone;
138		}
139
140		/**
141		* Set the headers to be used by the RecordSet object
142		*
143		* @param string[] $header
144		*
145		* @return self
146		*/
147	18	public function header(array $header): self
148		{
149	18	$header = $this->filterHeader($header);
150	16	if ($header === $this->header) {
151	2	return $this;
152		}
153
154	14	$clone = clone $this;
155	14	$clone->header = $header;
156
157	14	return $clone;
158		}
159
160		/**
161		* Returns the inner CSV Document Iterator object
162		*
163		* @return RecordSet
164		*/
165	120	public function process(Reader $reader)
166		{
167	120	$csv = $reader->getDocument();
168	120	$csv->setFlags(SplFileObject::READ_CSV \| SplFileObject::READ_AHEAD \| SplFileObject::SKIP_EMPTY);
169	120	$csv->setCsvControl($reader->getDelimiter(), $reader->getEnclosure(), $reader->getEscape());
170	120	$header = $this->header;
171	120	if (empty($header)) {
172	106	$header = $this->computeHeader($reader);
173		}
174
175		$normalized = function ($row) {
176	102	return is_array($row) && $row != [null];
177	118	};
178
179	118	$iterator = $this->stripBOM(
180	118	new CallbackFilterIterator($csv, $normalized),
181	118	$reader->getInputBOM(),
182	118	$reader->getEnclosure()
183		);
184	118	$iterator = $this->combineHeader($iterator, $header);
185	118	$iterator = $this->filterRecords($iterator);
186	118	$iterator = $this->orderRecords($iterator);
187
188	118	return new RecordSet(new LimitIterator($iterator, $this->offset, $this->limit), $header);
189		}
190
191		/**
192		* Set the computed RecordSet headers
193		*
194		* @param Reader $reader The CSV document Reader object
195		*
196		* @throws Exception If the header is not found
197		*
198		* @return string[]
199		*/
200	106	protected function computeHeader(Reader $reader)
201		{
202	106	$offset = $reader->getHeaderOffset();
203	106	if (null === $offset) {
204	92	return [];
205		}
206
207	14	$csv = $reader->getDocument();
208	14	$csv->seek($offset);
209	14	$header = $csv->current();
210	14	if (empty($header)) {
211	2	throw new Exception('The header record specified by `Reader::setHeaderOffset` does not exist or is empty');
212		}
213
214	12	if (0 === $offset) {
215	8	$header = $this->removeBOM($header, mb_strlen($reader->getInputBOM()), $reader->getEnclosure());
216		}
217	12	$header = $this->filterHeader($header);
218		array_unshift($this->where, function ($row, $index) use ($offset) {
219	8	return $index !== $offset;
220	12	});
221
222	12	return $header;
223		}
224
225		/**
226		* Remove the BOM sequence from the CSV
227		*
228		* @param Iterator $iterator
229		*
230		* @return Iterator
231		*/
232	118	protected function stripBOM(Iterator $iterator, string $bom, string $enclosure): Iterator
233		{
234	118	if ('' == $bom) {
235	100	return $iterator;
236		}
237
238	18	$bom_length = mb_strlen($bom);
239		$strip_bom = function ($row, $index) use ($bom_length, $enclosure) {
240	18	if (0 != $index \|\| !is_array($row)) {
241	14	return $row;
242		}
243
244	18	return $this->removeBOM($row, $bom_length, $enclosure);
245	18	};
246
247	18	return new MapIterator($iterator, $strip_bom);
248		}
249
250		/**
251		* Add the CSV header if present
252		*
253		* @param Iterator $iterator
254		* @param string[] $header
255		*
256		* @return Iterator
257		*/
258	118	protected function combineHeader(Iterator $iterator, array $header): Iterator
259		{
260	118	if (empty($header)) {
261	92	return $iterator;
262		}
263
264	26	$header_count = count($header);
265		$combine = function (array $row) use ($header_count, $header) {
266	18	if ($header_count != count($row)) {
267	4	$row = array_slice(array_pad($row, $header_count, null), 0, $header_count);
268		}
269
270	18	return array_combine($header, $row);
271	26	};
272
273	26	return new MapIterator($iterator, $combine);
274		}
275
276		/**
277		* Filter the Iterator
278		*
279		* @param Iterator $iterator
280		*
281		* @return Iterator
282		*/
283	118	protected function filterRecords(Iterator $iterator): Iterator
284		{
285		$reducer = function ($iterator, $callable) {
286	14	return new CallbackFilterIterator($iterator, $callable);
287	118	};
288
289	118	return array_reduce($this->where, $reducer, $iterator);
290		}
291
292		/**
293		* Sort the Iterator
294		*
295		* @param Iterator $iterator
296		*
297		* @return Iterator
298		*/
299	118	protected function orderRecords(Iterator $iterator): Iterator
300		{
301	118	if (empty($this->order_by)) {
302	116	return $iterator;
303		}
304
305	2	$obj = new ArrayIterator(iterator_to_array($iterator));
306	2	$obj->uasort(function ($row_a, $row_b) {
307	2	$res = 0;
308	2	foreach ($this->order_by as $compare) {
309	2	if (0 !== ($res = $compare($row_a, $row_b))) {
310	2	break;
311		}
312		}
313
314	2	return $res;
315	2	});
316
317	2	return $obj;
318		}
319		}
320

thephpleague / csv

Pull Request — master (#210)

Statement::computeHeader() B

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like