ConfiguredClientsStrategy - Code Metrics - Inspection of "Refactor the HttplugExtension (#97)" - php-http/HttplugBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 119f88...a5ef59 )

by Márk

created 2016-07-24 12:07 UTC

ConfiguredClientsStrategy A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	65
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	1

Test Coverage

Coverage

100%

Importance

Changes	2
Bugs	0	Features	1

Metric	Value
wmc	8
c	2
b	0
f	1
lcom	1
cbo	1
dl	0
loc	65
ccs	5
cts	5
cp	1
rs	10

4 Methods

Rating	Name	Size	Complexity
A	onEvent()	4	1
A	getSubscribedEvents()	7	1
A	__construct()	5	1
B	getCandidates()	16	5

<?php

namespace Http\HttplugBundle\Discovery;

use Http\Client\HttpClient;
use Http\Client\HttpAsyncClient;
use Http\Discovery\HttpClientDiscovery;
use Http\Discovery\Strategy\DiscoveryStrategy;
use Symfony\Component\Console\ConsoleEvents;
use Symfony\Component\EventDispatcher\Event;
use Symfony\Component\EventDispatcher\EventSubscriberInterface;
use Symfony\Component\HttpKernel\KernelEvents;

/**
 * A strategy that provide clients configured with HTTPlug bundle. With help from this strategy
 * we can use the web debug toolbar for clients found with the discovery.
 *
 * @author Tobias Nyholm <[email protected]>
 */
class ConfiguredClientsStrategy implements DiscoveryStrategy, EventSubscriberInterface
{
    /**
     * @var HttpClient
     */
    private static $client;

    /**
     * @var HttpAsyncClient
     */
    private static $asyncClient;

    /**
     * @param HttpClient      $httpClient
     * @param HttpAsyncClient $asyncClient
     */
    public function __construct(HttpClient $httpClient = null, HttpAsyncClient $asyncClient = null)
    {
        static::$client = $httpClient;
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
        static::$asyncClient = $asyncClient;
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
    }

    /**
     * {@inheritdoc}
     */
    public static function getCandidates($type)
    {
        if ($type === HttpClient::class && static::$client !== null) {
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
            return [['class' => function () {
                return static::$client;
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
            }]];
        }

        if ($type === HttpAsyncClient::class && static::$asyncClient !== null) {
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
            return [['class' => function () {
                return static::$asyncClient;
class YourClass
{
    private static $someVariable;

    public static function getSomeVariable()
    {
        return static::$someVariable;
    }
}
            }]];
        }

        return [];
    }

    /**
     * Make sure to use our custom strategy.
     *
     * @param Event $e
     */
    public function onEvent(Event $e)

    {
        HttpClientDiscovery::prependStrategy(self::class);
    }

    /**
     * Whenever these events occur we make sure to add our strategy to the discovery.
     *
     * {@inheritdoc}
     */
    public static function getSubscribedEvents()
    {
        return [
            KernelEvents::REQUEST => ['onEvent', 1024],
            ConsoleEvents::COMMAND => ['onEvent', 1024],
        ];
    }
}


1		<?php
2
3		namespace Http\HttplugBundle\Discovery;
4
5		use Http\Client\HttpClient;
6		use Http\Client\HttpAsyncClient;
7		use Http\Discovery\HttpClientDiscovery;
8		use Http\Discovery\Strategy\DiscoveryStrategy;
9		use Symfony\Component\Console\ConsoleEvents;
10		use Symfony\Component\EventDispatcher\Event;
11		use Symfony\Component\EventDispatcher\EventSubscriberInterface;
12		use Symfony\Component\HttpKernel\KernelEvents;
13
14		/**
15		* A strategy that provide clients configured with HTTPlug bundle. With help from this strategy
16		* we can use the web debug toolbar for clients found with the discovery.
17		*
18		* @author Tobias Nyholm <[email protected]>
19		*/
20		class ConfiguredClientsStrategy implements DiscoveryStrategy, EventSubscriberInterface
21		{
22		/**
23		* @var HttpClient
24		*/
25		private static $client;
26
27		/**
28		* @var HttpAsyncClient
29		*/
30		private static $asyncClient;
31
32		/**
33		* @param HttpClient $httpClient
34		* @param HttpAsyncClient $asyncClient
35		*/
36	4	public function __construct(HttpClient $httpClient = null, HttpAsyncClient $asyncClient = null)
37		{
38	4	static::$client = $httpClient;
		0 ignored issues – show Bug introduced 2016-07-13 16:35 UTC by Report Bug Copy Issue Report Since `$client` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$client` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
39	4	static::$asyncClient = $asyncClient;
		0 ignored issues – show Bug introduced 2016-07-16 00:10 UTC by Report Bug Copy Issue Report Since `$asyncClient` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$asyncClient` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
40	4	}
41
42		/**
43		* {@inheritdoc}
44		*/
45		public static function getCandidates($type)
46		{
47		if ($type === HttpClient::class && static::$client !== null) {
		0 ignored issues – show Bug introduced 2016-07-13 16:35 UTC by Report Bug Copy Issue Report Since `$client` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$client` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
48		return [['class' => function () {
49		return static::$client;
		0 ignored issues – show Bug introduced 2016-07-13 16:35 UTC by Report Bug Copy Issue Report Since `$client` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$client` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
50		}]];
51		}
52
53		if ($type === HttpAsyncClient::class && static::$asyncClient !== null) {
		0 ignored issues – show Bug introduced 2016-07-16 00:10 UTC by Report Bug Copy Issue Report Since `$asyncClient` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$asyncClient` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
54		return [['class' => function () {
55		return static::$asyncClient;
		0 ignored issues – show Bug introduced 2016-07-16 00:10 UTC by Report Bug Copy Issue Report Since `$asyncClient` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$asyncClient` to at least protected. Let’s assume you have a class which uses late-static binding: class YourClass { private static $someVariable; public static function getSomeVariable() { return static::$someVariable; } } The code above will run fine in your PHP runtime. However, if you now create a sub-class and call the `getSomeVariable()` on that sub-class, you will receive a runtime error: class YourSubClass extends YourClass { } YourSubClass::getSomeVariable(); // Will cause an access error. In the case above, it makes sense to update `SomeClass` to use `self` instead: class SomeClass { private static $someVariable; public static function getSomeVariable() { return self::$someVariable; // self works fine with private. } } Loading history...
56		}]];
57		}
58
59	3	return [];
60		}
61
62		/**
63		* Make sure to use our custom strategy.
64		*
65		* @param Event $e
66		*/
67		public function onEvent(Event $e)
		1 ignored issue – show Unused Code introduced 2016-07-13 16:35 UTC by Report Bug Copy Issue Report The parameter `$e` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
68		{
69		HttpClientDiscovery::prependStrategy(self::class);
70		}
71
72		/**
73		* Whenever these events occur we make sure to add our strategy to the discovery.
74		*
75		* {@inheritdoc}
76		*/
77		public static function getSubscribedEvents()
78		{
79		return [
80		KernelEvents::REQUEST => ['onEvent', 1024],
81		ConsoleEvents::COMMAND => ['onEvent', 1024],
82		];
83		}
84		}
85

php-http / HttplugBundle

Push — master ( 119f88...a5ef59 )

ConfiguredClientsStrategy A

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

4 Methods

Duplication Side-by-Side

Filter issues like