Organization::validateArray() - Code Metrics - Inspection of "Add validateArray method on elements they are arra..." - simplesamlphp/saml2 - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — master (#337)

by Tim
created 2023-05-29 12:02 UTC
Organization::validateArray() B

↳ Parent: Organization
Complexity

Conditions	7
Paths	32
Size

Total Lines	46
Code Lines	27
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	7
eloc	27
nc	32
nop	1
dl	0
loc	46
rs	8.5546
c	0
b	0
f	0
<?php

declare(strict_types=1);

namespace SimpleSAML\SAML2\XML\md;

use DOMDocument;
use DOMElement;
use Exception;
use SimpleSAML\Assert\Assert;
use SimpleSAML\SAML2\Exception\ProtocolViolationException;
use SimpleSAML\SAML2\XML\ExtendableElementTrait;
use SimpleSAML\XML\Constants as C;
use SimpleSAML\XML\ArrayizableElementInterface;
use SimpleSAML\XML\Attribute as XMLAttribute;
use SimpleSAML\XML\Exception\InvalidDOMElementException;
use SimpleSAML\XML\Exception\MissingElementException;
use SimpleSAML\XML\Exception\TooManyElementsException;
use SimpleSAML\XML\ExtendableAttributesTrait;
use SimpleSAML\XML\SerializableElementInterface;
use SimpleSAML\XML\Utils as XMLUtils;

use function array_filter;
use function array_key_exists;
use function array_merge;

/**
 * Class representing SAML 2 Organization element.
 *
 * @package simplesamlphp/saml2
 */
final class Organization extends AbstractMdElement implements ArrayizableElementInterface
{
    use ExtendableAttributesTrait;

    use ExtendableElementTrait;

    /** The namespace-attribute for the xs:anyAttribute element */
    public const XS_ANY_ATTR_NAMESPACE = C::XS_ANY_NS_OTHER;


    /**
     * Organization constructor.
     *
     * @param \SimpleSAML\SAML2\XML\md\OrganizationName[] $organizationName
     * @param \SimpleSAML\SAML2\XML\md\OrganizationDisplayName[] $organizationDisplayName
     * @param \SimpleSAML\SAML2\XML\md\OrganizationURL[] $organizationURL
     * @param \SimpleSAML\SAML2\XML\md\Extensions|null $extensions
     * @param list<\SimpleSAML\XML\Attribute> $namespacedAttributes
filter:
    dependency_paths: ["lib/*"]
     */
    public function __construct(
        protected array $organizationName,
        protected array $organizationDisplayName,
        protected array $organizationURL,
        ?Extensions $extensions = null,
        array $namespacedAttributes = [],
    ) {
        Assert::allIsInstanceOf($organizationName, OrganizationName::class);
        Assert::allIsInstanceOf($organizationDisplayName, OrganizationDisplayName::class);
        Assert::allIsInstanceOf($organizationURL, OrganizationURL::class);

        // [One or More]
        Assert::minCount($organizationName, 1, ProtocolViolationException::class);
        Assert::minCount($organizationDisplayName, 1, ProtocolViolationException::class);
        Assert::minCount($organizationURL, 1, ProtocolViolationException::class);

        $this->setExtensions($extensions);
        $this->setAttributesNS($namespacedAttributes);
    }


    /**
     * Collect the value of the OrganizationName property.
     *
     * @return \SimpleSAML\SAML2\XML\md\OrganizationName[]
     */
    public function getOrganizationName(): array
    {
        return $this->organizationName;
    }


    /**
     * Collect the value of the OrganizationDisplayName property.
     *
     * @return \SimpleSAML\SAML2\XML\md\OrganizationDisplayName[]
     */
    public function getOrganizationDisplayName(): array
    {
        return $this->organizationDisplayName;
    }


    /**
     * Collect the value of the OrganizationURL property.
     *
     * @return \SimpleSAML\SAML2\XML\md\OrganizationURL[]
     */
    public function getOrganizationURL(): array
    {
        return $this->organizationURL;
    }


    /**
     * Initialize an Organization element.
     *
     * @param \DOMElement $xml The XML element we should load.
     * @return static
     *
     * @throws \SimpleSAML\XML\Exception\InvalidDOMElementException
     *   if the qualified name of the supplied element is wrong
     * @throws \SimpleSAML\XML\Exception\MissingElementException
     *   if one of the mandatory child-elements is missing
     */
    public static function fromXML(DOMElement $xml): static
    {
        Assert::same($xml->localName, 'Organization', InvalidDOMElementException::class);
        Assert::same($xml->namespaceURI, Organization::NS, InvalidDOMElementException::class);

        $names = OrganizationName::getChildrenOfClass($xml);
        Assert::minCount($names, 1, 'Missing at least one OrganizationName.', MissingElementException::class);

        $displayNames = OrganizationDisplayName::getChildrenOfClass($xml);
        Assert::minCount(
            $displayNames,
            1,
            'Missing at least one OrganizationDisplayName',
            MissingElementException::class,
        );

        $urls = OrganizationURL::getChildrenOfClass($xml);
        Assert::minCount($urls, 1, 'Missing at least one OrganizationURL', MissingElementException::class);

        $extensions = Extensions::getChildrenOfClass($xml);
        Assert::maxCount(
            $extensions,
            1,
            'Cannot process more than one md:Extensions element.',
            TooManyElementsException::class,
        );

        return new static(
            $names,
            $displayNames,
            $urls,
            !empty($extensions) ? $extensions[0] : null,
            self::getAttributesNSFromXML($xml),
        );
    }


    /**
     * Convert this Organization to XML.
     *
     * @param \DOMElement|null $parent The element we should add this organization to.
     * @return \DOMElement This Organization-element.
     */
    public function toXML(DOMElement $parent = null): DOMElement
    {
        $e = $this->instantiateParentElement($parent);

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

        $this->getExtensions()?->toXML($e);

        foreach ($this->getOrganizationName() as $name) {
            $name->toXML($e);
        }

        foreach ($this->getOrganizationDisplayName() as $displayName) {
            $displayName->toXML($e);
        }

        foreach ($this->getOrganizationURL() as $url) {
            $url->toXML($e);
        }

        return $e;
    }


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

        $orgNames = [];
        if (array_key_exists('OrganizationName', $data)) {
            foreach ($data['OrganizationName'] as $lang => $orgName) {
                $orgNames[] = new OrganizationName($lang, $orgName);
            }
        }

        $orgDisplayNames = [];
        if (array_key_exists('OrganizationDisplayName', $data)) {
            foreach ($data['OrganizationDisplayName'] as $lang => $orgDisplayName) {
                $orgDisplayNames[] = new OrganizationDisplayName($lang, $orgDisplayName);
            }
        }

        $orgURLs = [];
        if (array_key_exists('OrganizationURL', $data)) {
            foreach ($data['OrganizationURL'] as $lang => $orgURL) {
                $orgURLs[] = new OrganizationURL($lang, $orgURL);
            }
        }

        $Extensions = array_key_exists('Extensions', $data) ? new Extensions($data['Extensions']) : null;

        $attributes = [];
        if (array_key_exists('attributes', $data)) {
            foreach ($data['attributes'] as $attr) {
                $attributes[] = new XMLAttribute(
                    $attr['namespaceURI'],
                    $attr['namespacePrefix'],
                    $attr['attrName'],
                    $attr['attrValue'],
                );
            }
        }

        return new static(
            $orgNames,
            $orgDisplayNames,
            $orgURLs,
            $Extensions,
            $attributes,
        );
    }


    /**
     * Validate an array
     *
     * @param array $data
     * @return void
     */
    public static function validateArray(array $data): void
    {
        // Make sure the array keys are known for this kind of object
        Assert::allOneOf(
            array_keys($data),
            [
                'OrganizationName',
                'OrganizationDisplayName',
                'OrganizationURL',
                'attributes',
                'Extensions',
            ],
        );

        Assert::keyExists($data, 'OrganizationName');
        Assert::keyExists($data, 'OrganizationDisplayName');
        Assert::keyExists($data, 'OrganizationURL');

        // The minimum count is validated by the constructor
        Assert::isArray($data['OrganizationName']);
        Assert::isArray($data['OrganizationDisplayName']);
        Assert::isArray($data['OrganizationURL']);

        foreach ($data['OrganizationName'] as $lang => $orgName) {
            AbstractLocalizedName::validateArray([$lang => $orgName]);
        }

        foreach ($data['OrganizationDisplayName'] as $lang => $orgDisplayName) {
            AbstractLocalizedName::validateArray([$lang => $orgName]);

        }

        foreach ($data['OrganizationURL'] as $lang => $orgUrl) {
            AbstractLocalizedName::validateArray([$lang => $orgUrl]);
        }

        if (array_key_exists('attributes', $data)) {
            Assert::isArray($data['attributes']);
            Assert::allIsArray($data['attributes']);
            foreach ($data['attributes'] as $attr) {
                XMLAttribute::validateArray($attr);
            }
        }

        if (array_key_exists('Extensions', $data)) {
            Assert::isArray($data['Extensions']);
            Assert::allIsInstanceOf($data['Extensions'], SerializableElementInterface::class);
        }
    }


    /**
     * Create an array from this class
     *
     * @return array
     */
    public function toArray(): array
    {
        $data = [
            'OrganizationName' => [],
            'OrganizationDisplayName' => [],
            'OrganizationURL' => [],
            'Extensions' => $this->getExtensions()?->getList(),
            'Extensions' => $this->getExtensions()?->/** @scrutinizer ignore-call */ getList(),
            'attributes' => [],
        ];

        foreach ($this->getOrganizationName() as $orgName) {
            $data['OrganizationName'] = array_merge($data['OrganizationName'], $orgName->toArray());
        }

        foreach ($this->getOrganizationDisplayName() as $orgDisplayName) {
            $data['OrganizationDisplayName'] = array_merge(
                $data['OrganizationDisplayName'],
                $orgDisplayName->toArray(),
            );
        }

        foreach ($this->getOrganizationURL() as $orgURL) {
            $data['OrganizationURL'] = array_merge($data['OrganizationURL'], $orgURL->toArray());
        }

        foreach ($this->getAttributesNS() as $attr) {
            $data['attributes'][] = $attr->toArray();
        }

        return array_filter($data);
    }
}

simplesamlphp / saml2

Pull Request — master (#337)

Organization::validateArray() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
