AbstractIndexedEndpointType::processArrayContents() - Code Metrics - Inspection of "Migrate to xsd-types" - simplesamlphp/saml2 - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#374)

by Tim

created 2025-10-02 19:06 UTC

processArrayContents() B

↳ Parent: AbstractIndexedEndpointType

Complexity

Conditions	6
Paths	16

Size

Total Lines	56
Code Lines	34

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	6
eloc	34
nc	16
nop	1
dl	0
loc	56
rs	8.7537
c	0
b	0
f	0

How to fix Long Method

<?php

declare(strict_types=1);

namespace SimpleSAML\SAML2\XML\md;

use DOMElement;
use SimpleSAML\SAML2\Assert\Assert;
use SimpleSAML\SAML2\Exception\ArrayValidationException;
use SimpleSAML\SAML2\Type\SAMLAnyURIValue;
use SimpleSAML\XML\ArrayizableElementInterface;
use SimpleSAML\XML\Attribute as XMLAttribute;
use SimpleSAML\XML\SerializableElementInterface;
use SimpleSAML\XMLSchema\Exception\InvalidDOMElementException;
use SimpleSAML\XMLSchema\Type\BooleanValue;
use SimpleSAML\XMLSchema\Type\UnsignedShortValue;

use function array_filter;
use function array_key_exists;
use function array_keys;

/**
 * Class representing a SAML2 IndexedEndpointType.
 *
 * @package simplesamlphp/saml2
 */
abstract class AbstractIndexedEndpointType extends AbstractEndpointType implements ArrayizableElementInterface
{
    use IndexedElementTrait;


    /**
     * IndexedEndpointType constructor.
     *
     * Note: if you extend this class, the constructor must retain its signature. You cannot extend this class and
     * modify the signature of the constructor, unless you implement fromXML() yourself. This class provides
     * static methods to get its properties from a given \DOMElement for your convenience. Look at the implementation
     * of fromXML() to know how to use them.
     *
     * @param \SimpleSAML\XMLSchema\Type\UnsignedShortValue $index
     * @param \SimpleSAML\SAML2\Type\SAMLAnyURIValue $binding
     * @param \SimpleSAML\SAML2\Type\SAMLAnyURIValue $location
     * @param \SimpleSAML\XMLSchema\Type\BooleanValue|null $isDefault
     * @param \SimpleSAML\SAML2\Type\SAMLAnyURIValue|null $responseLocation
     * @param array $children
     * @param list<\SimpleSAML\XML\Attribute> $attributes
filter:
    dependency_paths: ["lib/*"]
     */
    public function __construct(
        UnsignedShortValue $index,
        SAMLAnyURIValue $binding,
        SAMLAnyURIValue $location,
        ?BooleanValue $isDefault = null,
        ?SAMLAnyURIValue $responseLocation = null,
        array $children = [],
        array $attributes = [],
    ) {
        parent::__construct($binding, $location, $responseLocation, $children, $attributes);

        $this->setIndex($index);
        $this->setIsDefault($isDefault);
    }


    /**
     * Initialize an IndexedEndpointType.
     *
     * @param \DOMElement $xml The XML element we should load.
     * @return static
     *
     * @throws \SimpleSAML\XMLSchema\Exception\InvalidDOMElementException
     *   if the qualified name of the supplied element is wrong
     * @throws \SimpleSAML\XMLSchema\Exception\MissingAttributeException
     *   if the supplied element is missing any of the mandatory attributes
     */
    public static function fromXML(DOMElement $xml): static
    {
        $qualifiedName = static::getClassName(static::class);
        Assert::eq(
            $xml->localName,
            $qualifiedName,
            'Unexpected name for endpoint: ' . $xml->localName . '. Expected: ' . $qualifiedName . '.',
            InvalidDOMElementException::class,
        );

        return new static(
            self::getAttribute($xml, 'index', UnsignedShortValue::class),
            self::getAttribute($xml, 'Binding', SAMLAnyURIValue::class),
            self::getAttribute($xml, 'Location', SAMLAnyURIValue::class),
            self::getOptionalAttribute($xml, 'isDefault', BooleanValue::class, null),
            self::getOptionalAttribute($xml, 'ResponseLocation', SAMLAnyURIValue::class, null),
            self::getChildElementsFromXML($xml),
            self::getAttributesNSFromXML($xml),
        );
    }


    /**
     * Add this endpoint to an XML element.
     *
     * @param \DOMElement $parent The element we should append this endpoint to.
     * @return \DOMElement
     */
    public function toXML(?DOMElement $parent = null): DOMElement
    {
        $e = parent::instantiateParentElement($parent);
        $e->setAttribute('Binding', $this->getBinding()->getValue());
        $e->setAttribute('Location', $this->getLocation()->getValue());

        if ($this->getResponseLocation() !== null) {
            $e->setAttribute('ResponseLocation', $this->getResponseLocation()->getValue());
        }

        $e->setAttribute('index', $this->getIndex()->getValue());

        if ($this->getIsDefault() !== null) {
            $e->setAttribute('isDefault', $this->getIsDefault()->getValue());
        }

        foreach ($this->getAttributesNS() as $attr) {
            $attr->toXML($e);
        }

        /** @var \SimpleSAML\XML\SerializableElementInterface $child */
        foreach ($this->getElements() as $child) {
            if (!$child->isEmptyElement()) {
                $child->toXML($e);
            }
        }

        return $e;
    }


    /**
     * Create a class from an array
     *
     * @param array $data
     * @return static
     */
    public static function fromArray(array $data): static
    {
        $data = self::processArrayContents($data);

        return new static(
            UnsignedShortValue::fromInteger($data['index']),
            SAMLAnyURIValue::fromString($data['Binding']),
            SAMLAnyURIValue::fromString($data['Location']),
            $data['isDefault'] !== null ? BooleanValue::fromBoolean($data['isDefault']) : null,
            ($data['ResponseLocation'] ?? null) ? SAMLAnyURIValue::fromString($data['ResponseLocation']) : null,
            $data['children'] ?? [],
            $data['attributes'] ?? [],
        );
    }


    /**
     * Validates an array representation of this object and returns the same array with
     * rationalized keys (casing) and parsed sub-elements.
     *
     * @param array $data
     * @return array $data
     */
    private static function processArrayContents(array $data): array
    {
        $data = array_change_key_case($data, CASE_LOWER);

        // Make sure the array keys are known for this kind of object
        Assert::allOneOf(
            array_keys($data),
            ['index', 'binding', 'location', 'isdefault', 'responselocation', 'children', 'attributes'],
            ArrayValidationException::class,
        );

        // Make sure all the mandatory items exist
        Assert::keyExists($data, 'binding', ArrayValidationException::class);
        Assert::keyExists($data, 'location', ArrayValidationException::class);
        Assert::keyExists($data, 'index', ArrayValidationException::class);

        // Make sure the items have the correct data type
        Assert::integer($data['index'], ArrayValidationException::class);
        Assert::string($data['binding'], ArrayValidationException::class);
        Assert::string($data['location'], ArrayValidationException::class);

        $retval = [
            'Binding' => $data['binding'],
            'Location' => $data['location'],
            'index' => $data['index'],
        ];

        if (array_key_exists('isdefault', $data)) {
            Assert::boolean($data['isdefault'], ArrayValidationException::class);
            $retval['isDefault'] = $data['isdefault'];
        }

        if (array_key_exists('responselocation', $data)) {
            Assert::string($data['responselocation'], ArrayValidationException::class);
            $retval['ResponseLocation'] = $data['responselocation'];
        }

        if (array_key_exists('children', $data)) {
            Assert::isArray($data['children'], ArrayValidationException::class);
            Assert::allIsInstanceOf(
                $data['children'],
                SerializableElementInterface::class,
                ArrayValidationException::class,
            );
            $retval['children'] = $data['children'];
        }

        if (array_key_exists('attributes', $data)) {
            Assert::isArray($data['attributes'], ArrayValidationException::class);
            Assert::allIsArray($data['attributes'], ArrayValidationException::class);
            foreach ($data['attributes'] as $i => $attr) {
                $retval['attributes'][] = XMLAttribute::fromArray($attr);
            }
        }

        return $retval;
    }


    /**
     * Create an array from this class
     *
     * @return array
     */
    public function toArray(): array
    {
        $data = parent::toArray();
        $data['index'] = $this->getIndex()->toInteger();
        $data['isDefault'] = $this->getIsDefault()->toBoolean();

        return array_filter($data);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace SimpleSAML\SAML2\XML\md;
6
7			use DOMElement;
8			use SimpleSAML\SAML2\Assert\Assert;
9			use SimpleSAML\SAML2\Exception\ArrayValidationException;
10			use SimpleSAML\SAML2\Type\SAMLAnyURIValue;
11			use SimpleSAML\XML\ArrayizableElementInterface;
12			use SimpleSAML\XML\Attribute as XMLAttribute;
13			use SimpleSAML\XML\SerializableElementInterface;
14			use SimpleSAML\XMLSchema\Exception\InvalidDOMElementException;
15			use SimpleSAML\XMLSchema\Type\BooleanValue;
16			use SimpleSAML\XMLSchema\Type\UnsignedShortValue;
17
18			use function array_filter;
19			use function array_key_exists;
20			use function array_keys;
21
22			/**
23			* Class representing a SAML2 IndexedEndpointType.
24			*
25			* @package simplesamlphp/saml2
26			*/
27			abstract class AbstractIndexedEndpointType extends AbstractEndpointType implements ArrayizableElementInterface
28			{
29			use IndexedElementTrait;
30
31
32			/**
33			* IndexedEndpointType constructor.
34			*
35			* Note: if you extend this class, the constructor must retain its signature. You cannot extend this class and
36			* modify the signature of the constructor, unless you implement fromXML() yourself. This class provides
37			* static methods to get its properties from a given \DOMElement for your convenience. Look at the implementation
38			* of fromXML() to know how to use them.
39			*
40			* @param \SimpleSAML\XMLSchema\Type\UnsignedShortValue $index
41			* @param \SimpleSAML\SAML2\Type\SAMLAnyURIValue $binding
42			* @param \SimpleSAML\SAML2\Type\SAMLAnyURIValue $location
43			* @param \SimpleSAML\XMLSchema\Type\BooleanValue\|null $isDefault
44			* @param \SimpleSAML\SAML2\Type\SAMLAnyURIValue\|null $responseLocation
45			* @param array $children
46			* @param list<\SimpleSAML\XML\Attribute> $attributes
			0 ignored issues – show Bug introduced 2023-05-21 11:05 UTC by Report Bug Copy Issue Report The type `SimpleSAML\SAML2\XML\md\list` was not found. Maybe you did not declare it correctly or list all dependencies? The issue could also be caused by a filter entry in the build configuration. If the path has been excluded in your configuration, e.g. `excluded_paths: ["lib/"]`, you can move it to the dependency path list as follows: filter: dependency_paths: ["lib/"] For further information see https://scrutinizer-ci.com/docs/tools/php/php-scrutinizer/#list-dependency-paths Loading history...
47			*/
48			public function __construct(
49			UnsignedShortValue $index,
50			SAMLAnyURIValue $binding,
51			SAMLAnyURIValue $location,
52			?BooleanValue $isDefault = null,
53			?SAMLAnyURIValue $responseLocation = null,
54			array $children = [],
55			array $attributes = [],
56			) {
57			parent::__construct($binding, $location, $responseLocation, $children, $attributes);
58
59			$this->setIndex($index);
60			$this->setIsDefault($isDefault);
61			}
62
63
64			/**
65			* Initialize an IndexedEndpointType.
66			*
67			* @param \DOMElement $xml The XML element we should load.
68			* @return static
69			*
70			* @throws \SimpleSAML\XMLSchema\Exception\InvalidDOMElementException
71			* if the qualified name of the supplied element is wrong
72			* @throws \SimpleSAML\XMLSchema\Exception\MissingAttributeException
73			* if the supplied element is missing any of the mandatory attributes
74			*/
75			public static function fromXML(DOMElement $xml): static
76			{
77			$qualifiedName = static::getClassName(static::class);
78			Assert::eq(
79			$xml->localName,
80			$qualifiedName,
81			'Unexpected name for endpoint: ' . $xml->localName . '. Expected: ' . $qualifiedName . '.',
82			InvalidDOMElementException::class,
83			);
84
85			return new static(
86			self::getAttribute($xml, 'index', UnsignedShortValue::class),
87			self::getAttribute($xml, 'Binding', SAMLAnyURIValue::class),
88			self::getAttribute($xml, 'Location', SAMLAnyURIValue::class),
89			self::getOptionalAttribute($xml, 'isDefault', BooleanValue::class, null),
90			self::getOptionalAttribute($xml, 'ResponseLocation', SAMLAnyURIValue::class, null),
91			self::getChildElementsFromXML($xml),
92			self::getAttributesNSFromXML($xml),
93			);
94			}
95
96
97			/**
98			* Add this endpoint to an XML element.
99			*
100			* @param \DOMElement $parent The element we should append this endpoint to.
101			* @return \DOMElement
102			*/
103			public function toXML(?DOMElement $parent = null): DOMElement
104			{
105			$e = parent::instantiateParentElement($parent);
106			$e->setAttribute('Binding', $this->getBinding()->getValue());
107			$e->setAttribute('Location', $this->getLocation()->getValue());
108
109			if ($this->getResponseLocation() !== null) {
110			$e->setAttribute('ResponseLocation', $this->getResponseLocation()->getValue());
111			}
112
113			$e->setAttribute('index', $this->getIndex()->getValue());
114
115			if ($this->getIsDefault() !== null) {
116			$e->setAttribute('isDefault', $this->getIsDefault()->getValue());
117			}
118
119			foreach ($this->getAttributesNS() as $attr) {
120			$attr->toXML($e);
121			}
122
123			/** @var \SimpleSAML\XML\SerializableElementInterface $child */
124			foreach ($this->getElements() as $child) {
125			if (!$child->isEmptyElement()) {
126			$child->toXML($e);
127			}
128			}
129
130			return $e;
131			}
132
133
134			/**
135			* Create a class from an array
136			*
137			* @param array $data
138			* @return static
139			*/
140			public static function fromArray(array $data): static
141			{
142			$data = self::processArrayContents($data);
143
144			return new static(
145			UnsignedShortValue::fromInteger($data['index']),
146			SAMLAnyURIValue::fromString($data['Binding']),
147			SAMLAnyURIValue::fromString($data['Location']),
148			$data['isDefault'] !== null ? BooleanValue::fromBoolean($data['isDefault']) : null,
149			($data['ResponseLocation'] ?? null) ? SAMLAnyURIValue::fromString($data['ResponseLocation']) : null,
150			$data['children'] ?? [],
151			$data['attributes'] ?? [],
152			);
153			}
154
155
156			/**
157			* Validates an array representation of this object and returns the same array with
158			* rationalized keys (casing) and parsed sub-elements.
159			*
160			* @param array $data
161			* @return array $data
162			*/
163			private static function processArrayContents(array $data): array
164			{
165			$data = array_change_key_case($data, CASE_LOWER);
166
167			// Make sure the array keys are known for this kind of object
168			Assert::allOneOf(
169			array_keys($data),
170			['index', 'binding', 'location', 'isdefault', 'responselocation', 'children', 'attributes'],
171			ArrayValidationException::class,
172			);
173
174			// Make sure all the mandatory items exist
175			Assert::keyExists($data, 'binding', ArrayValidationException::class);
176			Assert::keyExists($data, 'location', ArrayValidationException::class);
177			Assert::keyExists($data, 'index', ArrayValidationException::class);
178
179			// Make sure the items have the correct data type
180			Assert::integer($data['index'], ArrayValidationException::class);
181			Assert::string($data['binding'], ArrayValidationException::class);
182			Assert::string($data['location'], ArrayValidationException::class);
183
184			$retval = [
185			'Binding' => $data['binding'],
186			'Location' => $data['location'],
187			'index' => $data['index'],
188			];
189
190			if (array_key_exists('isdefault', $data)) {
191			Assert::boolean($data['isdefault'], ArrayValidationException::class);
192			$retval['isDefault'] = $data['isdefault'];
193			}
194
195			if (array_key_exists('responselocation', $data)) {
196			Assert::string($data['responselocation'], ArrayValidationException::class);
197			$retval['ResponseLocation'] = $data['responselocation'];
198			}
199
200			if (array_key_exists('children', $data)) {
201			Assert::isArray($data['children'], ArrayValidationException::class);
202			Assert::allIsInstanceOf(
203			$data['children'],
204			SerializableElementInterface::class,
205			ArrayValidationException::class,
206			);
207			$retval['children'] = $data['children'];
208			}
209
210			if (array_key_exists('attributes', $data)) {
211			Assert::isArray($data['attributes'], ArrayValidationException::class);
212			Assert::allIsArray($data['attributes'], ArrayValidationException::class);
213			foreach ($data['attributes'] as $i => $attr) {
214			$retval['attributes'][] = XMLAttribute::fromArray($attr);
215			}
216			}
217
218			return $retval;
219			}
220
221
222			/**
223			* Create an array from this class
224			*
225			* @return array
226			*/
227			public function toArray(): array
228			{
229			$data = parent::toArray();
230			$data['index'] = $this->getIndex()->toInteger();
231			$data['isDefault'] = $this->getIsDefault()->toBoolean();
232
233			return array_filter($data);
234			}
235			}
236

simplesamlphp / saml2

Pull Request — master (#374)

processArrayContents() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like