Yoanm\JsonRpcParamsSymfonyConstraintDoc\App\Helper\MinMaxHelper

Complexity

Total Complexity

37

Size/Duplication

Total Lines	119
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	append()	0	8	4
B	appendStringDoc()	0	15	8
A	appendNumberDoc()	0	8	3
B	appendCollectionDoc()	0	18	7
B	appendLessGreaterThanMinMaxItem()	0	13	7
B	appendNumberMinMax()	0	17	8

<?php
namespace Yoanm\JsonRpcParamsSymfonyConstraintDoc\App\Helper;

use Symfony\Component\Validator\Constraint;
use Symfony\Component\Validator\Constraints as Assert;
use Yoanm\JsonRpcServerDoc\Domain\Model\Type\CollectionDoc;
use Yoanm\JsonRpcServerDoc\Domain\Model\Type\NumberDoc;
use Yoanm\JsonRpcServerDoc\Domain\Model\Type\StringDoc;
use Yoanm\JsonRpcServerDoc\Domain\Model\Type\TypeDoc;

/**
 * Class MinMaxHelper
 */
class MinMaxHelper
{
    /**
     * @param TypeDoc    $doc
     * @param Constraint $constraint
     */
    public function append(TypeDoc $doc, Constraint $constraint) : void
    {
        if ($doc instanceof StringDoc) {
            $this->appendStringDoc($doc, $constraint);
        } elseif ($doc instanceof NumberDoc) {
            $this->appendNumberDoc($doc, $constraint);
        } elseif ($doc instanceof CollectionDoc) {
            $this->appendCollectionDoc($doc, $constraint);
        }
    }

    /**
     * @param StringDoc  $doc
     * @param Constraint $constraint
     */
    private function appendStringDoc(StringDoc $doc, Constraint $constraint) : void
    {
        if ($constraint instanceof Assert\Length) {
            if (null !== $constraint->min) {
                $doc->setMinLength((int) $constraint->min);
            }
            if (null !== $constraint->max) {
                $doc->setMaxLength((int) $constraint->max);
            }
        } elseif ($constraint instanceof Assert\NotBlank && null === $doc->getMinLength()) {
            // Not blank so minimum 1 character
            $doc->setMinLength(1);
        } elseif ($constraint instanceof Assert\Blank && null === $doc->getMaxLength()) {
            // Blank so maximum 0 character
            $doc->setMaxLength(0);
        }
    }

    /**
     * @param NumberDoc  $doc
     * @param Constraint $constraint
     */
    private function appendNumberDoc(NumberDoc $doc, Constraint $constraint) : void
    {
        $this->appendNumberMinMax($doc, $constraint);

        if ($constraint instanceof Assert\LessThan) {
            $doc->setInclusiveMax(false);
        } elseif ($constraint instanceof Assert\GreaterThan) {
            $doc->setInclusiveMin(false);
        }
    }

    /**
     * @param CollectionDoc $doc
     * @param Constraint    $constraint
     */
    private function appendCollectionDoc(CollectionDoc $doc, Constraint $constraint) : void
    {
        if ($constraint instanceof Assert\Choice || $constraint instanceof Assert\Count) {
            if (null !== $constraint->min) {
                $doc->setMinItem((int) $constraint->min);
            }
            if (null !== $constraint->max) {
                $doc->setMaxItem((int) $constraint->max);
            }
        } elseif ($constraint instanceof Assert\NotBlank && null === $doc->getMinItem()) {
            // Not blank so minimum 1 item
            $doc->setMinItem(1);
        } /* Documentation does not mention array, counter to NotBlank constraint
         elseif ($constraint instanceof Assert\Blank && null === $doc->getMaxItem()) {
            // Blank so maximum 0 item
            $doc->setMaxItem(0);
        }*/
        $this->appendLessGreaterThanMinMaxItem($doc, $constraint);
    }

    /**
     * @param NumberDoc $doc
     * @param Constraint $constraint
     */
    private function appendNumberMinMax(NumberDoc $doc, Constraint $constraint) : void
    {
        if ($constraint instanceof Assert\Range) {
            if (null !== $constraint->min) {
                $doc->setMin($constraint->min);
            }
            if (null !== $constraint->max) {
                $doc->setMax($constraint->max);
            }
        } elseif ($constraint instanceof Assert\LessThanOrEqual
            || $constraint instanceof Assert\LessThan
        ) {
            $doc->setMax($constraint->value);
        } elseif ($constraint instanceof Assert\GreaterThanOrEqual
            || $constraint instanceof Assert\GreaterThan
        ) {
            $doc->setMin($constraint->value);
        }
    }

    /**
     * @param CollectionDoc $doc
     * @param Constraint    $constraint
     */
    private function appendLessGreaterThanMinMaxItem(CollectionDoc $doc, Constraint $constraint): void
    {
        if ($constraint instanceof Assert\GreaterThan || $constraint instanceof Assert\GreaterThanOrEqual) {
            $doc->setMinItem(
                $constraint instanceof Assert\GreaterThanOrEqual
                    ? $constraint->value
                    : $constraint->value + 1
            );
        } elseif ($constraint instanceof Assert\LessThan || $constraint instanceof Assert\LessThanOrEqual) {
            $doc->setMaxItem(
                $constraint instanceof Assert\LessThanOrEqual
                    ? $constraint->value
                    : $constraint->value - 1
            );
        }
    }
}