R\Hive\Providers\HiveServiceProvider

Complexity

Total Complexity

12

Size/Duplication

Total Lines	95
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	11

Importance

Changes	4
Bugs	0	Features	2

11 Methods

Rating	Name	Duplication	Size	Complexity
A	register()	0	10	2
A	registerAssembleCommand()	0	6	1
A	registerMakeFactoryCommand()	0	6	1
A	registerMakeInstanceCommand()	0	6	1
A	registerMakeRepoCommand()	0	6	1
A	registerMakeValidatorCommand()	0	6	1
A	registerMakeControllerCommand()	0	6	1
A	registerMakeCommandCommand()	0	6	1
A	registerMakeHandlerCommand()	0	6	1
A	registerMakeMutatorCommand()	0	6	1
A	provides()	0	4	1

<?php

namespace R\Hive\Providers;

use Illuminate\Support\ServiceProvider;
use R\Hive\Commands\AssembleCommand;
use R\Hive\Commands\MakeCommandCommand;
use R\Hive\Commands\MakeControllerCommand;
use R\Hive\Commands\MakeFactoryCommand;
use R\Hive\Commands\MakeHandlerCommand;
use R\Hive\Commands\MakeInstanceCommand;
use R\Hive\Commands\MakeMutatorCommand;
use R\Hive\Commands\MakeRepoCommand;
use R\Hive\Commands\MakeValidatorCommand;

class HiveServiceProvider extends ServiceProvider
{
    protected $defer = true;

    protected $commands = [
        'Assemble'       => 'command.assemble',
        'MakeFactory'    => 'command.make.factory',
        'MakeInstance'   => 'command.make.instance',
        'MakeRepo'       => 'command.make.repo',
        'MakeValidator'  => 'command.make.validator',
        'MakeController' => 'command.make.controller',
        'MakeCommand'    => 'command.make.command',
        'MakeHandler'    => 'command.make.handler',
        'MakeMutator'    => 'command.make.mutator',
    ];

    public function register()
    {
        foreach (array_keys($this->commands) as $command) {
            $method = "register{$command}Command";

            call_user_func_array([$this, $method], []);
        }

        $this->commands(array_values($this->commands));
    }

    protected function registerAssembleCommand()
    {
        $this->app->singleton('command.assemble', function () {
            return new AssembleCommand();
        });
    }

    protected function registerMakeFactoryCommand()
    {
        $this->app->singleton('command.make.factory', function ($app) {
            return new MakeFactoryCommand($app['files']);
        });
    }

    protected function registerMakeInstanceCommand()
    {
        $this->app->singleton('command.make.instance', function ($app) {
            return new MakeInstanceCommand($app['files']);
        });
    }

    protected function registerMakeRepoCommand()
    {
        $this->app->singleton('command.make.repo', function ($app) {
            return new MakeRepoCommand($app['files']);
        });
    }

    protected function registerMakeValidatorCommand()
    {
        $this->app->singleton('command.make.validator', function ($app) {
            return new MakeValidatorCommand($app['files']);
        });
    }

    protected function registerMakeControllerCommand()
    {
        $this->app->singleton('command.make.controller', function ($app) {
            return new MakeControllerCommand($app['files']);
        });
    }

    protected function registerMakeCommandCommand()
    {
        $this->app->singleton('command.make.command', function ($app) {
            return new MakeCommandCommand($app['files']);
        });
    }

    protected function registerMakeHandlerCommand()
    {
        $this->app->singleton('command.make.handler', function ($app) {
            return new MakeHandlerCommand($app['files']);
        });
    }

    protected function registerMakeMutatorCommand()
    {
        $this->app->singleton('command.make.mutator', function ($app) {
            return new MakeMutatorCommand($app['files']);
        });
    }

    public function provides()
    {
        return array_values($this->commands);
    }
}