Parser::processAst() - Code Metrics - Inspection of "using custom scalar types" - Corollarium/modelarium - Measure and Improve Code Quality continuously with Scrutinizer

Passed
Push — master ( 625be7...d965a1 )

by Bruno
created 2020-06-26 17:10 UTC
Parser::processAst() B

↳ Parent: Parser
Complexity

Conditions	6
Paths	1
Size

Total Lines	58
Code Lines	25
Duplication

Lines	0
Ratio	0 %
Code Coverage

Tests	5
CRAP Score	6
Importance

Changes
Metric	Value
eloc	25
c	0
b	0
f	0
dl	0
loc	58
rs	8.8977
ccs	5
cts	5
cp	1
cc	6
nc	1
nop	0
crap	6
How to fix Long Method

<?php declare(strict_types=1);

namespace Modelarium;

use GraphQL\Language\AST\DocumentNode;
use GraphQL\Language\AST\Node;
use GraphQL\Language\AST\NodeKind;
use GraphQL\Language\AST\ScalarTypeDefinitionNode;
use GraphQL\Language\Visitor;
use GraphQL\Type\Definition\ObjectType;
use GraphQL\Utils\AST;
use GraphQL\Type\Definition\Type;
use GraphQL\Type\Schema;
use GraphQL\Utils\SchemaExtender;
use Modelarium\Exception\ScalarNotFoundException;

class Parser
{
    /**
     * @var \GraphQL\Language\AST\DocumentNode
     */
    protected $ast;

    /**
     * @var \GraphQL\Type\Schema
     */
    protected $schema;

    protected $scalars = [];

    protected function __construct()
    {
        // empty
    }

    public static function extendDatatypes(array $typeConfig, $typeDefinitionNode): array
    public static function extendDatatypes(array $typeConfig, /** @scrutinizer ignore-unused */ $typeDefinitionNode): array
    {
        /* TODO: extended datatypes
        if ($typeConfig['name'] === 'Email') {
            $typeConfig = array_merge($typeConfig, [
                'serialize' => function ($value) {
                    // ...
                },
                'parseValue' => function ($value) {
                    // ...
                },
                'parseLiteral' => function ($ast) {
                    // ...
                }
            ]);
        } */
        return $typeConfig;
    }

    /**
     *
     * @param array $files
     * @return self
     * @throws \Safe\Exceptions\FilesystemException
     */
    public static function fromFiles(array $files): self
    {
        $p = new self();

        $sources = array_map('\Safe\file_get_contents', $files);
        return static::fromStrings($sources);
    }


    /**
     * Returns a Parser from a file path
     *
     * @param string $path The file path
     * @return Parser
     * @throws \Safe\Exceptions\FilesystemException If file is not found or parsing fails.
     */
    public static function fromFile(string $path): self
    {
        $data = \Safe\file_get_contents($path);
        return self::fromString($data);
    }

    /**
     * Returns a Parser from a string
     *
     * @param string $data the string
     * @return Parser
     */
    public static function fromString(string $data): self
    {
        $p = new self();
        $p->ast = \GraphQL\Language\Parser::parse($data);
        $p->processAst();
        $schemaBuilder = new \GraphQL\Utils\BuildSchema(
            $p->ast,
            [__CLASS__, 'extendDatatypes']
        );
        
        $p->schema = $schemaBuilder->buildSchema();
        $p->processSchema();
        return $p;
    }

    protected function processSchema(): void
    {
        $originalTypeLoader = $this->schema->getConfig()->typeLoader;

        $this->schema->getConfig()->typeLoader = function ($typeName) use ($originalTypeLoader) {
            $type = $originalTypeLoader($typeName);
            if ($type instanceof \GraphQL\Type\Definition\CustomScalarType) {
                $scalarName = $type->name;
                $className = $this->scalars[$scalarName];
                return new $className($type->config);
            }
            return $type;
        };
    }

    protected function processAst(): void
    {
        $this->ast = Visitor::visit($this->ast, [
            // load the scalar type classes
            NodeKind::SCALAR_TYPE_DEFINITION => function ($node) {
                $scalarName = $node->name->value;

                // load classes
                /**
                 * @var $astNode ScalarTypeDefinitionNode
                 */

                $className = null;
                foreach ($node->directives as $directive) {
                    switch ($directive->name->value) {
                    case 'scalar':
                        foreach ($directive->arguments as $arg) {
                            /**
                             * @var \GraphQL\Language\AST\ArgumentNode $arg
                             */
        
                            $value = $arg->value->value;

        
                            switch ($arg->name->value) {
                            case 'class':
                                $className = $value;
                            break;
                            }
                        }
                    break;
                    }
                }

                // Require special handler class for custom scalars:
                if (!class_exists($className, true)) {
                    throw new \Modelarium\Exception\Exception(
                        "Custom scalar must have corresponding handler class $className"
                    );
                }

                $this->scalars[$scalarName] = $className;

                // return
                //   null: no action
                //   Visitor::skipNode(): skip visiting this node
                //   Visitor::stop(): stop visiting altogether
                //   Visitor::removeNode(): delete this node
                //   any value: replace this node with the returned value
                return null;
            },
            NodeKind::NAMED_TYPE  => function ($node) {
            NodeKind::NAMED_TYPE  => function (/** @scrutinizer ignore-unused */ $node) {
                return null;
            },
            NodeKind::OBJECT_TYPE_DEFINITION  => function ($node) {
            NodeKind::OBJECT_TYPE_DEFINITION  => function (/** @scrutinizer ignore-unused */ $node) {
                return null;
            },
            'enter' => function ($node) {
            'enter' => function (/** @scrutinizer ignore-unused */ $node) {
                return null;
            }
        ]);
    }

    /**
     *
     * @param string[] $sources
     * @return self
     */
    public static function fromStrings(array $sources): self
    {
        $p = new self();
        $schema = new Schema([
            'query' => new ObjectType(['name' => 'Query']),
            'mutation' => new ObjectType(['name' => 'Mutation']),
        ]);

        foreach ($sources as &$s) {
            $s = \Safe\preg_replace('/^type Mutation/m', 'extend type Mutation', $s);
            $s = \Safe\preg_replace('/^type Query/m', 'extend type Query', $s);
        }
        $extensionSource = implode("\n", $sources);
        $p->ast = \GraphQL\Language\Parser::parse($extensionSource);

        // TODO: extendDatatypes
        $p->schema = SchemaExtender::extend(
            $schema,
            $p->ast
        );
        // $schemaBuilder = new \GraphQL\Utils\BuildSchema(
        //     $p->ast,
        //     [__CLASS__, 'extendDatatypes']
        // );

        // $p->schema = $schemaBuilder->buildSchema();
        $p->processAst();
        return $p;
    }


    public function getSchema(): Schema
    {
        return $this->schema;
    }

    public function getType(string $name) : ?Type
    {
        return $this->schema->getType($name);
    }

    /**
     * Factory.
     *
     * @param string $datatype
     * @return ScalarType
     */
    public function getScalarType(string $datatype): ?ScalarType
    {
        $className = $this->scalars[$datatype] ?? null;
        if (!$className) {
            return null;
        }
        if (!class_exists($className)) {
            throw new ScalarNotFoundException("Class not found for $datatype");
        }
        return new $className();
    }
}

Corollarium / modelarium

Push — master ( 625be7...d965a1 )

Parser::processAst() B

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like
