WsdlToPhp\PhpGenerator\Component\AbstractComponent

Complexity

Total Complexity

17

Size/Duplication

Total Lines	99
Duplicated Lines	0 %

Test Coverage

Coverage

97.06%

Importance

Changes

0

9 Methods

Rating	Name	Duplication	Size	Complexity
A	toString()	0	8	2
A	addConstant()	0	3	1
A	setMainElement()	0	9	3
A	addConstantElement()	0	8	3
A	addAnnotationBlockElement()	0	5	1
A	getMainElement()	0	3	1
A	addAnnotationBlock()	0	4	2
A	getElementString()	0	10	3
A	__toString()	0	3	1

<?php

declare(strict_types=1);

namespace WsdlToPhp\PhpGenerator\Component;

use InvalidArgumentException;
use WsdlToPhp\PhpGenerator\Element\AbstractElement;
use WsdlToPhp\PhpGenerator\Element\PhpFile as PhpFileElement;
use WsdlToPhp\PhpGenerator\Element\PhpClass as PhpClassElement;
use WsdlToPhp\PhpGenerator\Element\PhpConstant as PhpConstantElement;
use WsdlToPhp\PhpGenerator\Element\PhpAnnotationBlock as PhpAnnotationBlockElement;

abstract class AbstractComponent implements GenerateableInterface
{
    /**
     * @var PhpFileElement|PhpClassElement
     */
    protected $mainElement;

    public function __toString(): string
    {
        return $this->toString();
    }

    public function toString(): string
    {
        $content = [];
        foreach ($this->getElements() as $element) {
            $content[] = $this->getElementString($element);
        }

        return implode('', $content);
    }

    /**
     * @return AbstractElement[]|string[]
     */
    abstract public function getElements(): array;

    public function setMainElement(AbstractElement $element): self
    {
        if ($element instanceof PhpFileElement || $element instanceof PhpClassElement) {
            $this->mainElement = $element;
        } else {
            throw new InvalidArgumentException(sprintf('Element of type "%s" must be of type Element\PhpClass or Element\PhpFile', get_class($element)));
        }

        return $this;
    }

    /**
     * @return PhpFileElement|PhpClassElement
     */
    public function getMainElement(): AbstractElement
    {
        return $this->mainElement;
    }

    /**
     * @throws InvalidArgumentException
     * @param string|AbstractElement $element
     * @return string
     */
    protected function getElementString($element): string
    {
        $string = '';
        if (is_scalar($element)) {
            $string = $element;
        } elseif ($element instanceof AbstractElement) {

$element is always a sub-type of WsdlToPhp\PhpGenerator\Element\AbstractElement.

            $string = $element->toString();
        }

        return $string;
    }

    public function addConstantElement(PhpConstantElement $constant): self
    {
        if (!$constant->getClass() instanceof PhpClassElement && $this->mainElement instanceof PhpClassElement) {
            $constant->setClass($this->mainElement);
        }
        $this->mainElement->addChild($constant);

        return $this;
    }

    /**
     * @param string $name
     * @param mixed $value
     * @param PhpClassElement|null $class
     * @return AbstractComponent
     */
    public function addConstant(string $name, $value = null, ?PhpClassElement $class = null): self
    {
        return $this->addConstantElement(new PhpConstantElement($name, $value, $class));
    }

    public function addAnnotationBlockElement(PhpAnnotationBlockElement $annotationBlock): self
    {
        $this->mainElement->addChild($annotationBlock);

        return $this;
    }

    /**
     * @param array|string|PhpAnnotationBlockElement $annotations
     * @return AbstractComponent
     */
    public function addAnnotationBlock($annotations): self
    {
        return $this->addAnnotationBlockElement(new PhpAnnotationBlockElement(is_array($annotations) ? $annotations : [
            $annotations,
        ]));
    }
}