Imanghafoori\LaravelMicroscope\LaravelMicroscopeServiceProvider

Complexity

Total Complexity

33

Size/Duplication

Total Lines	189
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	17

Importance

Changes

0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	registerCompiler()	0	6	1
A	spyRouter()	0	8	1
A	spyFactory()	0	8	1
A	spyGates()	0	8	1
A	spyEvents()	0	11	1
A	boot()	0	28	5
B	register()	0	30	10
A	spyView()	0	22	4
A	loadConfig()	0	4	1
A	canRun()	0	4	4
A	getActionName()	0	6	2
A	resetCountersOnFinish()	0	8	1
A	logUnusedViewVars()	0	7	1

<?php

namespace Imanghafoori\LaravelMicroscope;

use Faker\Generator as FakerGenerator;
use Illuminate\Contracts\Auth\Access\Gate as GateContract;
use Illuminate\Contracts\Queue\Factory as QueueFactoryContract;
use Illuminate\Database\Eloquent\Factory as EloquentFactory;
use Illuminate\Support\Facades\Event;
use Illuminate\Support\Facades\Log;
use Illuminate\Support\Facades\Route;
use Illuminate\Support\ServiceProvider;
use Illuminate\Support\Str;
use Illuminate\View\View;
use Imanghafoori\LaravelMicroscope\Checks\CheckClassReferences;
use Imanghafoori\LaravelMicroscope\Commands\CheckViews;
use Imanghafoori\LaravelMicroscope\ErrorReporters\ConsolePrinterInstaller;
use Imanghafoori\LaravelMicroscope\ErrorReporters\ErrorPrinter;
use Imanghafoori\LaravelMicroscope\SpyClasses\SpyBladeCompiler;
use Imanghafoori\LaravelMicroscope\SpyClasses\SpyDispatcher;
use Imanghafoori\LaravelMicroscope\SpyClasses\SpyFactory;
use Imanghafoori\LaravelMicroscope\SpyClasses\SpyGate;
use Imanghafoori\LaravelMicroscope\SpyClasses\SpyRouter;
use Imanghafoori\LaravelMicroscope\SpyClasses\ViewsData;

class LaravelMicroscopeServiceProvider extends ServiceProvider
{
    private static $commandNames = [
        Commands\CheckEvents::class,
        Commands\CheckGates::class,
        Commands\CheckRoutes::class,
        Commands\CheckViews::class,
        Commands\CheckPsr4::class,
        Commands\CheckImports::class,
        Commands\CheckAll::class,
        Commands\ClassifyStrings::class,
        Commands\CheckDD::class,
        Commands\CheckEarlyReturns::class,
        Commands\CheckCompact::class,
        Commands\CheckBladeQueries::class,
        Commands\CheckActionComments::class,
        Commands\CheckBadPractice::class,
        Commands\CheckExtractBladeIncludes::class,
        Commands\PrettyPrintRoutes::class,
        Commands\CheckExpansions::class,
        Commands\CheckDeadControllers::class,
        Commands\CheckGenericActionComments::class,
        Commands\CheckPsr12::class,
        Commands\CheckEndIf::class,
    ];

    public function boot()
    {
        (app()['env'] !== 'production') && config('microscope.log_unused_view_vars', true) && $this->spyView();

        if (! $this->canRun()) {
            return;
        }

        Event::listen('microscope.start.command', function () {
            ! defined('microscope_start') && define('microscope_start', microtime(true));
        });

        $this->resetCountersOnFinish();

        $this->commands(self::$commandNames);

        $this->publishes([
            __DIR__.'/../config/config.php' => config_path('microscope.php'),
        ], 'config');

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

        ConsolePrinterInstaller::boot();

        Event::listen('microscope.checking', function ($path, $command) {
            $command->line('Checking: '.$path);
        });
    }

    public function register()
    {
        ! defined('T_NAME_QUALIFIED') && define('T_NAME_QUALIFIED', 3030);
        ! defined('T_NAME_FULLY_QUALIFIED') && define('T_NAME_FULLY_QUALIFIED', 3031);

        if (! $this->canRun()) {
            return;
        }
        $this->spyEvents();

        $this->registerCompiler();

        $this->loadConfig();

        app()->singleton(ErrorPrinter::class);
        // also we should spy the factory paths.
        $this->spyRouter();
        if (class_exists('Illuminate\Database\Eloquent\Factory')) {
            $this->spyFactory();
        }

        // We need to start spying before the boot process starts.
        $command = $_SERVER['argv'][1] ?? null;
        // We spy the router in order to have a list of route files.
        $checkAll = Str::startsWith('check:all', $command);
        ($checkAll || Str::startsWith('check:routes', $command)) && app('router')->spyRouteConflict();
        Str::startsWith('check:action_comment', $command) && app('router')->spyRouteConflict();
        // ($checkAll || Str::startsWith('check:events', $command)) && $this->spyEvents();
        ($checkAll || Str::startsWith('check:gates', $command)) && $this->spyGates();
    }

    private function spyRouter()
    {
        $router = new SpyRouter(app('events'), app());
        $this->app->singleton('router', function ($app) use ($router) {

The parameter $app is not used and could be removed.

            return $router;
        });
        Route::swap($router);
    }

    private function spyFactory()
    {
        $this->app->singleton(EloquentFactory::class, function ($app) {
            return SpyFactory::construct(
                $app->make(FakerGenerator::class), $app->databasePath('factories')
            );
        });
    }

    private function spyGates()
    {
        $this->app->singleton(GateContract::class, function ($app) {
            return new SpyGate($app, function () use ($app) {
                return call_user_func($app['auth']->userResolver());
            });
        });
    }

    private function spyEvents()
    {
        app()->booting(function () {
            $this->app->singleton('events', function ($app) {
                return (new SpyDispatcher($app))->setQueueResolver(function () use ($app) {
                    return $app->make(QueueFactoryContract::class);
                });
            });
            Event::clearResolvedInstance('events');
        });
    }

    public function spyView()
    {
        app()->singleton('microscope.views', ViewsData::class);

        \View::creator('*', function (View $view) {
            resolve('microscope.views')->add($view);
        });

        app()->terminating(function () {
            $spy = resolve('microscope.views');
            if (! $spy->main || Str::startsWith($spy->main->getName(), ['errors::'])) {
                return;
            }

            $action = $this->getActionName();

            $uselessVars = array_keys(array_diff_key($spy->getMainVars(), $spy->readTokenizedVars()));
            $viewName = $spy->main->getName();

            $uselessVars && $this->logUnusedViewVars($viewName, $action, $uselessVars);

The expression $uselessVars of type array<integer|string> is implicitly converted to a boolean; are you sure this is intended? If so, consider using ! empty($expr) instead to make it clear that you intend to check for an array without elements.

        });
    }

    private function loadConfig()
    {
        $this->mergeConfigFrom(__DIR__.'/../config/config.php', 'microscope');
    }

    private function canRun()
    {
        return $this->app->runningInConsole() && config('microscope.is_enabled', true) && ! $this->app->runningUnitTests() && app()['env'] !== 'production';
    }

    public function getActionName()
    {
        $cRoute = \Route::getCurrentRoute();

        return $cRoute ? $cRoute->getActionName() : '';
    }

    private function registerCompiler()
    {
        $this->app->singleton('microscope.blade.compiler', function () {
            return new SpyBladeCompiler($this->app['files'], $this->app['config']['view.compiled']);
        });
    }

    private function resetCountersOnFinish()
    {
        Event::listen('microscope.finished.checks', function () {
            CheckViews::$checkedCallsNum = 0;
            CheckClassReferences::$refCount = 0;
            Psr4Classes::$checkedFilesNum = 0;
        });
    }

    private function logUnusedViewVars($viewName, string $action, array $uselessVars)
    {
        Log::info('Laravel Microscope - The view file "'.$viewName.'"');
        Log::info('At "'.$action.'" has some unused variables passed to it: ');
        Log::info($uselessVars);

$uselessVars is of type array, but the function expects a string.

        Log::info('If you do not see these variables passed in a controller, look in view composers.');
    }
}