Yoanm\JsonRpcParamsSymfonyConstraintDoc\App\Helper\MinMaxHelper

Complexity

Total Complexity

39

Size/Duplication

Total Lines	120
Duplicated Lines	0 %

Test Coverage

Coverage

68.25%

Importance

Changes

0

5 Methods

Rating	Name	Duplication	Size	Complexity
C	appendCollectionDoc()	0	36	16
B	appendNumberMinMax()	0	17	8
B	appendStringDoc()	0	15	8
A	append()	0	8	4
A	appendNumberDoc()	0	8	3

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

use Symfony\Component\Validator\Constraint;
use Symfony\Component\Validator\Constraints as Assert;
use Yoanm\JsonRpcServerDoc\Domain\Model\Type\ArrayDoc;
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)
    {
        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)
    {
        if ($constraint instanceof Assert\Length) {
            if (null !== $constraint->min) {
                $doc->setMinLength($constraint->min);

$constraint->min of type mixed is incompatible with the type integer expected by parameter $minLength of Yoanm\JsonRpcServerDoc\Domain\Model\Type\StringDoc::setMinLength().

            }
            if (null !== $constraint->max) {
                $doc->setMaxLength($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)
    {
        $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)
    {
        if ($constraint instanceof Assert\Choice) {
            if (null !== $constraint->min) {
                $doc->setMinItem($constraint->min);
            }
            if (null !== $constraint->max) {
                $doc->setMaxItem($constraint->max);
            }
        } elseif ($constraint instanceof Assert\Count) {
            if (null !== $constraint->min) {
                $doc->setMinItem($constraint->min);

$constraint->min of type mixed is incompatible with the type integer expected by parameter $minItem of Yoanm\JsonRpcServerDoc\Domain\Model\Type\CollectionDoc::setMinItem().

            }
            if (null !== $constraint->max) {
                $doc->setMaxItem($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);
        }*/
        if ($doc instanceof ArrayDoc) {
            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
                );
            }
        }
    }

    /**
     * @param NumberDoc $doc
     * @param Constraint $constraint
     */
    private function appendNumberMinMax(NumberDoc $doc, Constraint $constraint)
    {
        if ($constraint instanceof Assert\Range) {
            if (null !== $constraint->min) {
                $doc->setMin($constraint->min);

$constraint->min of type mixed is incompatible with the type double|integer expected by parameter $min of Yoanm\JsonRpcServerDoc\Domain\Model\Type\NumberDoc::setMin().

            }
            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);
        }
    }
}