Digia\GraphQL\Schema\DefinitionPrinter

Complexity

Total Complexity

41

Size/Duplication

Total Lines	264
Duplicated Lines	0 %

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	printScalar()	0	2	1
B	printDescriptionWithComments()	0	12	5
A	printOne()	0	3	1
A	print()	0	7	2
A	printSchema()	0	11	2
A	printFilteredSchema()	0	14	1
B	printSchemaDefinition()	0	24	5
A	printIntrospectionSchema()	0	11	1
A	printMany()	0	5	1
C	printDescription()	0	45	13
B	isSchemaOfCommonNames()	0	18	7
A	getSchemaDirectives()	0	3	1
A	getSchemaTypes()	0	9	1

<?php

namespace Digia\GraphQL\Schema;

use Digia\GraphQL\Error\PrintException;
use Digia\GraphQL\Type\Definition\DefinitionInterface;
use Digia\GraphQL\Type\Definition\DescriptionAwareInterface;
use Digia\GraphQL\Type\Definition\Directive;
use Digia\GraphQL\Type\Definition\NamedTypeInterface;
use Digia\GraphQL\Type\Definition\ScalarType;
use Digia\GraphQL\Type\Definition\TypeInterface;
use function Digia\GraphQL\Type\isIntrospectionType;
use function Digia\GraphQL\Type\isSpecifiedScalarType;
use function Digia\GraphQL\Util\toString;

class DefinitionPrinter implements DefinitionPrinterInterface
{
    /**
     * @inheritdoc
     * @throws PrintException
     */
    public function printSchema(SchemaInterface $schema, array $options = []): string
    {
        return $this->printFilteredSchema(
            $schema,
            function (Directive $directive): bool {
                return !isSpecifiedDirective($directive);
            },
            function (TypeInterface $type): bool {
                return !isSpecifiedScalarType($type) && !isIntrospectionType($type);
            },
            $options
        );
    }

    /**
     * @inheritdoc
     * @throws PrintException
     */
    public function printIntrospectionSchema(SchemaInterface $schema, array $options = []): string
    {
        return $this->printFilteredSchema(
            $schema,
            function (Directive $directive): bool {
                return isSpecifiedDirective($directive);
            },
            function (TypeInterface $type): bool {
                return isIntrospectionType($type);
            },
            $options
        );
    }

    /**
     * @param mixed $definition
     * @param array $options
     * @return string
     * @throws PrintException
     */
    public function print(DefinitionInterface $definition, array $options): string
    {
        if ($definition instanceof Schema) {
            return $this->printSchemaDefinition($definition);
        }

        throw new PrintException(\sprintf('Invalid definition object: %s.', toString($definition)));
    }

    /**
     * @param SchemaInterface $schema
     * @param callable        $directiveFilter
     * @param callable        $typeFilter
     * @param array           $options
     * @return string
     * @throws PrintException
     */
    protected function printFilteredSchema(
        SchemaInterface $schema,
        callable $directiveFilter,
        callable $typeFilter,
        array $options
    ): string {
        /** @noinspection PhpParamsInspection */
        return \implode("\n\n", \array_filter(
                \array_merge(
                    [$this->printOne($schema, $options)],
                    $this->printMany($this->getSchemaDirectives($schema, $directiveFilter), $options),
                    $this->printMany($this->getSchemaTypes($schema, $typeFilter), $options)
                )
            )) . "\n";
    }

    /**
     * @param SchemaInterface $schema
     * @param callable        $filter
     * @return array
     */
    protected function getSchemaDirectives(SchemaInterface $schema, callable $filter): array
    {
        return \array_filter($schema->getDirectives(), $filter);
    }

    /**
     * @param SchemaInterface $schema
     * @param callable        $filter
     * @return array
     */
    protected function getSchemaTypes(SchemaInterface $schema, callable $filter): array
    {
        $types = \array_filter(\array_values($schema->getTypeMap()), $filter);

        usort($types, function (TypeInterface $typeA, TypeInterface $typeB) {
            return \strcasecmp($typeA->getName(), $typeB->getName());
        });

        return $types;
    }

    /**
     * @param Schema $definition
     * @return string
     */
    protected function printSchemaDefinition(Schema $definition): string
    {
        if ($this->isSchemaOfCommonNames($definition)) {
            return '';
        }

        $operationTypes = [];

        if (null !== ($queryType = $definition->getQueryType())) {
            $operationTypes[] = "  query: {$queryType->getName()}";
        }

        if (null !== ($mutationType = $definition->getMutationType())) {
            $operationTypes[] = "  mutation: {$mutationType->getName()}";
        }

        if (null !== ($subscriptionType = $definition->getSubscriptionType())) {
            $operationTypes[] = "  subscription: {$subscriptionType->getName()}";
        }

        return \implode('', [
            "schema {\n",
            \implode("\n", $operationTypes),
            "\n}"
        ]);
    }

    /**
     * GraphQL schema define root types for each type of operation. These types are
     * the same as any other type and can be named in any manner, however there is
     * a common naming convention:
     *
     *   schema {
     *     query: Query
     *     mutation: Mutation
     *     subscription: Subscription
     *   }
     *
     * When using this naming convention, the schema description can be omitted.
     *
     * @param SchemaInterface $schema
     * @return bool
     */
    protected function isSchemaOfCommonNames(SchemaInterface $schema): bool
    {
        if (null !== ($queryType = $schema->getQueryType()) &&
            $queryType->getName() !== 'Query') {
            return false;
        }

        if (null !== ($mutationType = $schema->getMutationType()) &&
            $mutationType->getName() !== 'Mutation') {
            return false;
        }

        if (null !== ($subscriptionType = $schema->getSubscriptionType()) &&
            $subscriptionType->getName() !== 'Subscription') {
            return false;
        }

        return true;
    }

    protected function printScalar(ScalarType $type, array $options): string

The parameter $type is not used and could be removed.

The parameter $options is not used and could be removed.

    {

    }

In this branch, the function will implicitly return null which is incompatible with the type-hinted return string. Consider adding a return statement or allowing null as return value.

    /**
     * @param NamedTypeInterface $type
     * @param array              $options
     * @param string             $indentation
     * @param bool               $isFirstInBlock
     * @return string
     */
    protected function printDescription(
        NamedTypeInterface $type,
        array $options,
        string $indentation = '',
        bool $isFirstInBlock = true
    ): string {
        if (!($type instanceof DescriptionAwareInterface)) {
            return '';
        }

        $lines      = descriptionLines($type->getDescription(), 120 - \strlen($indentation));
        $linesCount = \count($lines);

        if (isset($options['commentDescriptions'])) {
            return $this->printDescriptionWithComments($lines, $indentation, $isFirstInBlock);
        }

        $description = $indentation && !$isFirstInBlock
            ? "\n" . $indentation . '"""'
            : $indentation . '"""';

        // In some circumstances, a single line can be used for the description.
        if (
            $linesCount === 1 &&
            ($firstLineLength = \strlen($lines[0])) < 70 &&
            $lines[0][$firstLineLength - 1] !== '"'
        ) {
            return $description . escapeQuote($lines[0]) . '"""' . "\n";
        }

        // Format a multi-line block quote to account for leading space.
        $hasLeadingSpace = $lines[0][0] === ' ' || $lines[0][0] === "\t";
        if (!$hasLeadingSpace) {
            $description .= "\n";
        }

        for ($i = 0; $i < $linesCount; $i++) {
            $description .= $i !== 0 || !$hasLeadingSpace
                ? $description .= $indentation
                : escapeQuote($lines[$i]) . "\n";
        }

        $description .= $indentation . '"""' . "\n";

        return $description;
    }

    protected function printDescriptionWithComments(array $lines, string $indentation, bool $isFirstInBlock): string
    {
        $description = $indentation && !$isFirstInBlock ? "\n" : '';
        $linesCount  = \count($lines);

        for ($i = 0; $i < $linesCount; $i++) {
            $description .= $lines[$i] === ''
                ? $indentation . '#' . "\n"
                : $indentation . '# ' . $lines[$i] . "\n";
        }

        return $description;
    }

    /**
     * @param DefinitionInterface $definition
     * @param array               $options
     * @return string
     * @throws PrintException
     */
    protected function printOne(DefinitionInterface $definition, array $options): string
    {
        return $this->print($definition, $options);
    }

    /**
     * @param DefinitionInterface[] $definitions
     * @param array                 $options
     * @return array
     */
    protected function printMany(array $definitions, array $options): array
    {
        return \array_map(function ($definition) use ($options) {
            return $this->print($definition, $options);
        }, $definitions);
    }
}