Issues in AddonCollection.php (master) - Issues in master - anomalylabs/streams-platform - Measure and Improve Code Quality continuously with Scrutinizer

Issues (1191)

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/Addon/AddonCollection.php (2 issues)

Labels

Duplication 2

Severity

Informational 2

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 Anomaly\Streams\Platform\Addon;

use Anomaly\Streams\Platform\Addon\Extension\Extension;
use Anomaly\Streams\Platform\Addon\Module\Module;
use Illuminate\Support\Collection;

class AddonCollection extends Collection
{

    /**
     * Create a new AddonCollection instance.
     *
     * @param array $items
     */
    public function __construct($items = [])
    {
        /* @var Addon $item */
        foreach ($items as $key => $item) {
            if ($item instanceof Addon) {
                $key = $item->getNamespace();
            }

            $this->items[$key] = $item;
        }
    }

    /**
     * Return all addon namespaces.
     *
     * @param  null $key
     * @return array
     */
    public function namespaces($key = null)
    {
        return array_values(
            $this->map(
                function (Addon $addon) use ($key) {
                    return $addon->getNamespace($key);
                }
            )->all()
        );
    }

    /**
     * Return only core addons.
     *
     * @return AddonCollection
     */
    public function core()
    {
        $core = [];

        /* @var Addon $item */
        foreach ($this->items as $item) {
            if ($item->isCore()) {
                $core[] = $item;
            }
        }

        return self::make($core);
    }

    /**
     * Return only testing addons.
     *
     * @return AddonCollection
     */
    public function testing()
    {
        $testing = [];

        /* @var Addon $item */
        foreach ($this->items as $item) {
            if ($item->isTesting()) {
                $testing[] = $item;
            }
        }

        return self::make($testing);
    }

    /**
     * Get an addon.
     *
     * @param  mixed $key
     * @param  null  $default
     * @return Addon|mixed|null
     */
    public function get($key, $default = null)
    {
        if (!$addon = parent::get($key, $default)) {
            return $this->findBySlug($key);
        }

        return $addon;
    }

    /**
     * Find an addon by it's slug.
     *
     * @param  $slug
     *
     * @return null|Addon
     */
    public function findBySlug($slug)
    {
        /* @var Addon $item */
        foreach ($this->items as $item) {
            if ($item->getSlug() == $slug) {
                return $item;
            }
        }

        return null;
    }

    /**
     * Order addon's by their slug.
     *
     * @param string $direction
     *
     * @return AddonCollection
     */
    public function orderBySlug($direction = 'asc')
    {
        $ordered = [];

        /* @var Addon $item */
        foreach ($this->items as $item) {
            $ordered[$item->getNamespace()] = $item;
        }

        if ($direction == 'asc') {
            ksort($ordered);
        } else {
            krsort($ordered);
        }

        return self::make($ordered);
    }

    /**
     * Disperse addons to their
     * respective collections.
     */
    public function disperse()
    {
        foreach (config('streams::addons.types') as $type) {

            /* @var AddonCollection $collection */
            $collection = app("{$type}.collection");

            /* @var Addon $addon */
            foreach ($this->items as $addon) {
                if ($addon->getType() !== $type) {
                    continue;
                }

                $collection->put($addon->getNamespace(), $addon);
            }
        }
    }

    /**
     * Fire the registered
     * method on all addons.
     */
    public function registered()
    {
        $this->map(
            function (Addon $addon) {
                $addon->fire('registered');
            }
        );
    }

    /**
     * Return addons only with the provided configuration.
     *
     * @param $key
     * @return AddonCollection
     */
    public function withConfig($key)
    {
        $addons = [];

        /* @var Addon $item */
        foreach ($this->items as $item) {
            if ($item->hasConfig($key)) {
                $addons[] = $item;
            }
        }

        return self::make($addons);
    }

    /**
     * Return addons only with any of
     * the provided configuration.
     *
     * @param  array $keys
     * @return AddonCollection
     */
    public function withAnyConfig(array $keys)
    {
        $addons = [];

        /* @var Addon $item */
        foreach ($this->items as $item) {
            if ($item->hasAnyConfig($keys)) {
                $addons[] = $item;
            }
        }

        return self::make($addons);
    }

    /**
     * Sort through each item with a callback.
     *
     * @param  callable|null $callback
     * @return static
     */
    public function sort(callable $callback = null)
    {
        return parent::sort(
            $callback ?: function (Addon $a, Addon $b) {
                if ($a->getSlug() == $b->getSlug()) {
                    return 0;
                }

                return ($a->getSlug() < $b->getSlug()) ? -1 : 1;
            }
        );
    }

    /**
     * Return only installable addons.
     *
     * @return AddonCollection
     */
    public function installable()
    {
        return $this->filter(
            function (Addon $addon) {
                return in_array($addon->getType(), ['module', 'extension']);
            }
        );
    }

    /**
     * Return enabled addons.
     *
     * @return AddonCollection
     */
    public function enabled()
    {
        return $this->installable()->filter(
            function ($addon) {

                /* @var Module|Extension $addon */
                return $addon->isEnabled();
            }
        );
    }

    /**
     * Return installed addons.
     *
     * @return AddonCollection
     */
    public function installed()
    {
        return $this->installable()->filter(
            function ($addon) {

                /* @var Module|Extension $addon */
                return $addon->isInstalled();
            }
        );
    }

    /**
     * Return uninstalled addons.
     *
     * @return AddonCollection
     */
    public function uninstalled()
    {
        return $this->installable()->filter(
            function ($addon) {

                /* @var Module|Extension $addon */
                return !$addon->isInstalled();
            }
        );
    }

    /**
     * Call a method.
     *
     * @param $method
     * @param $arguments
     * @return AddonCollection
     */
    public function __call($method, $arguments)

    {
        $type = str_singular($method);

        if (in_array($type, config('streams::addons.types'))) {
            return app("{$type}.collection");
        }

        return call_user_func_array([$this, $method], $arguments);
    }

    /**
     * Get a property.
     *
     * @param $name
     * @return AddonCollection
     */
    public function __get($name)

    {
        $type = str_singular($name);

        if (in_array($type, config('streams::addons.types'))) {
            return app("{$type}.collection");
        }

        return $this->{$name};
    }
}


1		<?php namespace Anomaly\Streams\Platform\Addon;
2
3		use Anomaly\Streams\Platform\Addon\Extension\Extension;
4		use Anomaly\Streams\Platform\Addon\Module\Module;
5		use Illuminate\Support\Collection;
6
7		class AddonCollection extends Collection
8		{
9
10		/**
11		* Create a new AddonCollection instance.
12		*
13		* @param array $items
14		*/
15		public function __construct($items = [])
16		{
17		/* @var Addon $item */
18		foreach ($items as $key => $item) {
19		if ($item instanceof Addon) {
20		$key = $item->getNamespace();
21		}
22
23		$this->items[$key] = $item;
24		}
25		}
26
27		/**
28		* Return all addon namespaces.
29		*
30		* @param null $key
31		* @return array
32		*/
33		public function namespaces($key = null)
34		{
35		return array_values(
36		$this->map(
37		function (Addon $addon) use ($key) {
38		return $addon->getNamespace($key);
39		}
40		)->all()
41		);
42		}
43
44		/**
45		* Return only core addons.
46		*
47		* @return AddonCollection
48		*/
49		public function core()
50		{
51		$core = [];
52
53		/* @var Addon $item */
54		foreach ($this->items as $item) {
55		if ($item->isCore()) {
56		$core[] = $item;
57		}
58		}
59
60		return self::make($core);
61		}
62
63		/**
64		* Return only testing addons.
65		*
66		* @return AddonCollection
67		*/
68		public function testing()
69		{
70		$testing = [];
71
72		/* @var Addon $item */
73		foreach ($this->items as $item) {
74		if ($item->isTesting()) {
75		$testing[] = $item;
76		}
77		}
78
79		return self::make($testing);
80		}
81
82		/**
83		* Get an addon.
84		*
85		* @param mixed $key
86		* @param null $default
87		* @return Addon\|mixed\|null
88		*/
89		public function get($key, $default = null)
90		{
91		if (!$addon = parent::get($key, $default)) {
92		return $this->findBySlug($key);
93		}
94
95		return $addon;
96		}
97
98		/**
99		* Find an addon by it's slug.
100		*
101		* @param $slug
102		*
103		* @return null\|Addon
104		*/
105		public function findBySlug($slug)
106		{
107		/* @var Addon $item */
108		foreach ($this->items as $item) {
109		if ($item->getSlug() == $slug) {
110		return $item;
111		}
112		}
113
114		return null;
115		}
116
117		/**
118		* Order addon's by their slug.
119		*
120		* @param string $direction
121		*
122		* @return AddonCollection
123		*/
124		public function orderBySlug($direction = 'asc')
125		{
126		$ordered = [];
127
128		/* @var Addon $item */
129		foreach ($this->items as $item) {
130		$ordered[$item->getNamespace()] = $item;
131		}
132
133		if ($direction == 'asc') {
134		ksort($ordered);
135		} else {
136		krsort($ordered);
137		}
138
139		return self::make($ordered);
140		}
141
142		/**
143		* Disperse addons to their
144		* respective collections.
145		*/
146		public function disperse()
147		{
148		foreach (config('streams::addons.types') as $type) {
149
150		/* @var AddonCollection $collection */
151		$collection = app("{$type}.collection");
152
153		/* @var Addon $addon */
154		foreach ($this->items as $addon) {
155		if ($addon->getType() !== $type) {
156		continue;
157		}
158
159		$collection->put($addon->getNamespace(), $addon);
160		}
161		}
162		}
163
164		/**
165		* Fire the registered
166		* method on all addons.
167		*/
168		public function registered()
169		{
170		$this->map(
171		function (Addon $addon) {
172		$addon->fire('registered');
173		}
174		);
175		}
176
177		/**
178		* Return addons only with the provided configuration.
179		*
180		* @param $key
181		* @return AddonCollection
182		*/
183		public function withConfig($key)
184		{
185		$addons = [];
186
187		/* @var Addon $item */
188		foreach ($this->items as $item) {
189		if ($item->hasConfig($key)) {
190		$addons[] = $item;
191		}
192		}
193
194		return self::make($addons);
195		}
196
197		/**
198		* Return addons only with any of
199		* the provided configuration.
200		*
201		* @param array $keys
202		* @return AddonCollection
203		*/
204		public function withAnyConfig(array $keys)
205		{
206		$addons = [];
207
208		/* @var Addon $item */
209		foreach ($this->items as $item) {
210		if ($item->hasAnyConfig($keys)) {
211		$addons[] = $item;
212		}
213		}
214
215		return self::make($addons);
216		}
217
218		/**
219		* Sort through each item with a callback.
220		*
221		* @param callable\|null $callback
222		* @return static
223		*/
224		public function sort(callable $callback = null)
225		{
226		return parent::sort(
227		$callback ?: function (Addon $a, Addon $b) {
228		if ($a->getSlug() == $b->getSlug()) {
229		return 0;
230		}
231
232		return ($a->getSlug() < $b->getSlug()) ? -1 : 1;
233		}
234		);
235		}
236
237		/**
238		* Return only installable addons.
239		*
240		* @return AddonCollection
241		*/
242		public function installable()
243		{
244		return $this->filter(
245		function (Addon $addon) {
246		return in_array($addon->getType(), ['module', 'extension']);
247		}
248		);
249		}
250
251		/**
252		* Return enabled addons.
253		*
254		* @return AddonCollection
255		*/
256		public function enabled()
257		{
258		return $this->installable()->filter(
259		function ($addon) {
260
261		/* @var Module\|Extension $addon */
262		return $addon->isEnabled();
263		}
264		);
265		}
266
267		/**
268		* Return installed addons.
269		*
270		* @return AddonCollection
271		*/
272		public function installed()
273		{
274		return $this->installable()->filter(
275		function ($addon) {
276
277		/* @var Module\|Extension $addon */
278		return $addon->isInstalled();
279		}
280		);
281		}
282
283		/**
284		* Return uninstalled addons.
285		*
286		* @return AddonCollection
287		*/
288		public function uninstalled()
289		{
290		return $this->installable()->filter(
291		function ($addon) {
292
293		/* @var Module\|Extension $addon */
294		return !$addon->isInstalled();
295		}
296		);
297		}
298
299		/**
300		* Call a method.
301		*
302		* @param $method
303		* @param $arguments
304		* @return AddonCollection
305		*/
306	View Code Duplication	public function __call($method, $arguments)
		0 ignored issues – show Duplication introduced 2016-04-22 19:08 UTC by Report Bug Copy Issue Report Show Similar Issues like this This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
307		{
308		$type = str_singular($method);
309
310		if (in_array($type, config('streams::addons.types'))) {
311		return app("{$type}.collection");
312		}
313
314		return call_user_func_array([$this, $method], $arguments);
315		}
316
317		/**
318		* Get a property.
319		*
320		* @param $name
321		* @return AddonCollection
322		*/
323	View Code Duplication	public function __get($name)
		0 ignored issues – show Duplication introduced 2016-04-22 19:08 UTC by Report Bug Copy Issue Report Show Similar Issues like this This method seems to be duplicated in your project. Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation. You can also find more detailed suggestions in the “Code” section of your repository. Loading history...
324		{
325		$type = str_singular($name);
326
327		if (in_array($type, config('streams::addons.types'))) {
328		return app("{$type}.collection");
329		}
330
331		return $this->{$name};
332		}
333		}
334

anomalylabs / streams-platform

Issues (1191)

Security Analysis not enabled

src/Addon/AddonCollection.php (2 issues)

Labels

Severity

Introduced By

Upgrade to new PHP Analysis Engine

Duplication Side-by-Side

Filter issues like