TypeDefinition::validationSection() - Code Metrics - Inspection of "Callbacks enhancement" - overblog/GraphQLBundle - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Pull Request — 0.14 (#851)

by Jérémiah
created 2021-05-20 07:52 UTC
TypeDefinition::validationSection() B

↳ Parent: TypeDefinition
Complexity

Conditions	8
Paths	2
Size

Total Lines	64
Code Lines	41
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	41
CRAP Score	8
Importance

Changes
Metric	Value
eloc	41
c	0
b	0
f	0
dl	0
loc	64
ccs	41
cts	41
cp	1
rs	8.0195
cc	8
nc	2
nop	1
crap	8
How to fix Long Method

<?php

declare(strict_types=1);

namespace Overblog\GraphQLBundle\Config;

use Overblog\GraphQLBundle\ExpressionLanguage\ExpressionLanguage;
use Symfony\Component\Config\Definition\Builder\ArrayNodeDefinition;
use Symfony\Component\Config\Definition\Builder\NodeDefinition;
use Symfony\Component\Config\Definition\Builder\ScalarNodeDefinition;
use Symfony\Component\Config\Definition\Builder\TreeBuilder;
use Symfony\Component\Config\Definition\Builder\VariableNodeDefinition;
use function is_array;
use function is_int;
use function is_string;
use function preg_match;

abstract class TypeDefinition
{
    public const VALIDATION_LEVEL_CLASS = 0;
    public const VALIDATION_LEVEL_PROPERTY = 1;

    abstract public function getDefinition(): ArrayNodeDefinition;

    final protected function __construct()
    {
    }

    /**
     * @return static
     */
    public static function create(): self
    {
        return new static();
    }

    protected function nameSection(): ScalarNodeDefinition
    {
        /** @var ScalarNodeDefinition $node */
        $node = self::createNode('name', 'scalar');

        $node
            ->isRequired()
            ->validate()
                ->ifTrue(fn ($name) => !preg_match('/^[_a-z][_0-9a-z]*$/i', $name))
                ->thenInvalid('Invalid type name "%s". (see http://spec.graphql.org/June2018/#sec-Names)')
            ->end()
        ;

        return $node;
    }

    protected function defaultValueSection(): VariableNodeDefinition
    {
        return self::createNode('defaultValue', 'variable');

    }

    protected function validationSection(int $level): ArrayNodeDefinition
    {
        /** @var ArrayNodeDefinition $node */
        $node = self::createNode('validation', 'array');

        /** @phpstan-ignore-next-line */
        $node
            // allow shorthands
            ->beforeNormalization()
                ->always(function ($value) {
                    if (is_string($value)) {
                        // shorthand: cascade or link
                        return 'cascade' === $value ? ['cascade' => null] : ['link' => $value];
                    }

                    if (is_array($value)) {
                        foreach ($value as $k => $a) {
                            if (!is_int($k)) {
                                // validation: { link: ... , constraints: ..., cascade: ... }
                                return $value;
                            }
                        }
                        // validation: [list of constraints]
                        return ['constraints' => $value];
                    }

                    return [];
                })
            ->end()
            ->children()
                ->scalarNode('link')
                    ->validate()
                        ->ifTrue(function ($link) use ($level) {
                            if (self::VALIDATION_LEVEL_PROPERTY === $level) {
                                return !preg_match('/^(?:\\\\?[A-Za-z][A-Za-z\d]+)*[A-Za-z\d]+::(?:[$]?[A-Za-z][A-Za-z_\d]+|[A-Za-z_\d]+\(\))$/m', $link);
                            } else {
                                return !preg_match('/^(?:\\\\?[A-Za-z][A-Za-z\d]+)*[A-Za-z\d]$/m', $link);
                            }
                        })
                        ->thenInvalid('Invalid link provided: "%s".')
                    ->end()
                ->end()
                ->variableNode('constraints')->end()
            ->end();

        // Add the 'cascade' option if it's a property level validation section
        if (self::VALIDATION_LEVEL_PROPERTY === $level) {
            /** @phpstan-ignore-next-line */
            $node
                ->children()
                    ->arrayNode('cascade')
                        ->children()
                            ->arrayNode('groups')
                                ->beforeNormalization()
                                    ->castToArray()
                                ->end()
                                ->scalarPrototype()->end()
                                ->/** @scrutinizer ignore-call */ scalarPrototype()->end()
                            ->end()
                        ->end()
                    ->end()
                ->end();
        }

        return $node;
    }

    protected function descriptionSection(): ScalarNodeDefinition
    {
        /** @var ScalarNodeDefinition $node */
        $node = self::createNode('description', 'scalar');

        return $node;
    }

    protected function deprecationReasonSection(): ScalarNodeDefinition
    {
        /** @var ScalarNodeDefinition $node */
        $node = self::createNode('deprecationReason', 'scalar');

        $node->info('Text describing why this field is deprecated. When not empty - field will not be returned by introspection queries (unless forced)');

        return $node;
    }

    protected function typeSection(bool $isRequired = false): ScalarNodeDefinition
    {
        /** @var ScalarNodeDefinition $node */
        $node = self::createNode('type', 'scalar');

        $node->info('One of internal or custom types.');

        if ($isRequired) {
            $node->isRequired();
        }

        return $node;
    }

    protected function callbackNormalization(NodeDefinition $node, string $new, string $old): void
    {
        $node
            ->beforeNormalization()
                ->ifTrue(fn ($options) => !empty($options[$old]) && empty($options[$new]))
                ->then(function ($options) use ($old, $new) {
                    if (is_callable($options[$old])) {
                        if (is_array($options[$old])) {
                            $options[$new]['method'] = implode('::', $options[$old]);
                        } else {
                            $options[$new]['method'] = $options[$old];
                        }
                    } elseif (is_string($options[$old])) {
                        $options[$new]['expression'] = ExpressionLanguage::stringHasTrigger($options[$old]) ?
                            ExpressionLanguage::unprefixExpression($options[$old]) :
                            json_encode($options[$old]);
                    } else {
                        $options[$new]['expression'] = json_encode($options[$old]);
                    }

                    return $options;
                })
            ->end()
            ->beforeNormalization()
                ->ifTrue(fn ($options) => is_array($options) && array_key_exists($old, $options))
                ->then(function ($options) use ($old) {
                    unset($options[$old]);

                    return $options;
                })
            ->end()
            ->validate()
                ->ifTrue(fn (array $v) => !empty($v[$new]) && !empty($v[$old]))
                ->thenInvalid(sprintf(
                    '"%s" and "%s" should not be use together in "%%s".',
                    $new,
                    $old,
                ))
            ->end()
            ;
    }

    protected function callbackSection(string $name, string $info): ArrayNodeDefinition
    {
        /** @var ArrayNodeDefinition $node */
        $node = self::createNode($name);
        /** @phpstan-ignore-next-line */
        $node
            ->info($info)
            ->validate()
                ->ifTrue(fn (array $v) => !empty($v['method']) && !empty($v['expression']))
                ->thenInvalid('"method" and "expression" should not be use together.')
            ->end()
            ->beforeNormalization()
                // Allow short syntax
                ->ifTrue(fn ($options) => is_string($options) && ExpressionLanguage::stringHasTrigger($options))
                ->then(fn ($options) => ['expression' => ExpressionLanguage::unprefixExpression($options)])
            ->end()
            ->beforeNormalization()
                ->ifTrue(fn ($options) => is_string($options) && !ExpressionLanguage::stringHasTrigger($options))
                ->then(fn ($options) => ['method' => $options])
            ->end()
            ->beforeNormalization()
                // clean expression
                ->ifTrue(fn ($options) => isset($options['expression']) && is_string($options['expression']) && ExpressionLanguage::stringHasTrigger($options['expression']))
                ->then(function ($options) {
                    $options['expression'] = ExpressionLanguage::unprefixExpression($options['expression']);

                    return $options;
                })
            ->end()
            ->children()
                ->scalarNode('method')->end()
                ->scalarNode('expression')->end()
                ->scalarNode('id')->end()
            ->end()
        ;

        return $node;
    }

    /**
     * @return mixed
     *
     * @internal
     */
    protected static function createNode(string $name, string $type = 'array')
    {
        return (new TreeBuilder($name, $type))->getRootNode();
    }
}

overblog / GraphQLBundle

Scrutinizer GitHub App not installed

Pull Request — 0.14 (#851)

TypeDefinition::validationSection() B

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like
