UIInfo::toArray() - Code Metrics - Inspection of "Fix mdui:UIInfo toArray-method to not return empty..." - simplesamlphp/saml2 - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( e1b24a...13407a )

by Tim

created 2023-05-15 20:06 UTC

UIInfo::toArray() F

↳ Parent: UIInfo

Complexity

Conditions	13
Paths	4096

Size

Total Lines	39
Code Lines	25

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	13
eloc	25
nc	4096
nop	0
dl	0
loc	39
rs	2.45
c	1
b	0
f	0

How to fix Complexity

<?php

declare(strict_types=1);

namespace SimpleSAML\SAML2\XML\mdui;

use DOMElement;
use SimpleSAML\Assert\Assert;
use SimpleSAML\SAML2\Exception\ProtocolViolationException;
use SimpleSAML\SAML2\Utils\XPath;
use SimpleSAML\XML\Chunk;
use SimpleSAML\XML\Constants as C;
use SimpleSAML\XML\Exception\InvalidDOMElementException;
use SimpleSAML\XML\ExtendableElementTrait;

use function array_map;
use function array_merge;
use function array_unique;

/**
 * Class for handling the metadata extensions for login and discovery user interface
 *
 * @link: http://docs.oasis-open.org/security/saml/Post2.0/sstc-saml-metadata-ui/v1.0/sstc-saml-metadata-ui-v1.0.pdf
 * @package simplesamlphp/saml2
 */
final class UIInfo extends AbstractMduiElement
{
    use ExtendableElementTrait;

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

    /**
     * Create a UIInfo element.
     *
     * @param \SimpleSAML\SAML2\XML\mdui\DisplayName[] $displayName
     * @param \SimpleSAML\SAML2\XML\mdui\Description[] $description
     * @param \SimpleSAML\SAML2\XML\mdui\InformationURL[] $informationURL
     * @param \SimpleSAML\SAML2\XML\mdui\PrivacyStatementURL[] $privacyStatementURL
     * @param \SimpleSAML\SAML2\XML\mdui\Keywords[] $keywords
     * @param \SimpleSAML\SAML2\XML\mdui\Logo[] $logo
     * @param \SimpleSAML\XML\Chunk[] $children
     */
    public function __construct(
        protected array $displayName = [],
        protected array $description = [],
        protected array $informationURL = [],
        protected array $privacyStatementURL = [],
        protected array $keywords = [],
        protected array $logo = [],
        array $children = [],
    ) {
        Assert::allIsInstanceOf($displayName, DisplayName::class);
        /**
         * 2.1.2:  There MUST NOT be more than one <mdui:DisplayName>,
         *         within a given <mdui:UIInfo>, for a given language
         */
        $this->testLocalizedElements($displayName);

        Assert::allIsInstanceOf($description, Description::class);
        /**
         * 2.1.3:  There MUST NOT be more than one <mdui:Description>,
         *         within a given <mdui:UIInfo>, for a given language
         */
        $this->testLocalizedElements($description);

        Assert::allIsInstanceOf($keywords, Keywords::class);
        /**
         * 2.1.4:  There MUST NOT be more than one <mdui:Keywords>,
         *         within a given <mdui:UIInfo>, for a given language
         */
        $this->testLocalizedElements($keywords);

        Assert::allIsInstanceOf($informationURL, InformationURL::class);
        /**
         * 2.1.6:  There MUST NOT be more than one <mdui:InformationURL>,
         *         within a given <mdui:UIInfo>, for a given language
         */
        $this->testLocalizedElements($informationURL);

        Assert::allIsInstanceOf($privacyStatementURL, PrivacyStatementURL::class);
        /**
         * 2.1.7:  There MUST NOT be more than one <mdui:PrivacyStatementURL>,
         *         within a given <mdui:UIInfo>, for a given language
         */
        $this->testLocalizedElements($privacyStatementURL);

        Assert::allIsInstanceOf($logo, Logo::class);

        $this->setElements($children);
    }


    /**
     * Collect the value of the Keywords-property
     *
     * @return \SimpleSAML\SAML2\XML\mdui\Keywords[]
     */
    public function getKeywords(): array
    {
        return $this->keywords;
    }


    /**
     * Add the value to the Keywords-property
     *
     * @param \SimpleSAML\SAML2\XML\mdui\Keywords $keyword
     */
    public function addKeyword(Keywords $keyword): void
    {
        /**
         * 2.1.4:  There MUST NOT be more than one <mdui:Keywords>,
         *         within a given <mdui:UIInfo>, for a given language
         */
        $keywords = array_merge($this->keywords, [$keyword]);
        $this->testLocalizedElements($keywords);
        $this->keywords = $keywords;
    }


    /**
     * Collect the value of the DisplayName-property
     *
     * @return \SimpleSAML\SAML2\XML\mdui\DisplayName[]
     */
    public function getDisplayName(): array
    {
        return $this->displayName;
    }


    /**
     * Collect the value of the Description-property
     *
     * @return \SimpleSAML\SAML2\XML\mdui\Description[]
     */
    public function getDescription(): array
    {
        return $this->description;
    }


    /**
     * Collect the value of the InformationURL-property
     * @return \SimpleSAML\SAML2\XML\mdui\InformationURL[]
     */
    public function getInformationURL(): array
    {
        return $this->informationURL;
    }


    /**
     * Collect the value of the PrivacyStatementURL-property
     *
     * @return \SimpleSAML\SAML2\XML\mdui\PrivacyStatementURL[]
     */
    public function getPrivacyStatementURL(): array
    {
        return $this->privacyStatementURL;
    }


    /**
     * Collect the value of the Logo-property
     *
     * @return \SimpleSAML\SAML2\XML\mdui\Logo[]
     */
    public function getLogo(): array
    {
        return $this->logo;
    }


    /**
     * Add the value to the Logo-property
     *
     * @param \SimpleSAML\SAML2\XML\mdui\Logo $logo
     */
    public function addLogo(Logo $logo): void
    {
        $this->logo[] = $logo;
    }


    /**
     * Add the value to the elements-property
     *
     * @param \SimpleSAML\XML\Chunk $child
     */
    public function addChild(Chunk $child): void
    {
        $this->elements[] = $child;
    }


    /**
     * Test if an object, at the state it's in, would produce an empty XML-element
     *
     * @return bool
     */
    public function isEmptyElement(): bool
    {
        return empty($this->displayName)
            && empty($this->description)
            && empty($this->informationURL)
            && empty($this->privacyStatementURL)
            && empty($this->keywords)
            && empty($this->logo)
            && empty($this->elements);
    }


    /**
     * Test localized elements for multiple items with the same language
     *
     * @param (\SimpleSAML\SAML2\XML\md\AbstractLocalizedURL|
     *         \SimpleSAML\SAML2\XML\md\AbstractLocalizedName|
     *         \SimpleSAML\XML\SAML2\mdui\Keywords)[] $items
     * @return void
     */
    private function testLocalizedElements(array $elements)
    {
        if (!empty($elements)) {
            $types = array_map('get_class', $elements);
            Assert::maxCount(array_unique($types), 1, 'Multiple class types cannot be used.');

            $languages = array_map(
                function ($elt) {
                    return $elt->getLanguage();
                },
                $elements,
            );
            Assert::uniqueValues(
                $languages,
                'There MUST NOT be more than one <' . $elements[0]->getQualifiedName() . '>,'
                . ' within a given <mdui:UIInfo>, for a given language',
                ProtocolViolationException::class,
            );
        }
    }


    /**
     * Convert XML into a UIInfo
     *
     * @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
     */
    public static function fromXML(DOMElement $xml): static
    {
        Assert::same($xml->localName, 'UIInfo', InvalidDOMElementException::class);
        Assert::same($xml->namespaceURI, UIInfo::NS, InvalidDOMElementException::class);

        $DisplayName = DisplayName::getChildrenOfClass($xml);
        $Description = Description::getChildrenOfClass($xml);
        $InformationURL = InformationURL::getChildrenOfClass($xml);
        $PrivacyStatementURL = PrivacyStatementURL::getChildrenOfClass($xml);
        $Keywords = Keywords::getChildrenOfClass($xml);
        $Logo = Logo::getChildrenOfClass($xml);
        $children = [];

        /** @var \DOMElement $node */
        foreach (XPath::xpQuery($xml, './*', XPath::getXPath($xml)) as $node) {
            if ($node->namespaceURI !== UIInfo::NS) {
                $children[] = new Chunk($node);
            }
        }

        return new static(
            $DisplayName,
            $Description,
            $InformationURL,
            $PrivacyStatementURL,
            $Keywords,
            $Logo,
            $children,
        );
    }


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

        foreach ($this->getDisplayName() as $child) {
            $child->toXML($e);
        }

        foreach ($this->getDescription() as $child) {
            $child->toXML($e);
        }

        foreach ($this->getInformationURL() as $child) {
            $child->toXML($e);
        }

        foreach ($this->getPrivacyStatementURL() as $child) {
            $child->toXML($e);
        }

        foreach ($this->getKeywords() as $child) {
            $child->toXML($e);
        }

        foreach ($this->getLogo() as $child) {
            $child->toXML($e);
        }

        foreach ($this->getElements() as $child) {
            $child->toXML($e);
        }

        return $e;
    }


    /**
     * Create a class from an array
     *
     * NOTE: this method does not support passing additional child-objects
     *
     * @param array $data
     * @return static
     */
    public static function fromArray(array $data): static
    {
        $DisplayName = [];
        if (!empty($data['DisplayName'])) {
            foreach ($data['DisplayName'] as $l => $k) {
                $DisplayName[] = DisplayName::fromArray([$l => $k]);
            }
        }

        $Description = [];
        if (!empty($data['Description'])) {
            foreach ($data['Description'] as $l => $k) {
                $Description[] = Description::fromArray([$l => $k]);
            }
        }

        $InformationURL = [];
        if (!empty($data['InformationURL'])) {
            foreach ($data['InformationURL'] as $l => $k) {
                $InformationURL[] = InformationURL::fromArray([$l => $k]);
            }
        }

        $PrivacyStatementURL = [];
        if (!empty($data['PrivacyStatementURL'])) {
            foreach ($data['PrivacyStatementURL'] as $l => $k) {
                $PrivacyStatementURL[] = PrivacyStatementURL::fromArray([$l => $k]);
            }
        }

        $Keywords = [];
        if (!empty($data['Keywords'])) {
            foreach ($data['Keywords'] as $l => $k) {
                $Keywords[] = Keywords::fromArray([$l => $k]);
            }
        }

        $Logo = [];
        if (!empty($data['Logo'])) {
            foreach ($data['Logo'] as $l) {
                $Logo[] = Logo::fromArray($l);
            }
        }

        return new static(
            $DisplayName,
            $Description,
            $InformationURL,
            $PrivacyStatementURL,
            $Keywords,
            $Logo,
        );
    }


    /**
     * Create an array from this class
     *
     * NOTE: this method does not support passing additional child-objects
     *
     * @return array
     */
    public function toArray(): array
    {
        $displayName = [];
        foreach ($this->getDisplayName() as $child) {
            $displayName = array_merge($displayName, $child->toArray());
        }

        $description = [];
        foreach ($this->getDescription() as $child) {
            $description = array_merge($description, $child->toArray());
        }

        $infoUrl = [];
        foreach ($this->getInformationURL() as $child) {
            $infoUrl = array_merge($infoUrl, $child->toArray());
        }

        $privacyUrl = [];
        foreach ($this->getPrivacyStatementURL() as $child) {
            $privacyUrl = array_merge($privacyUrl, $child->toArray());
        }

        $keywords = [];
        foreach ($this->getKeywords() as $child) {
            $keywords = array_merge($keywords, $child->toArray());
        }

        $logo = [];
        foreach ($this->getLogo() as $child) {
            $logo[] = $child->toArray();
        }

        return [] +
            (empty($displayName) ? [] : ['DisplayName' => $displayName]) +
            (empty($description) ? [] : ['Description' => $description]) +
            (empty($infoUrl) ? [] : ['InformationURL' => $infoUrl]) +
            (empty($privacyUrl) ? [] : ['PrivacyStatementURL' => $privacyUrl]) +
            (empty($keywords) ? [] : ['Keywords' => $keywords]) +
            (empty($logo) ? [] : ['Logo' => $logo]);
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace SimpleSAML\SAML2\XML\mdui;
6
7			use DOMElement;
8			use SimpleSAML\Assert\Assert;
9			use SimpleSAML\SAML2\Exception\ProtocolViolationException;
10			use SimpleSAML\SAML2\Utils\XPath;
11			use SimpleSAML\XML\Chunk;
12			use SimpleSAML\XML\Constants as C;
13			use SimpleSAML\XML\Exception\InvalidDOMElementException;
14			use SimpleSAML\XML\ExtendableElementTrait;
15
16			use function array_map;
17			use function array_merge;
18			use function array_unique;
19
20			/**
21			* Class for handling the metadata extensions for login and discovery user interface
22			*
23			* @link: http://docs.oasis-open.org/security/saml/Post2.0/sstc-saml-metadata-ui/v1.0/sstc-saml-metadata-ui-v1.0.pdf
24			* @package simplesamlphp/saml2
25			*/
26			final class UIInfo extends AbstractMduiElement
27			{
28			use ExtendableElementTrait;
29
30			/** The namespace-attribute for the xs:any element */
31			public const NAMESPACE = C::XS_ANY_NS_OTHER;
32
33			/**
34			* Create a UIInfo element.
35			*
36			* @param \SimpleSAML\SAML2\XML\mdui\DisplayName[] $displayName
37			* @param \SimpleSAML\SAML2\XML\mdui\Description[] $description
38			* @param \SimpleSAML\SAML2\XML\mdui\InformationURL[] $informationURL
39			* @param \SimpleSAML\SAML2\XML\mdui\PrivacyStatementURL[] $privacyStatementURL
40			* @param \SimpleSAML\SAML2\XML\mdui\Keywords[] $keywords
41			* @param \SimpleSAML\SAML2\XML\mdui\Logo[] $logo
42			* @param \SimpleSAML\XML\Chunk[] $children
43			*/
44			public function __construct(
45			protected array $displayName = [],
46			protected array $description = [],
47			protected array $informationURL = [],
48			protected array $privacyStatementURL = [],
49			protected array $keywords = [],
50			protected array $logo = [],
51			array $children = [],
52			) {
53			Assert::allIsInstanceOf($displayName, DisplayName::class);
54			/**
55			* 2.1.2: There MUST NOT be more than one <mdui:DisplayName>,
56			* within a given <mdui:UIInfo>, for a given language
57			*/
58			$this->testLocalizedElements($displayName);
59
60			Assert::allIsInstanceOf($description, Description::class);
61			/**
62			* 2.1.3: There MUST NOT be more than one <mdui:Description>,
63			* within a given <mdui:UIInfo>, for a given language
64			*/
65			$this->testLocalizedElements($description);
66
67			Assert::allIsInstanceOf($keywords, Keywords::class);
68			/**
69			* 2.1.4: There MUST NOT be more than one <mdui:Keywords>,
70			* within a given <mdui:UIInfo>, for a given language
71			*/
72			$this->testLocalizedElements($keywords);
73
74			Assert::allIsInstanceOf($informationURL, InformationURL::class);
75			/**
76			* 2.1.6: There MUST NOT be more than one <mdui:InformationURL>,
77			* within a given <mdui:UIInfo>, for a given language
78			*/
79			$this->testLocalizedElements($informationURL);
80
81			Assert::allIsInstanceOf($privacyStatementURL, PrivacyStatementURL::class);
82			/**
83			* 2.1.7: There MUST NOT be more than one <mdui:PrivacyStatementURL>,
84			* within a given <mdui:UIInfo>, for a given language
85			*/
86			$this->testLocalizedElements($privacyStatementURL);
87
88			Assert::allIsInstanceOf($logo, Logo::class);
89
90			$this->setElements($children);
91			}
92
93
94			/**
95			* Collect the value of the Keywords-property
96			*
97			* @return \SimpleSAML\SAML2\XML\mdui\Keywords[]
98			*/
99			public function getKeywords(): array
100			{
101			return $this->keywords;
102			}
103
104
105			/**
106			* Add the value to the Keywords-property
107			*
108			* @param \SimpleSAML\SAML2\XML\mdui\Keywords $keyword
109			*/
110			public function addKeyword(Keywords $keyword): void
111			{
112			/**
113			* 2.1.4: There MUST NOT be more than one <mdui:Keywords>,
114			* within a given <mdui:UIInfo>, for a given language
115			*/
116			$keywords = array_merge($this->keywords, [$keyword]);
117			$this->testLocalizedElements($keywords);
118			$this->keywords = $keywords;
119			}
120
121
122			/**
123			* Collect the value of the DisplayName-property
124			*
125			* @return \SimpleSAML\SAML2\XML\mdui\DisplayName[]
126			*/
127			public function getDisplayName(): array
128			{
129			return $this->displayName;
130			}
131
132
133			/**
134			* Collect the value of the Description-property
135			*
136			* @return \SimpleSAML\SAML2\XML\mdui\Description[]
137			*/
138			public function getDescription(): array
139			{
140			return $this->description;
141			}
142
143
144			/**
145			* Collect the value of the InformationURL-property
146			* @return \SimpleSAML\SAML2\XML\mdui\InformationURL[]
147			*/
148			public function getInformationURL(): array
149			{
150			return $this->informationURL;
151			}
152
153
154			/**
155			* Collect the value of the PrivacyStatementURL-property
156			*
157			* @return \SimpleSAML\SAML2\XML\mdui\PrivacyStatementURL[]
158			*/
159			public function getPrivacyStatementURL(): array
160			{
161			return $this->privacyStatementURL;
162			}
163
164
165			/**
166			* Collect the value of the Logo-property
167			*
168			* @return \SimpleSAML\SAML2\XML\mdui\Logo[]
169			*/
170			public function getLogo(): array
171			{
172			return $this->logo;
173			}
174
175
176			/**
177			* Add the value to the Logo-property
178			*
179			* @param \SimpleSAML\SAML2\XML\mdui\Logo $logo
180			*/
181			public function addLogo(Logo $logo): void
182			{
183			$this->logo[] = $logo;
184			}
185
186
187			/**
188			* Add the value to the elements-property
189			*
190			* @param \SimpleSAML\XML\Chunk $child
191			*/
192			public function addChild(Chunk $child): void
193			{
194			$this->elements[] = $child;
195			}
196
197
198			/**
199			* Test if an object, at the state it's in, would produce an empty XML-element
200			*
201			* @return bool
202			*/
203			public function isEmptyElement(): bool
204			{
205			return empty($this->displayName)
206			&& empty($this->description)
207			&& empty($this->informationURL)
208			&& empty($this->privacyStatementURL)
209			&& empty($this->keywords)
210			&& empty($this->logo)
211			&& empty($this->elements);
212			}
213
214
215			/**
216			* Test localized elements for multiple items with the same language
217			*
218			* @param (\SimpleSAML\SAML2\XML\md\AbstractLocalizedURL\|
219			* \SimpleSAML\SAML2\XML\md\AbstractLocalizedName\|
220			* \SimpleSAML\XML\SAML2\mdui\Keywords)[] $items
221			* @return void
222			*/
223			private function testLocalizedElements(array $elements)
224			{
225			if (!empty($elements)) {
226			$types = array_map('get_class', $elements);
227			Assert::maxCount(array_unique($types), 1, 'Multiple class types cannot be used.');
228
229			$languages = array_map(
230			function ($elt) {
231			return $elt->getLanguage();
232			},
233			$elements,
234			);
235			Assert::uniqueValues(
236			$languages,
237			'There MUST NOT be more than one <' . $elements[0]->getQualifiedName() . '>,'
238			. ' within a given <mdui:UIInfo>, for a given language',
239			ProtocolViolationException::class,
240			);
241			}
242			}
243
244
245			/**
246			* Convert XML into a UIInfo
247			*
248			* @param \DOMElement $xml The XML element we should load
249			* @return static
250			*
251			* @throws \SimpleSAML\XML\Exception\InvalidDOMElementException
252			* if the qualified name of the supplied element is wrong
253			*/
254			public static function fromXML(DOMElement $xml): static
255			{
256			Assert::same($xml->localName, 'UIInfo', InvalidDOMElementException::class);
257			Assert::same($xml->namespaceURI, UIInfo::NS, InvalidDOMElementException::class);
258
259			$DisplayName = DisplayName::getChildrenOfClass($xml);
260			$Description = Description::getChildrenOfClass($xml);
261			$InformationURL = InformationURL::getChildrenOfClass($xml);
262			$PrivacyStatementURL = PrivacyStatementURL::getChildrenOfClass($xml);
263			$Keywords = Keywords::getChildrenOfClass($xml);
264			$Logo = Logo::getChildrenOfClass($xml);
265			$children = [];
266
267			/** @var \DOMElement $node */
268			foreach (XPath::xpQuery($xml, './*', XPath::getXPath($xml)) as $node) {
269			if ($node->namespaceURI !== UIInfo::NS) {
270			$children[] = new Chunk($node);
271			}
272			}
273
274			return new static(
275			$DisplayName,
276			$Description,
277			$InformationURL,
278			$PrivacyStatementURL,
279			$Keywords,
280			$Logo,
281			$children,
282			);
283			}
284
285
286			/**
287			* Convert this UIInfo to XML.
288			*
289			* @param \DOMElement\|null $parent The element we should append to.
290			* @return \DOMElement
291			*/
292			public function toXML(DOMElement $parent = null): DOMElement
293			{
294			$e = $this->instantiateParentElement($parent);
295
296			foreach ($this->getDisplayName() as $child) {
297			$child->toXML($e);
298			}
299
300			foreach ($this->getDescription() as $child) {
301			$child->toXML($e);
302			}
303
304			foreach ($this->getInformationURL() as $child) {
305			$child->toXML($e);
306			}
307
308			foreach ($this->getPrivacyStatementURL() as $child) {
309			$child->toXML($e);
310			}
311
312			foreach ($this->getKeywords() as $child) {
313			$child->toXML($e);
314			}
315
316			foreach ($this->getLogo() as $child) {
317			$child->toXML($e);
318			}
319
320			foreach ($this->getElements() as $child) {
321			$child->toXML($e);
322			}
323
324			return $e;
325			}
326
327
328			/**
329			* Create a class from an array
330			*
331			* NOTE: this method does not support passing additional child-objects
332			*
333			* @param array $data
334			* @return static
335			*/
336			public static function fromArray(array $data): static
337			{
338			$DisplayName = [];
339			if (!empty($data['DisplayName'])) {
340			foreach ($data['DisplayName'] as $l => $k) {
341			$DisplayName[] = DisplayName::fromArray([$l => $k]);
342			}
343			}
344
345			$Description = [];
346			if (!empty($data['Description'])) {
347			foreach ($data['Description'] as $l => $k) {
348			$Description[] = Description::fromArray([$l => $k]);
349			}
350			}
351
352			$InformationURL = [];
353			if (!empty($data['InformationURL'])) {
354			foreach ($data['InformationURL'] as $l => $k) {
355			$InformationURL[] = InformationURL::fromArray([$l => $k]);
356			}
357			}
358
359			$PrivacyStatementURL = [];
360			if (!empty($data['PrivacyStatementURL'])) {
361			foreach ($data['PrivacyStatementURL'] as $l => $k) {
362			$PrivacyStatementURL[] = PrivacyStatementURL::fromArray([$l => $k]);
363			}
364			}
365
366			$Keywords = [];
367			if (!empty($data['Keywords'])) {
368			foreach ($data['Keywords'] as $l => $k) {
369			$Keywords[] = Keywords::fromArray([$l => $k]);
370			}
371			}
372
373			$Logo = [];
374			if (!empty($data['Logo'])) {
375			foreach ($data['Logo'] as $l) {
376			$Logo[] = Logo::fromArray($l);
377			}
378			}
379
380			return new static(
381			$DisplayName,
382			$Description,
383			$InformationURL,
384			$PrivacyStatementURL,
385			$Keywords,
386			$Logo,
387			);
388			}
389
390
391			/**
392			* Create an array from this class
393			*
394			* NOTE: this method does not support passing additional child-objects
395			*
396			* @return array
397			*/
398			public function toArray(): array
399			{
400			$displayName = [];
401			foreach ($this->getDisplayName() as $child) {
402			$displayName = array_merge($displayName, $child->toArray());
403			}
404
405			$description = [];
406			foreach ($this->getDescription() as $child) {
407			$description = array_merge($description, $child->toArray());
408			}
409
410			$infoUrl = [];
411			foreach ($this->getInformationURL() as $child) {
412			$infoUrl = array_merge($infoUrl, $child->toArray());
413			}
414
415			$privacyUrl = [];
416			foreach ($this->getPrivacyStatementURL() as $child) {
417			$privacyUrl = array_merge($privacyUrl, $child->toArray());
418			}
419
420			$keywords = [];
421			foreach ($this->getKeywords() as $child) {
422			$keywords = array_merge($keywords, $child->toArray());
423			}
424
425			$logo = [];
426			foreach ($this->getLogo() as $child) {
427			$logo[] = $child->toArray();
428			}
429
430			return [] +
431			(empty($displayName) ? [] : ['DisplayName' => $displayName]) +
432			(empty($description) ? [] : ['Description' => $description]) +
433			(empty($infoUrl) ? [] : ['InformationURL' => $infoUrl]) +
434			(empty($privacyUrl) ? [] : ['PrivacyStatementURL' => $privacyUrl]) +
435			(empty($keywords) ? [] : ['Keywords' => $keywords]) +
436			(empty($logo) ? [] : ['Logo' => $logo]);
437			}
438			}
439

simplesamlphp / saml2

Push — master ( e1b24a...13407a )

UIInfo::toArray() F

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like