WsdlToPhp\PackageGenerator\File\StructEnum

Complexity

Total Complexity

18

Size/Duplication

Total Lines	105
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

10 Methods

Rating	Name	Duplication	Size	Complexity
A	setModel()	0	7	3
A	getEnumMethodValues()	0	11	2
A	getEnumGetValidValuesAnnotationBlock()	0	11	2
A	fillClassMethods()	0	3	1
A	getEnumMethodGetValidValues()	0	11	2
A	defineUseStatements()	0	3	1
A	addClassElement()	0	3	1
A	fillClassConstants()	0	6	2
A	getConstantAnnotationBlock()	0	14	2
A	getMethodAnnotationBlock()	0	12	2

<?php

declare(strict_types=1);

namespace WsdlToPhp\PackageGenerator\File;

use WsdlToPhp\PackageGenerator\Container\PhpElement\Constant as ConstantContainer;
use WsdlToPhp\PackageGenerator\Model\AbstractModel;
use WsdlToPhp\PackageGenerator\Model\Struct as StructModel;
use WsdlToPhp\PackageGenerator\Model\StructValue as StructValueModel;
use WsdlToPhp\PhpGenerator\Element\PhpAnnotation;
use WsdlToPhp\PhpGenerator\Element\PhpAnnotationBlock;
use WsdlToPhp\PhpGenerator\Element\PhpConstant;
use WsdlToPhp\PhpGenerator\Element\PhpMethod;

final class StructEnum extends Struct
{
    public const METHOD_VALUE_IS_VALID = 'valueIsValid';
    public const METHOD_GET_VALID_VALUES = 'getValidValues';

    public function setModel(AbstractModel $model): self
    {
        if ($model instanceof StructModel && !$model->isRestriction()) {
            throw new \InvalidArgumentException('Model must be a restriction containing values', __LINE__);
        }

        return parent::setModel($model);

The expression return parent::setModel($model) returns the type WsdlToPhp\PackageGenerator\File\Struct which includes types incompatible with the type-hinted return WsdlToPhp\PackageGenerator\File\StructEnum.

    }

    protected function addClassElement(): AbstractModelFile
    {
        return AbstractModelFile::addClassElement();
    }

    protected function fillClassConstants(ConstantContainer $constants): void
    {
        /** @var StructModel $model */
        $model = $this->getModel();
        foreach ($model->getValues() as $value) {
            $constants->add(new PhpConstant($value->getCleanName(), $value->getValue()));
        }
    }

    protected function defineUseStatements(): self
    {
        return AbstractModelFile::defineUseStatements();

The expression return WsdlToPhp\PackageGenerator\File\AbstractModelFile::defineUseStatements() returns the type WsdlToPhp\PackageGenerator\File\AbstractModelFile which includes types incompatible with the type-hinted return WsdlToPhp\PackageGenerator\File\StructEnum.

    }

    protected function getConstantAnnotationBlock(PhpConstant $constant): ?PhpAnnotationBlock
    {
        $block = new PhpAnnotationBlock([
            sprintf('Constant for value \'%s\'', $constant->getValue()),
        ]);

        /** @var StructModel $model */
        $model = $this->getModel();
        if (($value = $model->getValue($constant->getValue())) instanceof StructValueModel) {
            $this->defineModelAnnotationsFromWsdl($block, $value);
        }
        $block->addChild(new PhpAnnotation(self::ANNOTATION_RETURN, sprintf('string \'%s\'', $constant->getValue())));

        return $block;
    }

    protected function fillClassMethods(): void
    {
        $this->methods->add($this->getEnumMethodGetValidValues());
    }

    protected function getMethodAnnotationBlock(PhpMethod $method): ?PhpAnnotationBlock
    {
        $block = null;

        switch ($method->getName()) {
            case self::METHOD_GET_VALID_VALUES:
                $block = $this->getEnumGetValidValuesAnnotationBlock();

                break;
        }

        return $block;
    }

    protected function getEnumMethodGetValidValues(): PhpMethod
    {
        $method = new PhpMethod(self::METHOD_GET_VALID_VALUES, [], self::TYPE_ARRAY, PhpMethod::ACCESS_PUBLIC, false, true);
        $validValues = $this->getEnumMethodValues();
        $method->addChild('return [');
        foreach ($validValues as $validValue) {
            $method->addChild(sprintf('%s,', $method->getIndentedString($validValue, 1)));
        }
        $method->addChild('];');

        return $method;
    }

    protected function getEnumMethodValues(): array
    {
        $values = [];

        /** @var StructModel $model */
        $model = $this->getModel();
        foreach ($model->getValues() as $value) {
            $values[] = sprintf('self::%s', $value->getCleanName());
        }

        return $values;
    }

    protected function getEnumGetValidValuesAnnotationBlock(): PhpAnnotationBlock
    {
        $annotationBlock = new PhpAnnotationBlock([
            'Return allowed values',
        ]);
        foreach ($this->getEnumMethodValues() as $value) {
            $annotationBlock->addChild(new PhpAnnotation(self::ANNOTATION_USES, $value));
        }
        $annotationBlock->addChild(new PhpAnnotation(self::ANNOTATION_RETURN, 'string[]'));

        return $annotationBlock;
    }
}