JsonSerializer - Code Metrics - Inspection of "Added supported classes guard" - zumba/json-serializer - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#34)

by Chris

created 2018-06-15 16:06 UTC

JsonSerializer D

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	531
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Importance

Changes

Metric	Value
wmc	86
lcom	1
cbo	1
dl	0
loc	531
rs	4.8717
c	0
b	0
f	0

19 Methods

Rating	Name	Size	Complexity
A	__construct()	6	1
A	withSupportedClasses()	5	1
A	isClassSupported()	8	2
B	serialize()	19	6
A	calculateEncodeOptions()	8	2
C	encodeNonUtf8ToUtf8()	41	11
A	processEncodedValue()	7	2
A	unserialize()	14	4
A	setUnserializeUndeclaredPropertyMode()	13	2
D	serializeData()	27	10
B	serializeObject()	30	5
A	getObjectProperties()	12	3
A	extractObjectData()	14	3
B	unserializeData()	19	6
C	decodeNonUtf8FromUtf8()	36	11
C	unserializeObject()	67	14
A	isSplList()	4	1
A	restoreUsingUnserialize()	6	1
A	reset()	6	1

How to fix Complexity

<?php

namespace Zumba\JsonSerializer;

use InvalidArgumentException;
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;

    const UNDECLARED_PROPERTY_MODE_SET = 1;
    const UNDECLARED_PROPERTY_MODE_IGNORE = 2;
    const UNDECLARED_PROPERTY_MODE_EXCEPTION = 3;

    /**
     * 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;

    /**
     * Undefined Attribute Mode
     *
     * @var integer
     */
    protected $undefinedAttributeMode = self::UNDECLARED_PROPERTY_MODE_SET;

    /**
     * Undefined Attribute Mode
     *
     * @var false|array
     */
    protected $supportedClasses = false;

    /**
     * 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;
    }

    public function withSupportedClasses($supportedClasses)
    {
        $this->supportedClasses = $supportedClasses;
        return $this;
    }

    public function isClassSupported($className)
    {
        if(false === $this->supportedClasses){
            return true;
        }

        return in_array($className, $this->supportedClasses);
    }

    /**
     * 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);
    }

    /**
     * Set unserialization mode for undeclared class properties
     *
     * @param integer $value One of the JsonSerializer::UNDECLARED_PROPERTY_MODE_*
     * @return self
     * @throws InvalidArgumentException When the value is not one of the UNDECLARED_PROPERTY_MODE_* options
     */
    public function setUnserializeUndeclaredPropertyMode($value)
    {
        $availableOptions = [
            static::UNDECLARED_PROPERTY_MODE_SET,
            static::UNDECLARED_PROPERTY_MODE_IGNORE,
            static::UNDECLARED_PROPERTY_MODE_EXCEPTION
        ];
        if (!in_array($value, $availableOptions)) {
            throw new InvalidArgumentException('Invalid value.');
        }
        $this->undefinedAttributeMode = $value;
        return $this;
    }

    /**
     * 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(!$this->isClassSupported($className)){
            throw new JsonSerializerException('The supplied class was not on the explicitly allowed list of supported classes. Unable to serialize object.');
        }

        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(!$this->isClassSupported($className)){
            throw new JsonSerializerException('The supplied class was not on the explicitly allowed list of supported classes. Unable to unserialize object.');
        }

        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) {
                switch ($this->undefinedAttributeMode) {
                case static::UNDECLARED_PROPERTY_MODE_SET:
                    $obj->$property = $this->unserializeData($propertyValue);
                    break;
                case static::UNDECLARED_PROPERTY_MODE_IGNORE:
                    break;
                case static::UNDECLARED_PROPERTY_MODE_EXCEPTION:
                    throw new JsonSerializerException('Undefined attribute detected during unserialization');
                    break;
function fx() {
    try {
        doSomething();
        return true;
    }
    catch (\Exception $e) {
        return false;
    }

    return false;
}
                }
            }
        }
        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 (#34)

JsonSerializer D

Complexity

Size/Duplication

Coupling/Cohesion

Importance

19 Methods

How to fix Complexity

Complex Class

Available Fixes

1			<?php
2
3			namespace Zumba\JsonSerializer;
4
5			use InvalidArgumentException;
6			use ReflectionClass;
7			use ReflectionException;
8			use SplObjectStorage;
9			use Zumba\JsonSerializer\Exception\JsonSerializerException;
10			use SuperClosure\SerializerInterface as ClosureSerializerInterface;
11
12			class JsonSerializer
13			{
14
15			const CLASS_IDENTIFIER_KEY = '@type';
16			const CLOSURE_IDENTIFIER_KEY = '@closure';
17			const UTF8ENCODED_IDENTIFIER_KEY = '@utf8encoded';
18			const SCALAR_IDENTIFIER_KEY = '@scalar';
19			const FLOAT_ADAPTER = 'JsonSerializerFloatAdapter';
20
21			const KEY_UTF8ENCODED = 1;
22			const VALUE_UTF8ENCODED = 2;
23
24			const UNDECLARED_PROPERTY_MODE_SET = 1;
25			const UNDECLARED_PROPERTY_MODE_IGNORE = 2;
26			const UNDECLARED_PROPERTY_MODE_EXCEPTION = 3;
27
28			/**
29			* Storage for object
30			*
31			* Used for recursion
32			*
33			* @var SplObjectStorage
34			*/
35			protected $objectStorage;
36
37			/**
38			* Object mapping for recursion
39			*
40			* @var array
41			*/
42			protected $objectMapping = array();
43
44			/**
45			* Object mapping index
46			*
47			* @var integer
48			*/
49			protected $objectMappingIndex = 0;
50
51			/**
52			* Support PRESERVE_ZERO_FRACTION json option
53			*
54			* @var boolean
55			*/
56			protected $preserveZeroFractionSupport;
57
58			/**
59			* Closure serializer instance
60			*
61			* @var ClosureSerializerInterface
62			*/
63			protected $closureSerializer;
64
65			/**
66			* Map of custom object serializers
67			*
68			* @var array
69			*/
70			protected $customObjectSerializerMap;
71
72			/**
73			* Undefined Attribute Mode
74			*
75			* @var integer
76			*/
77			protected $undefinedAttributeMode = self::UNDECLARED_PROPERTY_MODE_SET;
78
79			/**
80			* Undefined Attribute Mode
81			*
82			* @var false\|array
83			*/
84			protected $supportedClasses = false;
85
86			/**
87			* Constructor.
88			*
89			* @param ClosureSerializerInterface $closureSerializer
90			* @param array $customObjectSerializerMap
91			*/
92			public function __construct(ClosureSerializerInterface $closureSerializer = null, $customObjectSerializerMap = array())
93			{
94			$this->preserveZeroFractionSupport = defined('JSON_PRESERVE_ZERO_FRACTION');
95			$this->closureSerializer = $closureSerializer;
96			$this->customObjectSerializerMap = (array)$customObjectSerializerMap;
97			}
98
99			public function withSupportedClasses($supportedClasses)
100			{
101			$this->supportedClasses = $supportedClasses;
102			return $this;
103			}
104
105			public function isClassSupported($className)
106			{
107			if(false === $this->supportedClasses){
108			return true;
109			}
110
111			return in_array($className, $this->supportedClasses);
112			}
113
114			/**
115			* Serialize the value in JSON
116			*
117			* @param mixed $value
118			* @return string JSON encoded
119			* @throws JsonSerializerException
120			*/
121			public function serialize($value)
122			{
123			$this->reset();
124			$serializedData = $this->serializeData($value);
125			$encoded = json_encode($serializedData, $this->calculateEncodeOptions());
126			if ($encoded === false \|\| json_last_error() != JSON_ERROR_NONE) {
127			if (json_last_error() != JSON_ERROR_UTF8) {
128			throw new JsonSerializerException('Invalid data to encode to JSON. Error: ' . json_last_error());
129			}
130
131			$serializedData = $this->encodeNonUtf8ToUtf8($serializedData);
132			$encoded = json_encode($serializedData, $this->calculateEncodeOptions());
133
134			if ($encoded === false \|\| json_last_error() != JSON_ERROR_NONE) {
135			throw new JsonSerializerException('Invalid data to encode to JSON. Error: ' . json_last_error());
136			}
137			}
138			return $this->processEncodedValue($encoded);
139			}
140
141			/**
142			* Calculate encoding options
143			*
144			* @return integer
145			*/
146			protected function calculateEncodeOptions()
147			{
148			$options = JSON_UNESCAPED_UNICODE;
149			if ($this->preserveZeroFractionSupport) {
150			$options \|= JSON_PRESERVE_ZERO_FRACTION;
151			}
152			return $options;
153			}
154
155			/**
156			* @param mixed $serializedData
157			*
158			* @return array
159			*/
160			protected function encodeNonUtf8ToUtf8($serializedData)
161			{
162			if (is_string($serializedData)) {
163			if (!mb_check_encoding($serializedData, 'UTF-8')) {
164			$serializedData = [
165			static::SCALAR_IDENTIFIER_KEY => mb_convert_encoding($serializedData, 'UTF-8', '8bit'),
166			static::UTF8ENCODED_IDENTIFIER_KEY => static::VALUE_UTF8ENCODED,
167			];
168			}
169
170			return $serializedData;
171			}
172
173			$encodedKeys = [];
174			$encodedData = [];
175			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...
176			if (is_array($value)) {
177			$value = $this->encodeNonUtf8ToUtf8($value);
178			}
179
180			if (!mb_check_encoding($key, 'UTF-8')) {
181			$key = mb_convert_encoding($key, 'UTF-8', '8bit');
182			$encodedKeys[$key] = (isset($encodedKeys[$key]) ? $encodedKeys[$key] : 0) \| static::KEY_UTF8ENCODED;
183			}
184
185			if (is_string($value)) {
186			if (!mb_check_encoding($value, 'UTF-8')) {
187			$value = mb_convert_encoding($value, 'UTF-8', '8bit');
188			$encodedKeys[$key] = (isset($encodedKeys[$key]) ? $encodedKeys[$key] : 0) \| static::VALUE_UTF8ENCODED;
189			}
190			}
191
192			$encodedData[$key] = $value;
193			}
194
195			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...
196			$encodedData[self::UTF8ENCODED_IDENTIFIER_KEY] = $encodedKeys;
197			}
198
199			return $encodedData;
200			}
201
202			/**
203			* Execute post-encoding actions
204			*
205			* @param string $encoded
206			* @return string
207			*/
208			protected function processEncodedValue($encoded)
209			{
210			if (!$this->preserveZeroFractionSupport) {
211			$encoded = preg_replace('/"' . static::FLOAT_ADAPTER . '\((.*?)\)"/', '\1', $encoded);
212			}
213			return $encoded;
214			}
215
216			/**
217			* Unserialize the value from JSON
218			*
219			* @param string $value
220			* @return mixed
221			*/
222			public function unserialize($value)
223			{
224			$this->reset();
225			$data = json_decode($value, true);
226			if ($data === null && json_last_error() != JSON_ERROR_NONE) {
227			throw new JsonSerializerException('Invalid JSON to unserialize.');
228			}
229
230			if (mb_strpos($value, static::UTF8ENCODED_IDENTIFIER_KEY) !== false) {
231			$data = $this->decodeNonUtf8FromUtf8($data);
232			}
233
234			return $this->unserializeData($data);
235			}
236
237			/**
238			* Set unserialization mode for undeclared class properties
239			*
240			* @param integer $value One of the JsonSerializer::UNDECLARED_PROPERTY_MODE_*
241			* @return self
242			* @throws InvalidArgumentException When the value is not one of the UNDECLARED_PROPERTY_MODE_* options
243			*/
244			public function setUnserializeUndeclaredPropertyMode($value)
245			{
246			$availableOptions = [
247			static::UNDECLARED_PROPERTY_MODE_SET,
248			static::UNDECLARED_PROPERTY_MODE_IGNORE,
249			static::UNDECLARED_PROPERTY_MODE_EXCEPTION
250			];
251			if (!in_array($value, $availableOptions)) {
252			throw new InvalidArgumentException('Invalid value.');
253			}
254			$this->undefinedAttributeMode = $value;
255			return $this;
256			}
257
258			/**
259			* Parse the data to be json encoded
260			*
261			* @param mixed $value
262			* @return mixed
263			* @throws JsonSerializerException
264			*/
265			protected function serializeData($value)
266			{
267			if (is_scalar($value) \|\| $value === null) {
268			if (!$this->preserveZeroFractionSupport && is_float($value) && ctype_digit((string)$value)) {
269			// Because the PHP bug #50224, the float numbers with no
270			// precision numbers are converted to integers when encoded
271			$value = static::FLOAT_ADAPTER . '(' . $value . '.0)';
272			}
273			return $value;
274			}
275			if (is_resource($value)) {
276			throw new JsonSerializerException('Resource is not supported in JsonSerializer');
277			}
278			if (is_array($value)) {
279			return array_map(array($this, __FUNCTION__), $value);
280			}
281			if ($value instanceof \Closure) {
282			if (!$this->closureSerializer) {
283			throw new JsonSerializerException('Closure serializer not given. Unable to serialize closure.');
284			}
285			return array(
286			static::CLOSURE_IDENTIFIER_KEY => true,
287			'value' => $this->closureSerializer->serialize($value)
288			);
289			}
290			return $this->serializeObject($value);
291			}
292
293			/**
294			* Extract the data from an object
295			*
296			* @param object $value
297			* @return array
298			*/
299			protected function serializeObject($value)
300			{
301			if ($this->objectStorage->contains($value)) {
302			return array(static::CLASS_IDENTIFIER_KEY => '@' . $this->objectStorage[$value]);
303			}
304			$this->objectStorage->attach($value, $this->objectMappingIndex++);
305
306			$ref = new ReflectionClass($value);
307			$className = $ref->getName();
308
309			if(!$this->isClassSupported($className)){
310			throw new JsonSerializerException('The supplied class was not on the explicitly allowed list of supported classes. Unable to serialize object.');
311			}
312
313			if (array_key_exists($className, $this->customObjectSerializerMap)) {
314			$data = array(static::CLASS_IDENTIFIER_KEY => $className);
315			$data += $this->customObjectSerializerMap[$className]->serialize($value);
316			return $data;
317			}
318
319			$paramsToSerialize = $this->getObjectProperties($ref, $value);
320			$data = array(static::CLASS_IDENTIFIER_KEY => $className);
321
322			if($value instanceof \SplDoublyLinkedList){
323			return $data + array('value' => $value->serialize());
324			}
325
326			$data += array_map(array($this, 'serializeData'), $this->extractObjectData($value, $ref, $paramsToSerialize));
327			return $data;
328			}
329
330			/**
331			* Return the list of properties to be serialized
332			*
333			* @param ReflectionClass $ref
334			* @param object $value
335			* @return array
336			*/
337			protected function getObjectProperties($ref, $value)
338			{
339			if (method_exists($value, '__sleep')) {
340			return $value->__sleep();
341			}
342
343			$props = array();
344			foreach ($ref->getProperties() as $prop) {
345			$props[] = $prop->getName();
346			}
347			return array_unique(array_merge($props, array_keys(get_object_vars($value))));
348			}
349
350			/**
351			* Extract the object data
352			*
353			* @param object $value
354			* @param ReflectionClass $ref
355			* @param array $properties
356			* @return array
357			*/
358			protected function extractObjectData($value, $ref, $properties)
359			{
360			$data = array();
361			foreach ($properties as $property) {
362			try {
363			$propRef = $ref->getProperty($property);
364			$propRef->setAccessible(true);
365			$data[$property] = $propRef->getValue($value);
366			} catch (ReflectionException $e) {
367			$data[$property] = $value->$property;
368			}
369			}
370			return $data;
371			}
372
373			/**
374			* Parse the json decode to convert to objects again
375			*
376			* @param mixed $value
377			* @return mixed
378			*/
379			protected function unserializeData($value)
380			{
381			if (is_scalar($value) \|\| $value === null) {
382			return $value;
383			}
384
385			if (isset($value[static::CLASS_IDENTIFIER_KEY])) {
386			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 379 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...
387			}
388
389			if (!empty($value[static::CLOSURE_IDENTIFIER_KEY])) {
390			if (!$this->closureSerializer) {
391			throw new JsonSerializerException('Closure serializer not provided to unserialize closure');
392			}
393			return $this->closureSerializer->unserialize($value['value']);
394			}
395
396			return array_map(array($this, __FUNCTION__), $value);
397			}
398
399			/**
400			* @param mixed $serializedData
401			*
402			* @return mixed
403			*/
404			protected function decodeNonUtf8FromUtf8($serializedData)
405			{
406			if (is_array($serializedData) && isset($serializedData[static::SCALAR_IDENTIFIER_KEY])) {
407			$serializedData = mb_convert_encoding($serializedData[static::SCALAR_IDENTIFIER_KEY], '8bit', 'UTF-8');
408			return $serializedData;
409			} elseif (is_scalar($serializedData) \|\| $serializedData === null) {
410			return $serializedData;
411			}
412
413			$encodedKeys = [];
414			if (isset($serializedData[static::UTF8ENCODED_IDENTIFIER_KEY])) {
415			$encodedKeys = $serializedData[static::UTF8ENCODED_IDENTIFIER_KEY];
416			unset($serializedData[static::UTF8ENCODED_IDENTIFIER_KEY]);
417			}
418
419			$decodedData = [];
420			foreach ($serializedData as $key => $value) {
421			if (is_array($value)) {
422			$value = $this->decodeNonUtf8FromUtf8($value);
423			}
424
425			if (isset($encodedKeys[$key])) {
426			$originalKey = $key;
427			if ($encodedKeys[$key] & static::KEY_UTF8ENCODED) {
428			$key = mb_convert_encoding($key, '8bit', 'UTF-8');
429			}
430			if ($encodedKeys[$originalKey] & static::VALUE_UTF8ENCODED) {
431			$value = mb_convert_encoding($value, '8bit', 'UTF-8');
432			}
433			}
434
435			$decodedData[$key] = $value;
436			}
437
438			return $decodedData;
439			}
440
441			/**
442			* Convert the serialized array into an object
443			*
444			* @param array $value
445			* @return object
446			* @throws JsonSerializerException
447			*/
448			protected function unserializeObject($value)
449			{
450			$className = $value[static::CLASS_IDENTIFIER_KEY];
451			unset($value[static::CLASS_IDENTIFIER_KEY]);
452
453			if(!$this->isClassSupported($className)){
454			throw new JsonSerializerException('The supplied class was not on the explicitly allowed list of supported classes. Unable to unserialize object.');
455			}
456
457			if ($className[0] === '@') {
458			$index = substr($className, 1);
459			return $this->objectMapping[$index];
460			}
461
462			if (array_key_exists($className, $this->customObjectSerializerMap)) {
463			$obj = $this->customObjectSerializerMap[$className]->unserialize($value);
464			$this->objectMapping[$this->objectMappingIndex++] = $obj;
465			return $obj;
466			}
467
468			if (!class_exists($className)) {
469			throw new JsonSerializerException('Unable to find class ' . $className);
470			}
471
472			if ($className === 'DateTime') {
473			$obj = $this->restoreUsingUnserialize($className, $value);
474			$this->objectMapping[$this->objectMappingIndex++] = $obj;
475			return $obj;
476			}
477
478			if (!$this->isSplList($className)) {
479			$ref = new ReflectionClass($className);
480			$obj = $ref->newInstanceWithoutConstructor();
481			} else {
482			$obj = new $className();
483			}
484
485			if ($obj instanceof \SplDoublyLinkedList ) {
486			$obj->unserialize($value['value']);
487			$this->objectMapping[$this->objectMappingIndex++] = $obj;
488			return $obj;
489			}
490
491			$this->objectMapping[$this->objectMappingIndex++] = $obj;
492			foreach ($value as $property => $propertyValue) {
493			try {
494			$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...
495			$propRef->setAccessible(true);
496			$propRef->setValue($obj, $this->unserializeData($propertyValue));
497			} catch (ReflectionException $e) {
498			switch ($this->undefinedAttributeMode) {
499			case static::UNDECLARED_PROPERTY_MODE_SET:
500			$obj->$property = $this->unserializeData($propertyValue);
501			break;
502			case static::UNDECLARED_PROPERTY_MODE_IGNORE:
503			break;
504			case static::UNDECLARED_PROPERTY_MODE_EXCEPTION:
505			throw new JsonSerializerException('Undefined attribute detected during unserialization');
506			break;
			0 ignored issues – show Unused Code introduced 2018-02-07 04:40 UTC by Report Bug Copy Issue Report `break;` does not seem to be reachable. This check looks for unreachable code. It uses sophisticated control flow analysis techniques to find statements which will never be executed. Unreachable code is most often the result of `return`, `die` or `exit` statements that have been added for debug purposes. function fx() { try { doSomething(); return true; } catch (\Exception $e) { return false; } return false; } In the above example, the last `return false` will never be executed, because a return statement has already been met in every possible execution path. Loading history...
507			}
508			}
509			}
510			if (method_exists($obj, '__wakeup')) {
511			$obj->__wakeup();
512			}
513			return $obj;
514			}
515
516			/**
517			* @return boolean
518			*/
519			protected function isSplList($className)
520			{
521			return in_array($className, array('SplQueue', 'SplDoublyLinkedList', 'SplStack'));
522			}
523
524			protected function restoreUsingUnserialize($className, $attributes)
525			{
526			$obj = (object)$attributes;
527			$serialized = preg_replace('\|^O:\d+:"\w+":\|', 'O:' . strlen($className) . ':"' . $className . '":', serialize($obj));
528			return unserialize($serialized);
529			}
530
531			/**
532			* Reset variables
533			*
534			* @return void
535			*/
536			protected function reset()
537			{
538			$this->objectStorage = new SplObjectStorage();
539			$this->objectMapping = array();
540			$this->objectMappingIndex = 0;
541			}
542			}
543

zumba / json-serializer

GitHub Access Token became invalid

Pull Request — master (#34)

JsonSerializer D

Complexity

Size/Duplication

Coupling/Cohesion

Importance

19 Methods

How to fix Complexity

Complex Class

Available Fixes

Duplication Side-by-Side

Filter issues like