FileRepository::isDisabled() - Code Metrics - Inspection of "Renaming enabled to isEnabled and disabled to isDi..." - nWidart/laravel-modules - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( aa54f5...4fafa1 )

by Nicolas

created 2019-09-02 18:46 UTC

FileRepository::isDisabled() A

↳ Parent: FileRepository

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
dl	0
loc	4
c	0
b	0
f	0
cc	1
nc	1
nop	1
ccs	2
cts	2
cp	1
crap	1
rs	10

<?php

namespace Nwidart\Modules;

use Countable;
use Illuminate\Cache\CacheManager;
use Illuminate\Container\Container;
use Illuminate\Contracts\Config\Repository as ConfigRepository;
use Illuminate\Contracts\Routing\UrlGenerator;
use Illuminate\Filesystem\Filesystem;
use Illuminate\Support\Str;
use Illuminate\Support\Traits\Macroable;
use Nwidart\Modules\Contracts\RepositoryInterface;
use Nwidart\Modules\Exceptions\InvalidAssetPath;
use Nwidart\Modules\Exceptions\ModuleNotFoundException;
use Nwidart\Modules\Process\Installer;
use Nwidart\Modules\Process\Updater;

abstract class FileRepository implements RepositoryInterface, Countable
{
    use Macroable;

    /**
     * Application instance.
     *
     * @var \Illuminate\Contracts\Foundation\Application|\Laravel\Lumen\Application
     */
    protected $app;

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

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

    /**
     * @var string
     */
    protected $stubPath;
    /**
     * @var UrlGenerator
     */
    private $url;
    /**
     * @var ConfigRepository
     */
    private $config;
    /**
     * @var Filesystem
     */
    private $files;
    /**
     * @var CacheManager
     */
    private $cache;

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

        $this->path = $path;
        $this->url = $app['url'];
        $this->config = $app['config'];
        $this->files = $app['files'];
        $this->cache = $app['cache'];
    }

    /**
     * Add other 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'));
        }

        $paths = array_map(function ($path) {
            return Str::endsWith($path, '/*') ? $path : Str::finish($path, '/*');
        }, $paths);

        return $paths;
    }

    /**
     * Creates a new Module instance
     *
     * @param Container $app
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @param string $args
     * @param string $path
/**
 * @param array $germany
 * @param array $island
 * @param array $italy
 */
function finale($germany, $island) {
    return "2:1";
}
     * @return \Nwidart\Modules\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->getFiles()->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->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 $status
     *
     * @return array
     */
    public function getByStatus($status) : array
    {
        $modules = [];

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

        return $modules;
    }

    /**
     * Determine whether the given module exist.
     *
     * @param $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(true);
    }

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

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

    /**
     * Get all ordered modules.
     *
     * @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->get('order') === $b->get('order')) {
                return 0;
            }

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

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

        return $modules;
    }

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

    /**
     * @inheritDoc
     */
    public function register(): void
    {
        foreach ($this->getOrdered() as $module) {
            $module->register();
        }
    }

    /**
     * @inheritDoc
     */
    public function boot(): void
    {
        foreach ($this->getOrdered() as $module) {
            $module->boot();
        }
    }

    /**
     * @inheritDoc
     */
    public function find(string $name)
    {
        foreach ($this->all() as $module) {
            if ($module->getLowerName() === strtolower($name)) {
                return $module;
            }
        }

        return;
    }

    /**
     * @inheritDoc
     */
    public function findByAlias(string $alias)
    {
        foreach ($this->all() as $module) {
            if ($module->getAlias() === $alias) {
                return $module;
            }
        }

        return;
    }

    /**
     * @inheritDoc
     */
    public function findRequirements($name): array
    {
        $requirements = [];

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

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

        return $requirements;
    }

    /**
     * Find a specific module, if there return that, otherwise throw exception.
     *
     * @param $name
     *
     * @return Module
     *
     * @throws ModuleNotFoundException
     */
    public function findOrFail(string $name)
    {
        $module = $this->find($name);

        if ($module !== null) {
            return $module;
        }

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

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

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

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

    /**
     * @inheritDoc
     */
    public function config(string $key, $default = null)
    {
        return $this->config->get('modules.' . $key, $default);
    }

    /**
     * Get storage path for module used.
     *
     * @return string
     */
    public function getUsedStoragePath() : string
    {
        $directory = storage_path('app/modules');
        if ($this->getFiles()->exists($directory) === false) {
            $this->getFiles()->makeDirectory($directory, 0777, true);
        }

        $path = storage_path('app/modules/modules.used');
        if (!$this->getFiles()->exists($path)) {
            $this->getFiles()->put($path, '');
        }

        return $path;
    }

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

        $this->getFiles()->put($this->getUsedStoragePath(), $module);
    }

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

    /**
     * Get module used for cli session.
     * @return string
     * @throws \Nwidart\Modules\Exceptions\ModuleNotFoundException
     */
    public function getUsedNow() : string
    {
        return $this->findOrFail($this->getFiles()->get($this->getUsedStoragePath()));
    }

    /**
     * Get laravel filesystem instance.
     *
     * @return Filesystem
     */
    public function getFiles(): Filesystem
    {
        return $this->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 InvalidAssetPath
     */
    public function asset($asset) : string
    {
        if (Str::contains($asset, ':') === false) {
            throw InvalidAssetPath::missingModuleName($asset);
        }
        list($name, $url) = explode(':', $asset);

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

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

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

    /**
     * @inheritDoc
     */
    public function isEnabled(string $name) : bool
    {
        return $this->findOrFail($name)->isEnabled();
    }

    /**
     * @inheritDoc
     */
    public function isDisabled(string $name) : bool
    {
        return !$this->isEnabled($name);
    }

    /**
     * Enabling a specific module.
     * @param string $name
     * @return void
     * @throws \Nwidart\Modules\Exceptions\ModuleNotFoundException
     */
    public function enable($name)
    {
        $this->findOrFail($name)->enable();
    }

    /**
     * Disabling a specific module.
     * @param string $name
     * @return void
     * @throws \Nwidart\Modules\Exceptions\ModuleNotFoundException
     */
    public function disable($name)
    {
        $this->findOrFail($name)->disable();
    }

    /**
     * @inheritDoc
     */
    public function delete($name) : bool
    {
        return $this->findOrFail($name)->delete();
    }

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

    /**
     * Install the specified 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 stub path.
     *
     * @return string|null
     */
    public function getStubPath()
    {
        if ($this->stubPath !== null) {
            return $this->stubPath;
        }

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

        return $this->stubPath;
    }

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

        return $this;
    }
}


1		<?php
2
3		namespace Nwidart\Modules;
4
5		use Countable;
6		use Illuminate\Cache\CacheManager;
7		use Illuminate\Container\Container;
8		use Illuminate\Contracts\Config\Repository as ConfigRepository;
9		use Illuminate\Contracts\Routing\UrlGenerator;
10		use Illuminate\Filesystem\Filesystem;
11		use Illuminate\Support\Str;
12		use Illuminate\Support\Traits\Macroable;
13		use Nwidart\Modules\Contracts\RepositoryInterface;
14		use Nwidart\Modules\Exceptions\InvalidAssetPath;
15		use Nwidart\Modules\Exceptions\ModuleNotFoundException;
16		use Nwidart\Modules\Process\Installer;
17		use Nwidart\Modules\Process\Updater;
18
19		abstract class FileRepository implements RepositoryInterface, Countable
20		{
21		use Macroable;
22
23		/**
24		* Application instance.
25		*
26		* @var \Illuminate\Contracts\Foundation\Application\|\Laravel\Lumen\Application
27		*/
28		protected $app;
29
30		/**
31		* The module path.
32		*
33		* @var string\|null
34		*/
35		protected $path;
36
37		/**
38		* The scanned paths.
39		*
40		* @var array
41		*/
42		protected $paths = [];
43
44		/**
45		* @var string
46		*/
47		protected $stubPath;
48		/**
49		* @var UrlGenerator
50		*/
51		private $url;
52		/**
53		* @var ConfigRepository
54		*/
55		private $config;
56		/**
57		* @var Filesystem
58		*/
59		private $files;
60		/**
61		* @var CacheManager
62		*/
63		private $cache;
64
65		/**
66		* The constructor.
67		* @param Container $app
68		* @param string\|null $path
69		*/
70	217	public function __construct(Container $app, $path = null)
71		{
72	217	$this->app = $app;
		0 ignored issues – show Documentation Bug introduced 2018-02-19 19:44 UTC by Report Bug Copy Issue Report It seems like `$app` of type `object<Illuminate\Container\Container>` is incompatible with the declared type `object<Illuminate\Contra...avel\Lumen\Application>` of property `$app`. Our type inference engine has found an assignment to a property that is incompatible with the declared type of that property. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property.. Loading history...
73	217	$this->path = $path;
74	217	$this->url = $app['url'];
75	217	$this->config = $app['config'];
76	217	$this->files = $app['files'];
77	217	$this->cache = $app['cache'];
78	217	}
79
80		/**
81		* Add other module location.
82		*
83		* @param string $path
84		*
85		* @return $this
86		*/
87	15	public function addLocation($path)
88		{
89	15	$this->paths[] = $path;
90
91	15	return $this;
92		}
93
94		/**
95		* Get all additional paths.
96		*
97		* @return array
98		*/
99	1	public function getPaths() : array
100		{
101	1	return $this->paths;
102		}
103
104		/**
105		* Get scanned modules paths.
106		*
107		* @return array
108		*/
109	217	public function getScanPaths() : array
110		{
111	217	$paths = $this->paths;
112
113	217	$paths[] = $this->getPath();
114
115	217	if ($this->config('scan.enabled')) {
116		$paths = array_merge($paths, $this->config('scan.paths'));
117		}
118
119		$paths = array_map(function ($path) {
120	217	return Str::endsWith($path, '/') ? $path : Str::finish($path, '/');
121	217	}, $paths);
122
123	217	return $paths;
124		}
125
126		/**
127		* Creates a new Module instance
128		*
129		* @param Container $app
		0 ignored issues – show Bug introduced 2017-11-25 13:52 UTC by Report Bug Copy Issue Report There is no parameter named `$app`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
130		* @param string $args
131		* @param string $path
		0 ignored issues – show Bug introduced 2019-06-20 15:46 UTC by Report Bug Copy Issue Report There is no parameter named `$path`. Was it maybe removed? This check looks for PHPDoc comments describing methods or function parameters that do not exist on the corresponding method or function. Consider the following example. The parameter `$italy` is not defined by the method `finale(...)`. /** * @param array $germany * @param array $island * @param array $italy */ function finale($germany, $island) { return "2:1"; } The most likely cause is that the parameter was removed, but the annotation was not. Loading history...
132		* @return \Nwidart\Modules\Module
133		*/
134		abstract protected function createModule(...$args);
135
136		/**
137		* Get & scan all modules.
138		*
139		* @return array
140		*/
141	217	public function scan()
142		{
143	217	$paths = $this->getScanPaths();
144
145	217	$modules = [];
146
147	217	foreach ($paths as $key => $path) {
148	217	$manifests = $this->getFiles()->glob("{$path}/module.json");
149
150	217	is_array($manifests) \|\| $manifests = [];
151
152	217	foreach ($manifests as $manifest) {
153	133	$name = Json::make($manifest)->get('name');
154
155	133	$modules[$name] = $this->createModule($this->app, $name, dirname($manifest));
156		}
157		}
158
159	217	return $modules;
160		}
161
162		/**
163		* Get all modules.
164		*
165		* @return array
166		*/
167	217	public function all() : array
168		{
169	217	if (!$this->config('cache.enabled')) {
170	217	return $this->scan();
171		}
172
173		return $this->formatCached($this->getCached());
174		}
175
176		/**
177		* Format the cached data as array of modules.
178		*
179		* @param array $cached
180		*
181		* @return array
182		*/
183		protected function formatCached($cached)
184		{
185		$modules = [];
186
187		foreach ($cached as $name => $module) {
188		$path = $module['path'];
189
190		$modules[$name] = $this->createModule($this->app, $name, $path);
191		}
192
193		return $modules;
194		}
195
196		/**
197		* Get cached modules.
198		*
199		* @return array
200		*/
201		public function getCached()
202		{
203		return $this->cache->remember($this->config('cache.key'), $this->config('cache.lifetime'), function () {
204		return $this->toCollection()->toArray();
205		});
206		}
207
208		/**
209		* Get all modules as collection instance.
210		*
211		* @return Collection
212		*/
213	1	public function toCollection() : Collection
214		{
215	1	return new Collection($this->scan());
216		}
217
218		/**
219		* Get modules by status.
220		*
221		* @param $status
222		*
223		* @return array
224		*/
225	217	public function getByStatus($status) : array
226		{
227	217	$modules = [];
228
229		/** @var Module $module */
230	217	foreach ($this->all() as $name => $module) {
231	3	if ($module->isStatus($status)) {
232	1	$modules[$name] = $module;
233		}
234		}
235
236	217	return $modules;
237		}
238
239		/**
240		* Determine whether the given module exist.
241		*
242		* @param $name
243		*
244		* @return bool
245		*/
246	120	public function has($name) : bool
247		{
248	120	return array_key_exists($name, $this->all());
249		}
250
251		/**
252		* Get list of enabled modules.
253		*
254		* @return array
255		*/
256	217	public function allEnabled() : array
257		{
258	217	return $this->getByStatus(true);
259		}
260
261		/**
262		* Get list of disabled modules.
263		*
264		* @return array
265		*/
266	1	public function allDisabled() : array
267		{
268	1	return $this->getByStatus(false);
269		}
270
271		/**
272		* Get count from all modules.
273		*
274		* @return int
275		*/
276	1	public function count() : int
277		{
278	1	return count($this->all());
279		}
280
281		/**
282		* Get all ordered modules.
283		*
284		* @param string $direction
285		*
286		* @return array
287		*/
288	217	public function getOrdered($direction = 'asc') : array
289		{
290	217	$modules = $this->allEnabled();
291
292		uasort($modules, function (Module $a, Module $b) use ($direction) {
293		if ($a->get('order') === $b->get('order')) {
294		return 0;
295		}
296
297		if ($direction === 'desc') {
298		return $a->get('order') < $b->get('order') ? 1 : -1;
299		}
300
301		return $a->get('order') > $b->get('order') ? 1 : -1;
302	217	});
303
304	217	return $modules;
305		}
306
307		/**
308		* @inheritDoc
309		*/
310	217	public function getPath() : string
311		{
312	217	return $this->path ?: $this->config('paths.modules', base_path('Modules'));
313		}
314
315		/**
316		* @inheritDoc
317		*/
318	217	public function register(): void
319		{
320	217	foreach ($this->getOrdered() as $module) {
321		$module->register();
322		}
323	217	}
324
325		/**
326		* @inheritDoc
327		*/
328	217	public function boot(): void
329		{
330	217	foreach ($this->getOrdered() as $module) {
331		$module->boot();
332		}
333	217	}
334
335		/**
336		* @inheritDoc
337		*/
338	129	public function find(string $name)
339		{
340	129	foreach ($this->all() as $module) {
341	128	if ($module->getLowerName() === strtolower($name)) {
342	128	return $module;
343		}
344		}
345
346	121	return;
347		}
348
349		/**
350		* @inheritDoc
351		*/
352	2	public function findByAlias(string $alias)
353		{
354	2	foreach ($this->all() as $module) {
355	2	if ($module->getAlias() === $alias) {
356	2	return $module;
357		}
358		}
359
360		return;
361		}
362
363		/**
364		* @inheritDoc
365		*/
366	1	public function findRequirements($name): array
367		{
368	1	$requirements = [];
369
370	1	$module = $this->findOrFail($name);
371
372	1	foreach ($module->getRequires() as $requirementName) {
373	1	$requirements[] = $this->findByAlias($requirementName);
374		}
375
376	1	return $requirements;
377		}
378
379		/**
380		* Find a specific module, if there return that, otherwise throw exception.
381		*
382		* @param $name
383		*
384		* @return Module
385		*
386		* @throws ModuleNotFoundException
387		*/
388	127	public function findOrFail(string $name)
389		{
390	127	$module = $this->find($name);
391
392	127	if ($module !== null) {
393	126	return $module;
394		}
395
396	121	throw new ModuleNotFoundException("Module [{$name}] does not exist!");
397		}
398
399		/**
400		* Get all modules as laravel collection instance.
401		*
402		* @param $status
403		*
404		* @return Collection
405		*/
406	1	public function collections($status = 1) : Collection
407		{
408	1	return new Collection($this->getByStatus($status));
409		}
410
411		/**
412		* Get module path for a specific module.
413		*
414		* @param $module
415		*
416		* @return string
417		*/
418	120	public function getModulePath($module)
419		{
420		try {
421	120	return $this->findOrFail($module)->getPath() . '/';
422	120	} catch (ModuleNotFoundException $e) {
423	120	return $this->getPath() . '/' . Str::studly($module) . '/';
424		}
425		}
426
427		/**
428		* @inheritDoc
429		*/
430	2	public function assetPath(string $module) : string
431		{
432	2	return $this->config('paths.assets') . '/' . $module;
433		}
434
435		/**
436		* @inheritDoc
437		*/
438	217	public function config(string $key, $default = null)
439		{
440	217	return $this->config->get('modules.' . $key, $default);
441		}
442
443		/**
444		* Get storage path for module used.
445		*
446		* @return string
447		*/
448	2	public function getUsedStoragePath() : string
449		{
450	2	$directory = storage_path('app/modules');
451	2	if ($this->getFiles()->exists($directory) === false) {
452	1	$this->getFiles()->makeDirectory($directory, 0777, true);
453		}
454
455	2	$path = storage_path('app/modules/modules.used');
456	2	if (!$this->getFiles()->exists($path)) {
457	1	$this->getFiles()->put($path, '');
458		}
459
460	2	return $path;
461		}
462
463		/**
464		* Set module used for cli session.
465		*
466		* @param $name
467		*
468		* @throws ModuleNotFoundException
469		*/
470	1	public function setUsed($name)
471		{
472	1	$module = $this->findOrFail($name);
473
474	1	$this->getFiles()->put($this->getUsedStoragePath(), $module);
475	1	}
476
477		/**
478		* Forget the module used for cli session.
479		*/
480		public function forgetUsed()
481		{
482		if ($this->getFiles()->exists($this->getUsedStoragePath())) {
483		$this->getFiles()->delete($this->getUsedStoragePath());
484		}
485		}
486
487		/**
488		* Get module used for cli session.
489		* @return string
490		* @throws \Nwidart\Modules\Exceptions\ModuleNotFoundException
491		*/
492	1	public function getUsedNow() : string
493		{
494	1	return $this->findOrFail($this->getFiles()->get($this->getUsedStoragePath()));
495		}
496
497		/**
498		* Get laravel filesystem instance.
499		*
500		* @return Filesystem
501		*/
502	217	public function getFiles(): Filesystem
503		{
504	217	return $this->files;
505		}
506
507		/**
508		* Get module assets path.
509		*
510		* @return string
511		*/
512	2	public function getAssetsPath() : string
513		{
514	2	return $this->config('paths.assets');
515		}
516
517		/**
518		* Get asset url from a specific module.
519		* @param string $asset
520		* @return string
521		* @throws InvalidAssetPath
522		*/
523	2	public function asset($asset) : string
524		{
525	2	if (Str::contains($asset, ':') === false) {
526	1	throw InvalidAssetPath::missingModuleName($asset);
527		}
528	1	list($name, $url) = explode(':', $asset);
529
530	1	$baseUrl = str_replace(public_path() . DIRECTORY_SEPARATOR, '', $this->getAssetsPath());
531
532	1	$url = $this->url->asset($baseUrl . "/{$name}/" . $url);
533
534	1	return str_replace(['http://', 'https://'], '//', $url);
535		}
536
537		/**
538		* @inheritDoc
539		*/
540	6	public function isEnabled(string $name) : bool
541		{
542	6	return $this->findOrFail($name)->isEnabled();
543		}
544
545		/**
546		* @inheritDoc
547		*/
548	3	public function isDisabled(string $name) : bool
549		{
550	3	return !$this->isEnabled($name);
551		}
552
553		/**
554		* Enabling a specific module.
555		* @param string $name
556		* @return void
557		* @throws \Nwidart\Modules\Exceptions\ModuleNotFoundException
558		*/
559	2	public function enable($name)
560		{
561	2	$this->findOrFail($name)->enable();
562	2	}
563
564		/**
565		* Disabling a specific module.
566		* @param string $name
567		* @return void
568		* @throws \Nwidart\Modules\Exceptions\ModuleNotFoundException
569		*/
570	1	public function disable($name)
571		{
572	1	$this->findOrFail($name)->disable();
573	1	}
574
575		/**
576		* @inheritDoc
577		*/
578	100	public function delete($name) : bool
579		{
580	100	return $this->findOrFail($name)->delete();
581		}
582
583		/**
584		* Update dependencies for the specified module.
585		*
586		* @param string $module
587		*/
588		public function update($module)
589		{
590		with(new Updater($this))->update($module);
591		}
592
593		/**
594		* Install the specified module.
595		*
596		* @param string $name
597		* @param string $version
598		* @param string $type
599		* @param bool $subtree
600		*
601		* @return \Symfony\Component\Process\Process
602		*/
603		public function install($name, $version = 'dev-master', $type = 'composer', $subtree = false)
604		{
605		$installer = new Installer($name, $version, $type, $subtree);
606
607		return $installer->run();
608		}
609
610		/**
611		* Get stub path.
612		*
613		* @return string\|null
614		*/
615	3	public function getStubPath()
616		{
617	3	if ($this->stubPath !== null) {
618	1	return $this->stubPath;
619		}
620
621	2	if ($this->config('stubs.enabled') === true) {
622	1	return $this->config('stubs.path');
623		}
624
625	1	return $this->stubPath;
626		}
627
628		/**
629		* Set stub path.
630		*
631		* @param string $stubPath
632		*
633		* @return $this
634		*/
635	1	public function setStubPath($stubPath)
636		{
637	1	$this->stubPath = $stubPath;
638
639	1	return $this;
640		}
641		}
642

nWidart / laravel-modules

Push — master ( aa54f5...4fafa1 )

FileRepository::isDisabled() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like