JsonEncoder::decodeNonUtf8FromUtf8() - Code Metrics - phpservicebus/core - Measure and Improve Code Quality continuously with Scrutinizer

JsonEncoder::decodeNonUtf8FromUtf8() B
last analyzed 2020-01-22 17:49 UTC

↳ Parent: JsonEncoder

Complexity

Conditions	7
Paths	22

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	16
CRAP Score	7.0099

Importance

Changes

Metric	Value
dl	0
loc	29
ccs	16
cts	17
cp	0.9412
rs	8.5226
c	0
b	0
f	0
cc	7
nc	22
nop	1
crap	7.0099

<?php
namespace PSB\Core\Serialization\Json;


use PSB\Core\Exception\JsonSerializerException;
use PSB\Core\Util\Guard;

class JsonEncoder
{
    const FLOAT_CASTER = 'PSBFloat';

    const KEY_UTF8ENCODED = 1;
    const VALUE_UTF8ENCODED = 2;

    /**
     * @var int
     */
    private $jsonEncodeOptions;

    /**
     * @var string
     */
    private $encodingAnnotation;

    /**
     * @param int    $jsonEncodeOptions
     * @param string $encodingAnnotation
     */
    public function __construct($jsonEncodeOptions = JSON_UNESCAPED_UNICODE, $encodingAnnotation = '@utf8encoded')
    {
        Guard::againstNullAndEmpty('encodingAnnotation', $encodingAnnotation);

        if (PHP_VERSION_ID >= 50606) {
            $jsonEncodeOptions |= JSON_PRESERVE_ZERO_FRACTION;
        }

        $this->jsonEncodeOptions = $jsonEncodeOptions;
        $this->encodingAnnotation = $encodingAnnotation;
    }

    /**
     * @param array $data
     *
     * @return string
     */
    public function encode(array $data)
    {
        $data = $this->escapeFloatsIfNeeded($data);

        $json = json_encode($data, $this->jsonEncodeOptions);
        if ($json === false || json_last_error() != JSON_ERROR_NONE) {
            if (json_last_error() != JSON_ERROR_UTF8) {
                throw new JsonSerializerException('Invalid data to encode to JSON. Error: ' . json_last_error_msg());
            }

            $data = $this->encodeNonUtf8ToUtf8($data);
            $json = json_encode($data, $this->jsonEncodeOptions);

            if ($json === false || json_last_error() != JSON_ERROR_NONE) {
                throw new JsonSerializerException('Invalid data to encode to JSON. Error: ' . json_last_error_msg());
            }
        }

        return $this->unescapeFloatsIfNeeded($json);
    }

    /**
     * @param string $json
     *
     * @return array
     */
    public function decode($json)
    {
        $data = json_decode($json, true);
        if ($data === null && json_last_error() != JSON_ERROR_NONE) {
            throw new JsonSerializerException('Invalid JSON to unserialize.');
        }

        if (!is_array($data)) {
            throw new JsonSerializerException('Given JSON cannot represent an object.');
        }

        if (mb_strpos($json, $this->encodingAnnotation) !== false) {
            $data = $this->decodeNonUtf8FromUtf8($data);
        }

        return $data;
    }

    /**
     * @param array $data
     *
     * @return array
     */
    private function escapeFloatsIfNeeded(array $data)
    {
        if (PHP_VERSION_ID >= 50606) {
            return $data;
        }

        array_walk_recursive(
            $data,
            function (&$value) {
                if (is_float($value) && ctype_digit((string)$value)) {
                    // Due to PHP bug #50224, floats with no decimals are converted to integers when encoded
                    $value = '(' . self::FLOAT_CASTER . ')' . $value . '.0';
                }
            }
        );

        return $data;
    }

    /**
     * @param string $json
     *
     * @return string
     */
    private function unescapeFloatsIfNeeded($json)
    {
        if (PHP_VERSION_ID >= 50606) {
            return $json;
        }

        $prevEncoding = mb_regex_encoding();
        mb_regex_encoding('UTF-8');
        $json = mb_ereg_replace('"\(' . self::FLOAT_CASTER . '\)([^"]+)"', '\1', $json);
        mb_regex_encoding($prevEncoding);

        return $json;
    }

    /**
     * @param array $serializedData
     *
     * @return array
     */
    private function encodeNonUtf8ToUtf8(array $serializedData)
    {
        $encodedKeys = [];
        $encodedData = [];
        foreach ($serializedData as $key => $value) {
            if (is_array($value)) {
                $value = $this->encodeNonUtf8ToUtf8($value);
            }

            if (!mb_check_encoding($key, 'UTF-8')) {
                $key = mb_convert_encoding($key, 'UTF-8', '8bit');
                $encodedKeys[$key] = (isset($encodedKeys[$key]) ? $encodedKeys[$key] : 0) | static::KEY_UTF8ENCODED;
            }

            if (is_string($value)) {
                if (!mb_check_encoding($value, 'UTF-8')) {
                    $value = mb_convert_encoding($value, 'UTF-8', '8bit');
                    $encodedKeys[$key] = (isset($encodedKeys[$key]) ? $encodedKeys[$key] : 0) | static::VALUE_UTF8ENCODED;
                }
            }

            $encodedData[$key] = $value;
        }

        if (!empty($encodedKeys)) {
            $encodedData[$this->encodingAnnotation] = $encodedKeys;
        }

        return $encodedData;
    }

    /**
     * @param array $data
     *
     * @return array
     */
    private function decodeNonUtf8FromUtf8(array $data)
    {
        $encodedKeys = [];
        if (isset($data[$this->encodingAnnotation])) {
            $encodedKeys = $data[$this->encodingAnnotation];
            unset($data[$this->encodingAnnotation]);
        }

        $decodedData = [];
        foreach ($data as $key => $value) {
            if (is_array($value)) {
                $value = $this->decodeNonUtf8FromUtf8($value);
            }

            if (isset($encodedKeys[$key])) {
                $originalKey = $key;
                if ($encodedKeys[$key] & static::KEY_UTF8ENCODED) {
                    $key = mb_convert_encoding($key, '8bit', 'UTF-8');
                }
                if ($encodedKeys[$originalKey] & static::VALUE_UTF8ENCODED) {
                    $value = mb_convert_encoding($value, '8bit', 'UTF-8');
                }
            }

            $decodedData[$key] = $value;
        }

        return $decodedData;
    }
}


1			<?php
2			namespace PSB\Core\Serialization\Json;
3
4
5			use PSB\Core\Exception\JsonSerializerException;
6			use PSB\Core\Util\Guard;
7
8			class JsonEncoder
9			{
10			const FLOAT_CASTER = 'PSBFloat';
11
12			const KEY_UTF8ENCODED = 1;
13			const VALUE_UTF8ENCODED = 2;
14
15			/**
16			* @var int
17			*/
18			private $jsonEncodeOptions;
19
20			/**
21			* @var string
22			*/
23			private $encodingAnnotation;
24
25			/**
26			* @param int $jsonEncodeOptions
27			* @param string $encodingAnnotation
28			*/
29	8		public function __construct($jsonEncodeOptions = JSON_UNESCAPED_UNICODE, $encodingAnnotation = '@utf8encoded')
30			{
31	8		Guard::againstNullAndEmpty('encodingAnnotation', $encodingAnnotation);
32
33	8		if (PHP_VERSION_ID >= 50606) {
34	8		$jsonEncodeOptions \|= JSON_PRESERVE_ZERO_FRACTION;
35			}
36
37	8		$this->jsonEncodeOptions = $jsonEncodeOptions;
38	8		$this->encodingAnnotation = $encodingAnnotation;
39	8		}
40
41			/**
42			* @param array $data
43			*
44			* @return string
45			*/
46	5		public function encode(array $data)
47			{
48	5		$data = $this->escapeFloatsIfNeeded($data);
49
50	5		$json = json_encode($data, $this->jsonEncodeOptions);
51	5		if ($json === false \|\| json_last_error() != JSON_ERROR_NONE) {
52	3		if (json_last_error() != JSON_ERROR_UTF8) {
53	1		throw new JsonSerializerException('Invalid data to encode to JSON. Error: ' . json_last_error_msg());
54			}
55
56	2		$data = $this->encodeNonUtf8ToUtf8($data);
57	2		$json = json_encode($data, $this->jsonEncodeOptions);
58
59	2		if ($json === false \|\| json_last_error() != JSON_ERROR_NONE) {
60			throw new JsonSerializerException('Invalid data to encode to JSON. Error: ' . json_last_error_msg());
61			}
62			}
63
64	4		return $this->unescapeFloatsIfNeeded($json);
65			}
66
67			/**
68			* @param string $json
69			*
70			* @return array
71			*/
72	4		public function decode($json)
73			{
74	4		$data = json_decode($json, true);
75	4		if ($data === null && json_last_error() != JSON_ERROR_NONE) {
76	1		throw new JsonSerializerException('Invalid JSON to unserialize.');
77			}
78
79	3		if (!is_array($data)) {
80			throw new JsonSerializerException('Given JSON cannot represent an object.');
81			}
82
83	3		if (mb_strpos($json, $this->encodingAnnotation) !== false) {
84	2		$data = $this->decodeNonUtf8FromUtf8($data);
85			}
86
87	3		return $data;
88			}
89
90			/**
91			* @param array $data
92			*
93			* @return array
94			*/
95	5		private function escapeFloatsIfNeeded(array $data)
96			{
97	5		if (PHP_VERSION_ID >= 50606) {
98	5		return $data;
99			}
100
101			array_walk_recursive(
102			$data,
103			function (&$value) {
104			if (is_float($value) && ctype_digit((string)$value)) {
105			// Due to PHP bug #50224, floats with no decimals are converted to integers when encoded
106			$value = '(' . self::FLOAT_CASTER . ')' . $value . '.0';
107			}
108			}
109			);
110
111			return $data;
112			}
113
114			/**
115			* @param string $json
116			*
117			* @return string
118			*/
119	4		private function unescapeFloatsIfNeeded($json)
120			{
121	4		if (PHP_VERSION_ID >= 50606) {
122	4		return $json;
123			}
124
125			$prevEncoding = mb_regex_encoding();
126			mb_regex_encoding('UTF-8');
127			$json = mb_ereg_replace('"\(' . self::FLOAT_CASTER . '\)([^"]+)"', '\1', $json);
128			mb_regex_encoding($prevEncoding);
129
130			return $json;
131			}
132
133			/**
134			* @param array $serializedData
135			*
136			* @return array
137			*/
138	2		private function encodeNonUtf8ToUtf8(array $serializedData)
139			{
140	2		$encodedKeys = [];
141	2		$encodedData = [];
142	2		foreach ($serializedData as $key => $value) {
143	2		if (is_array($value)) {
144			$value = $this->encodeNonUtf8ToUtf8($value);
145			}
146
147	2	View Code Duplication	if (!mb_check_encoding($key, 'UTF-8')) {
148	1		$key = mb_convert_encoding($key, 'UTF-8', '8bit');
149	1		$encodedKeys[$key] = (isset($encodedKeys[$key]) ? $encodedKeys[$key] : 0) \| static::KEY_UTF8ENCODED;
150			}
151
152	2	View Code Duplication	if (is_string($value)) {
153	2		if (!mb_check_encoding($value, 'UTF-8')) {
154	2		$value = mb_convert_encoding($value, 'UTF-8', '8bit');
155	2		$encodedKeys[$key] = (isset($encodedKeys[$key]) ? $encodedKeys[$key] : 0) \| static::VALUE_UTF8ENCODED;
156			}
157			}
158
159	2		$encodedData[$key] = $value;
160			}
161
162	2		if (!empty($encodedKeys)) {
163	2		$encodedData[$this->encodingAnnotation] = $encodedKeys;
164			}
165
166	2		return $encodedData;
167			}
168
169			/**
170			* @param array $data
171			*
172			* @return array
173			*/
174	2		private function decodeNonUtf8FromUtf8(array $data)
175			{
176	2		$encodedKeys = [];
177	2		if (isset($data[$this->encodingAnnotation])) {
178	2		$encodedKeys = $data[$this->encodingAnnotation];
179	2		unset($data[$this->encodingAnnotation]);
180			}
181
182	2		$decodedData = [];
183	2		foreach ($data as $key => $value) {
184	2		if (is_array($value)) {
185			$value = $this->decodeNonUtf8FromUtf8($value);
186			}
187
188	2		if (isset($encodedKeys[$key])) {
189	2		$originalKey = $key;
190	2		if ($encodedKeys[$key] & static::KEY_UTF8ENCODED) {
191	1		$key = mb_convert_encoding($key, '8bit', 'UTF-8');
192			}
193	2		if ($encodedKeys[$originalKey] & static::VALUE_UTF8ENCODED) {
194	2		$value = mb_convert_encoding($value, '8bit', 'UTF-8');
195			}
196			}
197
198	2		$decodedData[$key] = $value;
199			}
200
201	2		return $decodedData;
202			}
203			}
204

phpservicebus / core

JsonEncoder::decodeNonUtf8FromUtf8() B last analyzed 2020-01-22 17:49 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

JsonEncoder::decodeNonUtf8FromUtf8() B
last analyzed 2020-01-22 17:49 UTC