AbstractJsonDeserializeObject::toJson() - Code Metrics - Inspection of "fix(Reference): remove obj from serialized result..." - commercetools/commercetools-php-sdk - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( 61213d...79f8cb )

by Jens

created 2016-02-29 15:20 UTC

AbstractJsonDeserializeObject::toJson() A

↳ Parent: AbstractJsonDeserializeObject

Complexity

Conditions	1
Paths	1

Size

Total Lines	8
Code Lines	4

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	1

Importance

Changes	1
Bugs	1	Features	0

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

<?php
/**
 * @author @jayS-de <[email protected]>
 */

namespace Commercetools\Core\Model\Common;

/**
 * @package Commercetools\Core\Model\Common
 */
abstract class AbstractJsonDeserializeObject implements JsonDeserializeInterface, ObjectTreeInterface
{
    use ObjectTreeTrait;

    const JSON_DESERIALIZE_INTERFACE = 'Commercetools\Core\Model\Common\JsonDeserializeInterface';
    const TYPEABLE_INTERFACE = '\Commercetools\Core\Model\Common\TypeableInterface';

    abstract protected function initialize($field);

    protected $rawData = [];
    protected $typeData = [];
    protected $initialized = [];

    /**
     * @param array $data
     * @param Context|callable $context
     */
    public function __construct(array $data = [], $context = null)
    {
        $this->setContext($context);
        if (!is_null($data)) {
            $this->rawData = $this->typeData = $data;
        }
    }

    protected static $primitives = [
        'bool' => 'is_bool',
        'int' => 'is_int',
        'string' => 'is_string',
        'float' => 'is_float',
        'array' => 'is_array'
    ];

    /**
     * @var bool[]
     */
    protected static $interfaces = [];

    public function __sleep()
    {
        return array_diff(array_keys(get_object_vars($this)), ['context']);
    }

    /**
     * @param $type
     * @param $interfaceName
     * @return bool
     * @internal
     */
    protected function hasInterface($type, $interfaceName)
    {
        $interfaceName = trim($interfaceName, '\\');
        $cacheKey = $interfaceName . '-' . $type;
        if (!isset(static::$interfaces[$cacheKey])) {
            $interface = false;
            if ($this->isPrimitive($type) === false
                && isset(class_implements($type)[$interfaceName])
            ) {
                $interface = true;
            }
            static::$interfaces[$cacheKey] = $interface;
        }
        return static::$interfaces[$cacheKey];
    }

    /**
     * @param $type
     * @return string|false
     * @internal
     */
    protected function isPrimitive($type)
    {
        if (!isset(static::$primitives[$type])) {
            return false;
        }

        return static::$primitives[$type];
    }

    /**
     * @param string|bool $type
     * @param mixed $value
     * @return bool
     */
    protected function isValidType($type, $value)
    {
        return !is_string($type) || is_null($value) || $this->isType($type, $value);
    }

    /**
     * @param string $type
     * @param mixed $value
     * @return bool
     * @internal
     */
    protected function isType($type, $value)
    {
        if ($typeFunction = $this->isPrimitive($type)) {
            return $typeFunction($value);
        }
        return $value instanceof $type;
    }

    /**
     * @param $value
     * @return bool
     */
    protected function isDeserializable($value)
    {
        return (is_object($value) && $this->hasInterface(get_class($value), static::JSON_DESERIALIZE_INTERFACE));
    }

    /**
     * @param $type
     * @return bool
     */
    protected function isDeserializableType($type)

    {
        if (!is_string($type) || empty($type)) {
            return false;
        }
        return $this->hasInterface($type, static::JSON_DESERIALIZE_INTERFACE);
    }

    protected function isTypeableType($type)

    {
        if (!is_string($type) || empty($type)) {
            return false;
        }
        return $this->hasInterface($type, static::TYPEABLE_INTERFACE);
    }

    protected function getTyped($offset)
    {
        if (!isset($this->initialized[$offset])) {
            $this->initialize($offset);
        }
        if (array_key_exists($offset, $this->typeData)) {
            return $this->typeData[$offset];
        }
        return $this->rawData[$offset];
    }

    /**
     * @param array $rawData
     * @internal
     * @return $this
     */
    public function setRawData(array $rawData)
    {
        $this->rawData = $this->typeData = $rawData;

        return $this;
    }

    /**
     * @param $field
     * @param $default
     * @return mixed
     */
    protected function getRaw($field, $default = null)
    {
        return isset($this->rawData[$field])? $this->rawData[$field]: $default;
    }

    /**
     * (PHP 5 &gt;= 5.4.0)<br/>
     * Specify data which should be serialized to JSON
     * @link http://php.net/manual/en/jsonserializable.jsonserialize.php
     * @return mixed data which can be serialized by <b>json_encode</b>,
     * which is a value of any type other than a resource.
     */
    public function jsonSerialize()
    {
        return $this->toJson();
    }

    /**
     * @return array
     */
    protected function toJson()
    {
        $data = array_filter($this->typeData, function ($value) {
            return !is_null($value);
        });

        return $data;
    }

    /**
     * @return array
     */
    public function toArray()
    {
        $data = array_filter($this->typeData, function ($value) {
            return !is_null($value);
        });
        $data = array_map(
            function ($value) {
                if ($value instanceof JsonDeserializeInterface) {
                    return $value->toArray();
                }
                return $value;
            },
            $data
        );
        return $data;
    }

    /**
     * @param array $data
     * @param Context|callable $context
     * @return static
     */
    public static function fromArray(array $data, $context = null)
    {
        return new static($data, $context);
    }

    /**
     * @param Context|callable $context
     * @return static
     */
    final public static function of($context = null)
    {
        return new static([], $context);
    }
}


1			<?php
2			/**
3			* @author @jayS-de <[email protected]>
4			*/
5
6			namespace Commercetools\Core\Model\Common;
7
8			/**
9			* @package Commercetools\Core\Model\Common
10			*/
11			abstract class AbstractJsonDeserializeObject implements JsonDeserializeInterface, ObjectTreeInterface
12			{
13			use ObjectTreeTrait;
14
15			const JSON_DESERIALIZE_INTERFACE = 'Commercetools\Core\Model\Common\JsonDeserializeInterface';
16			const TYPEABLE_INTERFACE = '\Commercetools\Core\Model\Common\TypeableInterface';
17
18			abstract protected function initialize($field);
19
20			protected $rawData = [];
21			protected $typeData = [];
22			protected $initialized = [];
23
24			/**
25			* @param array $data
26			* @param Context\|callable $context
27			*/
28	874		public function __construct(array $data = [], $context = null)
29			{
30	874		$this->setContext($context);
31	874		if (!is_null($data)) {
32	874		$this->rawData = $this->typeData = $data;
33	874		}
34	874		}
35
36			protected static $primitives = [
37			'bool' => 'is_bool',
38			'int' => 'is_int',
39			'string' => 'is_string',
40			'float' => 'is_float',
41			'array' => 'is_array'
42			];
43
44			/**
45			* @var bool[]
46			*/
47			protected static $interfaces = [];
48
49			public function __sleep()
50			{
51			return array_diff(array_keys(get_object_vars($this)), ['context']);
52			}
53
54			/**
55			* @param $type
56			* @param $interfaceName
57			* @return bool
58			* @internal
59			*/
60	209		protected function hasInterface($type, $interfaceName)
61			{
62	209		$interfaceName = trim($interfaceName, '\\');
63	209		$cacheKey = $interfaceName . '-' . $type;
64	209		if (!isset(static::$interfaces[$cacheKey])) {
65	55		$interface = false;
66	55		if ($this->isPrimitive($type) === false
67	55		&& isset(class_implements($type)[$interfaceName])
68	55		) {
69	46		$interface = true;
70	46		}
71	55		static::$interfaces[$cacheKey] = $interface;
72	55		}
73	209		return static::$interfaces[$cacheKey];
74			}
75
76			/**
77			* @param $type
78			* @return string\|false
79			* @internal
80			*/
81	499		protected function isPrimitive($type)
82			{
83	499		if (!isset(static::$primitives[$type])) {
84	221		return false;
85			}
86
87	456		return static::$primitives[$type];
88			}
89
90			/**
91			* @param string\|bool $type
92			* @param mixed $value
93			* @return bool
94			*/
95	490		protected function isValidType($type, $value)
96			{
97	490		return !is_string($type) \|\| is_null($value) \|\| $this->isType($type, $value);
98			}
99
100			/**
101			* @param string $type
102			* @param mixed $value
103			* @return bool
104			* @internal
105			*/
106	486		protected function isType($type, $value)
107			{
108	486		if ($typeFunction = $this->isPrimitive($type)) {
109	454		return $typeFunction($value);
110			}
111	205		return $value instanceof $type;
112			}
113
114			/**
115			* @param $value
116			* @return bool
117			*/
118			protected function isDeserializable($value)
119			{
120			return (is_object($value) && $this->hasInterface(get_class($value), static::JSON_DESERIALIZE_INTERFACE));
121			}
122
123			/**
124			* @param $type
125			* @return bool
126			*/
127	210	View Code Duplication	protected function isDeserializableType($type)
			0 ignored issues – show Duplication introduced 2015-12-07 15:55 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
128			{
129	210		if (!is_string($type) \|\| empty($type)) {
130	4		return false;
131			}
132	209		return $this->hasInterface($type, static::JSON_DESERIALIZE_INTERFACE);
133			}
134
135	198	View Code Duplication	protected function isTypeableType($type)
			0 ignored issues – show Duplication introduced 2015-12-07 15:55 UTC by Report Bug Copy Issue Report This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
136			{
137	198		if (!is_string($type) \|\| empty($type)) {
138	4		return false;
139			}
140	197		return $this->hasInterface($type, static::TYPEABLE_INTERFACE);
141			}
142
143	272		protected function getTyped($offset)
144			{
145	272		if (!isset($this->initialized[$offset])) {
146	212		$this->initialize($offset);
147	212		}
148	272		if (array_key_exists($offset, $this->typeData)) {
149	272		return $this->typeData[$offset];
150			}
151			return $this->rawData[$offset];
152			}
153
154			/**
155			* @param array $rawData
156			* @internal
157			* @return $this
158			*/
159	10		public function setRawData(array $rawData)
160			{
161	10		$this->rawData = $this->typeData = $rawData;
162
163	10		return $this;
164			}
165
166			/**
167			* @param $field
168			* @param $default
169			* @return mixed
170			*/
171	209		protected function getRaw($field, $default = null)
172			{
173	209		return isset($this->rawData[$field])? $this->rawData[$field]: $default;
174			}
175
176			/**
177			* (PHP 5 >= 5.4.0)<br/>
178			* Specify data which should be serialized to JSON
179			* @link http://php.net/manual/en/jsonserializable.jsonserialize.php
180			* @return mixed data which can be serialized by <b>json_encode</b>,
181			* which is a value of any type other than a resource.
182			*/
183	140		public function jsonSerialize()
184			{
185	140		return $this->toJson();
186			}
187
188			/**
189			* @return array
190			*/
191	140		protected function toJson()
192			{
193			$data = array_filter($this->typeData, function ($value) {
194	138		return !is_null($value);
195	140		});
196
197	140		return $data;
198			}
199
200			/**
201			* @return array
202			*/
203	4		public function toArray()
204			{
205			$data = array_filter($this->typeData, function ($value) {
206	4		return !is_null($value);
207	4		});
208	4		$data = array_map(
209	4		function ($value) {
210	4		if ($value instanceof JsonDeserializeInterface) {
211	1		return $value->toArray();
212			}
213	4		return $value;
214	4		},
215			$data
216	4		);
217	4		return $data;
218			}
219
220			/**
221			* @param array $data
222			* @param Context\|callable $context
223			* @return static
224			*/
225	346		public static function fromArray(array $data, $context = null)
226			{
227	346		return new static($data, $context);
228			}
229
230			/**
231			* @param Context\|callable $context
232			* @return static
233			*/
234	645		final public static function of($context = null)
235			{
236	645		return new static([], $context);
237			}
238			}
239

commercetools / commercetools-php-sdk

Push — develop ( 61213d...79f8cb )

AbstractJsonDeserializeObject::toJson() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like