PhpUnitGen\Model\FunctionModel

Complexity

Total Complexity

15

Size/Duplication

Total Lines	141
Duplicated Lines	0 %

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	4	1
A	getParameters()	0	3	1
A	isGlobal()	0	3	1
A	getMockAnnotations()	0	4	1
A	addParameter()	0	3	1
A	getReturn()	0	3	1
A	getAssertAnnotations()	0	4	1
A	setIsGlobal()	0	3	1
A	setReturn()	0	3	1
A	getParamsAnnotation()	0	9	2
A	getGetAnnotation()	0	9	2
A	getSetAnnotation()	0	9	2

<?php

/**
 * This file is part of PhpUnitGen.
 *
 * (c) 2017-2018 Paul Thébaud <paul.thebaud29@gmail.com>
 *
 * For the full copyright and license information, please view the LICENSE.md
 * file that was distributed with this source code.
 */

namespace PhpUnitGen\Model;

use Doctrine\Common\Collections\ArrayCollection;
use Doctrine\Common\Collections\Collection;
use PhpUnitGen\Annotation\AnnotationInterface\AnnotationInterface;
use PhpUnitGen\Annotation\GetAnnotation;
use PhpUnitGen\Annotation\ParamsAnnotation;
use PhpUnitGen\Annotation\SetAnnotation;
use PhpUnitGen\Model\ModelInterface\FunctionModelInterface;
use PhpUnitGen\Model\ModelInterface\ParameterModelInterface;
use PhpUnitGen\Model\ModelInterface\ReturnModelInterface;
use PhpUnitGen\Model\PropertyTrait\AbstractTrait;
use PhpUnitGen\Model\PropertyTrait\DocumentationTrait;
use PhpUnitGen\Model\PropertyTrait\FinalTrait;
use PhpUnitGen\Model\PropertyTrait\NameTrait;
use PhpUnitGen\Model\PropertyTrait\NodeTrait;
use PhpUnitGen\Model\PropertyTrait\StaticTrait;
use PhpUnitGen\Model\PropertyTrait\VisibilityTrait;

/**
 * Class FunctionModel.
 *
 * @author     Paul Thébaud <paul.thebaud29@gmail.com>.
 * @copyright  2017-2018 Paul Thébaud <paul.thebaud29@gmail.com>.
 * @license    https://opensource.org/licenses/MIT The MIT license.
 * @link       https://github.com/paul-thebaud/phpunit-generator
 * @since      Class available since Release 2.0.0.
 */
class FunctionModel implements FunctionModelInterface
{
    use NameTrait;
    use VisibilityTrait;
    use StaticTrait;
    use FinalTrait;
    use AbstractTrait;
    use NodeTrait;
    use DocumentationTrait;

    /**
     * @var ParameterModelInterface[]|Collection $parameters The function methods.
     */
    private $parameters;

    /**
     * @var ReturnModelInterface $return The function return.
     */
    private $return;

    /**
     * @var bool $isGlobal Tells if the function is global.
     */
    private $isGlobal = false;

    /**
     * FunctionModel constructor.
     */
    public function __construct()
    {
        $this->parameters  = new ArrayCollection();
        $this->annotations = new ArrayCollection();
    }

    /**
     * {@inheritdoc}
     */
    public function addParameter(ParameterModelInterface $parameter): void
    {
        $this->parameters->add($parameter);
    }

    /**
     * {@inheritdoc}
     */
    public function getParameters(): Collection
    {
        return $this->parameters;
    }

    /**
     * {@inheritdoc}
     */
    public function setReturn(ReturnModelInterface $return): void
    {
        $this->return = $return;
    }

    /**
     * {@inheritdoc}
     */
    public function getReturn(): ReturnModelInterface
    {
        return $this->return;
    }

    /**
     * {@inheritdoc}
     */
    public function setIsGlobal(bool $isGlobal): void
    {
        $this->isGlobal = $isGlobal;
    }

    /**
     * {@inheritdoc}
     */
    public function isGlobal(): bool
    {
        return $this->isGlobal;
    }

    /**
     * {@inheritdoc}
     */
    public function getParamsAnnotation(): ?ParamsAnnotation
    {
        $annotations = $this->annotations->filter(function (AnnotationInterface $annotation) {
            return $annotation->getType() === AnnotationInterface::TYPE_PARAMS;
        });
        if ($annotations->isEmpty()) {
            return null;
        }
        return $annotations->first();
    }

    /**
     * {@inheritdoc}
     */
    public function getGetAnnotation(): ?GetAnnotation
    {
        $annotations = $this->annotations->filter(function (AnnotationInterface $annotation) {
            return $annotation->getType() === AnnotationInterface::TYPE_GET;
        });
        if ($annotations->isEmpty()) {
            return null;
        }
        return $annotations->first();
    }

    /**
     * {@inheritdoc}
     */
    public function getSetAnnotation(): ?SetAnnotation
    {
        $annotations = $this->annotations->filter(function (AnnotationInterface $annotation) {
            return $annotation->getType() === AnnotationInterface::TYPE_SET;
        });
        if ($annotations->isEmpty()) {
            return null;
        }
        return $annotations->first();
    }

    /**
     * {@inheritdoc}
     */
    public function getAssertAnnotations(): Collection
    {
        return $this->annotations->filter(function (AnnotationInterface $annotation) {
            return $annotation->getType() === AnnotationInterface::TYPE_ASSERT;
        });
    }

    /**
     * {@inheritdoc}
     */
    public function getMockAnnotations(): Collection
    {
        return $this->annotations->filter(function (AnnotationInterface $annotation) {
            return $annotation->getType() === AnnotationInterface::TYPE_MOCK;
        });
    }
}