Attribute::guessLocalizedText() - Code Metrics - commercetools/commercetools-php-sdk - Measure and Improve Code Quality continuously with Scrutinizer

Attribute::guessLocalizedText() A
last analyzed 2022-02-07 10:34 UTC

↳ Parent: Attribute

Complexity

Conditions	3
Paths	2

Size

Total Lines	7
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	4
CRAP Score	3

Importance

Changes

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

<?php
/**
 * @author @jenschude <[email protected]>
 * @created: 04.02.15, 17:46
 */

namespace Commercetools\Core\Model\Common;

use Commercetools\Core\Model\ProductType\AttributeDefinition;
use Commercetools\Core\Model\ProductType\AttributeType;
use Commercetools\Core\Model\ProductType\SetType;

/**
 * @package Commercetools\Core\Model\Common
 * @link https://docs.commercetools.com/http-api-projects-products.html#attribute
 * @method string getName()
 * @method Attribute setName(string $name = null)
 * @method mixed getValue()
 * @method Attribute setValue($value = null)
 */
class Attribute extends JsonObject
{
    // identifiers for the Api Product Attribute Types:
    const T_UNKNOWN = 'unknown';  // zero, should evaluate to false

    const PROP_VALUE = "value";
    const PROP_KEY = "key";
    const PROP_NAME = "name";
    const PROP_CURRENCY_CODE = "currencyCode";
    const PROP_CENT_AMOUNT = "centAmount";
    const PROP_TYPE_ID = "typeId";
    const PROP_ID = "id";
    const PROP_LABEL = "label";

    const API_BOOL = 'boolean';
    const API_NUMBER = 'number';
    const API_TEXT = 'text';
    const API_LTEXT = 'ltext';
    const API_LENUM = 'lenum';
    const API_ENUM = 'enum';
    const API_MONEY = 'money';
    const API_DATE = 'date';
    const API_TIME = 'time';
    const API_DATETIME = 'datetime';
    const API_SET = 'set';
    const API_NESTED = 'nested';
    const API_REFERENCE = 'reference';

    protected static $types = [];

    public function fieldDefinitions()
    {
        return [
            static::PROP_NAME => [static::TYPE => 'string'],
            static::PROP_VALUE => [],
        ];
    }

    public function fieldDefinition($field)
    {
        if ($field == static::PROP_VALUE) {
            if (isset(static::$types[$this->getName()])) {
                $fieldDefinition = static::$types[$this->getName()];
                if (!$fieldDefinition instanceof AttributeDefinition) {
                    return null;
                }
                $fieldType = $fieldDefinition->getType();
                if (!$fieldType instanceof AttributeType) {

                    return null;
                }
                return $fieldType->fieldTypeDefinition();
            }
            return null;
        }
        return parent::fieldDefinition($field);
    }

    /**
     * @param $attributeName
     * @param $value
     * @return mixed
     */
    protected function getApiType($attributeName, $value)
    {
        if (isset(static::$types[$attributeName])) {
            return static::$types[$attributeName];
        }

        $apiType = $this->guessApiType($value);
        $elementType = null;
        if ($apiType == static::API_SET) {
            $elementType = $this->guessApiType(current($value));
        }
        $this->setApiType($attributeName, $apiType, $elementType);

        return static::$types[$attributeName];
    }

    /**
     * @param AttributeDefinition $definition
     * @return $this
     */
    public function setAttributeDefinition(AttributeDefinition $definition)
    {
        static::$types[$definition->getName()] = $definition;

        return $this;
    }

    /**
     * @param string $field
     */
    protected function initialize($field)
    {
        if ($field == static::PROP_VALUE) {
            $name = $this->getRaw(static::PROP_NAME);
            $value = $this->getRaw(static::PROP_VALUE);
            $this->getApiType($name, $value);
        }
        parent::initialize($field);
    }

    private function setApiType($attributeName, $valueType, $elementType = null)
    {
        if (!isset(static::$types[$attributeName])) {
            $attributeType = AttributeType::fromArray(['name' => $valueType]);
            if ($attributeType instanceof SetType && $elementType != null) {
                $attributeType->setElementType(AttributeType::fromArray(['name' => $elementType]));
            }

            $definition = AttributeDefinition::of($this->getContextCallback());
            $definition->setName($attributeName);
            $definition->setType($attributeType);
            $this->setAttributeDefinition($definition);
        }
    }

    /**
     * @return bool
     */
    public function getValueAsBool()
    {
        $attributeName = $this->getName();
        $this->setApiType($attributeName, static::API_BOOL);
        return $this->getValue();
    }

    /**
     * @return int|float
     */
    public function getValueAsNumber()
    {
        $attributeName = $this->getName();
        $this->setApiType($attributeName, static::API_NUMBER);
        return $this->getValue();
    }

    /**
     * @return string
     */
    public function getValueAsString()
    {
        $attributeName = $this->getName();
        $this->setApiType($attributeName, static::API_TEXT);
        return $this->getValue();
    }

    /**
     * @return LocalizedString
     */
    public function getValueAsLocalizedString()
    {
        $attributeName = $this->getName();
        $this->setApiType($attributeName, static::API_LTEXT);
        return $this->getValue();
    }

    /**
     * @return LocalizedEnum
     */
    public function getValueAsLocalizedEnum()
    {
        $attributeName = $this->getName();
        $this->setApiType($attributeName, static::API_LENUM);
        return $this->getValue();
    }

    /**
     * @return Enum
     */
    public function getValueAsEnum()
    {
        $attributeName = $this->getName();
        $this->setApiType($attributeName, static::API_ENUM);
        return $this->getValue();
    }

    /**
     * @return Money
     */
    public function getValueAsMoney()
    {
        $attributeName = $this->getName();
        $this->setApiType($attributeName, static::API_MONEY);
        return $this->getValue();
    }

    /**
     * @return DateDecorator
     */
    public function getValueAsDate()
    {
        $attributeName = $this->getName();
        $this->setApiType($attributeName, static::API_DATE);
        return $this->getValue();
    }

    /**
     * @return TimeDecorator
     */
    public function getValueAsTime()
    {
        $attributeName = $this->getName();
        $this->setApiType($attributeName, static::API_TIME);
        return $this->getValue();
    }

    /**
     * @return DateTimeDecorator
     */
    public function getValueAsDateTime()
    {
        $attributeName = $this->getName();
        $this->setApiType($attributeName, static::API_DATETIME);
        return $this->getValue();
    }

    /**
     * @return AttributeCollection
     */
    public function getValueAsNested()
    {
        $attributeName = $this->getName();
        $this->setApiType($attributeName, static::API_NESTED);
        return $this->getValue();
    }

    /**
     * @return Reference
     */
    public function getValueAsReference()
    {
        $attributeName = $this->getName();
        $this->setApiType($attributeName, static::API_REFERENCE);
        return $this->getValue();
    }

    /**
     * @return Set
     */
    public function getValueAsBoolSet()
    {
        $attributeName = $this->getName();
        $this->setApiType($attributeName, static::API_SET, static::API_BOOL);
        return $this->getValue();
    }

    /**
     * @return Set
     */
    public function getValueAsNumberSet()
    {
        $attributeName = $this->getName();
        $this->setApiType($attributeName, static::API_SET, static::API_NUMBER);
        return $this->getValue();
    }

    /**
     * @return Set
     */
    public function getValueAsStringSet()
    {
        $attributeName = $this->getName();
        $this->setApiType($attributeName, static::API_SET, static::API_TEXT);
        return $this->getValue();
    }

    /**
     * @return Set
     */
    public function getValueAsLocalizedStringSet()
    {
        $attributeName = $this->getName();
        $this->setApiType($attributeName, static::API_SET, static::API_LTEXT);
        return $this->getValue();
    }

    /**
     * @return Set
     */
    public function getValueAsLocalizedEnumSet()
    {
        $attributeName = $this->getName();
        $this->setApiType($attributeName, static::API_SET, static::API_LENUM);
        return $this->getValue();
    }

    /**
     * @return Set
     */
    public function getValueAsEnumSet()
    {
        $attributeName = $this->getName();
        $this->setApiType($attributeName, static::API_SET, static::API_ENUM);
        return $this->getValue();
    }

    /**
     * @return Set
     */
    public function getValueAsMoneySet()
    {
        $attributeName = $this->getName();
        $this->setApiType($attributeName, static::API_SET, static::API_MONEY);
        return $this->getValue();
    }

    /**
     * @return Set
     */
    public function getValueAsDateSet()
    {
        $attributeName = $this->getName();
        $this->setApiType($attributeName, static::API_SET, static::API_DATE);
        return $this->getValue();
    }

    /**
     * @return Set
     */
    public function getValueAsTimeSet()
    {
        $attributeName = $this->getName();
        $this->setApiType($attributeName, static::API_SET, static::API_TIME);
        return $this->getValue();
    }

    /**
     * @return Set
     */
    public function getValueAsDateTimeSet()
    {
        $attributeName = $this->getName();
        $this->setApiType($attributeName, static::API_SET, static::API_DATETIME);
        return $this->getValue();
    }

    /**
     * @return Set
     */
    public function getValueAsNestedSet()
    {
        $attributeName = $this->getName();
        $this->setApiType($attributeName, static::API_SET, static::API_NESTED);
        return $this->getValue();
    }

    /**
     * @return Set
     */
    public function getValueAsReferenceSet()
    {
        $attributeName = $this->getName();
        $this->setApiType($attributeName, static::API_SET, static::API_REFERENCE);
        return $this->getValue();
    }

    /**
     * @param $value
     * @return string
     */
    protected function guessApiType($value)
    {
        $map = [
            'guessUnknown',
            'guessBool',
            'guessTextLike',
            'guessNumber',
            'guessEnum',
            'guessLocalizedEnum',
            'guessMoney',
            'guessReference',
            'guessLocalizedText',
            'guessNested',
            'guessSet',
        ];

        foreach ($map as $function) {
            if ($type = $this->$function($value)) {
                return $type;
            }
        }

        return static::T_UNKNOWN;
    }

    /**
     * @param $value
     * @param string[] $keys
     * @return bool
     */
    protected function hasKeys($value, $keys)
    {
        if (!is_array($value)) {
            return false;
        }
        $intersect = array_intersect_key(array_flip($keys), $value);
        return (count($intersect) == count($keys));
    }

    protected function guessUnknown($value)
    {
        return (!isset($value) ? static::T_UNKNOWN : null);
    }

    protected function guessTextLike($value)
    {
        return is_string($value) ? static::API_TEXT : null;
    }

    protected function guessBool($value)
    {
        return is_bool($value) ? static::API_BOOL : null;
    }

    protected function guessNumber($value)
    {
        return is_numeric($value) ? static::API_NUMBER : null;
    }

    protected function guessEnum($value)
    {
        if ($this->hasKeys($value, [static::PROP_KEY, static::PROP_LABEL]) && is_string($value[static::PROP_LABEL])) {
            return static::API_ENUM;
        }

        return null;
    }

    protected function guessLocalizedEnum($value)
    {
        if ($this->hasKeys($value, [static::PROP_KEY, static::PROP_LABEL]) && is_array($value[static::PROP_LABEL])) {
            return static::API_LENUM;
        }

        return null;
    }

    protected function guessMoney($value)
    {
        if ($this->hasKeys($value, [static::PROP_CENT_AMOUNT, static::PROP_CURRENCY_CODE])) {
            return static::API_MONEY;
        }

        return null;
    }

    protected function guessReference($value)
    {
        if ($this->hasKeys($value, [static::PROP_TYPE_ID, static::PROP_ID])) {
            return static::API_REFERENCE;
        }

        return null;
    }

    protected function guessLocalizedText($value)
    {
        if (is_array($value) && !is_numeric(key($value))) {
            return static::API_LTEXT;
        }

        return null;
    }

    protected function guessSet($value)
    {
        if (is_array($value)) {
            return static::API_SET;
        }

        return null;
    }

    protected function guessNested($value)
    {
        if (is_array($value)) {
            $first = reset($value);
            if ($this->hasKeys($first, [static::PROP_NAME, static::PROP_VALUE])) {
                return static::API_NESTED;
            }
        }

        return null;
    }
}


1		<?php
2		/**
3		* @author @jenschude <[email protected]>
4		* @created: 04.02.15, 17:46
5		*/
6
7		namespace Commercetools\Core\Model\Common;
8
9		use Commercetools\Core\Model\ProductType\AttributeDefinition;
10		use Commercetools\Core\Model\ProductType\AttributeType;
11		use Commercetools\Core\Model\ProductType\SetType;
12
13		/**
14		* @package Commercetools\Core\Model\Common
15		* @link https://docs.commercetools.com/http-api-projects-products.html#attribute
16		* @method string getName()
17		* @method Attribute setName(string $name = null)
18		* @method mixed getValue()
19		* @method Attribute setValue($value = null)
20		*/
21		class Attribute extends JsonObject
22		{
23		// identifiers for the Api Product Attribute Types:
24		const T_UNKNOWN = 'unknown'; // zero, should evaluate to false
25
26		const PROP_VALUE = "value";
27		const PROP_KEY = "key";
28		const PROP_NAME = "name";
29		const PROP_CURRENCY_CODE = "currencyCode";
30		const PROP_CENT_AMOUNT = "centAmount";
31		const PROP_TYPE_ID = "typeId";
32		const PROP_ID = "id";
33		const PROP_LABEL = "label";
34
35		const API_BOOL = 'boolean';
36		const API_NUMBER = 'number';
37		const API_TEXT = 'text';
38		const API_LTEXT = 'ltext';
39		const API_LENUM = 'lenum';
40		const API_ENUM = 'enum';
41		const API_MONEY = 'money';
42		const API_DATE = 'date';
43		const API_TIME = 'time';
44		const API_DATETIME = 'datetime';
45		const API_SET = 'set';
46		const API_NESTED = 'nested';
47		const API_REFERENCE = 'reference';
48
49		protected static $types = [];
50
51	52	public function fieldDefinitions()
52		{
53		return [
54	52	static::PROP_NAME => [static::TYPE => 'string'],
55	52	static::PROP_VALUE => [],
56		];
57		}
58
59	50	public function fieldDefinition($field)
60		{
61	50	if ($field == static::PROP_VALUE) {
62	49	if (isset(static::$types[$this->getName()])) {
63	43	$fieldDefinition = static::$types[$this->getName()];
64	43	if (!$fieldDefinition instanceof AttributeDefinition) {
65		return null;
66		}
67	43	$fieldType = $fieldDefinition->getType();
68	43	if (!$fieldType instanceof AttributeType) {
		0 ignored issues – show introduced 2018-10-19 12:44 UTC by Report Bug Copy Issue Report `$fieldType` is always a sub-type of `Commercetools\Core\Model\ProductType\AttributeType`. Loading history...
69		return null;
70		}
71	43	return $fieldType->fieldTypeDefinition();
72		}
73	7	return null;
74		}
75	50	return parent::fieldDefinition($field);
76		}
77
78		/**
79		* @param $attributeName
80		* @param $value
81		* @return mixed
82		*/
83	43	protected function getApiType($attributeName, $value)
84		{
85	43	if (isset(static::$types[$attributeName])) {
86	28	return static::$types[$attributeName];
87		}
88
89	15	$apiType = $this->guessApiType($value);
90	15	$elementType = null;
91	15	if ($apiType == static::API_SET) {
92	2	$elementType = $this->guessApiType(current($value));
93		}
94	15	$this->setApiType($attributeName, $apiType, $elementType);
95
96	15	return static::$types[$attributeName];
97		}
98
99		/**
100		* @param AttributeDefinition $definition
101		* @return $this
102		*/
103	40	public function setAttributeDefinition(AttributeDefinition $definition)
104		{
105	40	static::$types[$definition->getName()] = $definition;
106
107	40	return $this;
108		}
109
110		/**
111		* @param string $field
112		*/
113	44	protected function initialize($field)
114		{
115	44	if ($field == static::PROP_VALUE) {
116	43	$name = $this->getRaw(static::PROP_NAME);
117	43	$value = $this->getRaw(static::PROP_VALUE);
118	43	$this->getApiType($name, $value);
119		}
120	44	parent::initialize($field);
121	44	}
122
123	36	private function setApiType($attributeName, $valueType, $elementType = null)
124		{
125	36	if (!isset(static::$types[$attributeName])) {
126	36	$attributeType = AttributeType::fromArray(['name' => $valueType]);
127	36	if ($attributeType instanceof SetType && $elementType != null) {
128	13	$attributeType->setElementType(AttributeType::fromArray(['name' => $elementType]));
129		}
130
131	36	$definition = AttributeDefinition::of($this->getContextCallback());
132	36	$definition->setName($attributeName);
133	36	$definition->setType($attributeType);
134	36	$this->setAttributeDefinition($definition);
135		}
136	36	}
137
138		/**
139		* @return bool
140		*/
141	1	public function getValueAsBool()
142		{
143	1	$attributeName = $this->getName();
144	1	$this->setApiType($attributeName, static::API_BOOL);
145	1	return $this->getValue();
146		}
147
148		/**
149		* @return int\|float
150		*/
151	2	public function getValueAsNumber()
152		{
153	2	$attributeName = $this->getName();
154	2	$this->setApiType($attributeName, static::API_NUMBER);
155	2	return $this->getValue();
156		}
157
158		/**
159		* @return string
160		*/
161	1	public function getValueAsString()
162		{
163	1	$attributeName = $this->getName();
164	1	$this->setApiType($attributeName, static::API_TEXT);
165	1	return $this->getValue();
166		}
167
168		/**
169		* @return LocalizedString
170		*/
171	1	public function getValueAsLocalizedString()
172		{
173	1	$attributeName = $this->getName();
174	1	$this->setApiType($attributeName, static::API_LTEXT);
175	1	return $this->getValue();
176		}
177
178		/**
179		* @return LocalizedEnum
180		*/
181	1	public function getValueAsLocalizedEnum()
182		{
183	1	$attributeName = $this->getName();
184	1	$this->setApiType($attributeName, static::API_LENUM);
185	1	return $this->getValue();
186		}
187
188		/**
189		* @return Enum
190		*/
191	1	public function getValueAsEnum()
192		{
193	1	$attributeName = $this->getName();
194	1	$this->setApiType($attributeName, static::API_ENUM);
195	1	return $this->getValue();
196		}
197
198		/**
199		* @return Money
200		*/
201	1	public function getValueAsMoney()
202		{
203	1	$attributeName = $this->getName();
204	1	$this->setApiType($attributeName, static::API_MONEY);
205	1	return $this->getValue();
206		}
207
208		/**
209		* @return DateDecorator
210		*/
211		public function getValueAsDate()
212		{
213		$attributeName = $this->getName();
214		$this->setApiType($attributeName, static::API_DATE);
215		return $this->getValue();
216		}
217
218		/**
219		* @return TimeDecorator
220		*/
221		public function getValueAsTime()
222		{
223		$attributeName = $this->getName();
224		$this->setApiType($attributeName, static::API_TIME);
225		return $this->getValue();
226		}
227
228		/**
229		* @return DateTimeDecorator
230		*/
231		public function getValueAsDateTime()
232		{
233		$attributeName = $this->getName();
234		$this->setApiType($attributeName, static::API_DATETIME);
235		return $this->getValue();
236		}
237
238		/**
239		* @return AttributeCollection
240		*/
241	1	public function getValueAsNested()
242		{
243	1	$attributeName = $this->getName();
244	1	$this->setApiType($attributeName, static::API_NESTED);
245	1	return $this->getValue();
246		}
247
248		/**
249		* @return Reference
250		*/
251	1	public function getValueAsReference()
252		{
253	1	$attributeName = $this->getName();
254	1	$this->setApiType($attributeName, static::API_REFERENCE);
255	1	return $this->getValue();
256		}
257
258		/**
259		* @return Set
260		*/
261	1	public function getValueAsBoolSet()
262		{
263	1	$attributeName = $this->getName();
264	1	$this->setApiType($attributeName, static::API_SET, static::API_BOOL);
265	1	return $this->getValue();
266		}
267
268		/**
269		* @return Set
270		*/
271	2	public function getValueAsNumberSet()
272		{
273	2	$attributeName = $this->getName();
274	2	$this->setApiType($attributeName, static::API_SET, static::API_NUMBER);
275	2	return $this->getValue();
276		}
277
278		/**
279		* @return Set
280		*/
281	1	public function getValueAsStringSet()
282		{
283	1	$attributeName = $this->getName();
284	1	$this->setApiType($attributeName, static::API_SET, static::API_TEXT);
285	1	return $this->getValue();
286		}
287
288		/**
289		* @return Set
290		*/
291	1	public function getValueAsLocalizedStringSet()
292		{
293	1	$attributeName = $this->getName();
294	1	$this->setApiType($attributeName, static::API_SET, static::API_LTEXT);
295	1	return $this->getValue();
296		}
297
298		/**
299		* @return Set
300		*/
301	1	public function getValueAsLocalizedEnumSet()
302		{
303	1	$attributeName = $this->getName();
304	1	$this->setApiType($attributeName, static::API_SET, static::API_LENUM);
305	1	return $this->getValue();
306		}
307
308		/**
309		* @return Set
310		*/
311	2	public function getValueAsEnumSet()
312		{
313	2	$attributeName = $this->getName();
314	2	$this->setApiType($attributeName, static::API_SET, static::API_ENUM);
315	2	return $this->getValue();
316		}
317
318		/**
319		* @return Set
320		*/
321	1	public function getValueAsMoneySet()
322		{
323	1	$attributeName = $this->getName();
324	1	$this->setApiType($attributeName, static::API_SET, static::API_MONEY);
325	1	return $this->getValue();
326		}
327
328		/**
329		* @return Set
330		*/
331		public function getValueAsDateSet()
332		{
333		$attributeName = $this->getName();
334		$this->setApiType($attributeName, static::API_SET, static::API_DATE);
335		return $this->getValue();
336		}
337
338		/**
339		* @return Set
340		*/
341		public function getValueAsTimeSet()
342		{
343		$attributeName = $this->getName();
344		$this->setApiType($attributeName, static::API_SET, static::API_TIME);
345		return $this->getValue();
346		}
347
348		/**
349		* @return Set
350		*/
351		public function getValueAsDateTimeSet()
352		{
353		$attributeName = $this->getName();
354		$this->setApiType($attributeName, static::API_SET, static::API_DATETIME);
355		return $this->getValue();
356		}
357
358		/**
359		* @return Set
360		*/
361	1	public function getValueAsNestedSet()
362		{
363	1	$attributeName = $this->getName();
364	1	$this->setApiType($attributeName, static::API_SET, static::API_NESTED);
365	1	return $this->getValue();
366		}
367
368		/**
369		* @return Set
370		*/
371	1	public function getValueAsReferenceSet()
372		{
373	1	$attributeName = $this->getName();
374	1	$this->setApiType($attributeName, static::API_SET, static::API_REFERENCE);
375	1	return $this->getValue();
376		}
377
378		/**
379		* @param $value
380		* @return string
381		*/
382	15	protected function guessApiType($value)
383		{
384		$map = [
385	15	'guessUnknown',
386		'guessBool',
387		'guessTextLike',
388		'guessNumber',
389		'guessEnum',
390		'guessLocalizedEnum',
391		'guessMoney',
392		'guessReference',
393		'guessLocalizedText',
394		'guessNested',
395		'guessSet',
396		];
397
398	15	foreach ($map as $function) {
399	15	if ($type = $this->$function($value)) {
400	15	return $type;
401		}
402		}
403
404		return static::T_UNKNOWN;
405		}
406
407		/**
408		* @param $value
409		* @param string[] $keys
410		* @return bool
411		*/
412	9	protected function hasKeys($value, $keys)
413		{
414	9	if (!is_array($value)) {
415	1	return false;
416		}
417	9	$intersect = array_intersect_key(array_flip($keys), $value);
418	9	return (count($intersect) == count($keys));
419		}
420
421	15	protected function guessUnknown($value)
422		{
423	15	return (!isset($value) ? static::T_UNKNOWN : null);
424		}
425
426	13	protected function guessTextLike($value)
427		{
428	13	return is_string($value) ? static::API_TEXT : null;
429		}
430
431	14	protected function guessBool($value)
432		{
433	14	return is_bool($value) ? static::API_BOOL : null;
434		}
435
436	11	protected function guessNumber($value)
437		{
438	11	return is_numeric($value) ? static::API_NUMBER : null;
439		}
440
441	9	protected function guessEnum($value)
442		{
443	9	if ($this->hasKeys($value, [static::PROP_KEY, static::PROP_LABEL]) && is_string($value[static::PROP_LABEL])) {
444	2	return static::API_ENUM;
445		}
446
447	8	return null;
448		}
449
450	8	protected function guessLocalizedEnum($value)
451		{
452	8	if ($this->hasKeys($value, [static::PROP_KEY, static::PROP_LABEL]) && is_array($value[static::PROP_LABEL])) {
453	1	return static::API_LENUM;
454		}
455
456	7	return null;
457		}
458
459	7	protected function guessMoney($value)
460		{
461	7	if ($this->hasKeys($value, [static::PROP_CENT_AMOUNT, static::PROP_CURRENCY_CODE])) {
462	1	return static::API_MONEY;
463		}
464
465	6	return null;
466		}
467
468	6	protected function guessReference($value)
469		{
470	6	if ($this->hasKeys($value, [static::PROP_TYPE_ID, static::PROP_ID])) {
471	2	return static::API_REFERENCE;
472		}
473
474	4	return null;
475		}
476
477	4	protected function guessLocalizedText($value)
478		{
479	4	if (is_array($value) && !is_numeric(key($value))) {
480	1	return static::API_LTEXT;
481		}
482
483	3	return null;
484		}
485
486	2	protected function guessSet($value)
487		{
488	2	if (is_array($value)) {
489	2	return static::API_SET;
490		}
491
492		return null;
493		}
494
495	3	protected function guessNested($value)
496		{
497	3	if (is_array($value)) {
498	3	$first = reset($value);
499	3	if ($this->hasKeys($first, [static::PROP_NAME, static::PROP_VALUE])) {
500	1	return static::API_NESTED;
501		}
502		}
503
504	2	return null;
505		}
506		}
507

commercetools / commercetools-php-sdk

Attribute::guessLocalizedText() A last analyzed 2022-02-07 10:34 UTC

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like

Attribute::guessLocalizedText() A
last analyzed 2022-02-07 10:34 UTC