Sebdesign\SM\ServiceProvider

Complexity

Total Complexity

11

Size/Duplication

Total Lines	103
Duplicated Lines	0 %

Test Coverage

Coverage

96.72%

Importance

Changes	4
Bugs	0	Features	0

8 Methods

Rating	Name	Duplication	Size	Complexity
A	registerCallbackFactory()	0	7	1
A	register()	0	7	1
A	registerEventDispatcher()	0	7	1
A	boot()	0	9	4
A	registerCascadeTransitionCallback()	0	4	1
A	registerFactory()	0	11	1
A	provides()	0	7	1
A	registerCommands()	0	13	1

<?php

namespace Sebdesign\SM;

use Illuminate\Foundation\Application as LaravelApplication;
use Illuminate\Support\ServiceProvider as BaseServiceProvider;
use Laravel\Lumen\Application as LumenApplication;

The type Laravel\Lumen\Application was not found. Maybe you did not declare it correctly or list all dependencies?

use Sebdesign\SM\Callback\ContainerAwareCallback;
use Sebdesign\SM\Callback\ContainerAwareCallbackFactory;
use Sebdesign\SM\Commands\Debug;
use Sebdesign\SM\Commands\Visualize;
use Sebdesign\SM\Event\Dispatcher;
use Sebdesign\SM\Factory\Factory;
use SM\Callback\CallbackFactoryInterface;
use SM\Callback\CascadeTransitionCallback;
use SM\Factory\FactoryInterface;
use Symfony\Component\EventDispatcher\EventDispatcherInterface;

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

    /**
     * Bootstrap the application services.
     */
    public function boot()
    {
        if ($this->app->runningInConsole()) {
            if ($this->app instanceof LaravelApplication) {
                $this->publishes([
                    __DIR__.'/../config/state-machine.php' => config_path('state-machine.php'),
                ], 'config');
            } elseif ($this->app instanceof LumenApplication) {
                $this->app->configure('state-machine');

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

            }
        }
    }

    /**
     * Register the application services.
     */
    public function register()
    {
        $this->registerCallbackFactory();
        $this->registerEventDispatcher();
        $this->registerFactory();
        $this->registerCascadeTransitionCallback();
        $this->registerCommands();
    }

    protected function registerCallbackFactory()
    {
        $this->app->bind('sm.callback.factory', function ($app) {
            return new ContainerAwareCallbackFactory(ContainerAwareCallback::class, $app);
        });

        $this->app->alias('sm.callback.factory', CallbackFactoryInterface::class);
    }

    protected function registerEventDispatcher()
    {
        $this->app->bind('sm.event.dispatcher', function ($app) {
            return new Dispatcher($app->make('events'));
        });

        $this->app->alias('sm.event.dispatcher', EventDispatcherInterface::class);
    }

    protected function registerFactory()
    {
        $this->app->singleton('sm.factory', function ($app) {
            return new Factory(
                $app->make('config')->get('state-machine', []),
                $app->make('sm.event.dispatcher'),
                $app->make('sm.callback.factory')
            );
        });

        $this->app->alias('sm.factory', FactoryInterface::class);
    }

    protected function registerCascadeTransitionCallback()
    {
        $this->app->bind(CascadeTransitionCallback::class, function ($app) {
            return new CascadeTransitionCallback($app->make('sm.factory'));
        });
    }

    protected function registerCommands()
    {
        $this->app->bind(Debug::class, function ($app) {
            return new Debug($app->make('config')->get('state-machine', []));
        });

        $this->app->bind(Visualize::class, function ($app) {
            return new Visualize($app->make('config')->get('state-machine', []));
        });

        $this->commands([
            Debug::class,
            Visualize::class,
        ]);
    }

    /**
     * Get the services provided by the provider.
     *
     * @return array
     */
    public function provides()
    {
        return [
            'sm.callback.factory',
            'sm.event.dispatcher',
            'sm.factory',
            Debug::class,
        ];
    }
}