Converter::itemToElement() - Code Metrics - Inspection of "Adding a Converter class" - thephpleague/csv - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( c4412d...290452 )

by ignace nyamagana

created 2017-03-16 17:02 UTC

Converter::itemToElement() A

↳ Parent: Converter

Complexity

Conditions	1
Paths	1

Size

Total Lines	7
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	1

Importance

Changes

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

<?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 DOMDocument;
use DOMElement;
use Iterator;
use League\Csv\Exception\InvalidArgumentException;
use Traversable;

/**
 * A class to convert CSV records into a DOMDOcument object
 *
 * @package League.csv
 * @since   9.0.0
 * @author  Ignace Nyamagana Butera <[email protected]>
 * @internal used internally to returns the DOMDocument object representation of a CSV document
 *
 */
class Converter
{
    use ValidatorTrait;

    /**
     * XML Root name
     *
     * @var string
     */
    protected $root_name = 'csv';

    /**
     * XML Node name
     *
     * @var string
     */
    protected $record_name = 'row';

    /**
     * XML Item name
     *
     * @var string
     */
    protected $item_name = 'cell';

    /**
     * XML column attribute name
     *
     * @var string
     */
    protected $column_attr = 'name';

    /**
     * XML offset attribute name
     *
     * @var string
     */
    protected $offset_attr = 'offset';

    /**
     * Tell whether to preserve offset
     *
     * @var bool
     */
    protected $preserve_offset = false;

    /**
     * Charset Encoding for the CSV
     *
     * This information is used when converting the CSV to XML or JSON
     *
     * @var string
     */
    protected $input_encoding = 'UTF-8';

    /**
     * Conversion method list
     *
     * @var array
     */
    protected $encoder = [
        'item' => [
            true => 'itemToElementWithAttribute',
            false => 'itemToElement',
        ],
        'record' => [
            true => 'recordToElementWithAttribute',
            false => 'recordToElement',
        ],
    ];

    /**
     * XML Root name setter
     *
     * @param string $root_name
     *
     * @return self
     */
    public function rootName(string $root_name): self
    {
        if ($root_name === $this->root_name) {
            return $this;
        }

        $clone = clone $this;
        $clone->root_name = $root_name;

        return $clone;
    }

    /**
     * XML Record name setter
     *
     * @param string $record_name
     *
     * @return self
     */
    public function recordName(string $record_name): self
    {
        if ($record_name === $this->record_name) {
            return $this;
        }

        $clone = clone $this;
        $clone->record_name = $record_name;

        return $clone;
    }

    /**
     * XML Item name setter
     *
     * @param string $item_name
     *
     * @return self
     */
    public function itemName(string $item_name): self
    {
        if ($item_name === $this->item_name) {
            return $this;
        }

        $clone = clone $this;
        $clone->item_name = $item_name;

        return $clone;
    }

    /**
     * XML Column attribute name setter
     *
     * @param string $column_attr
     *
     * @return self
     */
    public function columnAttributeName(string $column_attr): self
    {
        if ($column_attr === $this->column_attr) {
            return $this;
        }

        $clone = clone $this;
        $clone->column_attr = $column_attr;

        return $clone;
    }

    /**
     * XML Offset attribute name setter
     *
     * @param string $offset_attr
     *
     * @return self
     */
    public function offsetAttributeName(string $offset_attr): self
    {
        if ($offset_attr === $this->offset_attr) {
            return $this;
        }

        $clone = clone $this;
        $clone->offset_attr = $offset_attr;

        return $clone;
    }


    /**
     * Whether we should preserve the CSV records keys.
     *
     * If set to true CSV document record keys will added to
     * the conversion output .
     *
     * @param bool $status
     *
     * @return self
     */
    public function preserveOffset(bool $status): self
    {
        if ($status === $this->preserve_offset) {
            return $this;
        }

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

        return $clone;
    }

    /**
     * Sets the CSV encoding charset
     *
     * @param string $str
     *
     * @throws InvalidArgumentException if the charset is empty
     *
     * @return static
     */
    public function inputEncoding(string $str): self
    {
        $str = str_replace('_', '-', $str);
        $str = filter_var($str, FILTER_SANITIZE_STRING, ['flags' => FILTER_FLAG_STRIP_LOW | FILTER_FLAG_STRIP_HIGH]);
        $str = trim($str);
        if ('' === $str) {
            throw new InvalidArgumentException('you should use a valid charset');
        }
        $input_encoding = strtoupper($str);
        if ($this->input_encoding == $input_encoding) {
            return $this;
        }

        $clone = clone $this;
        $clone->input_encoding = $input_encoding;

        return $clone;
    }

    /**
     * Convert Csv file into UTF-8
     *
     * @param array|Traversable $records the CSV records collection
     *
     * @return array|Iterator
     */
    protected function convertToUtf8($records)
    {
        if (stripos($this->input_encoding, 'UTF-8') !== false) {
            return $records;
        }

        $walker = function (&$value, &$offset) {
            $value = mb_convert_encoding((string) $value, 'UTF-8', $this->input_encoding);
            $offset = mb_convert_encoding((string) $offset, 'UTF-8', $this->input_encoding);
        };

        $convert = function (array $record) use ($walker): array {
            array_walk($record, $walker);
            return $record;
        };

        return is_array($records) ? array_map($convert, $records) : new MapIterator($records, $convert);
    }

    /**
     * Convert an Record collection into a DOMDocument
     *
     * @param array|Traversable $records the CSV records collection
     *
     * @return DOMDocument
     */
    public function toXML($records): DOMDocument
    {
        $item_encoder = $this->encoder['item'][$this->preserve_offset];
        $record_encoder = $this->encoder['record'][$this->preserve_offset];
        $doc = new DOMDocument('1.0', 'UTF-8');
        $root = $doc->createElement($this->root_name);
        $records = $this->convertToUtf8($this->filterIterable($records, __METHOD__));
        foreach ($records as $offset => $record) {
            $node = $this->{$record_encoder}($doc, $record, $item_encoder, $offset);
            $root->appendChild($node);
        }
        $doc->appendChild($root);

        return $doc;
    }

    /**
     * Convert an Record collection into a Json string
     *
     * @param array|Traversable $records the CSV records collection
     *
     * @return string
     */
    public function toJson($records, int $options = 0, int $depth = 512): string
    {
        $records = $this->convertToUtf8($this->filterIterable($records, __METHOD__));
        if (!is_array($records)) {
            return json_encode(iterator_to_array($records, $this->preserve_offset), $options, $depth);
        }

        return json_encode(!$this->preserve_offset ? array_values($records) : $records, $options, $depth);
    }

    /**
     * Convert an Record collection into a HTML table
     *
     * @param array|Traversable $records the CSV records collection
     *
     * @return DOMDocument
     */
    public function toHTML($records, string $class_attr = 'table-csv-data'): string
    {
        $doc = $this->rootName('table')->recordName('tr')->itemName('td')->toXML($records);
        $doc->documentElement->setAttribute('class', $class_attr);

        return $doc->saveHTML($doc->documentElement);
    }

    /**
     * Convert a CSV record into a DOMElement and
     * adds its offset as DOMElement attribute
     *
     * @param DOMDocument $doc
     * @param array       $record       CSV record
     * @param string      $item_encoder CSV Cell encoder method name
     * @param int         $offset       CSV record offset
     *
     * @return DOMElement
     */
    protected function recordToElementWithAttribute(DOMDocument $doc, array $record, string $item_encoder, int $offset): DOMElement
    {
        $node = $this->recordToElement($doc, $record, $item_encoder);
        $node->setAttribute($this->offset_attr, (string) $offset);

        return $node;
    }

    /**
     * Convert a CSV record into a DOMElement
     *
     * @param DOMDocument $doc
     * @param array       $record       CSV record
     * @param string      $item_encoder CSV Cell encoder method name
     *
     * @return DOMElement
     */
    protected function recordToElement(DOMDocument $doc, array $record, string $item_encoder): DOMElement
    {
        $node = $doc->createElement($this->record_name);
        foreach ($record as $name => $value) {
            $item = $this->{$item_encoder}($doc, $value, $name);
            $node->appendChild($item);
        }

        return $node;
    }

    /**
     * Convert Cell to Item.
     *
     * Convert the CSV item into a DOMElement and adds the item offset
     * as attribute to the returned DOMElement
     *
     * @param DOMDocument $doc
     * @param string      $value Record item value
     * @param int|string  $name  Record item offset
     *
     * @return DOMElement
     */
    protected function itemToElementWithAttribute(DOMDocument $doc, string $value, $name): DOMElement
    {
        $item = $this->itemToElement($doc, $value);
        $item->setAttribute($this->column_attr, (string) $name);

        return $item;
    }

    /**
     * Convert Cell to Item
     *
     * @param DOMDocument $doc
     * @param string      $value Record item value
     *
     * @return DOMElement
     */
    protected function itemToElement(DOMDocument $doc, string $value): DOMElement
    {
        $item = $doc->createElement($this->item_name);
        $item->appendChild($doc->createTextNode($value));

        return $item;
    }
}


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 DOMDocument;
18		use DOMElement;
19		use Iterator;
20		use League\Csv\Exception\InvalidArgumentException;
21		use Traversable;
22
23		/**
24		* A class to convert CSV records into a DOMDOcument object
25		*
26		* @package League.csv
27		* @since 9.0.0
28		* @author Ignace Nyamagana Butera <[email protected]>
29		* @internal used internally to returns the DOMDocument object representation of a CSV document
30		*
31		*/
32		class Converter
33		{
34		use ValidatorTrait;
35
36		/**
37		* XML Root name
38		*
39		* @var string
40		*/
41		protected $root_name = 'csv';
42
43		/**
44		* XML Node name
45		*
46		* @var string
47		*/
48		protected $record_name = 'row';
49
50		/**
51		* XML Item name
52		*
53		* @var string
54		*/
55		protected $item_name = 'cell';
56
57		/**
58		* XML column attribute name
59		*
60		* @var string
61		*/
62		protected $column_attr = 'name';
63
64		/**
65		* XML offset attribute name
66		*
67		* @var string
68		*/
69		protected $offset_attr = 'offset';
70
71		/**
72		* Tell whether to preserve offset
73		*
74		* @var bool
75		*/
76		protected $preserve_offset = false;
77
78		/**
79		* Charset Encoding for the CSV
80		*
81		* This information is used when converting the CSV to XML or JSON
82		*
83		* @var string
84		*/
85		protected $input_encoding = 'UTF-8';
86
87		/**
88		* Conversion method list
89		*
90		* @var array
91		*/
92		protected $encoder = [
93		'item' => [
94		true => 'itemToElementWithAttribute',
95		false => 'itemToElement',
96		],
97		'record' => [
98		true => 'recordToElementWithAttribute',
99		false => 'recordToElement',
100		],
101		];
102
103		/**
104		* XML Root name setter
105		*
106		* @param string $root_name
107		*
108		* @return self
109		*/
110	6	public function rootName(string $root_name): self
111		{
112	6	if ($root_name === $this->root_name) {
113	2	return $this;
114		}
115
116	4	$clone = clone $this;
117	4	$clone->root_name = $root_name;
118
119	4	return $clone;
120		}
121
122		/**
123		* XML Record name setter
124		*
125		* @param string $record_name
126		*
127		* @return self
128		*/
129	6	public function recordName(string $record_name): self
130		{
131	6	if ($record_name === $this->record_name) {
132	2	return $this;
133		}
134
135	4	$clone = clone $this;
136	4	$clone->record_name = $record_name;
137
138	4	return $clone;
139		}
140
141		/**
142		* XML Item name setter
143		*
144		* @param string $item_name
145		*
146		* @return self
147		*/
148	6	public function itemName(string $item_name): self
149		{
150	6	if ($item_name === $this->item_name) {
151	2	return $this;
152		}
153
154	4	$clone = clone $this;
155	4	$clone->item_name = $item_name;
156
157	4	return $clone;
158		}
159
160		/**
161		* XML Column attribute name setter
162		*
163		* @param string $column_attr
164		*
165		* @return self
166		*/
167	4	public function columnAttributeName(string $column_attr): self
168		{
169	4	if ($column_attr === $this->column_attr) {
170	2	return $this;
171		}
172
173	2	$clone = clone $this;
174	2	$clone->column_attr = $column_attr;
175
176	2	return $clone;
177		}
178
179		/**
180		* XML Offset attribute name setter
181		*
182		* @param string $offset_attr
183		*
184		* @return self
185		*/
186	4	public function offsetAttributeName(string $offset_attr): self
187		{
188	4	if ($offset_attr === $this->offset_attr) {
189	2	return $this;
190		}
191
192	2	$clone = clone $this;
193	2	$clone->offset_attr = $offset_attr;
194
195	2	return $clone;
196		}
197
198
199		/**
200		* Whether we should preserve the CSV records keys.
201		*
202		* If set to true CSV document record keys will added to
203		* the conversion output .
204		*
205		* @param bool $status
206		*
207		* @return self
208		*/
209	6	public function preserveOffset(bool $status): self
210		{
211	6	if ($status === $this->preserve_offset) {
212	2	return $this;
213		}
214
215	4	$clone = clone $this;
216	4	$clone->preserve_offset = $status;
217
218	4	return $clone;
219		}
220
221		/**
222		* Sets the CSV encoding charset
223		*
224		* @param string $str
225		*
226		* @throws InvalidArgumentException if the charset is empty
227		*
228		* @return static
229		*/
230	12	public function inputEncoding(string $str): self
231		{
232	12	$str = str_replace('_', '-', $str);
233	12	$str = filter_var($str, FILTER_SANITIZE_STRING, ['flags' => FILTER_FLAG_STRIP_LOW \| FILTER_FLAG_STRIP_HIGH]);
234	12	$str = trim($str);
235	12	if ('' === $str) {
236	2	throw new InvalidArgumentException('you should use a valid charset');
237		}
238	10	$input_encoding = strtoupper($str);
239	10	if ($this->input_encoding == $input_encoding) {
240	2	return $this;
241		}
242
243	8	$clone = clone $this;
244	8	$clone->input_encoding = $input_encoding;
245
246	8	return $clone;
247		}
248
249		/**
250		* Convert Csv file into UTF-8
251		*
252		* @param array\|Traversable $records the CSV records collection
253		*
254		* @return array\|Iterator
255		*/
256	6	protected function convertToUtf8($records)
257		{
258	6	if (stripos($this->input_encoding, 'UTF-8') !== false) {
259	2	return $records;
260		}
261
262		$walker = function (&$value, &$offset) {
263	4	$value = mb_convert_encoding((string) $value, 'UTF-8', $this->input_encoding);
264	4	$offset = mb_convert_encoding((string) $offset, 'UTF-8', $this->input_encoding);
265	4	};
266
267	4	$convert = function (array $record) use ($walker): array {
268	4	array_walk($record, $walker);
269	4	return $record;
270	4	};
271
272	4	return is_array($records) ? array_map($convert, $records) : new MapIterator($records, $convert);
273		}
274
275		/**
276		* Convert an Record collection into a DOMDocument
277		*
278		* @param array\|Traversable $records the CSV records collection
279		*
280		* @return DOMDocument
281		*/
282	4	public function toXML($records): DOMDocument
283		{
284	4	$item_encoder = $this->encoder['item'][$this->preserve_offset];
285	4	$record_encoder = $this->encoder['record'][$this->preserve_offset];
286	4	$doc = new DOMDocument('1.0', 'UTF-8');
287	4	$root = $doc->createElement($this->root_name);
288	4	$records = $this->convertToUtf8($this->filterIterable($records, __METHOD__));
289	4	foreach ($records as $offset => $record) {
290	4	$node = $this->{$record_encoder}($doc, $record, $item_encoder, $offset);
291	4	$root->appendChild($node);
292		}
293	4	$doc->appendChild($root);
294
295	4	return $doc;
296		}
297
298		/**
299		* Convert an Record collection into a Json string
300		*
301		* @param array\|Traversable $records the CSV records collection
302		*
303		* @return string
304		*/
305	2	public function toJson($records, int $options = 0, int $depth = 512): string
306		{
307	2	$records = $this->convertToUtf8($this->filterIterable($records, __METHOD__));
308	2	if (!is_array($records)) {
309	2	return json_encode(iterator_to_array($records, $this->preserve_offset), $options, $depth);
310		}
311
312	2	return json_encode(!$this->preserve_offset ? array_values($records) : $records, $options, $depth);
313		}
314
315		/**
316		* Convert an Record collection into a HTML table
317		*
318		* @param array\|Traversable $records the CSV records collection
319		*
320		* @return DOMDocument
321		*/
322	2	public function toHTML($records, string $class_attr = 'table-csv-data'): string
323		{
324	2	$doc = $this->rootName('table')->recordName('tr')->itemName('td')->toXML($records);
325	2	$doc->documentElement->setAttribute('class', $class_attr);
326
327	2	return $doc->saveHTML($doc->documentElement);
328		}
329
330		/**
331		* Convert a CSV record into a DOMElement and
332		* adds its offset as DOMElement attribute
333		*
334		* @param DOMDocument $doc
335		* @param array $record CSV record
336		* @param string $item_encoder CSV Cell encoder method name
337		* @param int $offset CSV record offset
338		*
339		* @return DOMElement
340		*/
341	2	protected function recordToElementWithAttribute(DOMDocument $doc, array $record, string $item_encoder, int $offset): DOMElement
342		{
343	2	$node = $this->recordToElement($doc, $record, $item_encoder);
344	2	$node->setAttribute($this->offset_attr, (string) $offset);
345
346	2	return $node;
347		}
348
349		/**
350		* Convert a CSV record into a DOMElement
351		*
352		* @param DOMDocument $doc
353		* @param array $record CSV record
354		* @param string $item_encoder CSV Cell encoder method name
355		*
356		* @return DOMElement
357		*/
358	4	protected function recordToElement(DOMDocument $doc, array $record, string $item_encoder): DOMElement
359		{
360	4	$node = $doc->createElement($this->record_name);
361	4	foreach ($record as $name => $value) {
362	4	$item = $this->{$item_encoder}($doc, $value, $name);
363	4	$node->appendChild($item);
364		}
365
366	4	return $node;
367		}
368
369		/**
370		* Convert Cell to Item.
371		*
372		* Convert the CSV item into a DOMElement and adds the item offset
373		* as attribute to the returned DOMElement
374		*
375		* @param DOMDocument $doc
376		* @param string $value Record item value
377		* @param int\|string $name Record item offset
378		*
379		* @return DOMElement
380		*/
381	2	protected function itemToElementWithAttribute(DOMDocument $doc, string $value, $name): DOMElement
382		{
383	2	$item = $this->itemToElement($doc, $value);
384	2	$item->setAttribute($this->column_attr, (string) $name);
385
386	2	return $item;
387		}
388
389		/**
390		* Convert Cell to Item
391		*
392		* @param DOMDocument $doc
393		* @param string $value Record item value
394		*
395		* @return DOMElement
396		*/
397	4	protected function itemToElement(DOMDocument $doc, string $value): DOMElement
398		{
399	4	$item = $doc->createElement($this->item_name);
400	4	$item->appendChild($doc->createTextNode($value));
401
402	4	return $item;
403		}
404		}
405

thephpleague / csv

Push — master ( c4412d...290452 )

Converter::itemToElement() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like