Joesama\Pintu\Routings\Builder

Complexity

Total Complexity

6

Size/Duplication

Total Lines	129
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	3
Bugs	1	Features	1

4 Methods

Rating	Name	Duplication	Size	Complexity
A	landingRouting()	0	19	1
A	componentRouting()	0	31	2
A	__construct()	0	3	1
A	apiRouting()	0	19	2

<?php

namespace Joesama\Pintu\Routings;

use Illuminate\Support\Arr;
use Illuminate\Support\Str;
use Illuminate\Support\Collection;
use Illuminate\Routing\Router;
use Joesama\Pintu\Routings\Concerns\Grammar;

class Builder
{
    use Grammar;

    /**
     * Array of component.
     *
     * @var Illuminate\Routing\Router

The type Joesama\Pintu\Routings\Illuminate\Routing\Router was not found. Did you mean Illuminate\Routing\Router? If so, make sure to prefix the type with \.

     */
    private $router;

    /**
     * Array of methods.
     *
     * @var array
     */
    private $componentMethods = ['GET', 'POST', 'PUT'];

    /**
     * Construct routing builder.
     *
     * @param Router $router
     */
    public function __construct(Router $router)
    {
        $this->router = $router;

It seems like $router of type Illuminate\Routing\Router is incompatible with the declared type Joesama\Pintu\Routings\Illuminate\Routing\Router of property $router.

    }

    /**
     * Component routing registration.
     *
     * @param Collection $component
     *
     * @return void
     */
    public function componentRouting(Collection $components, string $namespace)
    {
        $options = [
            'namespace' => $namespace,
            'middleware' => ['web']
        ];

        $components->each(function ($component, $controller) use ($options) {
            collect($component)->each(function ($attributes, $function) use ($controller, $options) {
                $options = Arr::set($options, 'prefix', $controller);

                if (Arr::get($attributes, 'auth', false)) {
                    $middleware = Arr::get($options, 'middleware');

                    $options = Arr::set($options, 'middleware', array_merge(Arr::wrap($middleware), ['auth']));
                }

                $only = Arr::get($attributes, 'only', collect($this->componentMethods)->toArray());

                $componentMethods = collect($this->componentMethods)->filter(function ($item) use ($only) {
                    return \in_array($item, \array_flip(\array_change_key_case(\array_flip($only), \CASE_UPPER)));
                });

                $this->router->group($options, function (Router $router) use ($componentMethods, $controller, $function, $attributes) {
                    $componentMethods->each(function ($type) use ($router, $controller, $function, $attributes) {
                        $router->addRoute(
                            Str::upper($type),
                            $this->pathConvention($type, $function, $attributes),
                            $this->classConvention($type, $controller, $function)
                        )->name(
                            $this->namedConvention($type, $controller, $function, $attributes)
                        );
                    });
                });
            });
        });
    }

    /**
     * Landing routing registration.
     *
     * @param Collection $component
     *
     * @return void
     */
    public function landingRouting(string $namespace)
    {
        $options = [
            'namespace' => $namespace,
            'middleware' => ['web', 'guest']
        ];

        $type = 'GET';
        $controller = 'landing';
        $function = 'default';
        $attributes = [];

        $this->router->group($options, function (Router $router) use ($type, $controller, $function, $attributes) {

The import $attributes is not used and could be removed.

            $router->addRoute(
                Str::upper($type),
                '/',
                $this->classConvention($type, $controller, $function)
            )->name(
                $controller
            );
        });
    }

    /**
     * API routing registration.
     *
     * @param Collection $api
     *
     * @return void
     */
    public function apiRouting(Collection $apis, string $namespace)
    {
        $options = [
            'namespace' => $namespace,
            'prefix' => 'api',
            'middleware' => ['auth:api']
        ];

        $this->router->group($options, function (Router $router) use ($apis) {
            $apis->each(function ($routes, $method) use ($router) {
                if (!empty($routes)) {
                    list($path, $controller, $named) = Arr::first($routes);

                    $router->addRoute(
                        Str::upper($method),
                        $path,
                        Str::ucfirst($controller)
                    )->name(
                        'api.' . $named
                    );
                }
            });
        });
    }
}