Foundation\Services\BootstrapRegistrarService

Complexity

Total Complexity

27

Size/Duplication

Total Lines	134
Duplicated Lines	0 %

Test Coverage

Coverage

0%

Importance

Changes

0

12 Methods

Rating	Name	Duplication	Size	Complexity
A	getSeeders()	0	3	1
A	getConfigs()	0	3	1
A	__construct()	0	3	1
C	scanDirectories()	0	54	14
A	getMigrations()	0	3	1
A	cache()	0	5	1
A	getCommands()	0	3	1
A	getCachePath()	0	3	1
A	getFactories()	0	3	1
A	loadBootstrapFromCache()	0	9	2
A	hasPhpExtension()	0	3	2
A	getRoutes()	0	3	1

<?php
/**
 * Created by PhpStorm.
 * User: arthur
 * Date: 04.10.18
 * Time: 02:13.
 */

namespace Foundation\Services;

use Illuminate\Console\Command;

class BootstrapRegistrarService
{
    protected $files;

    protected $moduleEntityDirectories = [
        'commands' => 'Console',
        'routes' => 'Routes',
        'configs' => 'Config',
        'factories' => 'Database/factories',
        'migrations' => 'Database/Migrations',
        'seeders' => 'Database/Seeders'
    ];

    protected $cacheFile = 'bootstrap.php';

    protected $bootstrap;

    public function __construct()
    {
        $this->files = new \Illuminate\Filesystem\Filesystem();
    }

    public function cache()
    {
        $boostrap = $this->scanDirectories();
        $this->bootstrap = $boostrap;
        $this->files->put($this->getCachePath(), serialize($boostrap));
    }

    public function scanDirectories(): array
    {
        $bootstrap = [];
        $modules = \Module::all();


        foreach ($modules as $module) {
            foreach ($this->moduleEntityDirectories as $key => $directory) {
                $directory = ucfirst($directory);
                $directoryPath = $module->getPath() . '/' . $directory;
                $namespace = 'Modules' . '\\' . $module->getName();
                if (file_exists($directoryPath)) {
                    $files = scandir($directoryPath);
                    foreach ($files as $fileName) {
                        if ($this->hasPhpExtension($fileName)) {
                            $className = basename($fileName, '.php');
                            $class = $namespace . '\\' . str_replace('/', '\\', $directory) . '\\' . $className;

                            try {
                                switch ($key) {
                                    case 'commands':
                                        if (new $class() instanceof Command) {
                                            $bootstrap[$key][] = $class;
                                        }
                                        break;
                                    case 'routes':
                                        $bootstrap[$key][] = [$directoryPath . '/' . $fileName, $namespace];
                                        break;
                                    case 'configs':
                                        $bootstrap[$key][] = [$directoryPath . '/' . $fileName, strtolower($module->getName())];
                                        break;
                                    case 'factories':
                                        $bootstrap[$key][] = $directoryPath;
                                        break;
                                    case 'migrations':
                                        $bootstrap[$key][] = $directoryPath;
                                        break;
                                    case 'seeders':
                                        $bootstrap[$key][] = $class;
                                        break;
                                    default:
                                        break;
                                }


                            } catch (\Exception $e) {

Consider adding a comment why this CATCH block is empty.

                            }
                        }
                    }
                }
            }
        }

        return $bootstrap;
    }

    private function hasPhpExtension(string $fileName): bool
    {
        return strlen($fileName) > 4 && '.php' === ($fileName[-4] . $fileName[-3] . $fileName[-2] . $fileName[-1]);
    }

    private function loadBootstrapFromCache()
    {
        if (!isset($this->bootstrap)) {
            $commandCachePath = $this->getCachePath();
            $this->cache();
            $this->boostrap = unserialize($this->files->get($commandCachePath));

The property boostrap does not exist. Although not strictly required by PHP, it is generally a best practice to declare properties explicitly.

        }

        return $this->bootstrap;
    }

    public function getCommands(): array
    {
        return $this->loadBootstrapFromCache()['commands'] ?? [];
    }

    public function getRoutes(): array
    {
        return $this->loadBootstrapFromCache()['routes'] ?? [];
    }

    public function getConfigs(): array
    {
        return $this->loadBootstrapFromCache()['configs'] ?? [];
    }

    public function getFactories(): array
    {
        return $this->loadBootstrapFromCache()['factories'] ?? [];
    }

    public function getMigrations(): array
    {
        return $this->loadBootstrapFromCache()['migrations'] ?? [];
    }

    public function getSeeders(): array
    {
        return $this->loadBootstrapFromCache()['seeders'] ?? [];
    }

    public function getCachePath(): string
    {
        return app()->bootstrapPath() . '/cache/' . $this->cacheFile;

The method bootstrapPath() does not exist on Illuminate\Container\Container. Are you sure you never get this type here, but always one of the subclasses?

    }
}