LaraComponents\GraphQL\Helpers\TypeRegistry

Complexity

Total Complexity

15

Size/Duplication

Total Lines	129
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Importance

Changes

0

6 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	8	3
A	setType()	0	5	1
A	resolveType()	0	16	4
A	make()	0	10	2
A	getName()	0	16	4
A	__call()	0	4	1

<?php

namespace LaraComponents\GraphQL\Helpers;

use InvalidArgumentException;

class TypeRegistry
{
    /**
     * The application instance.
     *
     * @var \Illuminate\Foundation\Application
     */
    protected $app;

    /**
     * The array of types.
     *
     * @var array
     */
    protected $types = [];

    /**
     * The array of resolved types.
     *
     * @var array
     */
    protected $instances = [];

    /**
     * Create a new instance.
     *
     * @param  \Illuminate\Foundation\Application  $app
     * @param  array  $types
     * @return void

Adding a @return annotation to constructors is generally not recommended as a constructor does not have a meaningful return value.

     */
    public function __construct($app, array $types = [])
    {
        $this->app = $app;

        foreach ($types as $name => $class) {
            $this->setType($class, is_numeric($name) ? null : $name);
        }
    }

    /**
     * Set type into registry
     *
     * @param string $class
     * @param string $name
     */
    public function setType($class, $name = null)
    {
        $name = $this->getName($class, $name);
        $this->types[$name] = $class;
    }

    /**
     * Resolve type from registry
     *
     * @param  string $type
     * @param  string $parameters
     * @return mixed
     * @throws \InvalidArgumentException
     */
    protected function resolveType($type, array $parameters)
    {
        if (! array_key_exists($type, $this->types)) {
            throw new InvalidArgumentException(sprintf('The type "%s" is not found.', $type));
        }

        if (count($parameters)) {
            return $this->make($type, $parameters);

$parameters is of type array, but the function expects a string.

        }

        if (! array_key_exists($type, $this->instances)) {
            $this->instances[$type] = $this->make($type, $parameters);

$parameters is of type array, but the function expects a string.

        }

        return $this->instances[$type];
    }

    /**
     * Make a new instance of type
     *
     * @param  string $type
     * @param  string $parameters
     * @return mixed
     */
    protected function make($type, $parameters)
    {
        $class = $this->types[$type];

        if (count($parameters)) {
            return new $class(...$parameters);
        }

        return new $class();
    }

    /**
     * Get name  from className
     * @param  string $class
     * @param  string $name
     * @return string
     */
    protected function getName($class, $name = null)
    {
        if ($name) {

The expression $name of type string|null is loosely compared to true; this is ambiguous if the string can be empty. You might want to explicitly use !== null instead.

            return $name;
        }

        if ($prevPos = strrpos($class, '\\')) {
            $class = substr($class, $prevPos + 1);
        }

        if (substr($class, -4) == 'Type') {
            $class = substr($class, 0, -4);
        }

        return lcfirst($class);
    }

    /**
     * Dynamically call the type instance.
     *
     * @param  string $type
     * @param  array $parameters
     * @return mixed
     */
    public function __call($type, $parameters)
    {
        return $this->resolveType($type, $parameters);
    }
}