Attribute::__construct() - Code Metrics - tmilos/scim-schema - Measure and Improve Code Quality continuously with Scrutinizer

Attribute::__construct() A
last analyzed 2023-01-24 20:42 UTC

↳ Parent: Attribute

Complexity

Conditions	2
Paths	2

Size

Total Lines	26
Code Lines	12

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
eloc	12
dl	0
loc	26
rs	9.8666
c	0
b	0
f	0
cc	2
nc	2
nop	12

How to fix Many Parameters

<?php

/*
 * This file is part of the tmilos/scim-schema package.
 *
 * (c) Milos Tomic <[email protected]>
 *
 * This source file is subject to the MIT license that is bundled
 * with this source code in the file LICENSE.
 */

namespace Tmilos\ScimSchema\Model\Schema;

use Tmilos\ScimSchema\Model\SerializableInterface;
use Tmilos\ScimSchema\ScimConstants;

class Attribute implements SerializableInterface
{
    /** @var string */
    protected $name;

    /** @var string */
    protected $type;

    /** @var bool */
    protected $multiValued = false;

    /** @var bool */
    protected $required = false;

    /** @var string */
    protected $description;

    /** @var Attribute[] */
    protected $subAttributes = [];

    /** @var string[] */
    protected $canonicalValues = [];

    /** @var bool */
    protected $caseExact = false;

    /** @var string */
    protected $mutability = ScimConstants::MUTABILITY_READ_WRITE;

    /** @var string */
    protected $returned = ScimConstants::RETURNED_ALWAYS;

    /** @var string */
    protected $uniqueness = ScimConstants::UNIQUENESS_NONE;

    /** @var string[] */
    protected $referenceTypes = [];

    /**
     * @param string      $name
     * @param string      $type
     * @param bool        $multiValued
     * @param bool        $required
     * @param string      $description
     * @param Attribute[] $subAttributes
     * @param \string[]   $canonicalValues
     * @param bool        $caseExact
     * @param string      $mutability
     * @param string      $returned
     * @param string      $uniqueness
     * @param \string[]   $referenceTypes
     */
    public function __construct(
        $name,
        $type,
        $multiValued,
        $required,
        $description,
        array $subAttributes,
        array $canonicalValues,
        $caseExact,
        $mutability,
        $returned,
        $uniqueness,
        array $referenceTypes
    ) {
        $this->name = $name;
        $this->type = $type;
        $this->multiValued = $multiValued;
        $this->required = $required;
        $this->description = $description;
        $this->subAttributes = $subAttributes;
        $this->canonicalValues = $canonicalValues;
        $this->caseExact = $caseExact;
        $this->mutability = $mutability;
        $this->returned = $returned;
        $this->uniqueness = $uniqueness;
        $this->referenceTypes = $referenceTypes === null ? [] : $referenceTypes;

    }

    /**
     * @return string
     */
    public function getName()
    {
        return $this->name;
    }

    /**
     * @return string
     */
    public function getType()
    {
        return $this->type;
    }

    /**
     * @return bool
     */
    public function isMultiValued()
    {
        return $this->multiValued;
    }

    /**
     * @return bool
     */
    public function isRequired()
    {
        return $this->required;
    }

    /**
     * @return string
     */
    public function getDescription()
    {
        return $this->description;
    }

    /**
     * @return Attribute[]
     */
    public function getSubAttributes()
    {
        return $this->subAttributes;
    }

    /**
     * @return \string[]
     */
    public function getCanonicalValues()
    {
        return $this->canonicalValues;

    }

    /**
     * @return bool
     */
    public function isCaseExact()
    {
        return $this->caseExact;
    }

    /**
     * @return string
     */
    public function getMutability()
    {
        return $this->mutability;
    }

    /**
     * @return string
     */
    public function getReturned()
    {
        return $this->returned;
    }

    /**
     * @return string
     */
    public function getUniqueness()
    {
        return $this->uniqueness;
    }

    /**
     * @return \string[]
     */
    public function getReferenceTypes()
    {
        return $this->referenceTypes;

    }

    /**
     * @param string $name
     *
     * @return null|Attribute
     */
    public function findAttribute($name)
    {
        foreach ($this->subAttributes as $attribute) {
            if ($attribute->getName() === $name) {
                return $attribute;
            }
        }

        return null;
    }

    public function isValueValid($value)
    {
        switch ($this->type) {
            case ScimConstants::ATTRIBUTE_TYPE_STRING: return is_string($value);
            case ScimConstants::ATTRIBUTE_TYPE_BOOLEAN: return is_bool($value);
            case ScimConstants::ATTRIBUTE_TYPE_DECIMAL: return is_float($value) || is_int($value);
            case ScimConstants::ATTRIBUTE_TYPE_INTEGER: return is_int($value);
            case ScimConstants::ATTRIBUTE_TYPE_DATETIME:
                return $value instanceof \DateTime || false !== \DateTime::createFromFormat(\DateTime::ATOM, $value);
            case ScimConstants::ATTRIBUTE_TYPE_BINARY: return true;
            case ScimConstants::ATTRIBUTE_TYPE_REFERENCE: return is_string($value); // improve this
            case ScimConstants::ATTRIBUTE_TYPE_COMPLEX: return is_array($value) || is_object($value);
            default: throw new \LogicException('Unrecognized attribute type: '.$this->type);
        }
    }

    /**
     * @return array
     */
    public function serializeObject()
    {
        $result = [
            'name' => $this->name,
        ];
        if ($this->description) {
            $result['description'] = $this->description;
        }
        $result['type'] = $this->type;
        $result['mutability'] = $this->mutability;
        $result['returned'] = $this->returned;

        if ($this->type !== ScimConstants::ATTRIBUTE_TYPE_BOOLEAN) {
            $result['uniqueness'] = $this->uniqueness;
        }

        $result['required'] = $this->required;
        $result['multiValued'] = $this->multiValued;
        $result['caseExact'] = $this->caseExact;

        if ($this->subAttributes) {

            $result['subAttributes'] = [];
            foreach ($this->subAttributes as $subAttribute) {
                $result['subAttributes'][] = $subAttribute->serializeObject();
            }
        }
        if ($this->canonicalValues) {

            $result['canonicalValues'] = $this->canonicalValues;
        }
        if ($this->referenceTypes) {

            $result['referenceTypes'] = $this->referenceTypes;
        }

        return $result;
    }

    /**
     * @param array $data
     *
     * @return Attribute
     */
    public static function deserializeObject(array $data)
    {
        $subAttributes = [];
        if (isset($data['subAttributes'])) {
            foreach ($data['subAttributes'] as $subAttribute) {
                $subAttributes[] = static::deserializeObject($subAttribute);
            }
        }
        $result = new static(
            $data['name'],
            $data['type'],
            $data['multiValued'],
            $data['required'],
            isset($data['description']) ? $data['description'] : null,
            $subAttributes,
            isset($data['canonicalValues']) ? $data['canonicalValues'] : [],
            isset($data['caseExact']) ? $data['caseExact'] : false,
            $data['mutability'],
            $data['returned'],
            isset($data['uniqueness']) ? $data['uniqueness'] : null,
            isset($data['referenceTypes']) ? $data['referenceTypes'] : []
        );

        return $result;
    }
}


1			<?php
2
3			/*
4			* This file is part of the tmilos/scim-schema package.
5			*
6			* (c) Milos Tomic <[email protected]>
7			*
8			* This source file is subject to the MIT license that is bundled
9			* with this source code in the file LICENSE.
10			*/
11
12			namespace Tmilos\ScimSchema\Model\Schema;
13
14			use Tmilos\ScimSchema\Model\SerializableInterface;
15			use Tmilos\ScimSchema\ScimConstants;
16
17			class Attribute implements SerializableInterface
18			{
19			/** @var string */
20			protected $name;
21
22			/** @var string */
23			protected $type;
24
25			/** @var bool */
26			protected $multiValued = false;
27
28			/** @var bool */
29			protected $required = false;
30
31			/** @var string */
32			protected $description;
33
34			/** @var Attribute[] */
35			protected $subAttributes = [];
36
37			/** @var string[] */
38			protected $canonicalValues = [];
39
40			/** @var bool */
41			protected $caseExact = false;
42
43			/** @var string */
44			protected $mutability = ScimConstants::MUTABILITY_READ_WRITE;
45
46			/** @var string */
47			protected $returned = ScimConstants::RETURNED_ALWAYS;
48
49			/** @var string */
50			protected $uniqueness = ScimConstants::UNIQUENESS_NONE;
51
52			/** @var string[] */
53			protected $referenceTypes = [];
54
55			/**
56			* @param string $name
57			* @param string $type
58			* @param bool $multiValued
59			* @param bool $required
60			* @param string $description
61			* @param Attribute[] $subAttributes
62			* @param \string[] $canonicalValues
63			* @param bool $caseExact
64			* @param string $mutability
65			* @param string $returned
66			* @param string $uniqueness
67			* @param \string[] $referenceTypes
68			*/
69			public function __construct(
70			$name,
71			$type,
72			$multiValued,
73			$required,
74			$description,
75			array $subAttributes,
76			array $canonicalValues,
77			$caseExact,
78			$mutability,
79			$returned,
80			$uniqueness,
81			array $referenceTypes
82			) {
83			$this->name = $name;
84			$this->type = $type;
85			$this->multiValued = $multiValued;
86			$this->required = $required;
87			$this->description = $description;
88			$this->subAttributes = $subAttributes;
89			$this->canonicalValues = $canonicalValues;
90			$this->caseExact = $caseExact;
91			$this->mutability = $mutability;
92			$this->returned = $returned;
93			$this->uniqueness = $uniqueness;
94			$this->referenceTypes = $referenceTypes === null ? [] : $referenceTypes;
			0 ignored issues – show introduced 2019-01-31 16:40 UTC by Report Bug Copy Issue Report The condition `$referenceTypes === null` is always `false`. Loading history...
95			}
96
97			/**
98			* @return string
99			*/
100			public function getName()
101			{
102			return $this->name;
103			}
104
105			/**
106			* @return string
107			*/
108			public function getType()
109			{
110			return $this->type;
111			}
112
113			/**
114			* @return bool
115			*/
116			public function isMultiValued()
117			{
118			return $this->multiValued;
119			}
120
121			/**
122			* @return bool
123			*/
124			public function isRequired()
125			{
126			return $this->required;
127			}
128
129			/**
130			* @return string
131			*/
132			public function getDescription()
133			{
134			return $this->description;
135			}
136
137			/**
138			* @return Attribute[]
139			*/
140			public function getSubAttributes()
141			{
142			return $this->subAttributes;
143			}
144
145			/**
146			* @return \string[]
147			*/
148			public function getCanonicalValues()
149			{
150			return $this->canonicalValues;
			0 ignored issues – show Bug Best Practice introduced 2017-11-26 06:25 UTC by Report Bug Copy Issue Report The expression `return $this->canonicalValues` returns the type `string[]` which is incompatible with the documented return type `string[]`. Loading history...
151			}
152
153			/**
154			* @return bool
155			*/
156			public function isCaseExact()
157			{
158			return $this->caseExact;
159			}
160
161			/**
162			* @return string
163			*/
164			public function getMutability()
165			{
166			return $this->mutability;
167			}
168
169			/**
170			* @return string
171			*/
172			public function getReturned()
173			{
174			return $this->returned;
175			}
176
177			/**
178			* @return string
179			*/
180			public function getUniqueness()
181			{
182			return $this->uniqueness;
183			}
184
185			/**
186			* @return \string[]
187			*/
188			public function getReferenceTypes()
189			{
190			return $this->referenceTypes;
			0 ignored issues – show Bug Best Practice introduced 2017-11-26 06:25 UTC by Report Bug Copy Issue Report The expression `return $this->referenceTypes` returns the type `string[]` which is incompatible with the documented return type `string[]`. Loading history...
191			}
192
193			/**
194			* @param string $name
195			*
196			* @return null\|Attribute
197			*/
198			public function findAttribute($name)
199			{
200			foreach ($this->subAttributes as $attribute) {
201			if ($attribute->getName() === $name) {
202			return $attribute;
203			}
204			}
205
206			return null;
207			}
208
209			public function isValueValid($value)
210			{
211			switch ($this->type) {
212			case ScimConstants::ATTRIBUTE_TYPE_STRING: return is_string($value);
213			case ScimConstants::ATTRIBUTE_TYPE_BOOLEAN: return is_bool($value);
214			case ScimConstants::ATTRIBUTE_TYPE_DECIMAL: return is_float($value) \|\| is_int($value);
215			case ScimConstants::ATTRIBUTE_TYPE_INTEGER: return is_int($value);
216			case ScimConstants::ATTRIBUTE_TYPE_DATETIME:
217			return $value instanceof \DateTime \|\| false !== \DateTime::createFromFormat(\DateTime::ATOM, $value);
218			case ScimConstants::ATTRIBUTE_TYPE_BINARY: return true;
219			case ScimConstants::ATTRIBUTE_TYPE_REFERENCE: return is_string($value); // improve this
220			case ScimConstants::ATTRIBUTE_TYPE_COMPLEX: return is_array($value) \|\| is_object($value);
221			default: throw new \LogicException('Unrecognized attribute type: '.$this->type);
222			}
223			}
224
225			/**
226			* @return array
227			*/
228			public function serializeObject()
229			{
230			$result = [
231			'name' => $this->name,
232			];
233			if ($this->description) {
234			$result['description'] = $this->description;
235			}
236			$result['type'] = $this->type;
237			$result['mutability'] = $this->mutability;
238			$result['returned'] = $this->returned;
239
240			if ($this->type !== ScimConstants::ATTRIBUTE_TYPE_BOOLEAN) {
241			$result['uniqueness'] = $this->uniqueness;
242			}
243
244			$result['required'] = $this->required;
245			$result['multiValued'] = $this->multiValued;
246			$result['caseExact'] = $this->caseExact;
247
248			if ($this->subAttributes) {
			0 ignored issues – show Bug Best Practice introduced 2017-11-26 06:25 UTC by Report Bug Copy Issue Report The expression `$this->subAttributes` of type `Tmilos\ScimSchema\Model\Schema\Attribute[]` 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...
249			$result['subAttributes'] = [];
250			foreach ($this->subAttributes as $subAttribute) {
251			$result['subAttributes'][] = $subAttribute->serializeObject();
252			}
253			}
254			if ($this->canonicalValues) {
			0 ignored issues – show Bug Best Practice introduced 2017-11-26 06:25 UTC by Report Bug Copy Issue Report The expression `$this->canonicalValues` of type `string[]` 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...
255			$result['canonicalValues'] = $this->canonicalValues;
256			}
257			if ($this->referenceTypes) {
			0 ignored issues – show Bug Best Practice introduced 2017-11-26 06:25 UTC by Report Bug Copy Issue Report The expression `$this->referenceTypes` of type `string[]` 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...
258			$result['referenceTypes'] = $this->referenceTypes;
259			}
260
261			return $result;
262			}
263
264			/**
265			* @param array $data
266			*
267			* @return Attribute
268			*/
269			public static function deserializeObject(array $data)
270			{
271			$subAttributes = [];
272			if (isset($data['subAttributes'])) {
273			foreach ($data['subAttributes'] as $subAttribute) {
274			$subAttributes[] = static::deserializeObject($subAttribute);
275			}
276			}
277			$result = new static(
278			$data['name'],
279			$data['type'],
280			$data['multiValued'],
281			$data['required'],
282			isset($data['description']) ? $data['description'] : null,
283			$subAttributes,
284			isset($data['canonicalValues']) ? $data['canonicalValues'] : [],
285			isset($data['caseExact']) ? $data['caseExact'] : false,
286			$data['mutability'],
287			$data['returned'],
288			isset($data['uniqueness']) ? $data['uniqueness'] : null,
289			isset($data['referenceTypes']) ? $data['referenceTypes'] : []
290			);
291
292			return $result;
293			}
294			}
295

tmilos / scim-schema

Attribute::__construct() A last analyzed 2023-01-24 20:42 UTC

Complexity

Size

Duplication

Importance

How to fix Many Parameters

Many Parameters

Duplication Side-by-Side

Filter issues like

Attribute::__construct() A
last analyzed 2023-01-24 20:42 UTC