AbstractJsonDeserializeObject::__construct() - Code Metrics - Inspection of "Merge pull request #491 from commercetools/externa..." - commercetools/commercetools-php-sdk - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — develop ( 1e6961...793156 )

by Jens

created 2019-06-04 11:09 UTC

AbstractJsonDeserializeObject::__construct() A

↳ Parent: AbstractJsonDeserializeObject

Complexity

Conditions	2
Paths	2

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	2

Importance

Changes

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

<?php
/**
 * @author @jenschude <[email protected]>
 */

namespace Commercetools\Core\Model\Common;

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

    const JSON_DESERIALIZE_INTERFACE = JsonDeserializeInterface::class;
    const TYPEABLE_INTERFACE = TypeableInterface::class;

    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 @jenschude <[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 = JsonDeserializeInterface::class;
16		const TYPEABLE_INTERFACE = TypeableInterface::class;
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	3011	public function __construct(array $data = [], $context = null)
29		{
30	3011	$this->setContext($context);
31	3011	if (!is_null($data)) {
		0 ignored issues – show introduced 2018-10-19 12:44 UTC by Report Bug Copy Issue Report The condition `is_null($data)` is always `false`. Loading history...
32	3011	$this->rawData = $this->typeData = $data;
33		}
34	3011	}
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	660	protected function hasInterface($type, $interfaceName)
61		{
62	660	$interfaceName = trim($interfaceName, '\\');
63	660	$cacheKey = $interfaceName . '-' . $type;
64	660	if (!isset(static::$interfaces[$cacheKey])) {
65	111	$interface = false;
66	111	if ($this->isPrimitive($type) === false
67	111	&& isset(class_implements($type)[$interfaceName])
68		) {
69	97	$interface = true;
70		}
71	111	static::$interfaces[$cacheKey] = $interface;
72		}
73	660	return static::$interfaces[$cacheKey];
74		}
75
76		/**
77		* @param $type
78		* @return string\|false
79		* @internal
80		*/
81	2245	protected function isPrimitive($type)
82		{
83	2245	if (!isset(static::$primitives[$type])) {
84	835	return false;
85		}
86
87	2185	return static::$primitives[$type];
88		}
89
90		/**
91		* @param string\|bool $type
92		* @param mixed $value
93		* @return bool
94		*/
95	2161	protected function isValidType($type, $value)
96		{
97	2161	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	2155	protected function isType($type, $value)
107		{
108	2155	if ($typeFunction = $this->isPrimitive($type)) {
109	2115	return $typeFunction($value);
110		}
111	715	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	667	protected function isDeserializableType($type)
128		{
129	667	if (!is_string($type) \|\| empty($type)) {
130	46	return false;
131		}
132	659	return $this->hasInterface($type, static::JSON_DESERIALIZE_INTERFACE);
133		}
134
135	612	protected function isTypeableType($type)
136		{
137	612	if (!is_string($type) \|\| empty($type)) {
138	46	return false;
139		}
140	583	return $this->hasInterface($type, static::TYPEABLE_INTERFACE);
141		}
142
143	1357	protected function getTyped($offset)
144		{
145	1357	if (!isset($this->initialized[$offset])) {
146	845	$this->initialize($offset);
147		}
148	1357	if (array_key_exists($offset, $this->typeData)) {
149	1357	return $this->typeData[$offset];
150		}
151		return $this->rawData[$offset];
152		}
153
154		/**
155		* @param array $rawData
156		* @internal
157		* @return $this
158		*/
159	34	public function setRawData(array $rawData)
160		{
161	34	$this->rawData = $this->typeData = $rawData;
162
163	34	return $this;
164		}
165
166		/**
167		* @param $field
168		* @param $default
169		* @return mixed
170		*/
171	841	protected function getRaw($field, $default = null)
172		{
173	841	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	705	public function jsonSerialize()
184		{
185	705	return $this->toJson();
186		}
187
188		/**
189		* @return array
190		*/
191	628	protected function toJson()
192		{
193		$data = array_filter($this->typeData, function ($value) {
194	626	return !is_null($value);
195	628	});
196
197	628	return $data;
198		}
199
200		/**
201		* @return array
202		*/
203	336	public function toArray()
204		{
205		$data = array_filter($this->typeData, function ($value) {
206	335	return !is_null($value);
207	336	});
208	336	$data = array_map(
209		function ($value) {
210	335	if ($value instanceof JsonDeserializeInterface) {
211	221	return $value->toArray();
212		}
213	335	return $value;
214	336	},
215	336	$data
216		);
217	336	return $data;
218		}
219
220		/**
221		* @param array $data
222		* @param Context\|callable $context
223		* @return static
224		*/
225	1071	public static function fromArray(array $data, $context = null)
226		{
227	1071	return new static($data, $context);
228		}
229
230		/**
231		* @param Context\|callable $context
232		* @return static
233		*/
234	2627	final public static function of($context = null)
235		{
236	2627	return new static([], $context);
237		}
238		}
239

commercetools / commercetools-php-sdk

Push — develop ( 1e6961...793156 )

AbstractJsonDeserializeObject::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like