AbstractCsv::validateString() - Code Metrics - Inspection of "Decoupling Query from Reader" - thephpleague/csv - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#178)

by ignace nyamagana

created 2016-09-06 20:09 UTC

AbstractCsv::validateString() A

↳ Parent: AbstractCsv

Complexity

Conditions	4
Paths	2

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	4

Importance

Changes	3
Bugs	0	Features	0

Metric	Value
c	3
b	0
f	0
dl	0
loc	7
ccs	3
cts	3
cp	1
rs	9.2
cc	4
eloc	4
nc	2
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 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 InvalidArgumentException;
use IteratorAggregate;
use League\Csv\Config\Controls;
use SplFileInfo;
use SplFileObject;
use SplTempFileObject;

/**
 *  An abstract class to enable basic CSV manipulation
 *
 * @package League.csv
 * @since  4.0.0
 *
 */
abstract class AbstractCsv implements IteratorAggregate
{
    use Controls;

    /**
     *  UTF-8 BOM sequence
     */
    const BOM_UTF8 = "\xEF\xBB\xBF";

    /**
     * UTF-16 BE BOM sequence
     */
    const BOM_UTF16_BE = "\xFE\xFF";

    /**
     * UTF-16 LE BOM sequence
     */
    const BOM_UTF16_LE = "\xFF\xFE";

    /**
     * UTF-32 BE BOM sequence
     */
    const BOM_UTF32_BE = "\x00\x00\xFE\xFF";

    /**
     * UTF-32 LE BOM sequence
     */
    const BOM_UTF32_LE = "\x00\x00\xFF\xFE";

    /**
     * The constructor path
     *
     * can be a SplFileInfo object or the string path to a file
     *
     * @var SplFileObject|string
     */
    protected $path;

    /**
     * The file open mode flag
     *
     * @var string
     */
    protected $open_mode;

    /**
     * Creates a new instance
     *
     * The path must be an SplFileInfo object
     * an object that implements the `__toString` method
     * a path to a file
     *
     * @param SplFileObject|string $path      The file path
     * @param string               $open_mode The file open mode flag
     */
    protected function __construct($path, $open_mode = 'r+')
    {
        $this->open_mode = strtolower($open_mode);
        $this->path = $path;
        $this->initStreamFilter($this->path);
    }

    /**
     * The destructor
     */
    public function __destruct()
    {
        $this->path = null;
    }

    /**
     * Return a new {@link AbstractCsv} from a SplFileObject
     *
     * @param SplFileObject $file
     *
     * @return static
     */
    public static function createFromFileObject(SplFileObject $file)
    {
        $csv = new static($file);
        $controls = $file->getCsvControl();
        $csv->setDelimiter($controls[0]);
        $csv->setEnclosure($controls[1]);
        if (isset($controls[2])) {
            $csv->setEscape($controls[2]);
        }

        return $csv;
    }

    /**
     * Return a new {@link AbstractCsv} from a string
     *
     * The string must be an object that implements the `__toString` method,
     * or a string
     *
     * @param string|object $str the string
     *
     * @return static
     */
    public static function createFromString($str)
    {
        $file = new SplTempFileObject();
        $file->fwrite(static::validateString($str));

        return new static($file);
    }

    /**
     * Return a new {@link AbstractCsv} from a string
     *
     * @param mixed  $path      file path
     * @param string $open_mode the file open mode flag
     *
     * @throws InvalidArgumentException If $path is a SplTempFileObject object
     *
     * @return static
     */
    public static function createFromPath($path, $open_mode = 'r+')
    {
        if ($path instanceof SplTempFileObject) {
            throw new InvalidArgumentException('an `SplTempFileObject` object does not contain a valid path');
        }

        if ($path instanceof SplFileInfo) {
            $path = $path->getPath().'/'.$path->getBasename();
        }

        return new static(static::validateString($path), $open_mode);
    }

    /**
     * Return a new {@link AbstractCsv} instance from another {@link AbstractCsv} object
     *
     * @param string $class     the class to be instantiated
     * @param string $open_mode the file open mode flag
     *
     * @return static
     */
    protected function newInstance($class, $open_mode)
    {
        $csv = new $class($this->path, $open_mode);
        $csv->delimiter = $this->delimiter;
        $csv->enclosure = $this->enclosure;
        $csv->escape = $this->escape;
        $csv->input_encoding = $this->input_encoding;
        $csv->input_bom = $this->input_bom;
        $csv->output_bom = $this->output_bom;
        $csv->newline = $this->newline;

        return $csv;
    }

    /**
     * Return a new {@link Writer} instance from a {@link AbstractCsv} object
     *
     * @param string $open_mode the file open mode flag
     *
     * @return Writer
     */
    public function newWriter($open_mode = 'r+')
    {
        return $this->newInstance(Writer::class, $open_mode);
    }

    /**
     * Return a new {@link Reader} instance from a {@link AbstractCsv} object
     *
     * @param string $open_mode the file open mode flag
     *
     * @return Reader
     */
    public function newReader($open_mode = 'r+')
    {
        return $this->newInstance(Reader::class, $open_mode);
    }

    /**
     * Returns the inner SplFileObject
     *
     * @return SplFileObject
     */
    public function getIterator()
    {
        $iterator = $this->path;
        if (!$iterator instanceof SplFileObject) {
            $iterator = new SplFileObject($this->getStreamFilterPath(), $this->open_mode);
        }
        $iterator->setCsvControl($this->delimiter, $this->enclosure, $this->escape);
        $iterator->setFlags(SplFileObject::READ_CSV | SplFileObject::READ_AHEAD | SplFileObject::SKIP_EMPTY);

        return $iterator;
    }

    /**
     * Returns the Record object
     *
     * @param Query|null $query
     *
     * @return Records
     */
    public function getRecords(Query $query = null)
    {
        $query = $query ?: new Query();

        return $query($this);
    }
}


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 8.1.1
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		namespace League\Csv;
14
15		use InvalidArgumentException;
16		use IteratorAggregate;
17		use League\Csv\Config\Controls;
18		use SplFileInfo;
19		use SplFileObject;
20		use SplTempFileObject;
21
22		/**
23		* An abstract class to enable basic CSV manipulation
24		*
25		* @package League.csv
26		* @since 4.0.0
27		*
28		*/
29		abstract class AbstractCsv implements IteratorAggregate
30		{
31		use Controls;
32
33		/**
34		* UTF-8 BOM sequence
35		*/
36		const BOM_UTF8 = "\xEF\xBB\xBF";
37
38		/**
39		* UTF-16 BE BOM sequence
40		*/
41		const BOM_UTF16_BE = "\xFE\xFF";
42
43		/**
44		* UTF-16 LE BOM sequence
45		*/
46		const BOM_UTF16_LE = "\xFF\xFE";
47
48		/**
49		* UTF-32 BE BOM sequence
50		*/
51		const BOM_UTF32_BE = "\x00\x00\xFE\xFF";
52
53		/**
54		* UTF-32 LE BOM sequence
55		*/
56		const BOM_UTF32_LE = "\x00\x00\xFF\xFE";
57
58		/**
59		* The constructor path
60		*
61		* can be a SplFileInfo object or the string path to a file
62		*
63		* @var SplFileObject\|string
64		*/
65		protected $path;
66
67		/**
68		* The file open mode flag
69		*
70		* @var string
71		*/
72		protected $open_mode;
73
74		/**
75		* Creates a new instance
76		*
77		* The path must be an SplFileInfo object
78		* an object that implements the `__toString` method
79		* a path to a file
80		*
81		* @param SplFileObject\|string $path The file path
82		* @param string $open_mode The file open mode flag
83		*/
84		protected function __construct($path, $open_mode = 'r+')
85		{
86		$this->open_mode = strtolower($open_mode);
87		$this->path = $path;
88		$this->initStreamFilter($this->path);
89		}
90
91		/**
92		* The destructor
93		*/
94		public function __destruct()
95		{
96		$this->path = null;
97		}
98
99		/**
100		* Return a new {@link AbstractCsv} from a SplFileObject
101		*
102		* @param SplFileObject $file
103		*
104		* @return static
105	357	*/
106		public static function createFromFileObject(SplFileObject $file)
107	357	{
108	357	$csv = new static($file);
109	357	$controls = $file->getCsvControl();
110	357	$csv->setDelimiter($controls[0]);
111		$csv->setEnclosure($controls[1]);
112		if (isset($controls[2])) {
113		$csv->setEscape($controls[2]);
114		}
115	240
116		return $csv;
117	240	}
118	240
119		/**
120		* Return a new {@link AbstractCsv} from a string
121		*
122		* The string must be an object that implements the `__toString` method,
123		* or a string
124		*
125		* @param string\|object $str the string
126		*
127	312	* @return static
128		*/
129	312	public static function createFromString($str)
130		{
131		$file = new SplTempFileObject();
132		$file->fwrite(static::validateString($str));
133
134		return new static($file);
135		}
136
137		/**
138		* Return a new {@link AbstractCsv} from a string
139		*
140		* @param mixed $path file path
141		* @param string $open_mode the file open mode flag
142	27	*
143		* @throws InvalidArgumentException If $path is a SplTempFileObject object
144	27	*
145	27	* @return static
146		*/
147	27	public static function createFromPath($path, $open_mode = 'r+')
148		{
149		if ($path instanceof SplTempFileObject) {
150		throw new InvalidArgumentException('an `SplTempFileObject` object does not contain a valid path');
151		}
152
153		if ($path instanceof SplFileInfo) {
154		$path = $path->getPath().'/'.$path->getBasename();
155		}
156
157		return new static(static::validateString($path), $open_mode);
158		}
159	90
160		/**
161	90	* Return a new {@link AbstractCsv} instance from another {@link AbstractCsv} object
162	87	*
163		* @param string $class the class to be instantiated
164	3	* @param string $open_mode the file open mode flag
165		*
166		* @return static
167		*/
168		protected function newInstance($class, $open_mode)
169		{
170		$csv = new $class($this->path, $open_mode);
171		$csv->delimiter = $this->delimiter;
172		$csv->enclosure = $this->enclosure;
173		$csv->escape = $this->escape;
174		$csv->input_encoding = $this->input_encoding;
175		$csv->input_bom = $this->input_bom;
176		$csv->output_bom = $this->output_bom;
177	54	$csv->newline = $this->newline;
178
179	54	return $csv;
180	3	}
181
182		/**
183	51	* Return a new {@link Writer} instance from a {@link AbstractCsv} object
184	3	*
185	2	* @param string $open_mode the file open mode flag
186		*
187	51	* @return Writer
188		*/
189		public function newWriter($open_mode = 'r+')
190		{
191		return $this->newInstance(Writer::class, $open_mode);
192		}
193
194		/**
195		* Return a new {@link Reader} instance from a {@link AbstractCsv} object
196		*
197		* @param string $open_mode the file open mode flag
198	6	*
199		* @return Reader
200	6	*/
201	6	public function newReader($open_mode = 'r+')
202	6	{
203	6	return $this->newInstance(Reader::class, $open_mode);
204	6	}
205	6
206	6	/**
207	6	* Returns the inner SplFileObject
208		*
209	6	* @return SplFileObject
210		*/
211		public function getIterator()
212		{
213		$iterator = $this->path;
214		if (!$iterator instanceof SplFileObject) {
215		$iterator = new SplFileObject($this->getStreamFilterPath(), $this->open_mode);
216		}
217		$iterator->setCsvControl($this->delimiter, $this->enclosure, $this->escape);
218		$iterator->setFlags(SplFileObject::READ_CSV \| SplFileObject::READ_AHEAD \| SplFileObject::SKIP_EMPTY);
219	3
220		return $iterator;
221	3	}
222
223		/**
224		* Returns the Record object
225		*
226		* @param Query\|null $query
227		*
228		* @return Records
229		*/
230		public function getRecords(Query $query = null)
231	3	{
232		$query = $query ?: new Query();
233	3
234		return $query($this);
235		}
236		}
237

thephpleague / csv

Pull Request — master (#178)

AbstractCsv::validateString() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like