Rawilk\LaravelModules\Repository

Complexity

Total Complexity

77

Size/Duplication

Total Lines	664
Duplicated Lines	0 %

Importance

Changes

0

43 Methods

Rating	Name	Duplication	Size	Complexity
A	getByStatus()	0	11	3
A	getCached()	0	4	1
A	has()	0	3	1
A	addLocation()	0	5	1
A	toCollection()	0	3	1
A	all()	0	7	2
A	__construct()	0	4	1
A	getScanPaths()	0	13	3
A	getPaths()	0	3	1
A	scan()	0	18	4
A	allDisabled()	0	3	1
A	formatCached()	0	11	2
A	allEnabled()	0	3	1
A	count()	0	3	1
A	getOrdered()	0	17	5
A	config()	0	3	1
A	install()	0	5	1
A	getUsedStoragePath()	0	15	3
A	getAssetsPath()	0	3	1
A	getUsedNow()	0	3	1
A	collections()	0	3	1
A	getPath()	0	3	2
A	enabled()	0	3	1
A	enable()	0	3	1
A	boot()	0	4	2
A	assetPath()	0	3	1
A	getViewPartials()	0	33	6
A	findOrFail()	0	9	2
A	findByAlias()	0	9	3
A	getModulePath()	0	6	2
A	asset()	0	13	2
A	forgetUsed()	0	4	2
A	setStubPath()	0	5	1
A	setUsed()	0	5	1
A	delete()	0	3	1
A	findRequirements()	0	11	2
A	find()	0	9	3
A	disabled()	0	3	1
A	update()	0	3	1
A	register()	0	4	2
A	disable()	0	3	1
A	getFiles()	0	3	1
A	getStubPath()	0	11	3

<?php

namespace Rawilk\LaravelModules;

use Countable;
use Illuminate\Container\Container;
use Illuminate\Support\Str;
use Illuminate\Support\Traits\Macroable;
use Rawilk\LaravelModules\Contracts\RepositoryInterface;
use Rawilk\LaravelModules\Exceptions\InvalidAssetPathException;
use Rawilk\LaravelModules\Exceptions\ModuleNotFoundException;
use Rawilk\LaravelModules\Process\Installer;
use Rawilk\LaravelModules\Process\Updater;

abstract class Repository implements RepositoryInterface, Countable
{
    use Macroable;

The trait Illuminate\Support\Traits\Macroable requires the property $name which is not provided by Rawilk\LaravelModules\Repository.

    /**
     * The application instance.
     *
     * @var \Illuminate\Contracts\Foundation\Application
     */
    protected $app;

    /**
     * The module path.
     *
     * @var string|null
     */
    protected $path;

    /**
     * The scanned paths.
     *
     * @var array
     */
    protected $paths = [];

    /**
     * The path for stubs.
     *
     * @var string
     */
    protected $stubPath;

    /**
     * @param Container $app
     * @param string|null $path
     */
    public function __construct(Container $app, $path = null)
    {
        $this->app = $app;

It seems like $app of type Illuminate\Container\Container is incompatible with the declared type Illuminate\Contracts\Foundation\Application of property $app.

        $this->path = $path;
    }

    /**
     * Add another module location.
     *
     * @param string $path
     * @return $this
     */
    public function addLocation($path)
    {
        $this->paths[] = $path;

        return $this;
    }

    /**
     * Get all additional paths.
     *
     * @return array
     */
    public function getPaths() : array
    {
        return $this->paths;
    }

    /**
     * Get scanned modules paths.
     *
     * @return array
     */
    public function getScanPaths() : array
    {
        $paths = $this->paths;

        $paths[] = $this->getPath();

        if ($this->config('scan.enabled')) {
            $paths = array_merge($paths, $this->config('scan.paths'));
        }

        return array_map(function ($path) {
            return ends_with($path, '/*') ? $path : str_finish($path, '/*');
        }, $paths);
    }

    /**
     * Create a new Module instance
     *
     * @param array $args
     * @return \Rawilk\LaravelModules\Module
     */
    abstract protected function createModule(...$args);

    /**
     * Get & scan all modules.
     *
     * @return array
     */
    public function scan()
    {
        $paths = $this->getScanPaths();

        $modules = [];

        foreach ($paths as $key => $path) {
            $manifests = $this->app['files']->glob("{$path}/module.json");

            is_array($manifests) || $manifests = [];

            foreach ($manifests as $manifest) {
                $name = Json::make($manifest)->get('name');
                $modules[$name] = $this->createModule($this->app, $name, dirname($manifest));
            }
        }

        return $modules;
    }

    /**
     * Get all modules.
     *
     * @return array
     */
    public function all() : array
    {
        if (! $this->config('cache.enabled')) {
            return $this->scan();
        }

        return $this->formatCached($this->getCached());
    }

    /**
     * Format the cached data as array of modules.
     *
     * @param array $cached
     * @return array
     */
    protected function formatCached($cached)
    {
        $modules = [];

        foreach ($cached as $name => $module) {
            $path = $module['path'];

            $modules[$name] = $this->createModule($this->app, $name, $path);
        }

        return $modules;
    }

    /**
     * Get cached modules.
     *
     * @return array
     */
    public function getCached()
    {
        return $this->app['cache']->remember($this->config('cache.key'), $this->config('cache.lifetime'), function () {
            return $this->toCollection()->toArray();
        });
    }

    /**
     * Get all modules as collection instance.
     *
     * @return Collection
     */
    public function toCollection() : Collection
    {
        return new Collection($this->scan());
    }

    /**
     * Get modules by status.
     *
     * @param int $status
     * @return array
     */
    public function getByStatus($status) : array
    {
        $modules = [];

        foreach ($this->all() as $name => $module) {
            if ($module->isStatus($status)) {
                $modules[$name] = $module;
            }
        }

        return $modules;
    }

    /**
     * Determine whether the given module exists.
     *
     * @param string $name
     * @return bool
     */
    public function has($name) : bool
    {
        return array_key_exists($name, $this->all());
    }

    /**
     * Get list of enabled modules.
     *
     * @return array
     */
    public function allEnabled() : array
    {
        return $this->getByStatus(1);
    }

    /**
     * Get list of disabled modules.
     *
     * @return array
     */
    public function allDisabled() : array
    {
        return $this->getByStatus(0);
    }

    /**
     * Get count of all modules.
     *
     * @return int
     */
    public function count() : int
    {
        return count($this->all());
    }

    /**
     * Get all modules ordered.
     *
     * @param string $direction
     * @return array
     */
    public function getOrdered($direction = 'asc') : array
    {
        $modules = $this->allEnabled();

        uasort($modules, function (Module $a, Module $b) use ($direction) {
            if ($a->order == $b->order) {

The property order does not exist on Rawilk\LaravelModules\Module. Since you implemented __get, consider adding a @property annotation.

                return 0;
            }

            if ($direction == 'desc') {
                return $a->order < $b->order ? 1 : -1;
            }

            return $a->order > $b->order ? 1 : -1;
        });

        return $modules;
    }

    /**
     * Retrieve a sorted list of view partials to render for the given module.
     *
     * @param string $moduleKey
     * @return array
     */
    public function getViewPartials($moduleKey) : array
    {
        $modules = $this->getOrdered();

        $viewPartials = [];

        foreach ($modules as $module) {
            $path = $module->getExtraPath('config') . '/module-views.php';

            if (! $this->app['files']->exists($path)) {
                continue;
            }

            $moduleViews = $this->app['files']->getRequire($path);
            $moduleViews = array_get($moduleViews, $moduleKey, []);

            if (! empty($moduleViews)) {
                $viewPartials = array_merge($viewPartials, $moduleViews);
            }
        }

        uasort($viewPartials, function ($a, $b) {
            $aPriority = $a['priority'] ?? 0;
            $bPriority = $b['priority'] ?? 0;

            if ($aPriority == $bPriority) {
                return 0;
            }

            return $aPriority > $bPriority ? 1 : -1;
        });

        return $viewPartials;
    }

    /**
     * Get the module path.
     *
     * @return string
     */
    public function getPath() : string
    {
        return $this->path ?: $this->config('paths.modules', base_path('Modules'));
    }

    /**
     * Register the modules.
     */
    public function register()
    {
        foreach ($this->getOrdered() as $module) {
            $module->register();
        }
    }

    /**
     * Boot the modules.
     */
    public function boot()
    {
        foreach ($this->getOrdered() as $module) {
            $module->boot();
        }
    }

    /**
     * Find a specific module.
     *
     * @param string $name
     * @return null|\Rawilk\LaravelModules\Module
     */
    public function find($name)
    {
        foreach ($this->all() as $module) {
            if ($module->getLowerName() === strtolower($name)) {
                return $module;
            }
        }

        return null;
    }

    /**
     * Find a specific module by its alias.
     *
     * @param string $alias
     * @return null|\Rawilk\LaravelModules\Module
     */
    public function findByAlias($alias)
    {
        foreach ($this->all() as $module) {
            if ($module->getAlias() === $alias) {
                return $module;
            }
        }

        return null;
    }

    /**
     * Find all modules that are required by the given.
     * If the module cannot be found, throw an exception.
     *
     * @param string $name
     * @return array
     * @throws \Rawilk\LaravelModules\Exceptions\ModuleNotFoundException
     */
    public function findRequirements($name)
    {
        $requirements = [];

        $module = $this->findOrFail($name);

        foreach ($module->getRequires() as $requirementName) {
            $requirements[] = $this->findByAlias($requirementName);
        }

        return $requirements;
    }

    /**
     * Find the given module.
     *
     * @param string $name
     * @return \Rawilk\LaravelModules\Module
     * @throws \Rawilk\LaravelModules\Exceptions\ModuleNotFoundException
     */
    public function findOrFail($name)
    {
        $module = $this->find($name);

        if (! is_null($module)) {
            return $module;
        }

        throw new ModuleNotFoundException("Module [{$name}] does not exist!");
    }

    /**
     * Get all modules as laravel collection instance.
     *
     * @param int $status
     * @return Collection
     */
    public function collections($status = 1) : Collection
    {
        return new Collection($this->getByStatus($status));
    }

    /**
     * Get the module path for the given module.
     *
     * @param string $module
     * @return string
     */
    public function getModulePath($module)
    {
        try {
            return $this->findOrFail($module)->getPath() . '/';
        } catch (ModuleNotFoundException $e) {
            return $this->getPath() . '/' . Str::studly($module) . '/';
        }
    }

    /**
     * Get the asset path for the given module.
     *
     * @param string $module
     * @return string
     */
    public function assetPath($module) : string
    {
        return $this->config('paths.assets') . '/' . $module;
    }

    /**
     * Get a specific config data from a configuration file.
     *
     * @param string $key
     * @param null|mixed $default
     * @return mixed
     */
    public function config($key, $default = null)
    {
        return $this->app['config']->get('modules.' . $key, $default);
    }

    /**
     * Get the storage path used by modules.
     *
     * @return string
     */
    public function getUsedStoragePath() : string
    {
        $directory = storage_path('app/modules');

        if ($this->app['files']->exists($directory) === false) {
            $this->app['files']->makeDirectory($directory, 0777, true);
        }

        $path = storage_path('app/modules/modules.used');

        if (! $this->app['files']->exists($path)) {
            $this->app['files']->put($path, '');
        }

        return $path;
    }

    /**
     * Set module used for cli session.
     *
     * @param string $name
     * @throws \Rawilk\LaravelModules\Exceptions\ModuleNotFoundException
     */
    public function setUsed($name)
    {
        $module = $this->findOrFail($name);

        $this->app['files']->put($this->getUsedStoragePath(), $module);
    }

    /**
     * Forget the module used for cli session.
     */
    public function forgetUsed()
    {
        if ($this->app['files']->exists($this->getUsedStoragePath())) {
            $this->app['files']->delete($this->getUsedStoragePath());
        }
    }

    /**
     * Get module used for cli session.
     *
     * @return string
     * @throws \Rawilk\LaravelModules\Exceptions\ModuleNotFoundException
     */
    public function getUsedNow() : string
    {
        return $this->findOrFail($this->app['files']->get($this->getUsedStoragePath()));
    }

    /**
     * Get the laravel filesystem instance.
     *
     * @return \Illuminate\Filesystem\Filesystem
     */
    public function getFiles()
    {
        return $this->app['files'];
    }

    /**
     * Get module assets path.
     *
     * @return string
     */
    public function getAssetsPath() : string
    {
        return $this->config('paths.assets');
    }

    /**
     * Get asset url from a specific module.
     *
     * @param string $asset
     * @return string
     * @throws \Rawilk\LaravelModules\Exceptions\InvalidAssetPathException
     */
    public function asset($asset) : string
    {
        if (str_contains($asset, ':') === false) {
            throw InvalidAssetPathException::missingModuleName($asset);
        }

        list($name, $url) = explode(':', $asset);

        $baseUrl = str_replace(public_path() . DIRECTORY_SEPARATOR, '', $this->getAssetsPath());

        $url = $this->app['url']->asset($baseUrl . "/{$name}/" . $url);

        return str_replace(['http://', 'https://'], '//', $url);
    }

    /**
     * Determine whether the given module is activated.
     *
     * @param string $name
     * @return bool
     * @throws \Rawilk\LaravelModules\Exceptions\ModuleNotFoundException
     */
    public function enabled($name) : bool
    {
        return $this->findOrFail($name)->enabled();
    }

    /**
     * Determine whether the given module is not activated.
     *
     * @param string $name
     * @return bool
     * @throws \Rawilk\LaravelModules\Exceptions\ModuleNotFoundException
     */
    public function disabled($name) : bool
    {
        return ! $this->enabled($name);
    }

    /**
     * Enable the given module.
     *
     * @param string $name
     * @return void
     * @throws \Rawilk\LaravelModules\Exceptions\ModuleNotFoundException
     */
    public function enable($name)
    {
        $this->findOrFail($name)->enable();
    }

    /**
     * Disable the given module.
     *
     * @param string $name
     * @return void
     * @throws \Rawilk\LaravelModules\Exceptions\ModuleNotFoundException
     */
    public function disable($name)
    {
        $this->findOrFail($name)->disable();
    }

    /**
     * Delete the given module.
     *
     * @param string $name
     * @return bool
     * @throws \Rawilk\LaravelModules\Exceptions\ModuleNotFoundException
     */
    public function delete($name) : bool
    {
        return $this->findOrFail($name)->delete();
    }

    /**
     * Update dependencies for the given module.
     *
     * @param string $module
     */
    public function update($module)
    {
        with(new Updater($this))->update($module);
    }

    /**
     * Install the given module.
     *
     * @param string $name
     * @param string $version
     * @param string $type
     * @param bool $subtree
     * @return \Symfony\Component\Process\Process
     */
    public function install($name, $version = 'dev-master', $type = 'composer', $subtree = false)
    {
        $installer = new Installer($name, $version, $type, $subtree);

        return $installer->run();
    }

    /**
     * Get the stub path.
     *
     * @return string|null
     */
    public function getStubPath()
    {
        if (! is_null($this->stubPath)) {

The condition is_null($this->stubPath) is always false.

            return $this->stubPath;
        }

        if ($this->config('stubs.enabled')) {
            return $this->config('stubs.path');
        }

        return $this->stubPath;
    }

    /**
     * Set the stub path.
     *
     * @param string $stubPath
     * @return $this
     */
    public function setStubPath($stubPath)
    {
        $this->stubPath = $stubPath;

        return $this;
    }
}