ElfSundae\Laravel\Hashid\HashidManager

Complexity

Total Complexity

19

Size/Duplication

Total Lines	158
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes

0

11 Methods

Rating	Name	Duplication	Size	Complexity
A	connection()	0	4	1
A	getConnections()	0	4	1
A	getDefaultConnection()	0	4	1
A	setDefaultConnection()	0	6	1
A	getDefaultDriver()	0	4	1
A	createDriver()	0	12	2
A	callCustomCreator()	0	7	2
A	createConnectionForDriver()	0	12	3
A	getBindingForDriver()	0	8	3
A	configuration()	0	4	1
A	resolveBinding()	0	10	3

<?php

namespace ElfSundae\Laravel\Hashid;

use Illuminate\Support\Arr;
use InvalidArgumentException;
use Illuminate\Support\Manager;

class HashidManager extends Manager
{
    /**
     * Get a hashid connection instance.
     *
     * @param  string|null  $name
     * @return mixed
     */
    public function connection($name = null)
    {
        return $this->driver($name);
    }

    /**
     * Get all of the created connections.
     *
     * @return array
     */
    public function getConnections()
    {
        return $this->getDrivers();
    }

    /**
     * Get the default connection name.
     *
     * @return string
     */
    public function getDefaultConnection()
    {
        return $this->app['config']['hashid.default'];
    }

    /**
     * Set the default connection name.
     *
     * @param  string  $name
     * @return $this
     */
    public function setDefaultConnection($name)
    {
        $this->app['config']['hashid.default'] = $name;

        return $this;
    }

    /**
     * {@inheritdoc}
     */
    public function getDefaultDriver()
    {
        return $this->getDefaultConnection();
    }

    /**
     * {@inheritdoc}
     */
    protected function createDriver($name)
    {
        $config = $this->configuration($name);

        if (isset($this->customCreators[$name])) {
            return $this->callCustomCreator($name, compact('config'));
        }

        $driver = Arr::pull($config, 'driver', $name);

        return $this->createConnectionForDriver($driver, $config);
    }

    /**
     * {@inheritdoc}
     */
    protected function callCustomCreator($driver)
    {
        return $this->app->call(
            $this->customCreators[$driver],
            func_num_args() > 1 ? func_get_arg(1) : []
        );
    }

    /**
     * Create a new hashid connection instance for the driver.
     *
     * We will check to see if a creator method exists for the given driver,
     * and will call the Closure if so, which allows us to have a more generic
     * resolver for the drivers themselves which applies to all connections.
     *
     * @param  string  $driver
     * @param  array  $config
     * @return mixed
     *
     * @throws \InvalidArgumentException
     */
    protected function createConnectionForDriver($driver, array $config = [])
    {
        if (isset($this->customCreators[$driver])) {
            return $this->callCustomCreator($driver, compact('config'));
        }

        if ($binding = $this->getBindingForDriver($driver)) {
            return $this->resolveBinding($binding, compact('config'));
        }

        throw new InvalidArgumentException("Unsupported driver [$driver]");
    }

    /**
     * Get the container binding for the driver.
     *
     * @param  string  $driver
     * @return string|null
     */
    protected function getBindingForDriver($driver)
    {
        foreach ([$driver, 'hashid.driver.'.$driver] as $name) {
            if ($this->app->bound($name)) {
                return $name;
            }
        }
    }

    /**
     * Resolve the given binding from the container.
     *
     * NOTE:
     * `Container::make($abstract, $parameters)` which can pass additional
     * parameters to the constructor was removed in Laravel 5.4
     * (https://github.com/laravel/internals/issues/391), but then re-added
     * as `makeWith()` in v5.4.16 (https://github.com/laravel/framework/pull/18271).
     * And in L55 the `makeWith()` is just an alias to `make()`.
     *
     * @param  string  $abstract
     * @param  array  $parameters
     * @return mixed
     */
    protected function resolveBinding($abstract, array $parameters = [])
    {
        if ($this->app->isShared($abstract)) {
            return $this->app->make($abstract);
        }

        $makeWith = method_exists($this->app, 'makeWith') ? 'makeWith' : 'make';

        return $this->app->$makeWith($abstract, $parameters);
    }

    /**
     * Get the configuration for a connection.
     *
     * @param  string  $name
     * @return array
     */
    protected function configuration($name)
    {
        return Arr::get($this->app['config']['hashid.connections'], $name, []);
    }
}