WsdlToPhp\DomHandler\AbstractElementHandler

Complexity

Total Complexity

28

Size/Duplication

Total Lines	158
Duplicated Lines	0 %

Test Coverage

Coverage

96.15%

Importance

Changes	1
Bugs	0	Features	0

17 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	3	1
A	getAttribute()	0	3	2
A	getElement()	0	3	1
A	hasAttribute()	0	3	1
A	isOptional()	0	3	1
A	isRemovable()	0	3	2
A	isRequired()	0	3	1
A	getAttributeValue()	0	9	2
A	getChildrenByName()	0	13	3
A	getChildrenByNameAndAttributes()	0	3	1
A	canOccurSeveralTimes()	0	3	3
A	getMaxOccurs()	0	11	3
A	getMinOccurs()	0	8	2
A	getChildByNameAndAttributes()	0	5	1
A	getNillable()	0	3	1
A	canOccurOnlyOnce()	0	3	1
A	getElementChildren()	0	3	2

<?php

declare(strict_types=1);

namespace WsdlToPhp\DomHandler;

use DOMElement;

abstract class AbstractElementHandler extends AbstractNodeHandler
{
    public function __construct(DOMElement $element, AbstractDomDocumentHandler $domDocument, int $index = -1)
    {
        parent::__construct($element, $domDocument, $index);
    }

    public function getElement(): DOMElement
    {
        return $this->getNode();

The expression return $this->getNode() returns the type DOMNode which includes types incompatible with the type-hinted return DOMElement.

    }

    public function hasAttribute(string $name): bool
    {
        return $this->getElement()->hasAttribute($name);
    }

    public function getAttribute(string $name): ?AttributeHandler
    {
        return $this->hasAttribute($name) ? $this->getDomDocumentHandler()->getHandler($this->getElement()->getAttributeNode($name)) : null;
    }

    /**
     * @return null|bool|mixed|string
     */
    public function getAttributeValue(string $name, bool $withNamespace = false, bool $withinItsType = true, ?string $asType = AbstractAttributeHandler::DEFAULT_VALUE_TYPE)
    {
        $value = null;
        $attribute = $this->getAttribute($name);
        if ($attribute instanceof AbstractAttributeHandler) {
            $value = $attribute->getValue($withNamespace, $withinItsType, $asType);
        }

        return $value;
    }

    /**
     * @return array<int, AbstractElementHandler|AbstractNodeHandler>
     */
    public function getChildrenByName(string $name): array
    {
        $children = [];

        if (!$this->hasChildren()) {
            return $children;
        }

        foreach ($this->getElement()->getElementsByTagName($name) as $index => $node) {
            $children[] = $this->getDomDocumentHandler()->getHandler($node, $index);
        }

        return $children;
    }

    /**
     * @return AbstractElementHandler[]
     */
    public function getElementChildren(): array
    {
        return $this->hasChildren() ? $this->getDomDocumentHandler()->getElementsHandlers($this->getChildNodes()) : [];
    }

    /**
     * @param string[] $attributes
     *
     * @return AbstractAttributeHandler[]|AbstractElementHandler[]|AbstractNodeHandler[]
     */
    public function getChildrenByNameAndAttributes(string $name, array $attributes): array
    {
        return $this->getDomDocumentHandler()->getElementsByNameAndAttributes($name, $attributes, $this->getNode());
    }

    /**
     * @param string[] $attributes
     */
    public function getChildByNameAndAttributes(string $name, array $attributes): ?ElementHandler
    {
        $children = $this->getChildrenByNameAndAttributes($name, $attributes);

        return array_shift($children);
    }

    /**
     * Info at {@link https://www.w3.org/TR/xmlschema-0/#OccurrenceConstraints}.
     *
     * @return mixed
     */
    public function getMaxOccurs()
    {
        $maxOccurs = $this->getAttributeValue(AbstractAttributeHandler::ATTRIBUTE_MAX_OCCURS);
        if (AbstractAttributeHandler::VALUE_UNBOUNDED === $maxOccurs) {
            return $maxOccurs;
        }
        if (!is_numeric($maxOccurs)) {
            return AbstractAttributeHandler::DEFAULT_OCCURRENCE_VALUE;
        }

        return (int) $maxOccurs;
    }

    /**
     * Info at {@link https://www.w3.org/TR/xmlschema-0/#OccurrenceConstraints}.
     *
     * @return int
     */
    public function getMinOccurs()
    {
        $minOccurs = $this->getAttributeValue(AbstractAttributeHandler::ATTRIBUTE_MIN_OCCURS);
        if (!is_numeric($minOccurs)) {
            return AbstractAttributeHandler::DEFAULT_OCCURRENCE_VALUE;
        }

        return (int) $minOccurs;
    }

    /**
     * Info at {@link http://www.w3schools.com/xml/el_element.asp}.
     */
    public function getNillable(): bool
    {
        return (bool) $this->getAttributeValue(AbstractAttributeHandler::ATTRIBUTE_NILLABLE, false, true, 'bool');
    }

    /**
     * Info at {@link https://www.w3.org/TR/xmlschema-0/#OccurrenceConstraints}.
     */
    public function canOccurSeveralTimes(): bool
    {
        return (1 < $this->getMinOccurs()) || (1 < $this->getMaxOccurs()) || (AbstractAttributeHandler::VALUE_UNBOUNDED === $this->getMaxOccurs());
    }

    /**
     * Info at {@link https://www.w3.org/TR/xmlschema-0/#OccurrenceConstraints}.
     */
    public function canOccurOnlyOnce(): bool
    {
        return 1 === $this->getMaxOccurs();
    }

    /**
     * Info at {@link https://www.w3.org/TR/xmlschema-0/#OccurrenceConstraints}.
     */
    public function isOptional(): bool
    {
        return 0 === $this->getMinOccurs();
    }

    /**
     * Info at {@link https://www.w3.org/TR/xmlschema-0/#OccurrenceConstraints}.
     */
    public function isRequired(): bool
    {
        return 1 <= $this->getMinOccurs();
    }

    public function isRemovable(): bool
    {
        return $this->isOptional() && $this->getNillable();
    }
}