Reader::header() - Code Metrics - Inspection of "Scrutinizer fixes" - nozavroni/csvelte - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 5c1aea...9ef1c4 )

by Luke

created 2016-11-06 18:15 UTC

Reader::header() A

↳ Parent: Reader

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
c	0
b	0
f	0
dl	0
loc	4
ccs	2
cts	2
cp	1
rs	10
cc	1
eloc	2
nc	1
nop	0
crap	1

<?php
/**
 * CSVelte: Slender, elegant CSV for PHP
 *
 * Inspired by Python's CSV module and Frictionless Data and the W3C's CSV
 * standardization efforts, CSVelte was written in an effort to take all the
 * suck out of working with CSV.
 *
 * @version   v0.2.1
 * @copyright Copyright (c) 2016 Luke Visinoni <[email protected]>
 * @author    Luke Visinoni <[email protected]>
 * @license   https://github.com/deni-zen/csvelte/blob/master/LICENSE The MIT License (MIT)
 */
namespace CSVelte;

use CSVelte\Contract\Streamable;

use CSVelte\Table\Row;
use CSVelte\Table\HeaderRow;
use CSVelte\Reader\FilteredIterator as FilteredReader;

use CSVelte\Exception\EndOfFileException;

use function
    CSVelte\streamize,
    CSVelte\taste,
    CSVelte\taste_has_header,
    CSVelte\collect;

/**
 * CSV Reader
 *
 * Reads CSV data from any object that implements CSVelte\Contract\Readable.
 *
 * @package CSVelte
 * @subpackage Reader
 * @since v0.1
 * @todo Also, is there any way to do some kind of caching or something? Probably
 *     not but if you could that would be a cool feature...
 */
class Reader implements \Iterator
{
    const PLACEHOLDER_DELIM   = '[=[__DLIM__]=]';
    const PLACEHOLDER_NEWLINE = '[=[__NWLN__]=]';

    /**
     * This class supports any sources of input that implements this interface.
     * This way I can read from local files, streams, FTP, any class that implements
     * the "Readable" interface
     * @var Contract\Streamable
     */
    protected $source;

    /**
     * @var Flavor The "flavor" or format of the CSV being read
     */
    protected $flavor;

    /**
     * @var Table\Row Row currently loaded into memory
     */
    protected $current;

    /**
     * @var integer The current line being read (from input source)
     */
    protected $line = 0;

    /**
     * @var Table\HeaderRow The header row (if any)
     */
    protected $header;

    /**
     * @var array An array of callback functions
     */
    protected $filters = array();

    /**
     * @var bool True if current line ended while inside a quoted string
     */
    protected $open = false;

    /**
     * @var bool True if last character read was the escape character
     */
    protected $escape = false;

    /**
     * Reader Constructor.
     * Initializes a reader object using an input source and optionally a flavor
     *
     * @param mixed $input The source of our CSV data
     * @param Flavor|array|null $flavor The "flavor" or format specification object
     */
    public function __construct($input, $flavor = null)
    {
        $this->setSource($input)
             ->setFlavor($flavor)
             ->rewind();
    }

    /**
     * Set the flavor.
     *
     * Set the ``CSVelte\Flavor`` object, used to determine CSV format.
     *
     * @param Flavor|array|null $flavor Either an array or a flavor object
     * @return $this
     */
    protected function setFlavor($flavor = null)
    {
        if (is_array($flavor)) $flavor = new Flavor($flavor);
        // @todo put this inside a try/catch
        if (is_null($flavor)) {
            $flavor = taste($this->source);
        }
        if (is_null($flavor->header)) {
            // Flavor is immutable, give me a new one with header set to lickHeader return val
            $flavor = $flavor->copy(['header' => taste_has_header($this->source)]);
        }
        $this->flavor = $flavor;
        return $this;
    }

    /**
     * Set the reader source.
     *
     * The reader can accept anything that implements Readable and is actually
     * readable (can be read). This will make sure that whatever is passed to
     * the reader meets these expectations and set $this->source. It can also
     * accept any string (or any object with a __toString() method), or an
     * SplFileObject, so long as it represents a file rather than a directory.
     *
     * @param mixed $input See description
     * @return $this
     */
    protected function setSource($input)
    {
        if (!($input instanceof Streamable)) {
            $input = streamize($input);
        }
        $this->source = $input;
        return $this;
    }

    /**
     * Load a line into memory
     */
    protected function load()
    {
        if (is_null($this->current)) {
            try {
                $line = $this->readLine();
                $this->line++;
                $parsed = $this->parse($line);
                if ($this->hasHeader() && $this->line === 1) {
                    $this->header = new HeaderRow($parsed);
                } else {
                    $this->current = new Row($parsed);
                    if ($this->header) $this->current->setHeaderRow($this->header);
                }
            } catch (EndOfFileException $e) {
                $this->current = false;

            }
        }
    }

    /**
     * Read single line from CSV data source (stream, file, etc.), taking into
     * account CSV's de-facto quoting rules with respect to designated line
     * terminator character when they fall within quoted strings.
     *
     * @return string A CSV row (could possibly span multiple lines depending on
     *     quoting and escaping)
     * @throws Exception\EndOfFileException when eof has been reached
     *     and the read buffer has all been returned
     */
    protected function readLine()
    {
        $f = $this->getFlavor();
        $eol = $f->lineTerminator;
        try {
            do {
                if (!isset($lines)) $lines = array();
                if (false === ($line = $this->source->readLine($eol))) {
                    throw new EndOfFileException("End of file reached");
                }
                array_push($lines, rtrim($line, $eol));
            } while ($this->inQuotedString(end($lines), $f->quoteChar, $f->escapeChar));
        } catch (EndOfFileException $e) {
            // only throw the exception if we don't already have lines in the buffer
            if (!count($lines)) throw $e;
        }
        return rtrim(implode($eol, $lines), $eol);
    }

    /**
     * Determine whether last line ended while a quoted string was still "open"
     *
     * This method is used in a loop to determine if each line being read ends
     * while a quoted string is still "open".
     *
     * @param string $line Line of csv to analyze
     * @param string $quoteChar The quote/enclosure character to use
     * @param string $escapeChar The escape char/sequence to use
     * @return bool True if currently within a quoted string
     */
    protected function inQuotedString($line, $quoteChar, $escapeChar)
    {
        if (!empty($line)) {
            do {
                if (!isset($i)) $i = 0;
                $c = $line[$i++];
                if ($this->escape) {
                    $this->escape = false;
                    continue;
                }
                $this->escape = ($c == $escapeChar);
                if ($c == $quoteChar) $this->open = !$this->open;
            } while ($i < strlen($line));
        }
        return $this->open;
    }

    /**
     * Flavor Getter.
     *
     * Retreive the "flavor" object being used by the reader
     *
     * @return Flavor
     */
    public function getFlavor()
    {
        return $this->flavor;
    }

    /**
     * Check if flavor object defines header.
     *
     * Determine whether or not the input source's CSV data contains a header
     * row or not. Unless you explicitly specify so within your Flavor object,
     * this method is a logical best guess. The CSV format does not
     * provide metadata of any kind and therefor does not provide this info.
     *
     * @return boolean True if the input source has a header row (or, to be more )
     *     accurate, if the flavor SAYS it has a header row)
     * @todo Rather than always reading in Taster::SAMPLE_SIZE, read in ten lines at a time until
     *     whatever method it is has enough data to make a reliable decision/guess
     */
    public function hasHeader()
    {
        return $this->getFlavor()->header;
    }

    /**
     * Temporarily replace special characters within a quoted string
     *
     * Replace all instances of newlines and whatever character you specify (as
     * the delimiter) that are contained within quoted text. The replacements are
     * simply a special placeholder string. This is done so that I can use the
     * very unsmart "explode" function and not have to worry about it exploding
     * on delimiters or newlines within quotes. Once I have exploded, I typically
     * sub back in the real characters before doing anything else.
     *
     * @param string $data The string to do the replacements on
     * @param string $delim The delimiter character to replace
     * @param string $quo The quote character
     * @param string $eol Line terminator character/sequence
     * @return string The data with replacements performed
     * @internal
     * @todo I could probably pass in (maybe optionally) the newline character I
     *     want to replace as well. I'll do that if I need to.
     * @todo Create a regex class so you can do $regex->escape() rather than
     *     preg_quote
     */
    protected function replaceQuotedSpecialChars($data, $delim, $quo, $eol)
    {
        return preg_replace_callback('/(['. preg_quote($quo, '/') . '])(.*)\1/imsU', function($matches) use ($delim, $eol) {
            $ret = str_replace($eol, self::PLACEHOLDER_NEWLINE, $matches[0]);
            $ret = str_replace($delim, self::PLACEHOLDER_DELIM, $ret);
            return $ret;
        }, $data);
    }

    /**
     * Undo temporary special char replacements
     *
     * Replace the special character placeholders with the characters they
     * originally substituted.
     *
     * @param string $data The data to undo replacements in
     * @param string $delim The delimiter character
     * @param string $eol The character or string of characters used to terminate lines
     * @return string The data with placeholders replaced with original characters
     * @internal
     */
    protected function undoReplaceQuotedSpecialChars($data, $delim, $eol)
    {
        $replacements = array(self::PLACEHOLDER_DELIM => $delim, self::PLACEHOLDER_NEWLINE => $eol);
        if (array_walk($replacements, function($replacement, $placeholder) use (&$data) {
            $data = str_replace($placeholder, $replacement, $data);
        })) {
            return $data;
        }
    }

    /**
     * Remove quotes wrapping text.
     *
     * @param string $data The data to unquote
     * @return string The data with quotes stripped from the outside of it
     * @internal
     */
    protected function unQuote($data)
    {
        $escapeChar = $this->getFlavor()->doubleQuote ? $this->getFlavor()->quoteChar : $this->getFlavor()->escapeChar;
        $quoteChar = $this->getFlavor()->quoteChar;
        $data = $this->unEscape($data, $escapeChar, $quoteChar);
        return preg_replace('/^(["\'])(.*)\1$/ms', '\2', $data);
    }

    /**
     * "Unescape" a string.
     *
     * Replaces escaped characters with their unescaped versions.
     *
     * @internal
     * @param string $str The string to unescape
     * @param string $esc The escape character used
     * @param string $quo The quote character used
     * @return mixed The string with characters unescaped
     * @todo This actually shouldn't even be necessary. Characters should be read
     *     in one at a time and a quote that follows another should just be ignored
     *     deeming this unnecessary.
     */
    protected function unEscape($str, $esc, $quo)
    {
        return str_replace($esc . $quo, $quo, $str);
    }

    /**
     * Parse a line of CSV data into an array of columns
     *
     * @param string $line A line of CSV data to parse
     * @return array An array of columns
     * @internal
     */
    protected function parse($line)
    {
        $f = $this->getFlavor();
        $replaced = $this->replaceQuotedSpecialChars($line, $f->delimiter, $f->quoteChar, $f->lineTerminator);
        $columns = explode($f->delimiter, $replaced);
        $that = $this;
        return array_map(function($val) use ($that, $f) {
            $undone = $that->undoReplaceQuotedSpecialChars($val, $f->delimiter, $f->lineTerminator);
            return $this->unQuote($undone);
        }, $columns);
    }

    /**
     * Retrieve current row.
     *
     * @return Table\Row The current row
     */
    public function current()
    {
        return $this->current;
    }

    /**
     * Advance to the next row
     *
     * @return Table\Row|null The current row (if there is one)
     */
    public function next()
    {

        $this->current = null;
        $this->load();
        return $this->current;
    }

    /**
     * Determine if current position has valid row.
     *
     * @return boolean True if current row is valid
     */
    public function valid()
    {
        return (bool) $this->current;
    }

    /**
     * Retrieve current row key (line number).
     *
     * @return int The current line number
     */
    public function key()
    {
        return $this->line;
    }

    /**
     * Rewind to the beginning of the dataset.
     *
     * @return Table\Row|null The current row
     */
    public function rewind()
    {
        $this->line = 0;
        $this->source->rewind();
        $this->current = null;
        $this->load();
        if ($this->hasHeader()) {
            $this->next();
        }
        return $this->current();
    }

    /**
     * Retrieve header row.
     *
     * @return Table\HeaderRow The header row if there is one
     */
    public function header()
    {
        return $this->header;
    }

    /**
     * Add anonumous function as filter.
     *
     * Add an anonymous function that accepts the current row as its only argument.
     * Return true from the function to keep that row, false otherwise.
     *
     * @param Callable $filter An anonymous function to filter out row by certain criteria
     * @return $this
     */
    public function addFilter(Callable $filter)
    {
        array_push($this->filters, $filter);
        return $this;
    }

    /**
     * Add multiple filters at once.
     *
     * Add an array of anonymous functions to filter out certain rows.
     *
     * @param array $filters An array of anonymous functions
     * @return $this
     */
    public function addFilters(array $filters)
    {
        foreach ($filters as $filter) {
            $this->addFilter($filter);
        }
        return $this;
    }

    /**
     * Returns an iterator with rows from user-supplied filter functions removed
     *
     * @return FilteredReader An iterator with filtered rows
     */
    public function filter()
    {
        return new FilteredReader($this, $this->filters);
    }

    /**
     * Retrieve the contents of the dataset as an array of arrays.
     *
     * @return array An array of arrays of CSV content
     */
    public function toArray()
    {
        return array_map(function($row){
            return $row->toArray();
        }, iterator_to_array($this));
    }

}


1		<?php
2		/**
3		* CSVelte: Slender, elegant CSV for PHP
4		*
5		* Inspired by Python's CSV module and Frictionless Data and the W3C's CSV
6		* standardization efforts, CSVelte was written in an effort to take all the
7		* suck out of working with CSV.
8		*
9		* @version v0.2.1
10		* @copyright Copyright (c) 2016 Luke Visinoni <[email protected]>
11		* @author Luke Visinoni <[email protected]>
12		* @license https://github.com/deni-zen/csvelte/blob/master/LICENSE The MIT License (MIT)
13		*/
14		namespace CSVelte;
15
16		use CSVelte\Contract\Streamable;
17
18		use CSVelte\Table\Row;
19		use CSVelte\Table\HeaderRow;
20		use CSVelte\Reader\FilteredIterator as FilteredReader;
21
22		use CSVelte\Exception\EndOfFileException;
23
24		use function
25		CSVelte\streamize,
26		CSVelte\taste,
27		CSVelte\taste_has_header,
28		CSVelte\collect;
29
30		/**
31		* CSV Reader
32		*
33		* Reads CSV data from any object that implements CSVelte\Contract\Readable.
34		*
35		* @package CSVelte
36		* @subpackage Reader
37		* @since v0.1
38		* @todo Also, is there any way to do some kind of caching or something? Probably
39		* not but if you could that would be a cool feature...
40		*/
41		class Reader implements \Iterator
42		{
43		const PLACEHOLDER_DELIM = '[=[__DLIM__]=]';
44		const PLACEHOLDER_NEWLINE = '[=[__NWLN__]=]';
45
46		/**
47		* This class supports any sources of input that implements this interface.
48		* This way I can read from local files, streams, FTP, any class that implements
49		* the "Readable" interface
50		* @var Contract\Streamable
51		*/
52		protected $source;
53
54		/**
55		* @var Flavor The "flavor" or format of the CSV being read
56		*/
57		protected $flavor;
58
59		/**
60		* @var Table\Row Row currently loaded into memory
61		*/
62		protected $current;
63
64		/**
65		* @var integer The current line being read (from input source)
66		*/
67		protected $line = 0;
68
69		/**
70		* @var Table\HeaderRow The header row (if any)
71		*/
72		protected $header;
73
74		/**
75		* @var array An array of callback functions
76		*/
77		protected $filters = array();
78
79		/**
80		* @var bool True if current line ended while inside a quoted string
81		*/
82		protected $open = false;
83
84		/**
85		* @var bool True if last character read was the escape character
86		*/
87		protected $escape = false;
88
89		/**
90		* Reader Constructor.
91		* Initializes a reader object using an input source and optionally a flavor
92		*
93		* @param mixed $input The source of our CSV data
94		* @param Flavor\|array\|null $flavor The "flavor" or format specification object
95		*/
96	21	public function __construct($input, $flavor = null)
97		{
98	21	$this->setSource($input)
99	21	->setFlavor($flavor)
100	21	->rewind();
101	21	}
102
103		/**
104		* Set the flavor.
105		*
106		* Set the ``CSVelte\Flavor`` object, used to determine CSV format.
107		*
108		* @param Flavor\|array\|null $flavor Either an array or a flavor object
109		* @return $this
110		*/
111	19	protected function setFlavor($flavor = null)
112		{
113	19	if (is_array($flavor)) $flavor = new Flavor($flavor);
114		// @todo put this inside a try/catch
115	19	if (is_null($flavor)) {
116	11	$flavor = taste($this->source);
117	11	}
118	19	if (is_null($flavor->header)) {
119		// Flavor is immutable, give me a new one with header set to lickHeader return val
120	4	$flavor = $flavor->copy(['header' => taste_has_header($this->source)]);
121	4	}
122	19	$this->flavor = $flavor;
123	19	return $this;
124		}
125
126		/**
127		* Set the reader source.
128		*
129		* The reader can accept anything that implements Readable and is actually
130		* readable (can be read). This will make sure that whatever is passed to
131		* the reader meets these expectations and set $this->source. It can also
132		* accept any string (or any object with a __toString() method), or an
133		* SplFileObject, so long as it represents a file rather than a directory.
134		*
135		* @param mixed $input See description
136		* @return $this
137		*/
138	19	protected function setSource($input)
139		{
140	19	if (!($input instanceof Streamable)) {
141	9	$input = streamize($input);
142	9	}
143	19	$this->source = $input;
144	19	return $this;
145		}
146
147		/**
148		* Load a line into memory
149		*/
150	19	protected function load()
151		{
152	19	if (is_null($this->current)) {
153		try {
154	19	$line = $this->readLine();
155	19	$this->line++;
156	19	$parsed = $this->parse($line);
157	19	if ($this->hasHeader() && $this->line === 1) {
158	13	$this->header = new HeaderRow($parsed);
159	13	} else {
160	19	$this->current = new Row($parsed);
161	19	if ($this->header) $this->current->setHeaderRow($this->header);
162		}
163	19	} catch (EndOfFileException $e) {
164	7	$this->current = false;
		0 ignored issues – show Documentation Bug introduced 2016-11-06 18:03 UTC by Report Bug Copy Issue Report It seems like `false` of type `false` is incompatible with the declared type `object<CSVelte\Table\Row>` of property `$current`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
165		}
166	19	}
167	19	}
168
169		/**
170		* Read single line from CSV data source (stream, file, etc.), taking into
171		* account CSV's de-facto quoting rules with respect to designated line
172		* terminator character when they fall within quoted strings.
173		*
174		* @return string A CSV row (could possibly span multiple lines depending on
175		* quoting and escaping)
176		* @throws Exception\EndOfFileException when eof has been reached
177		* and the read buffer has all been returned
178		*/
179	19	protected function readLine()
180		{
181	19	$f = $this->getFlavor();
182	19	$eol = $f->lineTerminator;
183		try {
184		do {
185	19	if (!isset($lines)) $lines = array();
186	19	if (false === ($line = $this->source->readLine($eol))) {
187	7	throw new EndOfFileException("End of file reached");
188		}
189	19	array_push($lines, rtrim($line, $eol));
190	19	} while ($this->inQuotedString(end($lines), $f->quoteChar, $f->escapeChar));
191	19	} catch (EndOfFileException $e) {
192		// only throw the exception if we don't already have lines in the buffer
193	7	if (!count($lines)) throw $e;
194		}
195	19	return rtrim(implode($eol, $lines), $eol);
196		}
197
198		/**
199		* Determine whether last line ended while a quoted string was still "open"
200		*
201		* This method is used in a loop to determine if each line being read ends
202		* while a quoted string is still "open".
203		*
204		* @param string $line Line of csv to analyze
205		* @param string $quoteChar The quote/enclosure character to use
206		* @param string $escapeChar The escape char/sequence to use
207		* @return bool True if currently within a quoted string
208		*/
209	19	protected function inQuotedString($line, $quoteChar, $escapeChar)
210		{
211	19	if (!empty($line)) {
212		do {
213	19	if (!isset($i)) $i = 0;
214	19	$c = $line[$i++];
215	19	if ($this->escape) {
216		$this->escape = false;
217		continue;
218		}
219	19	$this->escape = ($c == $escapeChar);
220	19	if ($c == $quoteChar) $this->open = !$this->open;
221	19	} while ($i < strlen($line));
222	19	}
223	19	return $this->open;
224		}
225
226		/**
227		* Flavor Getter.
228		*
229		* Retreive the "flavor" object being used by the reader
230		*
231		* @return Flavor
232		*/
233	19	public function getFlavor()
234		{
235	19	return $this->flavor;
236		}
237
238		/**
239		* Check if flavor object defines header.
240		*
241		* Determine whether or not the input source's CSV data contains a header
242		* row or not. Unless you explicitly specify so within your Flavor object,
243		* this method is a logical best guess. The CSV format does not
244		* provide metadata of any kind and therefor does not provide this info.
245		*
246		* @return boolean True if the input source has a header row (or, to be more )
247		* accurate, if the flavor SAYS it has a header row)
248		* @todo Rather than always reading in Taster::SAMPLE_SIZE, read in ten lines at a time until
249		* whatever method it is has enough data to make a reliable decision/guess
250		*/
251	19	public function hasHeader()
252		{
253	19	return $this->getFlavor()->header;
254		}
255
256		/**
257		* Temporarily replace special characters within a quoted string
258		*
259		* Replace all instances of newlines and whatever character you specify (as
260		* the delimiter) that are contained within quoted text. The replacements are
261		* simply a special placeholder string. This is done so that I can use the
262		* very unsmart "explode" function and not have to worry about it exploding
263		* on delimiters or newlines within quotes. Once I have exploded, I typically
264		* sub back in the real characters before doing anything else.
265		*
266		* @param string $data The string to do the replacements on
267		* @param string $delim The delimiter character to replace
268		* @param string $quo The quote character
269		* @param string $eol Line terminator character/sequence
270		* @return string The data with replacements performed
271		* @internal
272		* @todo I could probably pass in (maybe optionally) the newline character I
273		* want to replace as well. I'll do that if I need to.
274		* @todo Create a regex class so you can do $regex->escape() rather than
275		* preg_quote
276		*/
277	19	protected function replaceQuotedSpecialChars($data, $delim, $quo, $eol)
278		{
279		return preg_replace_callback('/(['. preg_quote($quo, '/') . '])(.*)\1/imsU', function($matches) use ($delim, $eol) {
280	11	$ret = str_replace($eol, self::PLACEHOLDER_NEWLINE, $matches[0]);
281	11	$ret = str_replace($delim, self::PLACEHOLDER_DELIM, $ret);
282	11	return $ret;
283	19	}, $data);
284		}
285
286		/**
287		* Undo temporary special char replacements
288		*
289		* Replace the special character placeholders with the characters they
290		* originally substituted.
291		*
292		* @param string $data The data to undo replacements in
293		* @param string $delim The delimiter character
294		* @param string $eol The character or string of characters used to terminate lines
295		* @return string The data with placeholders replaced with original characters
296		* @internal
297		*/
298	19	protected function undoReplaceQuotedSpecialChars($data, $delim, $eol)
299		{
300	19	$replacements = array(self::PLACEHOLDER_DELIM => $delim, self::PLACEHOLDER_NEWLINE => $eol);
301		if (array_walk($replacements, function($replacement, $placeholder) use (&$data) {
302	19	$data = str_replace($placeholder, $replacement, $data);
303	19	})) {
304	19	return $data;
305		}
306		}
307
308		/**
309		* Remove quotes wrapping text.
310		*
311		* @param string $data The data to unquote
312		* @return string The data with quotes stripped from the outside of it
313		* @internal
314		*/
315	19	protected function unQuote($data)
316		{
317	19	$escapeChar = $this->getFlavor()->doubleQuote ? $this->getFlavor()->quoteChar : $this->getFlavor()->escapeChar;
318	19	$quoteChar = $this->getFlavor()->quoteChar;
319	19	$data = $this->unEscape($data, $escapeChar, $quoteChar);
320	19	return preg_replace('/^(["\'])(.*)\1$/ms', '\2', $data);
321		}
322
323		/**
324		* "Unescape" a string.
325		*
326		* Replaces escaped characters with their unescaped versions.
327		*
328		* @internal
329		* @param string $str The string to unescape
330		* @param string $esc The escape character used
331		* @param string $quo The quote character used
332		* @return mixed The string with characters unescaped
333		* @todo This actually shouldn't even be necessary. Characters should be read
334		* in one at a time and a quote that follows another should just be ignored
335		* deeming this unnecessary.
336		*/
337	19	protected function unEscape($str, $esc, $quo)
338		{
339	19	return str_replace($esc . $quo, $quo, $str);
340		}
341
342		/**
343		* Parse a line of CSV data into an array of columns
344		*
345		* @param string $line A line of CSV data to parse
346		* @return array An array of columns
347		* @internal
348		*/
349	19	protected function parse($line)
350		{
351	19	$f = $this->getFlavor();
352	19	$replaced = $this->replaceQuotedSpecialChars($line, $f->delimiter, $f->quoteChar, $f->lineTerminator);
353	19	$columns = explode($f->delimiter, $replaced);
354	19	$that = $this;
355		return array_map(function($val) use ($that, $f) {
356	19	$undone = $that->undoReplaceQuotedSpecialChars($val, $f->delimiter, $f->lineTerminator);
357	19	return $this->unQuote($undone);
358	19	}, $columns);
359		}
360
361		/**
362		* Retrieve current row.
363		*
364		* @return Table\Row The current row
365		*/
366	19	public function current()
367		{
368	19	return $this->current;
369		}
370
371		/**
372		* Advance to the next row
373		*
374		* @return Table\Row\|null The current row (if there is one)
375		*/
376	14	public function next()
377		{
378
379	14	$this->current = null;
380	14	$this->load();
381	14	return $this->current;
382		}
383
384		/**
385		* Determine if current position has valid row.
386		*
387		* @return boolean True if current row is valid
388		*/
389	8	public function valid()
390		{
391	8	return (bool) $this->current;
392		}
393
394		/**
395		* Retrieve current row key (line number).
396		*
397		* @return int The current line number
398		*/
399	5	public function key()
400		{
401	5	return $this->line;
402		}
403
404		/**
405		* Rewind to the beginning of the dataset.
406		*
407		* @return Table\Row\|null The current row
408		*/
409	19	public function rewind()
410		{
411	19	$this->line = 0;
412	19	$this->source->rewind();
413	19	$this->current = null;
414	19	$this->load();
415	19	if ($this->hasHeader()) {
416	13	$this->next();
417	13	}
418	19	return $this->current();
419		}
420
421		/**
422		* Retrieve header row.
423		*
424		* @return Table\HeaderRow The header row if there is one
425		*/
426	2	public function header()
427		{
428	2	return $this->header;
429		}
430
431		/**
432		* Add anonumous function as filter.
433		*
434		* Add an anonymous function that accepts the current row as its only argument.
435		* Return true from the function to keep that row, false otherwise.
436		*
437		* @param Callable $filter An anonymous function to filter out row by certain criteria
438		* @return $this
439		*/
440	3	public function addFilter(Callable $filter)
441		{
442	3	array_push($this->filters, $filter);
443	3	return $this;
444		}
445
446		/**
447		* Add multiple filters at once.
448		*
449		* Add an array of anonymous functions to filter out certain rows.
450		*
451		* @param array $filters An array of anonymous functions
452		* @return $this
453		*/
454	1	public function addFilters(array $filters)
455		{
456	1	foreach ($filters as $filter) {
457	1	$this->addFilter($filter);
458	1	}
459	1	return $this;
460		}
461
462		/**
463		* Returns an iterator with rows from user-supplied filter functions removed
464		*
465		* @return FilteredReader An iterator with filtered rows
466		*/
467	3	public function filter()
468		{
469	3	return new FilteredReader($this, $this->filters);
470		}
471
472		/**
473		* Retrieve the contents of the dataset as an array of arrays.
474		*
475		* @return array An array of arrays of CSV content
476		*/
477		public function toArray()
478		{
479	1	return array_map(function($row){
480	1	return $row->toArray();
481	1	}, iterator_to_array($this));
482		}
483
484		}
485

nozavroni / csvelte

Push — master ( 5c1aea...9ef1c4 )

Reader::header() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like