ElfSundae\Laravel\Hashid\HashidManager

Complexity

Total Complexity

15

Size/Duplication

Total Lines	125
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

97.22%

Importance

Changes

0

8 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	getConfigWithoutDriver()	0	6	1
B	createDriver()	0	22	4
B	createConnection()	0	23	5

<?php

namespace ElfSundae\Laravel\Hashid;

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->app['config']->get("hashid.connections.{$name}", []);

        // First we will check by the connection name to see if a creator method
        // exists for the given connection.
        if (isset($this->customCreators[$name])) {
            return $this->customCreators[$name]($this->app, $config, $name);
        }

        // Next we will check by the driver name 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.
        if (isset($config['driver']) &&
            isset($this->customCreators[$driver = $config['driver']])
        ) {
            return $this->customCreators[$driver]($this->app, $this->getConfigWithoutDriver($config), $name);
        }

        return $this->createConnection($config);
    }

    /**
     * Create a new hashid connection instance.
     *
     * @param  array  $config
     * @return mixed
     *
     * @throws \InvalidArgumentException
     */
    protected function createConnection(array $config)
    {
        if (! isset($config['driver'])) {
            throw new InvalidArgumentException('A driver must be specified.');
        }

        $driver = $config['driver'];

        if ($this->app->bound($key = "hashid.connection.{$driver}")) {
            if ($this->app->isShared($key)) {
                return $this->app->make($key);
            }

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

            return $this->app->{$make}($key, [
                'app' => $this->app,
                'config' => $this->getConfigWithoutDriver($config),
            ]);
        }

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

    /**
     * Get connection configuration without "driver" element.
     *
     * @param  array  $config
     * @return array
     */
    protected function getConfigWithoutDriver($config)
    {
        unset($config['driver']);

        return $config;
    }
}