WsdlToPhp\WsdlHandler\Wsdl

Complexity

Total Complexity

19

Size/Duplication

Total Lines	100
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	1	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	getElementsByName()	0	5	1
A	addExternalSchema()	0	5	1
A	getElementsByNameAndAttributes()	0	25	4
A	getExternalSchemas()	0	3	1
A	getElementByNameAndAttributes()	0	6	1
A	getElementByName()	0	5	1
A	useParentMethodAndExternals()	0	9	4
A	useExternalSchemas()	0	18	6

<?php

declare(strict_types=1);

namespace WsdlToPhp\WsdlHandler;

use WsdlToPhp\WsdlHandler\Tag\AbstractTag;

class Wsdl extends AbstractDocument
{
    protected array $externalSchemas = [];

    public function addExternalSchema(Schema $schema): Wsdl
    {
        $this->externalSchemas[] = $schema;

        return $this;
    }

    public function getExternalSchemas(): array
    {
        return $this->externalSchemas;
    }

    public function getElementByName(string $name, bool $includeExternals = false): ?AbstractTag
    {
        return $this->useParentMethodAndExternals(__FUNCTION__, [
            $name,
        ], $includeExternals, true);
    }

    public function getElementByNameAndAttributes(string $name, array $attributes, bool $includeExternals = false): ?AbstractTag
    {
        return $this->useParentMethodAndExternals(__FUNCTION__, [
            $name,
            $attributes,
        ], $includeExternals, true);
    }

    public function getElementsByName(string $name, bool $includeExternals = false): array
    {
        return $this->useParentMethodAndExternals(__FUNCTION__, [
            $name,
        ], $includeExternals);
    }

    public function getElementsByNameAndAttributes(string $name, array $attributes, ?\DOMNode $node = null, bool $includeExternals = false): array
    {
        if ($includeExternals) {
            $elements = $this->useParentMethodAndExternals(__FUNCTION__, [
                $name,
                $attributes,
                $node,
            ]);

            /** @var Schema $externalSchema */
            foreach ($this->getExternalSchemas() as $index => $externalSchema) {
                if (0 < ($nodes = $externalSchema->searchTagsByXpath($name, $attributes, $node))->count()) {
                    $elements = array_merge($elements, $this->getElementsHandlers($nodes));
                }
            }
            $elements = array_unique($elements, SORT_REGULAR);
        } else {
            $elements = $this->useParentMethodAndExternals(__FUNCTION__, [
                $name,
                $attributes,
                $node,
            ], $includeExternals);
        }

        return $elements;
    }

    /**
     * Handles any method that exists within the parent class,
     * in addition it handles the case when we want to use the external schemas to search in.
     *
     * @return mixed
     */
    protected function useParentMethodAndExternals(string $method, array $parameters, bool $includeExternals = false, bool $returnOne = false)
    {
        $result = parent::{$method}(...$parameters);

        if ($includeExternals && (!$returnOne || empty($result))) {
            $result = $this->useExternalSchemas($method, $parameters, $result, $returnOne);
        }

        return $result;
    }

    protected function useExternalSchemas(string $method, array $parameters, ?array $parentResult, bool $returnOne = false)
    {
        $result = $parentResult;

        foreach ($this->getExternalSchemas() as $externalSchema) {
            $externalResult = call_user_func_array([$externalSchema, $method], $parameters);

            if ($returnOne && !is_null($externalResult)) {
                $result = $externalResult;

                break;
            }
            if (is_array($externalResult) && !empty($externalResult)) {
                $result = array_merge($result, $externalResult);
            }
        }

        return $result;
    }
}