getNullableType() - Code Metrics - Inspection of "WIP: Type info Visitor" - digiaonline/graphql-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed
Pull Request — master (#38)

by Christoffer
created 2018-03-08 08:00 UTC
getNullableType() A

↳ Parent: Project
Complexity

Conditions	3
Paths	3
Size

Total Lines	7
Code Lines	3
Duplication

Lines	0
Ratio	0 %
Importance

Changes
Metric	Value
cc	3
eloc	3
nc	3
nop	1
dl	0
loc	7
rs	9.4285
c	0
b	0
f	0
<?php

namespace Digia\GraphQL\Type;

use Digia\GraphQL\Type\Definition\AbstractTypeInterface;
use Digia\GraphQL\Type\Definition\CompositeTypeInterface;
use Digia\GraphQL\Type\Definition\Directive;
use Digia\GraphQL\Type\Definition\EnumType;
use Digia\GraphQL\Type\Definition\InputObjectType;
use Digia\GraphQL\Type\Definition\InputTypeInterface;
use Digia\GraphQL\Type\Definition\InterfaceType;
use Digia\GraphQL\Type\Definition\LeafTypeInterface;
use Digia\GraphQL\Type\Definition\ListType;
use Digia\GraphQL\Type\Definition\NamedTypeInterface;
use Digia\GraphQL\Type\Definition\NonNullType;
use Digia\GraphQL\Type\Definition\ObjectType;
use Digia\GraphQL\Type\Definition\OutputTypeInterface;
use Digia\GraphQL\Type\Definition\ScalarType;
use Digia\GraphQL\Type\Definition\TypeInterface;
use Digia\GraphQL\Type\Definition\UnionType;
use Digia\GraphQL\Type\Definition\WrappingTypeInterface;
use function Digia\GraphQL\Util\invariant;
use function Digia\GraphQL\Util\toString;

/**
 * @param $thunk
 * @return null|array
 */
function resolveThunk($thunk): ?array
{
    return \is_callable($thunk) ? $thunk() : $thunk;
}

/**
 * @param mixed $value
 * @return bool
 */
function isAssocArray($value): bool
{
    if (!is_array($value)) {
        return false;
    }
    if (empty($value)) {
        return true;
    }
    $keys = array_keys($value);
    return $keys !== array_keys($keys);
}

/**
 * @param $resolver
 * @return bool
 */
function isValidResolver($resolver): bool
{
    return $resolver === null || \is_callable($resolver);
}

/**
 * @param $type
 * @throws \Exception
 */
function assertType($type)
{
    invariant(
        $type instanceof TypeInterface,
        sprintf(sprintf('Expected %s to be a GraphQL type.', $type), toString($type))
    );
}

/**
 * @param TypeInterface $type
 * @throws \Exception
 */
function assertScalarType(TypeInterface $type)
{
    invariant(
        $type instanceof ScalarType,
        sprintf('Expected %s to be a GraphQL Scalar type.', $type)
        sprintf('Expected %s to be a GraphQL Scalar type.', /** @scrutinizer ignore-type */ $type)
    );
}

/**
 * @param TypeInterface $type
 * @throws \Exception
 */
function assertObjectType(TypeInterface $type)
{
    invariant(
        $type instanceof ObjectType,
        sprintf('Expected %s to be a GraphQL Object type.', $type)
        sprintf('Expected %s to be a GraphQL Object type.', /** @scrutinizer ignore-type */ $type)
    );
}

/**
 * @param TypeInterface $type
 * @throws \Exception
 */
function assertInterfaceType(TypeInterface $type)
{
    invariant(
        $type instanceof InterfaceType,
        sprintf('Expected %s to be a GraphQL Interface type.', $type)
        sprintf('Expected %s to be a GraphQL Interface type.', /** @scrutinizer ignore-type */ $type)
    );
}

/**
 * @param TypeInterface $type
 * @throws \Exception
 */
function assertUnionType(TypeInterface $type)
{
    invariant(
        $type instanceof UnionType,
        sprintf('Expected %s to be a GraphQL Union type.', $type)
        sprintf('Expected %s to be a GraphQL Union type.', /** @scrutinizer ignore-type */ $type)
    );
}

/**
 * @param TypeInterface $type
 * @throws \Exception
 */
function assertEnumType(TypeInterface $type)
{
    invariant(
        $type instanceof EnumType,
        sprintf('Expected %s to be a GraphQL Enum type.', $type)
        sprintf('Expected %s to be a GraphQL Enum type.', /** @scrutinizer ignore-type */ $type)
    );
}

/**
 * @param TypeInterface $type
 * @throws \Exception
 */
function assertInputObjectType(TypeInterface $type)
{
    invariant(
        $type instanceof InputObjectType,
        sprintf('Expected %s to be a GraphQL InputObject type.', $type)
        sprintf('Expected %s to be a GraphQL InputObject type.', /** @scrutinizer ignore-type */ $type)
    );
}

/**
 * @param TypeInterface $type
 * @throws \Exception
 */
function assertListType(TypeInterface $type)
{
    invariant(
        $type instanceof ListType,
        sprintf('Expected %s to be a GraphQL List type.', $type)
        sprintf('Expected %s to be a GraphQL List type.', /** @scrutinizer ignore-type */ $type)
    );
}

/**
 * @param TypeInterface $type
 * @throws \Exception
 */
function assertNonNullType(TypeInterface $type)
{
    invariant(
        $type instanceof NonNullType,
        sprintf('Expected %s to be a GraphQL NonNull type.', $type)
        sprintf('Expected %s to be a GraphQL NonNull type.', /** @scrutinizer ignore-type */ $type)
    );
}

/**
 * @param TypeInterface|null $type
 * @return bool
 */
function isInputType(?TypeInterface $type): bool
{
    return null !== $type && ($type instanceof InputTypeInterface || ($type instanceof WrappingTypeInterface && isInputType($type->getOfType())));
}

/**
 * @param TypeInterface $type
 * @throws \Exception
 */
function assertInputType(TypeInterface $type)
{
    invariant(
        isInputType($type),
        sprintf('Expected %s to be a GraphQL input type.', $type)
        sprintf('Expected %s to be a GraphQL input type.', /** @scrutinizer ignore-type */ $type)
    );
}

/**
 * @param TypeInterface|null $type
 * @return bool
 */
function isOutputType(?TypeInterface $type): bool
{
    return null !== $type && ($type instanceof OutputTypeInterface || ($type instanceof WrappingTypeInterface && isOutputType($type->getOfType())));
}

/**
 * @param TypeInterface $type
 * @throws \Exception
 */
function assertOutputType(TypeInterface $type)
{
    invariant(
        isOutputType($type),
        sprintf('Expected %s to be a GraphQL output type.', $type)
        sprintf('Expected %s to be a GraphQL output type.', /** @scrutinizer ignore-type */ $type)
    );
}

/**
 * @param TypeInterface $type
 * @throws \Exception
 */
function assertLeafType(TypeInterface $type)
{
    invariant(
        $type instanceof LeafTypeInterface,
        sprintf('Expected %s to be a GraphQL leaf type.', $type)
        sprintf('Expected %s to be a GraphQL leaf type.', /** @scrutinizer ignore-type */ $type)
    );
}

/**
 * @param TypeInterface $type
 * @throws \Exception
 */
function assertCompositeType(TypeInterface $type)
{
    invariant(
        $type instanceof CompositeTypeInterface,
        sprintf('Expected %s to be a GraphQL composite type.', $type)
        sprintf('Expected %s to be a GraphQL composite type.', /** @scrutinizer ignore-type */ $type)
    );
}

/**
 * @param TypeInterface $type
 * @throws \Exception
 */
function assertAbstractType(TypeInterface $type)
{
    invariant(
        $type instanceof AbstractTypeInterface,
        sprintf('Expected %s to be a GraphQL abstract type.', $type)
        sprintf('Expected %s to be a GraphQL abstract type.', /** @scrutinizer ignore-type */ $type)
    );
}

/**
 * @param TypeInterface $type
 * @throws \Exception
 */
function assertWrappingType(TypeInterface $type)
{
    invariant(
        $type instanceof WrappingTypeInterface,
        sprintf('Expected %s to be a GraphQL wrapping type.', $type)
        sprintf('Expected %s to be a GraphQL wrapping type.', /** @scrutinizer ignore-type */ $type)
    );
}

/**
 * @param TypeInterface $type
 * @return bool
 */
function isNullableType(TypeInterface $type): bool
{
    return !$type instanceof NonNullType;
}

/**
 * @param TypeInterface $type
 * @return TypeInterface
 * @throws \Exception
 */
function assertNullableType(TypeInterface $type): TypeInterface
{
    invariant(
        isNullableType($type),
        sprintf('Expected %s to be a GraphQL nullable type.', $type)
        sprintf('Expected %s to be a GraphQL nullable type.', /** @scrutinizer ignore-type */ $type)
    );

    return $type;
}

/**
 * @param TypeInterface|null $type
 * @return TypeInterface|null
 */
function getNullableType(?TypeInterface $type): ?TypeInterface
{
    if (null !== $type) {
        return null;
    }

    return $type instanceof NonNullType ? $type->getOfType() : $type;
}

/**
 * @param TypeInterface $type
 * @throws \Exception
 */
function assertNamedType(TypeInterface $type)
{
    invariant(
        $type instanceof NamedTypeInterface,
        sprintf('Expected %s to be a GraphQL named type.', $type)
        sprintf('Expected %s to be a GraphQL named type.', /** @scrutinizer ignore-type */ $type)
    );
}

/**
 * @param TypeInterface|null $type
 * @return NamedTypeInterface|null
 */
function getNamedType(?TypeInterface $type): ?NamedTypeInterface
{
    if (!$type) {
        return null;
    }

    $unwrappedType = $type;

    while ($unwrappedType instanceof WrappingTypeInterface) {
        $unwrappedType = $unwrappedType->getOfType();
    }

    return $unwrappedType;

}

/**
 * @param array $config
 * @return ScalarType
 */
function GraphQLScalarType(array $config = []): ScalarType
{
    return new ScalarType($config);
}

/**
 * @param array $config
 * @return EnumType
 */
function GraphQLEnumType(array $config = []): EnumType
{
    return new EnumType($config);
}

/**
 * @param array $config
 * @return InputObjectType
 */
function GraphQLInputObjectType(array $config = []): InputObjectType
{
    return new InputObjectType($config);
}

/**
 * @param array $config
 * @return InterfaceType
 */
function GraphQLInterfaceType(array $config = []): InterfaceType
{
    return new InterfaceType($config);
}

/**
 * @param array $config
 * @return ObjectType
 */
function GraphQLObjectType(array $config = []): ObjectType
{
    return new ObjectType($config);
}

/**
 * @param array $config
 * @return UnionType
 */
function GraphQLUnionType(array $config = []): UnionType
{
    return new UnionType($config);
}

/**
 * @param array $config
 * @return Schema
 */
function GraphQLSchema(array $config = []): Schema
{
    return new Schema($config);
}

/**
 * @param array $config
 * @return Directive
 */
function GraphQLDirective(array $config = []): Directive
{
    return new Directive($config);
}

/**
 * @param TypeInterface $ofType
 * @return ListType
 * @throws \TypeError
 */
function GraphQLList(TypeInterface $ofType): ListType
{
    return new ListType($ofType);
}

/**
 * @param TypeInterface $ofType
 * @return NonNullType
 * @throws \TypeError
 */
function GraphQLNonNull(TypeInterface $ofType): NonNullType
{
    return new NonNullType($ofType);
}

digiaonline / graphql-php

Pull Request — master (#38)

getNullableType() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
