CharsetConverter::encodeField() - Code Metrics - Inspection of "Update coding standard" - thephpleague/csv - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( ecd0f8...3ad52b )

by ignace nyamagana

created 2018-07-30 14:40 UTC

CharsetConverter::encodeField() A

↳ Parent: CharsetConverter

Complexity

Conditions	4
Paths	4

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	5
CRAP Score	4

Importance

Changes

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

<?php

/**
 * League.Csv (https://csv.thephpleague.com).
 *
 * @author  Ignace Nyamagana Butera <[email protected]>
 * @license https://github.com/thephpleague/csv/blob/master/LICENSE (MIT License)
 * @version 9.1.5
 * @link    https://github.com/thephpleague/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 OutOfRangeException;
use php_user_filter;
use Traversable;
use TypeError;
use function array_combine;
use function array_map;
use function array_walk;
use function gettype;
use function in_array;
use function is_iterable;
use function is_numeric;
use function mb_convert_encoding;
use function mb_list_encodings;
use function preg_match;
use function sprintf;
use function stream_bucket_append;
use function stream_bucket_make_writeable;
use function stream_filter_register;
use function stream_get_filters;
use function strpos;
use function strtolower;
use function substr;

/**
 * A class to convert resource stream or tabular data content charset.
 *
 * @package League.csv
 * @since   9.0.0
 * @author  Ignace Nyamagana Butera <[email protected]>
 */
class CharsetConverter extends php_user_filter
{
    const FILTERNAME = 'convert.league.csv';

    /**
     * the filter name used to instantiate the class with.
     *
     * @var string
     */
    public $filtername;

    /**
     * Contents of the params parameter passed to stream_filter_append
     * or stream_filter_prepend functions.
     *
     * @var mixed
     */
    public $params;

    /**
     * The records input encoding charset.
     *
     * @var string
     */
    protected $input_encoding = 'UTF-8';

    /**
     * The records output encoding charset.
     *
     * @var string
     */
    protected $output_encoding = 'UTF-8';

    /**
     * Static method to add the stream filter to a {@link AbstractCsv} object.
     */
    public static function addTo(AbstractCsv $csv, string $input_encoding, string $output_encoding): AbstractCsv
    {
        self::register();

        return $csv->addStreamFilter(self::getFiltername($input_encoding, $output_encoding));
    }

    /**
     * Static method to register the class as a stream filter.
     */
    public static function register()
    {
        $filtername = self::FILTERNAME.'.*';
        if (!in_array($filtername, stream_get_filters(), true)) {
            stream_filter_register($filtername, __CLASS__);
        }
    }

    /**
     * Static method to return the stream filter filtername.
     */
    public static function getFiltername(string $input_encoding, string $output_encoding): string
    {
        return sprintf(
            '%s.%s/%s',
            self::FILTERNAME,
            self::filterEncoding($input_encoding),
            self::filterEncoding($output_encoding)
        );
    }

    /**
     * Filter encoding charset.
     *
     * @throws OutOfRangeException if the charset is malformed or unsupported
     */
    protected static function filterEncoding(string $encoding): string
    {
        static $encoding_list;
        if (null === $encoding_list) {
            $list = mb_list_encodings();
            $encoding_list = array_combine(array_map('strtolower', $list), $list);
        }

        $key = strtolower($encoding);
        if (isset($encoding_list[$key])) {
            return $encoding_list[$key];
        }

        throw new OutOfRangeException(sprintf('The submitted charset %s is not supported by the mbstring extension', $encoding));
    }

    /**
     * {@inheritdoc}
     */
    public function onCreate()
    {
        $prefix = self::FILTERNAME.'.';
        if (0 !== strpos($this->filtername, $prefix)) {
            return false;
        }

        $encodings = substr($this->filtername, strlen($prefix));
        if (!preg_match(',^(?<input>[-\w]+)\/(?<output>[-\w]+)$,', $encodings, $matches)) {
            return false;
        }

        try {
            $this->input_encoding = $this->filterEncoding($matches['input']);
            $this->output_encoding = $this->filterEncoding($matches['output']);
            return true;
        } catch (OutOfRangeException $e) {
            return false;
        }
    }

    /**
     * {@inheritdoc}
     */
    public function filter($in, $out, &$consumed, $closing)
    {
        while ($res = stream_bucket_make_writeable($in)) {
            $res->data = @mb_convert_encoding($res->data, $this->output_encoding, $this->input_encoding);
            $consumed += $res->datalen;
            stream_bucket_append($out, $res);
        }

        return PSFS_PASS_ON;
    }

    /**
     * Convert Csv records collection into UTF-8.
     *
     * @param array|Traversable $records
     *
     * @return array|Traversable
     */
    public function convert($records)
    {
        if (!is_iterable($records)) {
            throw new TypeError(sprintf('%s() expects argument passed to be iterable, %s given', __METHOD__, gettype($records)));
        }

        if ($this->output_encoding === $this->input_encoding) {
            return $records;
        }

        if (is_array($records)) {
            return array_map($this, $records);
        }

        return new MapIterator($records, $this);
    }

    /**
     * Enable using the class as a formatter for the {@link Writer}.
     */
    public function __invoke(array $record): array
    {
        array_walk($record, [$this, 'encodeField']);

        return $record;
    }

    /**
     * Walker method to convert the offset and the value of a CSV record field.
     *
     * @param mixed $value
     * @param mixed $offset
     */
    protected function encodeField(&$value, &$offset)
    {
        if (null !== $value && !is_numeric($value)) {
            $value = mb_convert_encoding((string) $value, $this->output_encoding, $this->input_encoding);
        }

        if (!is_numeric($offset)) {
            $offset = mb_convert_encoding((string) $offset, $this->output_encoding, $this->input_encoding);
        }
    }

    /**
     * Sets the records input encoding charset.
     */
    public function inputEncoding(string $encoding): self
    {
        $encoding = $this->filterEncoding($encoding);
        if ($encoding === $this->input_encoding) {
            return $this;
        }

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

        return $clone;
    }

    /**
     * Sets the records output encoding charset.
     */
    public function outputEncoding(string $encoding): self
    {
        $encoding = $this->filterEncoding($encoding);
        if ($encoding === $this->output_encoding) {
            return $this;
        }

        $clone = clone $this;
        $clone->output_encoding = $encoding;

        return $clone;
    }
}


1		<?php
2
3		/**
4		* League.Csv (https://csv.thephpleague.com).
5		*
6		* @author Ignace Nyamagana Butera <[email protected]>
7		* @license https://github.com/thephpleague/csv/blob/master/LICENSE (MIT License)
8		* @version 9.1.5
9		* @link https://github.com/thephpleague/csv
10		*
11		* For the full copyright and license information, please view the LICENSE
12		* file that was distributed with this source code.
13		*/
14
15		declare(strict_types=1);
16
17		namespace League\Csv;
18
19		use OutOfRangeException;
20		use php_user_filter;
21		use Traversable;
22		use TypeError;
23		use function array_combine;
24		use function array_map;
25		use function array_walk;
26		use function gettype;
27		use function in_array;
28		use function is_iterable;
29		use function is_numeric;
30		use function mb_convert_encoding;
31		use function mb_list_encodings;
32		use function preg_match;
33		use function sprintf;
34		use function stream_bucket_append;
35		use function stream_bucket_make_writeable;
36		use function stream_filter_register;
37		use function stream_get_filters;
38		use function strpos;
39		use function strtolower;
40		use function substr;
41
42		/**
43		* A class to convert resource stream or tabular data content charset.
44		*
45		* @package League.csv
46		* @since 9.0.0
47		* @author Ignace Nyamagana Butera <[email protected]>
48		*/
49		class CharsetConverter extends php_user_filter
50		{
51		const FILTERNAME = 'convert.league.csv';
52
53		/**
54		* the filter name used to instantiate the class with.
55		*
56		* @var string
57		*/
58		public $filtername;
59
60		/**
61		* Contents of the params parameter passed to stream_filter_append
62		* or stream_filter_prepend functions.
63		*
64		* @var mixed
65		*/
66		public $params;
67
68		/**
69		* The records input encoding charset.
70		*
71	2	* @var string
72		*/
73	2	protected $input_encoding = 'UTF-8';
74
75	2	/**
76		* The records output encoding charset.
77		*
78		* @var string
79		*/
80		protected $output_encoding = 'UTF-8';
81	2
82		/**
83	2	* Static method to add the stream filter to a {@link AbstractCsv} object.
84	2	*/
85	2	public static function addTo(AbstractCsv $csv, string $input_encoding, string $output_encoding): AbstractCsv
86		{
87	2	self::register();
88
89		return $csv->addStreamFilter(self::getFiltername($input_encoding, $output_encoding));
90		}
91
92		/**
93		* Static method to register the class as a stream filter.
94		*/
95		public static function register()
96		{
97	2	$filtername = self::FILTERNAME.'.*';
98		if (!in_array($filtername, stream_get_filters(), true)) {
99	2	stream_filter_register($filtername, __CLASS__);
100	2	}
101	2	}
102	2
103	2	/**
104		* Static method to return the stream filter filtername.
105		*/
106		public static function getFiltername(string $input_encoding, string $output_encoding): string
107		{
108		return sprintf(
109		'%s.%s/%s',
110		self::FILTERNAME,
111		self::filterEncoding($input_encoding),
112		self::filterEncoding($output_encoding)
113		);
114		}
115
116	4	/**
117		* Filter encoding charset.
118	4	*
119	4	* @throws OutOfRangeException if the charset is malformed or unsupported
120	2	*/
121	2	protected static function filterEncoding(string $encoding): string
122		{
123		static $encoding_list;
124	4	if (null === $encoding_list) {
125	4	$list = mb_list_encodings();
126	2	$encoding_list = array_combine(array_map('strtolower', $list), $list);
127		}
128
129	2	$key = strtolower($encoding);
130		if (isset($encoding_list[$key])) {
131		return $encoding_list[$key];
132		}
133
134		throw new OutOfRangeException(sprintf('The submitted charset %s is not supported by the mbstring extension', $encoding));
135	8	}
136
137	8	/**
138	8	* {@inheritdoc}
139	2	*/
140		public function onCreate()
141		{
142	6	$prefix = self::FILTERNAME.'.';
143	6	if (0 !== strpos($this->filtername, $prefix)) {
144	2	return false;
145		}
146
147		$encodings = substr($this->filtername, strlen($prefix));
148	4	if (!preg_match(',^(?<input>[-\w]+)\/(?<output>[-\w]+)$,', $encodings, $matches)) {
149	2	return false;
150	2	}
151	2
152	2	try {
153		$this->input_encoding = $this->filterEncoding($matches['input']);
154		$this->output_encoding = $this->filterEncoding($matches['output']);
155		return true;
156		} catch (OutOfRangeException $e) {
157		return false;
158		}
159	2	}
160
161	2	/**
162	2	* {@inheritdoc}
163	2	*/
164	2	public function filter($in, $out, &$consumed, $closing)
165		{
166		while ($res = stream_bucket_make_writeable($in)) {
167	2	$res->data = @mb_convert_encoding($res->data, $this->output_encoding, $this->input_encoding);
168		$consumed += $res->datalen;
169		stream_bucket_append($out, $res);
170		}
171
172		return PSFS_PASS_ON;
173		}
174
175		/**
176		* Convert Csv records collection into UTF-8.
177	16	*
178		* @param array\|Traversable $records
179	16	*
180	2	* @return array\|Traversable
181		*/
182		public function convert($records)
183	14	{
184	2	if (!is_iterable($records)) {
185		throw new TypeError(sprintf('%s() expects argument passed to be iterable, %s given', __METHOD__, gettype($records)));
186		}
187	12
188	10	if ($this->output_encoding === $this->input_encoding) {
189		return $records;
190		}
191	2
192		if (is_array($records)) {
193		return array_map($this, $records);
194		}
195
196		return new MapIterator($records, $this);
197		}
198
199		/**
200		* Enable using the class as a formatter for the {@link Writer}.
201	2	*/
202		public function __invoke(array $record): array
203	2	{
204		array_walk($record, [$this, 'encodeField']);
205	2
206		return $record;
207		}
208
209		/**
210		* Walker method to convert the offset and the value of a CSV record field.
211		*
212		* @param mixed $value
213		* @param mixed $offset
214	10	*/
215		protected function encodeField(&$value, &$offset)
216	10	{
217	2	if (null !== $value && !is_numeric($value)) {
218		$value = mb_convert_encoding((string) $value, $this->output_encoding, $this->input_encoding);
219		}
220	10
221	2	if (!is_numeric($offset)) {
222		$offset = mb_convert_encoding((string) $offset, $this->output_encoding, $this->input_encoding);
223	10	}
224		}
225
226		/**
227		* Sets the records input encoding charset.
228		*/
229		public function inputEncoding(string $encoding): self
230		{
231		$encoding = $this->filterEncoding($encoding);
232	8	if ($encoding === $this->input_encoding) {
233		return $this;
234	8	}
235	6
236	4	$clone = clone $this;
237		$clone->input_encoding = $encoding;
238
239	4	return $clone;
240	4	}
241
242	4	/**
243		* Sets the records output encoding charset.
244		*/
245		public function outputEncoding(string $encoding): self
246		{
247		$encoding = $this->filterEncoding($encoding);
248		if ($encoding === $this->output_encoding) {
249		return $this;
250		}
251
252	2	$clone = clone $this;
253		$clone->output_encoding = $encoding;
254	2
255	2	return $clone;
256	2	}
257		}
258

thephpleague / csv

Push — master ( ecd0f8...3ad52b )

CharsetConverter::encodeField() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like