ElfSundae\Laravel\Hashid\HashidServiceProvider

Complexity

Total Complexity

14

Size/Duplication

Total Lines	139
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

94.83%

Importance

Changes	2
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	register()	0	7	1
A	setupAssets()	0	12	3
A	registerServices()	0	14	3
A	createInstance()	0	10	2
A	getSingletonBindings()	0	10	1
A	getClassAliases()	0	11	1
A	registerCommands()	0	9	2
A	provides()	0	7	1

<?php

namespace ElfSundae\Laravel\Hashid;

use ReflectionClass;
use Illuminate\Support\ServiceProvider;

class HashidServiceProvider extends ServiceProvider
{
    /**
     * Indicates if loading of the provider is deferred.
     *
     * @var bool
     */
    protected $defer = true;

    /**
     * Register the service provider.
     *
     * @return void
     */
    public function register()
    {
        $this->setupAssets();

        $this->registerServices();
        $this->registerCommands();
    }

    /**
     * Setup package assets.
     *
     * @return void
     */
    protected function setupAssets()
    {
        if (is_a($this->app, 'Laravel\Lumen\Application')) {
            $this->app->configure('hashid');

The method configure() does not exist on Illuminate\Contracts\Foundation\Application. Did you maybe mean registerConfiguredProviders()?

        }

        $this->mergeConfigFrom($config = __DIR__.'/../config/hashid.php', 'hashid');

        if ($this->app->runningInConsole()) {
            $this->publishes([$config => config_path('hashid.php')], 'hashid');
        }
    }

    /**
     * Register service bindings.
     *
     * @return void
     */
    protected function registerServices()
    {
        foreach ($this->getSingletonBindings() as $abstract => $concrete) {
            $this->app->singleton($abstract, function ($app) use ($concrete) {
                return $this->createInstance($concrete, [$app]);
            });

            $this->app->alias($abstract, $concrete);
        }

        foreach ($this->getClassAliases() as $abstract => $alias) {
            $this->app->alias($abstract, $alias);
        }
    }

    /**
     * Create a new instance from class name.
     *
     * @param  string  $class
     * @param  array  $args
     * @return mixed
     */
    protected function createInstance($class, array $args = [])
    {
        $reflector = new ReflectionClass($class);

        if (is_null($reflector->getConstructor())) {
            return new $class;
        }

        return $reflector->newInstanceArgs($args);
    }

    /**
     * Get singleton bindings to be registered.
     *
     * @return array
     */
    protected function getSingletonBindings()
    {
        return [
            'hashid' => HashidManager::class,
            'hashid.driver.base64' => Base64Driver::class,
            'hashid.driver.base64.integer' => Base64IntegerDriver::class,
            'hashid.driver.hex' => HexDriver::class,
            'hashid.driver.hex.integer' => HexIntegerDriver::class,
        ];
    }

    /**
     * Get class aliases to be registered.
     *
     * @return array
     */
    protected function getClassAliases()
    {
        return [
            Base62Driver::class => 'hashid.driver.base62',
            Base62IntegerDriver::class => 'hashid.driver.base62.integer',
            HashidsDriver::class => 'hashid.driver.hashids',
            HashidsHexDriver::class => 'hashid.driver.hashids.hex',
            HashidsIntegerDriver::class => 'hashid.driver.hashids.integer',
            OptimusDriver::class => 'hashid.driver.optimus',
        ];
    }

    /**
     * Register console commands.
     *
     * @return void
     */
    protected function registerCommands()
    {
        if ($this->app->runningInConsole()) {
            $this->commands([
                Console\AlphabetGenerateCommand::class,
                Console\OptimusGenerateCommand::class,
            ]);
        }
    }

    /**
     * Get the services provided by the provider.
     *
     * @return string[]
     */
    public function provides()
    {
        return array_merge(
            array_keys($bindings = $this->getSingletonBindings()),
            array_values($bindings)
        );
    }
}