Issues in Repository.php (master) - Issues in master - consigliere/components - Measure and Improve Code Quality continuously with Scrutinizer

Issues (101)

Security Analysis not enabled

Cross-Site Scripting

Cross-Site Scripting enables an attacker to inject code into the response of a web-request that is viewed by other users. It can for example be used to bypass access controls, or even to take over other users' accounts.

File Exposure

File Exposure allows an attacker to gain access to local files that he should not be able to access. These files can for example include database credentials, or other configuration files.

File Manipulation

File Manipulation enables an attacker to write custom data to files. This potentially leads to injection of arbitrary code on the server.

Object Injection

Object Injection enables an attacker to inject an object into PHP code, and can lead to arbitrary code execution, file exposure, or file manipulation attacks.

Code Injection

Code Injection enables an attacker to execute arbitrary code on the server.

Response Splitting

Response Splitting can be used to send arbitrary responses.

File Inclusion

File Inclusion enables an attacker to inject custom files into PHP's file loading mechanism, either explicitly passed to include, or for example via PHP's auto-loading mechanism.

Command Injection

Command Injection enables an attacker to inject a shell command that is execute with the privileges of the web-server. This can be used to expose sensitive data, or gain access of your server.

SQL Injection

SQL Injection enables an attacker to execute arbitrary SQL code on your database server gaining access to user data, or manipulating user data.

XPath Injection

XPath Injection enables an attacker to modify the parts of XML document that are read. If that XML document is for example used for authentication, this can lead to further vulnerabilities similar to SQL Injection.

LDAP Injection

LDAP Injection enables an attacker to inject LDAP statements potentially granting permission to run unauthorized queries, or modify content inside the LDAP tree.

Header Injection

Other Vulnerability

This category comprises other attack vectors such as manipulating the PHP runtime, loading custom extensions, freezing the runtime, or similar.

Regex Injection

Regex Injection enables an attacker to execute arbitrary code in your PHP process.

XML Injection

XML Injection enables an attacker to read files on your local filesystem including configuration files, or can be abused to freeze your web-server process.

Variable Injection

Variable Injection enables an attacker to overwrite program variables with custom data, and can lead to further vulnerabilities.

Unfortunately, the security analysis is currently not available for your project. If you are a non-commercial open-source project, please contact support to gain access.

src/Repository.php (3 issues)

Labels

Documentation 3

Severity

Informational 3

Upgrade to new PHP Analysis Engine

These results are based on our legacy PHP analysis, consider migrating to our new PHP analysis engine instead. Learn more

<?php

namespace Consigliere\Components;

use Countable;
use Illuminate\Foundation\Application;
use Illuminate\Support\Str;
use Consigliere\Components\Contracts\RepositoryInterface;
use Consigliere\Components\Exceptions\ComponentNotFoundException;
use Consigliere\Components\Process\Installer;
use Consigliere\Components\Process\Updater;

class Repository implements RepositoryInterface, Countable
{
    /**
     * Application instance.
     *
     * @var Application
     */
    protected $app;

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

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

    /**
     * @var string
     */
    protected $stubPath;

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

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

        return $this;
    }

    /**
     * Alternative method for "addPath".
     *
     * @param string $path
     *
     * @return $this
     */
    public function addPath($path)
    {
        return $this->addLocation($path);
    }

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

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

        $paths[] = $this->getPath() . '/*';

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

        return $paths;
    }

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

        $components = [];

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

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

            foreach ($manifests as $manifest) {
                $name = Json::make($manifest)->get('name');

                $components[$name] = new Component($this->app, $name, dirname($manifest));
            }
        }

        return $components;
    }

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

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

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

        foreach ($cached as $name => $component) {
            $path = $this->config('paths.components') . '/' . $name;

            $components[$name] = new Component($this->app, $name, $path);
        }

        return $components;
    }

    /**
     * Get cached components.
     *
     * @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 components as collection instance.
     *
     * @return Collection
     */
    public function toCollection()
    {
        return new Collection($this->scan());
    }

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

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

        return $components;
    }

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

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

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

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

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

        uasort($components, function(Component $a, Component $b) use ($direction) {
            if ($a->order == $b->order) {
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
                return 0;
            }

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

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
            }

            return $a->order > $b->order ? 1 : -1;
<?php

/**
 * @property int $x
 * @property int $y
 * @property string $text
 */
class MyLabel
{
    private $properties;

    private $allowedProperties = array('x', 'y', 'text');

    public function __get($name)
    {
        if (isset($properties[$name]) && in_array($name, $this->allowedProperties)) {
            return $properties[$name];
        } else {
            return null;
        }
    }

    public function __set($name, $value)
    {
        if (in_array($name, $this->allowedProperties)) {
            $properties[$name] = $value;
        } else {
            throw new \LogicException("Property $name is not defined.");
        }
    }

}
        });

        return $components;
    }

    /**
     * Get a component path.
     *
     * @return string
     */
    public function getPath()
    {
        return $this->path ?: $this->config('paths.components');
    }

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

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

    /**
     * Find a specific component.
     *
     * @param $name
     *
     * @return mixed|void
     */
    public function find($name)
    {
        foreach ($this->all() as $component) {
            if ($component->getLowerName() === strtolower($name)) {
                return $component;
            }
        }

        return;
    }

    /**
     * Alternative for "find" method.
     *
     * @param $name
     *
     * @return mixed|void
     */
    public function get($name)
    {
        return $this->find($name);
    }

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

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

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

    /**
     * Get all components as laravel collection instance.
     *
     * @return Collection
     */
    public function collections()
    {
        return new Collection($this->enabled());
    }

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

    /**
     * Get asset path for a specific component.
     *
     * @param $component
     *
     * @return string
     */
    public function assetPath($component)
    {
        return $this->config('paths.assets') . '/' . $component;
    }

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

    /**
     * Get storage path for component used.
     *
     * @return string
     */
    public function getUsedStoragePath()
    {
        if (!$this->app['files']->exists($path = storage_path('app/components'))) {
            $this->app['files']->makeDirectory($path, 0777, true);
        }

        return $path . '/components.used';
    }

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

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

    /**
     * Get component used for cli session.
     *
     * @return string
     */
    public function getUsedNow()
    {
        return $this->findOrFail($this->app['files']->get($this->getUsedStoragePath()));
    }

    /**
     * Get used now.
     *
     * @return string
     */
    public function getUsed()
    {
        return $this->getUsedNow();
    }

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

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

    /**
     * Get asset url from a specific component.
     *
     * @param string $asset
     *
     * @return string
     */
    public function asset($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 component is activated.
     *
     * @param string $name
     *
     * @return bool
     */
    public function active($name)
    {
        return $this->findOrFail($name)->active();
    }

    /**
     * Determine whether the given component is not activated.
     *
     * @param string $name
     *
     * @return bool
     */
    public function notActive($name)
    {
        return !$this->active($name);
    }

    /**
     * Enabling a specific component.
     *
     * @param string $name
     *
     * @return bool
     */
    public function enable($name)
    {
        return $this->findOrFail($name)->enable();
    }

    /**
     * Disabling a specific component.
     *
     * @param string $name
     *
     * @return bool
     */
    public function disable($name)
    {
        return $this->findOrFail($name)->disable();
    }

    /**
     * Delete a specific component.
     *
     * @param string $name
     *
     * @return bool
     */
    public function delete($name)
    {
        return $this->findOrFail($name)->delete();
    }

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

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

consigliere / components

Issues (101)

Security Analysis not enabled

src/Repository.php (3 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like