WsdlToPhp\WsdlHandler\Tag\AbstractTag

Complexity

Total Complexity

33

Size/Duplication

Total Lines	110
Duplicated Lines	0 %

Test Coverage

Coverage

97.96%

Importance

Changes	1
Bugs	0	Features	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	hasAttributeTargetNamespace()	0	3	1
A	getSuitableParentTags()	0	8	1
A	getDomDocumentHandler()	0	3	1
A	getValueAttributeValue()	0	3	2
A	hasAttributeValue()	0	3	1
C	getSuitableParent()	0	17	12
A	getStrictParent()	0	11	3
A	getAttributeName()	0	3	2
A	getTargetNamespaceAttributeValue()	0	3	2
A	hasAttributeName()	0	3	1
A	getTargetNamespace()	0	10	4
A	getAttributeRef()	0	3	2
A	hasAttributeRef()	0	3	1

<?php

declare(strict_types=1);

namespace WsdlToPhp\WsdlHandler\Tag;

use WsdlToPhp\DomHandler\AbstractAttributeHandler as Attribute;
use WsdlToPhp\DomHandler\AbstractNodeHandler;
use WsdlToPhp\DomHandler\ElementHandler;
use WsdlToPhp\DomHandler\NodeHandler;
use WsdlToPhp\WsdlHandler\AbstractDocument;

abstract class AbstractTag extends ElementHandler
{
    public const MAX_DEEP = 5;

    public function getDomDocumentHandler(): AbstractDocument
    {
        return parent::getDomDocumentHandler();

The expression return parent::getDomDocumentHandler() returns the type WsdlToPhp\DomHandler\AbstractDomDocumentHandler which includes types incompatible with the type-hinted return WsdlToPhp\WsdlHandler\AbstractDocument.

    }

    /**
     * This method aims to get the parent element that matches a valid Wsdl element (aka struct).
     *
     * @return null|NodeHandler
     */
    public function getSuitableParent(bool $checkName = true, array $additionalTags = [], int $maxDeep = self::MAX_DEEP, bool $strict = false): ?AbstractNodeHandler
    {
        $parentNode = null;
        if ($this->getParent() instanceof AbstractNodeHandler) {

$this->getParent() is always a sub-type of WsdlToPhp\DomHandler\AbstractNodeHandler.

            $parentTags = $strict ? $additionalTags : $this->getSuitableParentTags($additionalTags);
            $parentNode = $this->getParent()->getNode();
            while ($maxDeep-- > 0 && ($parentNode instanceof \DOMElement) && !empty($parentNode->nodeName) && (!preg_match('/'.implode('|', $parentTags).'/i', $parentNode->nodeName) || ($checkName && preg_match('/'.implode('|', $parentTags).'/i', $parentNode->nodeName) && (!$parentNode->hasAttribute('name') || '' === $parentNode->getAttribute('name'))))) {
                $parentNode = $parentNode->parentNode;
            }
            if ($parentNode instanceof \DOMElement) {
                $parentNode = $this->getDomDocumentHandler()->getHandler($parentNode);
            } else {
                $parentNode = null;
            }
        }

        return $parentNode;

The expression return $parentNode also could return the type WsdlToPhp\DomHandler\ElementHandler which is incompatible with the documented return type WsdlToPhp\DomHandler\NodeHandler|null.

    }

    public function hasAttributeName(): bool
    {
        return $this->hasAttribute(Attribute::ATTRIBUTE_NAME);
    }

    public function hasAttributeRef(): bool
    {
        return $this->hasAttribute(Attribute::ATTRIBUTE_REF);
    }

    public function getAttributeName(): string
    {
        return $this->getAttribute(Attribute::ATTRIBUTE_NAME) instanceof Attribute ? $this->getAttribute(Attribute::ATTRIBUTE_NAME)->getValue() : '';
    }

    public function getAttributeRef(): string
    {
        return $this->getAttribute(Attribute::ATTRIBUTE_REF) instanceof Attribute ? $this->getAttribute(Attribute::ATTRIBUTE_REF)->getValue() : '';
    }

    public function hasAttributeValue(): bool
    {
        return $this->hasAttribute(Attribute::ATTRIBUTE_VALUE);
    }

    public function getValueAttributeValue(bool $withNamespace = false, bool $withinItsType = true, ?string $asType = null)
    {
        return $this->getAttribute(Attribute::ATTRIBUTE_VALUE) instanceof Attribute ? $this->getAttribute(Attribute::ATTRIBUTE_VALUE)->getValue($withNamespace, $withinItsType, $asType) : '';
    }

    public function hasAttributeTargetNamespace(): bool
    {
        return $this->hasAttribute(AbstractDocument::ATTRIBUTE_TARGET_NAMESPACE);
    }

    public function getTargetNamespaceAttributeValue()
    {
        return $this->getAttribute(AbstractDocument::ATTRIBUTE_TARGET_NAMESPACE) instanceof Attribute ? $this->getAttribute(AbstractDocument::ATTRIBUTE_TARGET_NAMESPACE)->getValue(true) : '';
    }

    /**
     * Retrieve element targetNamespace applicable value,
     * from targetNamespace attribute depending on the current Tag.
     */
    public function getTargetNamespace(): string
    {
        $schema = $this instanceof TagSchema ? $this : $this->getStrictParent(AbstractDocument::TAG_SCHEMA);
        if ($schema instanceof TagSchema && $schema->hasAttributeTargetNamespace()) {
            $namespace = $schema->getTargetNamespaceAttributeValue();
        } else {
            $namespace = $this->getDomDocumentHandler()->getAttributeTargetNamespaceValue();
        }

        return $namespace;
    }

    protected function getSuitableParentTags(array $additionalTags = []): array
    {
        return array_merge([
            AbstractDocument::TAG_ELEMENT,
            AbstractDocument::TAG_ATTRIBUTE,
            AbstractDocument::TAG_SIMPLE_TYPE,
            AbstractDocument::TAG_COMPLEX_TYPE,
        ], $additionalTags);
    }

    protected function getStrictParent(string $name, bool $checkName = false): ?AbstractNodeHandler
    {
        $parent = $this->getSuitableParent($checkName, [
            $name,
        ], self::MAX_DEEP, true);

        if ($parent instanceof AbstractNodeHandler && $parent->getName() === $name) {
            return $parent;
        }

        return null;
    }
}