JsonSerializer::isSplList() - Code Metrics - Inspection of "fix spl types" - zumba/json-serializer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#29)

unknown

created 2016-09-03 14:17 UTC

JsonSerializer::isSplList() A

↳ Parent: JsonSerializer

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

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

<?php

namespace Zumba\JsonSerializer;

use ReflectionClass;
use ReflectionException;
use SplObjectStorage;
use Zumba\JsonSerializer\Exception\JsonSerializerException;
use SuperClosure\SerializerInterface as ClosureSerializerInterface;

class JsonSerializer
{

    const CLASS_IDENTIFIER_KEY = '@type';
    const CLOSURE_IDENTIFIER_KEY = '@closure';
    const UTF8ENCODED_IDENTIFIER_KEY = '@utf8encoded';
    const SCALAR_IDENTIFIER_KEY = '@scalar';
    const FLOAT_ADAPTER = 'JsonSerializerFloatAdapter';

    const KEY_UTF8ENCODED = 1;
    const VALUE_UTF8ENCODED = 2;

    /**
     * Storage for object
     *
     * Used for recursion
     *
     * @var SplObjectStorage
     */
    protected $objectStorage;

    /**
     * Object mapping for recursion
     *
     * @var array
     */
    protected $objectMapping = array();

    /**
     * Object mapping index
     *
     * @var integer
     */
    protected $objectMappingIndex = 0;

    /**
     * Support PRESERVE_ZERO_FRACTION json option
     *
     * @var boolean
     */
    protected $preserveZeroFractionSupport;

    /**
     * Closure serializer instance
     *
     * @var ClosureSerializerInterface
     */
    protected $closureSerializer;

    /**
     * Map of custom object serializers
     *
     * @var array
     */
    protected $customObjectSerializerMap;

    /**
     * Constructor.
     *
     * @param ClosureSerializerInterface $closureSerializer
     * @param array $customObjectSerializerMap
     */
    public function __construct(ClosureSerializerInterface $closureSerializer = null, $customObjectSerializerMap = array())
    {
        $this->preserveZeroFractionSupport = defined('JSON_PRESERVE_ZERO_FRACTION');
        $this->closureSerializer = $closureSerializer;
        $this->customObjectSerializerMap = (array)$customObjectSerializerMap;
    }

    /**
     * Serialize the value in JSON
     *
     * @param mixed $value
     * @return string JSON encoded
     * @throws JsonSerializerException
     */
    public function serialize($value)
    {
        $this->reset();
        $serializedData = $this->serializeData($value);
        $encoded = json_encode($serializedData, $this->calculateEncodeOptions());
        if ($encoded === 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());
            }

            $serializedData = $this->encodeNonUtf8ToUtf8($serializedData);
            $encoded = json_encode($serializedData, $this->calculateEncodeOptions());

            if ($encoded === false || json_last_error() != JSON_ERROR_NONE) {
                throw new JsonSerializerException('Invalid data to encode to JSON. Error: ' . json_last_error());
            }
        }
        return $this->processEncodedValue($encoded);
    }

    /**
     * Calculate encoding options
     *
     * @return integer
     */
    protected function calculateEncodeOptions()
    {
        $options = JSON_UNESCAPED_UNICODE;
        if ($this->preserveZeroFractionSupport) {
            $options |= JSON_PRESERVE_ZERO_FRACTION;
        }
        return $options;
    }

    /**
     * @param mixed $serializedData
     *
     * @return array
     */
    protected function encodeNonUtf8ToUtf8($serializedData)
    {
        if (is_string($serializedData)) {
            if (!mb_check_encoding($serializedData, 'UTF-8')) {
                $serializedData = [
                    static::SCALAR_IDENTIFIER_KEY => mb_convert_encoding($serializedData, 'UTF-8', '8bit'),
                    static::UTF8ENCODED_IDENTIFIER_KEY => static::VALUE_UTF8ENCODED,
                ];
            }

            return $serializedData;
        }

        $encodedKeys = [];
        $encodedData = [];
        foreach ($serializedData as $key => $value) {
$collection = json_decode($data, true);
if ( ! is_array($collection)) {
    throw new \RuntimeException('$collection must be an array.');
}

foreach ($collection as $item) { /** ... */ }
            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 ($encodedKeys) {

            $encodedData[self::UTF8ENCODED_IDENTIFIER_KEY] = $encodedKeys;
        }

        return $encodedData;
    }

    /**
     * Execute post-encoding actions
     *
     * @param string $encoded
     * @return string
     */
    protected function processEncodedValue($encoded)
    {
        if (!$this->preserveZeroFractionSupport) {
            $encoded = preg_replace('/"' . static::FLOAT_ADAPTER . '\((.*?)\)"/', '\1', $encoded);
        }
        return $encoded;
    }

    /**
     * Unserialize the value from JSON
     *
     * @param string $value
     * @return mixed
     */
    public function unserialize($value)
    {
        $this->reset();
        $data = json_decode($value, true);
        if ($data === null && json_last_error() != JSON_ERROR_NONE) {
            throw new JsonSerializerException('Invalid JSON to unserialize.');
        }

        if (mb_strpos($value, static::UTF8ENCODED_IDENTIFIER_KEY) !== false) {
            $data = $this->decodeNonUtf8FromUtf8($data);
        }

        return $this->unserializeData($data);
    }

    /**
     * Parse the data to be json encoded
     *
     * @param mixed $value
     * @return mixed
     * @throws JsonSerializerException
     */
    protected function serializeData($value)
    {
        if (is_scalar($value) || $value === null) {
            if (!$this->preserveZeroFractionSupport && is_float($value) && ctype_digit((string)$value)) {
                // Because the PHP bug #50224, the float numbers with no
                // precision numbers are converted to integers when encoded
                $value = static::FLOAT_ADAPTER . '(' . $value . '.0)';
            }
            return $value;
        }
        if (is_resource($value)) {
            throw new JsonSerializerException('Resource is not supported in JsonSerializer');
        }
        if (is_array($value)) {
            return array_map(array($this, __FUNCTION__), $value);
        }
        if ($value instanceof \Closure) {
            if (!$this->closureSerializer) {
                throw new JsonSerializerException('Closure serializer not given. Unable to serialize closure.');
            }
            return array(
                static::CLOSURE_IDENTIFIER_KEY => true,
                'value' => $this->closureSerializer->serialize($value)
            );
        }
        return $this->serializeObject($value);
    }

    /**
     * Extract the data from an object
     *
     * @param object $value
     * @return array
     */
    protected function serializeObject($value)
    {
        if ($this->objectStorage->contains($value)) {
            return array(static::CLASS_IDENTIFIER_KEY => '@' . $this->objectStorage[$value]);
        }
        $this->objectStorage->attach($value, $this->objectMappingIndex++);

        $ref = new ReflectionClass($value);
        $className = $ref->getName();
        if (array_key_exists($className, $this->customObjectSerializerMap)) {
            $data = array(static::CLASS_IDENTIFIER_KEY => $className);
            $data += $this->customObjectSerializerMap[$className]->serialize($value);
            return $data;
        }

        $paramsToSerialize = $this->getObjectProperties($ref, $value);
        $data = array(static::CLASS_IDENTIFIER_KEY => $className);

        if($value instanceof \SplDoublyLinkedList){
            return $data + array('value' => $value->serialize());
        }

        $data += array_map(array($this, 'serializeData'), $this->extractObjectData($value, $ref, $paramsToSerialize));
        return $data;
    }

    /**
     * Return the list of properties to be serialized
     *
     * @param ReflectionClass $ref
     * @param object $value
     * @return array
     */
    protected function getObjectProperties($ref, $value)
    {
        if (method_exists($value, '__sleep')) {
            return $value->__sleep();
        }

        $props = array();
        foreach ($ref->getProperties() as $prop) {
            $props[] = $prop->getName();
        }
        return array_unique(array_merge($props, array_keys(get_object_vars($value))));
    }

    /**
     * Extract the object data
     *
     * @param object $value
     * @param ReflectionClass $ref
     * @param array $properties
     * @return array
     */
    protected function extractObjectData($value, $ref, $properties)
    {
        $data = array();
        foreach ($properties as $property) {
            try {
                $propRef = $ref->getProperty($property);
                $propRef->setAccessible(true);
                $data[$property] = $propRef->getValue($value);
            } catch (ReflectionException $e) {
                $data[$property] = $value->$property;
            }
        }
        return $data;
    }

    /**
     * Parse the json decode to convert to objects again
     *
     * @param mixed $value
     * @return mixed
     */
    protected function unserializeData($value)
    {
        if (is_scalar($value) || $value === null) {
            return $value;
        }

        if (isset($value[static::CLASS_IDENTIFIER_KEY])) {
            return $this->unserializeObject($value);

        }

        if (!empty($value[static::CLOSURE_IDENTIFIER_KEY])) {
            if (!$this->closureSerializer) {
                throw new JsonSerializerException('Closure serializer not provided to unserialize closure');
            }
            return $this->closureSerializer->unserialize($value['value']);
        }

        return array_map(array($this, __FUNCTION__), $value);
    }

    /**
     * @param mixed $serializedData
     *
     * @return mixed
     */
    protected function decodeNonUtf8FromUtf8($serializedData)
    {
        if (is_array($serializedData) && isset($serializedData[static::SCALAR_IDENTIFIER_KEY])) {
            $serializedData = mb_convert_encoding($serializedData[static::SCALAR_IDENTIFIER_KEY], '8bit', 'UTF-8');
            return $serializedData;
        } elseif (is_scalar($serializedData) || $serializedData === null) {
            return $serializedData;
        }

        $encodedKeys = [];
        if (isset($serializedData[static::UTF8ENCODED_IDENTIFIER_KEY])) {
            $encodedKeys = $serializedData[static::UTF8ENCODED_IDENTIFIER_KEY];
            unset($serializedData[static::UTF8ENCODED_IDENTIFIER_KEY]);
        }

        $decodedData = [];
        foreach ($serializedData 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;
    }

    /**
     * Convert the serialized array into an object
     *
     * @param array $value
     * @return object
     * @throws JsonSerializerException
     */
    protected function unserializeObject($value)
    {
        $className = $value[static::CLASS_IDENTIFIER_KEY];
        unset($value[static::CLASS_IDENTIFIER_KEY]);

        if ($className[0] === '@') {
            $index = substr($className, 1);
            return $this->objectMapping[$index];
        }

        if (array_key_exists($className, $this->customObjectSerializerMap)) {
            $obj = $this->customObjectSerializerMap[$className]->unserialize($value);
            $this->objectMapping[$this->objectMappingIndex++] = $obj;
            return $obj;
        }

        if (!class_exists($className)) {
            throw new JsonSerializerException('Unable to find class ' . $className);
        }

        if ($className === 'DateTime') {
            $obj = $this->restoreUsingUnserialize($className, $value);
            $this->objectMapping[$this->objectMappingIndex++] = $obj;
            return $obj;
        }

        if (!$this->isSplList($className)) {
            $ref = new ReflectionClass($className);
            $obj = $ref->newInstanceWithoutConstructor();
        } else {
            $obj = new $className();
        }

        if ($obj instanceof \SplDoublyLinkedList ) {
            $obj->unserialize($value['value']);
            $this->objectMapping[$this->objectMappingIndex++] = $obj;
            return $obj;
        }

        $this->objectMapping[$this->objectMappingIndex++] = $obj;
        foreach ($value as $property => $propertyValue) {
            try {
                $propRef = $ref->getProperty($property);
function myFunction($a) {
    switch ($a) {
        case 'foo':
            $x = 1;
            break;

        case 'bar':
            $x = 2;
            break;
    }

    // $x is potentially undefined here.
    echo $x;
}
                $propRef->setAccessible(true);
                $propRef->setValue($obj, $this->unserializeData($propertyValue));
            } catch (ReflectionException $e) {
                $obj->$property = $this->unserializeData($propertyValue);
            }
        }
        if (method_exists($obj, '__wakeup')) {
            $obj->__wakeup();
        }
        return $obj;
    }

    /**
     * @return boolean
     */
    protected function isSplList($className)
    {
        return in_array($className, array('SplQueue', 'SplDoublyLinkedList', 'SplStack'));
    }

    protected function restoreUsingUnserialize($className, $attributes)
    {
        $obj = (object)$attributes;
        $serialized = preg_replace('|^O:\d+:"\w+":|', 'O:' . strlen($className) . ':"' . $className . '":', serialize($obj));
        return unserialize($serialized);
    }

    /**
     * Reset variables
     *
     * @return void
     */
    protected function reset()
    {
        $this->objectStorage = new SplObjectStorage();
        $this->objectMapping = array();
        $this->objectMappingIndex = 0;
    }
}


GitHub Access Token became invalid

Pull Request — master (#29)

JsonSerializer::isSplList() A

Complexity

Size

Duplication

Importance

Available Fixes

1			<?php
2
3			namespace Zumba\JsonSerializer;
4
5			use ReflectionClass;
6			use ReflectionException;
7			use SplObjectStorage;
8			use Zumba\JsonSerializer\Exception\JsonSerializerException;
9			use SuperClosure\SerializerInterface as ClosureSerializerInterface;
10
11			class JsonSerializer
12			{
13
14			const CLASS_IDENTIFIER_KEY = '@type';
15			const CLOSURE_IDENTIFIER_KEY = '@closure';
16			const UTF8ENCODED_IDENTIFIER_KEY = '@utf8encoded';
17			const SCALAR_IDENTIFIER_KEY = '@scalar';
18			const FLOAT_ADAPTER = 'JsonSerializerFloatAdapter';
19
20			const KEY_UTF8ENCODED = 1;
21			const VALUE_UTF8ENCODED = 2;
22
23			/**
24			* Storage for object
25			*
26			* Used for recursion
27			*
28			* @var SplObjectStorage
29			*/
30			protected $objectStorage;
31
32			/**
33			* Object mapping for recursion
34			*
35			* @var array
36			*/
37			protected $objectMapping = array();
38
39			/**
40			* Object mapping index
41			*
42			* @var integer
43			*/
44			protected $objectMappingIndex = 0;
45
46			/**
47			* Support PRESERVE_ZERO_FRACTION json option
48			*
49			* @var boolean
50			*/
51			protected $preserveZeroFractionSupport;
52
53			/**
54			* Closure serializer instance
55			*
56			* @var ClosureSerializerInterface
57			*/
58			protected $closureSerializer;
59
60			/**
61			* Map of custom object serializers
62			*
63			* @var array
64			*/
65			protected $customObjectSerializerMap;
66
67			/**
68			* Constructor.
69			*
70			* @param ClosureSerializerInterface $closureSerializer
71			* @param array $customObjectSerializerMap
72			*/
73			public function __construct(ClosureSerializerInterface $closureSerializer = null, $customObjectSerializerMap = array())
74			{
75			$this->preserveZeroFractionSupport = defined('JSON_PRESERVE_ZERO_FRACTION');
76			$this->closureSerializer = $closureSerializer;
77			$this->customObjectSerializerMap = (array)$customObjectSerializerMap;
78			}
79
80			/**
81			* Serialize the value in JSON
82			*
83			* @param mixed $value
84			* @return string JSON encoded
85			* @throws JsonSerializerException
86			*/
87			public function serialize($value)
88			{
89			$this->reset();
90			$serializedData = $this->serializeData($value);
91			$encoded = json_encode($serializedData, $this->calculateEncodeOptions());
92			if ($encoded === false \|\| json_last_error() != JSON_ERROR_NONE) {
93			if (json_last_error() != JSON_ERROR_UTF8) {
94			throw new JsonSerializerException('Invalid data to encode to JSON. Error: ' . json_last_error());
95			}
96
97			$serializedData = $this->encodeNonUtf8ToUtf8($serializedData);
98			$encoded = json_encode($serializedData, $this->calculateEncodeOptions());
99
100			if ($encoded === false \|\| json_last_error() != JSON_ERROR_NONE) {
101			throw new JsonSerializerException('Invalid data to encode to JSON. Error: ' . json_last_error());
102			}
103			}
104			return $this->processEncodedValue($encoded);
105			}
106
107			/**
108			* Calculate encoding options
109			*
110			* @return integer
111			*/
112			protected function calculateEncodeOptions()
113			{
114			$options = JSON_UNESCAPED_UNICODE;
115			if ($this->preserveZeroFractionSupport) {
116			$options \|= JSON_PRESERVE_ZERO_FRACTION;
117			}
118			return $options;
119			}
120
121			/**
122			* @param mixed $serializedData
123			*
124			* @return array
125			*/
126			protected function encodeNonUtf8ToUtf8($serializedData)
127			{
128			if (is_string($serializedData)) {
129			if (!mb_check_encoding($serializedData, 'UTF-8')) {
130			$serializedData = [
131			static::SCALAR_IDENTIFIER_KEY => mb_convert_encoding($serializedData, 'UTF-8', '8bit'),
132			static::UTF8ENCODED_IDENTIFIER_KEY => static::VALUE_UTF8ENCODED,
133			];
134			}
135
136			return $serializedData;
137			}
138
139			$encodedKeys = [];
140			$encodedData = [];
141			foreach ($serializedData as $key => $value) {
			0 ignored issues – show Bug introduced 2016-06-07 11:42 UTC by Report Bug Copy Issue Report The expression `$serializedData` of type `object\|integer\|double\|null\|array\|boolean` is not guaranteed to be traversable. How about adding an additional type check? There are different options of fixing this problem. If you want to be on the safe side, you can add an additional type-check: $collection = json_decode($data, true); if ( ! is_array($collection)) { throw new \RuntimeException('$collection must be an array.'); } foreach ($collection as $item) { /** ... / } If you are sure that the expression is traversable, you might want to add a doc comment cast* to improve IDE auto-completion and static analysis: /** @var array $collection / $collection = json_decode($data, true); foreach ($collection as $item) { /* .. / } Mark the issue as a false-positive*: Just hover the remove button, in the top-right corner of this issue for more options. Loading history...
142			if (is_array($value)) {
143			$value = $this->encodeNonUtf8ToUtf8($value);
144			}
145
146			if (!mb_check_encoding($key, 'UTF-8')) {
147			$key = mb_convert_encoding($key, 'UTF-8', '8bit');
148			$encodedKeys[$key] = (isset($encodedKeys[$key]) ? $encodedKeys[$key] : 0) \| static::KEY_UTF8ENCODED;
149			}
150
151			if (is_string($value)) {
152			if (!mb_check_encoding($value, 'UTF-8')) {
153			$value = mb_convert_encoding($value, 'UTF-8', '8bit');
154			$encodedKeys[$key] = (isset($encodedKeys[$key]) ? $encodedKeys[$key] : 0) \| static::VALUE_UTF8ENCODED;
155			}
156			}
157
158			$encodedData[$key] = $value;
159			}
160
161			if ($encodedKeys) {
			0 ignored issues – show Bug Best Practice introduced 2016-06-07 11:42 UTC by Report Bug Copy Issue Report The expression `$encodedKeys` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
162			$encodedData[self::UTF8ENCODED_IDENTIFIER_KEY] = $encodedKeys;
163			}
164
165			return $encodedData;
166			}
167
168			/**
169			* Execute post-encoding actions
170			*
171			* @param string $encoded
172			* @return string
173			*/
174			protected function processEncodedValue($encoded)
175			{
176			if (!$this->preserveZeroFractionSupport) {
177			$encoded = preg_replace('/"' . static::FLOAT_ADAPTER . '\((.*?)\)"/', '\1', $encoded);
178			}
179			return $encoded;
180			}
181
182			/**
183			* Unserialize the value from JSON
184			*
185			* @param string $value
186			* @return mixed
187			*/
188			public function unserialize($value)
189			{
190			$this->reset();
191			$data = json_decode($value, true);
192			if ($data === null && json_last_error() != JSON_ERROR_NONE) {
193			throw new JsonSerializerException('Invalid JSON to unserialize.');
194			}
195
196			if (mb_strpos($value, static::UTF8ENCODED_IDENTIFIER_KEY) !== false) {
197			$data = $this->decodeNonUtf8FromUtf8($data);
198			}
199
200			return $this->unserializeData($data);
201			}
202
203			/**
204			* Parse the data to be json encoded
205			*
206			* @param mixed $value
207			* @return mixed
208			* @throws JsonSerializerException
209			*/
210			protected function serializeData($value)
211			{
212			if (is_scalar($value) \|\| $value === null) {
213			if (!$this->preserveZeroFractionSupport && is_float($value) && ctype_digit((string)$value)) {
214			// Because the PHP bug #50224, the float numbers with no
215			// precision numbers are converted to integers when encoded
216			$value = static::FLOAT_ADAPTER . '(' . $value . '.0)';
217			}
218			return $value;
219			}
220			if (is_resource($value)) {
221			throw new JsonSerializerException('Resource is not supported in JsonSerializer');
222			}
223			if (is_array($value)) {
224			return array_map(array($this, __FUNCTION__), $value);
225			}
226			if ($value instanceof \Closure) {
227			if (!$this->closureSerializer) {
228			throw new JsonSerializerException('Closure serializer not given. Unable to serialize closure.');
229			}
230			return array(
231			static::CLOSURE_IDENTIFIER_KEY => true,
232			'value' => $this->closureSerializer->serialize($value)
233			);
234			}
235			return $this->serializeObject($value);
236			}
237
238			/**
239			* Extract the data from an object
240			*
241			* @param object $value
242			* @return array
243			*/
244			protected function serializeObject($value)
245			{
246			if ($this->objectStorage->contains($value)) {
247			return array(static::CLASS_IDENTIFIER_KEY => '@' . $this->objectStorage[$value]);
248			}
249			$this->objectStorage->attach($value, $this->objectMappingIndex++);
250
251			$ref = new ReflectionClass($value);
252			$className = $ref->getName();
253			if (array_key_exists($className, $this->customObjectSerializerMap)) {
254			$data = array(static::CLASS_IDENTIFIER_KEY => $className);
255			$data += $this->customObjectSerializerMap[$className]->serialize($value);
256			return $data;
257			}
258
259			$paramsToSerialize = $this->getObjectProperties($ref, $value);
260			$data = array(static::CLASS_IDENTIFIER_KEY => $className);
261
262			if($value instanceof \SplDoublyLinkedList){
263			return $data + array('value' => $value->serialize());
264			}
265
266			$data += array_map(array($this, 'serializeData'), $this->extractObjectData($value, $ref, $paramsToSerialize));
267			return $data;
268			}
269
270			/**
271			* Return the list of properties to be serialized
272			*
273			* @param ReflectionClass $ref
274			* @param object $value
275			* @return array
276			*/
277			protected function getObjectProperties($ref, $value)
278			{
279			if (method_exists($value, '__sleep')) {
280			return $value->__sleep();
281			}
282
283			$props = array();
284			foreach ($ref->getProperties() as $prop) {
285			$props[] = $prop->getName();
286			}
287			return array_unique(array_merge($props, array_keys(get_object_vars($value))));
288			}
289
290			/**
291			* Extract the object data
292			*
293			* @param object $value
294			* @param ReflectionClass $ref
295			* @param array $properties
296			* @return array
297			*/
298			protected function extractObjectData($value, $ref, $properties)
299			{
300			$data = array();
301			foreach ($properties as $property) {
302			try {
303			$propRef = $ref->getProperty($property);
304			$propRef->setAccessible(true);
305			$data[$property] = $propRef->getValue($value);
306			} catch (ReflectionException $e) {
307			$data[$property] = $value->$property;
308			}
309			}
310			return $data;
311			}
312
313			/**
314			* Parse the json decode to convert to objects again
315			*
316			* @param mixed $value
317			* @return mixed
318			*/
319			protected function unserializeData($value)
320			{
321			if (is_scalar($value) \|\| $value === null) {
322			return $value;
323			}
324
325			if (isset($value[static::CLASS_IDENTIFIER_KEY])) {
326			return $this->unserializeObject($value);
			0 ignored issues – show Bug introduced 2016-06-02 20:40 UTC by Report Bug Copy Issue Report It seems like `$value` defined by parameter `$value` on line 319 can also be of type `object`; however, `Zumba\JsonSerializer\Jso...er::unserializeObject()` does only seem to accept `array`, maybe add an additional type check? This check looks at variables that have been passed in as parameters and are passed out again to other methods. If the outgoing method call has stricter type requirements than the method itself, an issue is raised. An additional type check may prevent trouble. Loading history...
327			}
328
329			if (!empty($value[static::CLOSURE_IDENTIFIER_KEY])) {
330			if (!$this->closureSerializer) {
331			throw new JsonSerializerException('Closure serializer not provided to unserialize closure');
332			}
333			return $this->closureSerializer->unserialize($value['value']);
334			}
335
336			return array_map(array($this, __FUNCTION__), $value);
337			}
338
339			/**
340			* @param mixed $serializedData
341			*
342			* @return mixed
343			*/
344			protected function decodeNonUtf8FromUtf8($serializedData)
345			{
346			if (is_array($serializedData) && isset($serializedData[static::SCALAR_IDENTIFIER_KEY])) {
347			$serializedData = mb_convert_encoding($serializedData[static::SCALAR_IDENTIFIER_KEY], '8bit', 'UTF-8');
348			return $serializedData;
349			} elseif (is_scalar($serializedData) \|\| $serializedData === null) {
350			return $serializedData;
351			}
352
353			$encodedKeys = [];
354			if (isset($serializedData[static::UTF8ENCODED_IDENTIFIER_KEY])) {
355			$encodedKeys = $serializedData[static::UTF8ENCODED_IDENTIFIER_KEY];
356			unset($serializedData[static::UTF8ENCODED_IDENTIFIER_KEY]);
357			}
358
359			$decodedData = [];
360			foreach ($serializedData as $key => $value) {
361			if (is_array($value)) {
362			$value = $this->decodeNonUtf8FromUtf8($value);
363			}
364
365			if (isset($encodedKeys[$key])) {
366			$originalKey = $key;
367			if ($encodedKeys[$key] & static::KEY_UTF8ENCODED) {
368			$key = mb_convert_encoding($key, '8bit', 'UTF-8');
369			}
370			if ($encodedKeys[$originalKey] & static::VALUE_UTF8ENCODED) {
371			$value = mb_convert_encoding($value, '8bit', 'UTF-8');
372			}
373			}
374
375			$decodedData[$key] = $value;
376			}
377
378			return $decodedData;
379			}
380
381			/**
382			* Convert the serialized array into an object
383			*
384			* @param array $value
385			* @return object
386			* @throws JsonSerializerException
387			*/
388			protected function unserializeObject($value)
389			{
390			$className = $value[static::CLASS_IDENTIFIER_KEY];
391			unset($value[static::CLASS_IDENTIFIER_KEY]);
392
393			if ($className[0] === '@') {
394			$index = substr($className, 1);
395			return $this->objectMapping[$index];
396			}
397
398			if (array_key_exists($className, $this->customObjectSerializerMap)) {
399			$obj = $this->customObjectSerializerMap[$className]->unserialize($value);
400			$this->objectMapping[$this->objectMappingIndex++] = $obj;
401			return $obj;
402			}
403
404			if (!class_exists($className)) {
405			throw new JsonSerializerException('Unable to find class ' . $className);
406			}
407
408			if ($className === 'DateTime') {
409			$obj = $this->restoreUsingUnserialize($className, $value);
410			$this->objectMapping[$this->objectMappingIndex++] = $obj;
411			return $obj;
412			}
413
414			if (!$this->isSplList($className)) {
415			$ref = new ReflectionClass($className);
416			$obj = $ref->newInstanceWithoutConstructor();
417			} else {
418			$obj = new $className();
419			}
420
421			if ($obj instanceof \SplDoublyLinkedList ) {
422			$obj->unserialize($value['value']);
423			$this->objectMapping[$this->objectMappingIndex++] = $obj;
424			return $obj;
425			}
426
427			$this->objectMapping[$this->objectMappingIndex++] = $obj;
428			foreach ($value as $property => $propertyValue) {
429			try {
430			$propRef = $ref->getProperty($property);
			0 ignored issues – show Bug introduced 2016-09-03 14:19 UTC by Report Bug Copy Issue Report The variable `$ref` does not seem to be defined for all execution paths leading up to this point. If you define a variable conditionally, it can happen that it is not defined for all execution paths. Let’s take a look at an example: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } // $x is potentially undefined here. echo $x; } In the above example, the variable `$x` is defined if you pass “foo” or “bar” as argument for `$a`. However, since the `switch` statement has no default case statement, if you pass any other value, the variable `$x` would be undefined. Available Fixes Check for existence of the variable explicitly: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } if (isset($x)) { // Make sure it's always set. echo $x; } } Define a default value for the variable: function myFunction($a) { $x = ''; // Set a default which gets overridden for certain paths. switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; } echo $x; } Add a value for the missing path: function myFunction($a) { switch ($a) { case 'foo': $x = 1; break; case 'bar': $x = 2; break; // We add support for the missing case. default: $x = ''; break; } echo $x; } Loading history...
431			$propRef->setAccessible(true);
432			$propRef->setValue($obj, $this->unserializeData($propertyValue));
433			} catch (ReflectionException $e) {
434			$obj->$property = $this->unserializeData($propertyValue);
435			}
436			}
437			if (method_exists($obj, '__wakeup')) {
438			$obj->__wakeup();
439			}
440			return $obj;
441			}
442
443			/**
444			* @return boolean
445			*/
446			protected function isSplList($className)
447			{
448			return in_array($className, array('SplQueue', 'SplDoublyLinkedList', 'SplStack'));
449			}
450
451			protected function restoreUsingUnserialize($className, $attributes)
452			{
453			$obj = (object)$attributes;
454			$serialized = preg_replace('\|^O:\d+:"\w+":\|', 'O:' . strlen($className) . ':"' . $className . '":', serialize($obj));
455			return unserialize($serialized);
456			}
457
458			/**
459			* Reset variables
460			*
461			* @return void
462			*/
463			protected function reset()
464			{
465			$this->objectStorage = new SplObjectStorage();
466			$this->objectMapping = array();
467			$this->objectMappingIndex = 0;
468			}
469			}
470

zumba / json-serializer

GitHub Access Token became invalid

Pull Request — master (#29)

JsonSerializer::isSplList() A

Complexity

Size

Duplication

Importance

Available Fixes

Duplication Side-by-Side

Filter issues like