Yoanm\JsonRpcParamsSymfonyConstraintDoc\Infra\Transformer\ConstraintToParamsDocTransformer

Complexity

Total Complexity

20

Size/Duplication

Total Lines	127
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	appendAllConstraintToDoc()	0	8	2
A	transform()	0	10	2
A	appendToDoc()	0	22	6
A	__construct()	0	10	1
A	appendCollectionDoc()	0	17	4
A	appendValidItemListDoc()	0	10	5

<?php
namespace Yoanm\JsonRpcParamsSymfonyConstraintDoc\Infra\Transformer;

use Symfony\Component\Validator\Constraint;
use Symfony\Component\Validator\Constraints as Assert;
use Yoanm\JsonRpcParamsSymfonyConstraintDoc\App\Helper\ConstraintPayloadDocHelper;
use Yoanm\JsonRpcParamsSymfonyConstraintDoc\App\Helper\DocTypeHelper;
use Yoanm\JsonRpcParamsSymfonyConstraintDoc\App\Helper\MinMaxHelper;
use Yoanm\JsonRpcParamsSymfonyConstraintDoc\App\Helper\StringDocHelper;
use Yoanm\JsonRpcServerDoc\Domain\Model\Type\ArrayDoc;
use Yoanm\JsonRpcServerDoc\Domain\Model\Type\CollectionDoc;
use Yoanm\JsonRpcServerDoc\Domain\Model\Type\TypeDoc;

/**
 * Class ConstraintToParamsDocTransformer
 */
class ConstraintToParamsDocTransformer
{
    /** @var DocTypeHelper */
    private $docTypeHelper;
    /** @var StringDocHelper */
    private $stringDocHelper;
    /** @var MinMaxHelper */
    private $minMaxHelper;
    /** @var ConstraintPayloadDocHelper */
    private $constraintPayloadDocHelper;

    /**
     * @param DocTypeHelper              $docTypeHelper
     * @param ConstraintPayloadDocHelper $constraintPayloadDocHelper
     */
    public function __construct(
        DocTypeHelper $docTypeHelper,
        StringDocHelper $stringDocHelper,
        MinMaxHelper $minMaxHelper,
        ConstraintPayloadDocHelper $constraintPayloadDocHelper
    ) {
        $this->docTypeHelper = $docTypeHelper;
        $this->minMaxHelper = $minMaxHelper;
        $this->stringDocHelper = $stringDocHelper;
        $this->constraintPayloadDocHelper = $constraintPayloadDocHelper;
    }

    /**
     * @param Constraint $constraint
     *
     * @return TypeDoc
     */
    public function transform(Constraint $constraint) : TypeDoc
    {
        $constraintList = [$constraint];
        $constraintDoc = $this->docTypeHelper->guess($constraintList);

        foreach ($constraintList as $constraint) {
            $this->appendToDoc($constraintDoc, $constraint);
        }

        return $constraintDoc;
    }

    /**
     * @param TypeDoc $doc
     * @param Constraint   $constraint
     */
    private function appendToDoc(TypeDoc $doc, Constraint $constraint) : void
    {
        if ($doc instanceof ArrayDoc && $constraint instanceof Assert\All) {
            $this->appendAllConstraintToDoc($doc, $constraint);
        } else {
            $this->stringDocHelper->append($doc, $constraint);
            $this->appendCollectionDoc($doc, $constraint);

            $this->minMaxHelper->append($doc, $constraint);
            $this->appendValidItemListDoc($doc, $constraint);

            if ($constraint instanceof Assert\Existence) {
                $doc->setRequired($constraint instanceof Assert\Required);
                foreach ($constraint->constraints as $subConstraint) {
                    $this->appendToDoc($doc, $subConstraint);
                }
            } elseif ($constraint instanceof Assert\NotNull) {
                $doc->setNullable(false);
            }

            // /!\ Payload doc will override values even if already defined
            $this->constraintPayloadDocHelper->appendPayloadDoc($doc, $constraint);
        }
    }

    /**
     * @param TypeDoc $doc
     * @param Constraint $constraint
     */
    private function appendCollectionDoc(TypeDoc $doc, Constraint $constraint) : void
    {
        // If not a collection => give up
        if (!$doc instanceof CollectionDoc) {
            return;
        }

        if ($constraint instanceof Assert\Collection) {
            foreach ($constraint->fields as $fieldName => $constraintOrConstrainList) {
                $doc->addSibling(
                    $this->transform($constraintOrConstrainList)
                        ->setName($fieldName)
                );
            }

            $doc->setAllowExtraSibling($constraint->allowExtraFields === true);
            $doc->setAllowMissingSibling($constraint->allowMissingFields === true);
        }
    }

    /**
     * @param TypeDoc $doc
     * @param Constraint $constraint
     */
    private function appendValidItemListDoc(TypeDoc $doc, Constraint $constraint) : void
    {
        if ($constraint instanceof Assert\Choice) {
            if ($constraint->callback && is_callable($constraint->callback)) {
                $choiceList = call_user_func($constraint->callback);
            } else {
                $choiceList = $constraint->choices ?? [];
            }
            foreach ($choiceList as $fieldName => $choice) {
                $doc->addAllowedValue($choice);
            }
        }
    }

    /**
     * @param ArrayDoc   $doc
     * @param Assert\All $constraint
     */
    private function appendAllConstraintToDoc(ArrayDoc $doc, Assert\All $constraint) : void
    {
        $itemDoc = $this->docTypeHelper->guess($constraint->constraints);
        foreach ($constraint->constraints as $subConstraint) {
            $this->appendToDoc($itemDoc, $subConstraint);
        }

        $doc->setItemValidation($itemDoc);
    }
}