Flugg\Responder\ResponderServiceProvider

Complexity

Total Complexity

21

Size/Duplication

Total Lines	243
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	7

Test Coverage

Coverage

83.72%

Importance

Changes	7
Bugs	1	Features	0

15 Methods

Rating	Name	Duplication	Size	Complexity
A	register()	0	17	3
A	registerLaravelBindings()	0	6	1
A	registerLumenBindings()	0	6	1
A	decorateResponseFactory()	0	8	2
A	registerSerializerBindings()	0	10	1
A	registerErrorBindings()	0	15	1
A	registerFractalBindings()	0	6	1
A	registerPaginationBindings()	0	6	1
A	registerTransformationBindings()	0	13	1
A	registerServiceBindings()	0	10	1
A	boot()	0	11	3
A	bootLaravelApplication()	0	11	2
A	bootLumenApplication()	0	4	1
A	registerTransformerBindings()	0	10	1
A	registerResourceBindings()	0	10	1

<?php

namespace Flugg\Responder;

use Flugg\Responder\Console\MakeTransformer;
use Flugg\Responder\Contracts\ErrorFactory as ErrorFactoryContract;
use Flugg\Responder\Contracts\ErrorMessageResolver as ErrorMessageResolverContract;
use Flugg\Responder\Contracts\ErrorSerializer as ErrorSerializerContract;
use Flugg\Responder\Contracts\Pagination\PaginatorFactory as PaginatorFactoryContract;
use Flugg\Responder\Contracts\Resources\ResourceFactory as ResourceFactoryContract;
use Flugg\Responder\Contracts\Resources\ResourceKeyResolver as ResourceKeyResolverContract;
use Flugg\Responder\Contracts\Responder as ResponderContract;
use Flugg\Responder\Contracts\ResponseFactory as ResponseFactoryContract;
use Flugg\Responder\Contracts\Transformer as TransformerContract;
use Flugg\Responder\Contracts\Transformers\TransformerResolver as TransformerResolverContract;
use Flugg\Responder\Contracts\TransformFactory as TransformFactoryContract;
use Flugg\Responder\Http\Responses\ErrorResponseBuilder;
use Flugg\Responder\Http\Responses\Factories\LaravelResponseFactory;
use Flugg\Responder\Http\Responses\Factories\LumenResponseFactory;
use Flugg\Responder\Pagination\PaginatorFactory;
use Flugg\Responder\Resources\ResourceFactory;
use Flugg\Responder\Resources\ResourceKeyResolver;
use Flugg\Responder\Transformers\Transformer as BaseTransformer;
use Flugg\Responder\Transformers\TransformerResolver;
use Illuminate\Contracts\Container\Container;
use Illuminate\Foundation\Application as Laravel;
use Illuminate\Http\Request;
use Illuminate\Support\ServiceProvider as BaseServiceProvider;
use Laravel\Lumen\Application as Lumen;
use League\Fractal\Manager;
use League\Fractal\Serializer\SerializerAbstract;

/**
 * A service provider class responsible for bootstrapping the parts of the Laravel package.
 *
 * @package flugger/laravel-responder
 * @author  Alexander Tømmerås <flugged@gmail.com>
 * @license The MIT License
 */
class ResponderServiceProvider extends BaseServiceProvider
{
    /**
     * Indicates if loading of the provider is deferred.
     *
     * @var bool
     */
    protected $defer = false;

    /**
     * Register the service provider.
     *
     * @return void
     */
    public function register()
    {
        if ($this->app instanceof Laravel) {
            $this->registerLaravelBindings();
        } elseif ($this->app instanceof Lumen) {

The class Laravel\Lumen\Application does not exist. Did you forget a USE statement, or did you not list all dependencies?

            $this->registerLumenBindings();
        }

        $this->registerSerializerBindings();
        $this->registerErrorBindings();
        $this->registerFractalBindings();
        $this->registerTransformerBindings();
        $this->registerResourceBindings();
        $this->registerPaginationBindings();
        $this->registerTransformationBindings();
        $this->registerServiceBindings();
    }

    /**
     * Register Laravel bindings.
     *
     * @return void
     */
    protected function registerLaravelBindings()
    {
        $this->app->singleton(ResponseFactoryContract::class, function ($app) {
            return $this->decorateResponseFactory($app->make(LaravelResponseFactory::class));
        });
    }

    /**
     * Register Lumen bindings.
     *
     * @return void
     */
    protected function registerLumenBindings()
    {
        $this->app->singleton(ResponseFactoryContract::class, function ($app) {
            return $this->decorateResponseFactory($app->make(LumenResponseFactory::class));
        });
    }

    /**
     * Decorate response factories.
     *
     * @param  \Flugg\Responder\Contracts\ResponseFactory $factory
     * @return void
     */
    protected function decorateResponseFactory(ResponseFactoryContract $factory)
    {
        foreach ($this->app->config['responder.decorators'] as $decorator) {
            $factory = new $decorator($factory);
        };

        return $factory;
    }

    /**
     * Register serializer bindings.
     *
     * @return void
     */
    protected function registerSerializerBindings()
    {
        $this->app->bind(ErrorSerializerContract::class, function ($app) {
            return $app->make($app->config['responder.serializers.error']);
        });

        $this->app->bind(SerializerAbstract::class, function ($app) {
            return $app->make($app->config['responder.serializers.success']);
        });
    }

    /**
     * Register error bindings.
     *
     * @return void
     */
    protected function registerErrorBindings()
    {
        $this->app->singleton(ErrorMessageResolverContract::class, function ($app) {
            return $app->make(ErrorMessageResolver::class);
        });

        $this->app->singleton(ErrorFactoryContract::class, function ($app) {
            return $app->make(ErrorFactory::class);
        });

        $this->app->bind(ErrorResponseBuilder::class, function ($app) {
            return (new ErrorResponseBuilder($app->make(ResponseFactoryContract::class), $app->make(ErrorFactoryContract::class)))
                ->serializer($app->make(ErrorSerializerContract::class));
        });
    }

    /**
     * Register Fractal bindings.
     *
     * @return void
     */
    protected function registerFractalBindings()
    {
        $this->app->bind(Manager::class, function ($app) {
            return (new Manager)->setRecursionLimit($app->config['responder.recursion_limit']);
        });
    }

    /**
     * Register transformer bindings.
     *
     * @return void
     */
    protected function registerTransformerBindings()
    {
        $this->app->singleton(TransformerResolverContract::class, function ($app) {
            return $app->make(TransformerResolver::class);
        });

        BaseTransformer::containerResolver(function () {
            return $this->app->make(Container::class);
        });
    }

    /**
     * Register pagination bindings.
     *
     * @return void
     */
    protected function registerResourceBindings()
    {
        $this->app->singleton(ResourceKeyResolverContract::class, function ($app) {
            return $app->make(ResourceKeyResolver::class);
        });

        $this->app->singleton(ResourceFactoryContract::class, function ($app) {
            return $app->make(ResourceFactory::class);
        });
    }

    /**
     * Register pagination bindings.
     *
     * @return void
     */
    protected function registerPaginationBindings()
    {
        $this->app->singleton(PaginatorFactoryContract::class, function ($app) {
            return new PaginatorFactory($app->make(Request::class)->query());
        });
    }

    /**
     * Register transformation bindings.
     *
     * @return void
     */
    protected function registerTransformationBindings()
    {
        $this->app->singleton(TransformFactoryContract::class, function ($app) {
            return $app->make(FractalTransformFactory::class);
        });

        $this->app->bind(TransformBuilder::class, function ($app) {
            return (new TransformBuilder($app->make(ResourceFactoryContract::class), $app->make(TransformFactoryContract::class), $app->make(PaginatorFactoryContract::class)))
                ->serializer($app->make(SerializerAbstract::class))
                ->with($app->make(Request::class)->input($app->config['responder.load_relations_parameter'], []))
                ->only($app->make(Request::class)->input($app->config['responder.filter_fields_parameter'], []));
        });
    }

    /**
     * Register service bindings.
     *
     * @return void
     */
    protected function registerServiceBindings()
    {
        $this->app->singleton(ResponderContract::class, function ($app) {
            return $app->make(Responder::class);
        });

        $this->app->singleton(TransformerContract::class, function ($app) {
            return $app->make(Transformer::class);
        });
    }

    /**
     * Bootstrap the application events.
     *
     * @return void
     */
    public function boot()
    {
        if ($this->app instanceof Laravel) {
            $this->bootLaravelApplication();
        } elseif ($this->app instanceof Lumen) {

The class Laravel\Lumen\Application does not exist. Did you forget a USE statement, or did you not list all dependencies?

            $this->bootLumenApplication();
        }

        $this->mergeConfigFrom(__DIR__ . '/../config/responder.php', 'responder');
        $this->commands(MakeTransformer::class);
    }

    /**
     * Bootstrap the Laravel application.
     *
     * @return void
     */
    protected function bootLaravelApplication()
    {
        if ($this->app->runningInConsole()) {
            $this->publishes([
                __DIR__ . '/../config/responder.php' => config_path('responder.php'),
            ], 'config');
            $this->publishes([
                __DIR__ . '/../resources/lang/en/errors.php' => base_path('resources/lang/en/errors.php'),
            ], 'lang');
        }
    }

    /**
     * Bootstrap the Lumen application.
     *
     * @return void
     */
    protected function bootLumenApplication()
    {
        $this->app->configure('responder');

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

    }
}