ShippoClient - Code Metrics - Inspection of "Merge pull request #9 from gong023/enable_tracking..." - gong023/shippo-http-client - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( d2378f...d01cde )

by Sho

created 2016-02-10 00:32 UTC

ShippoClient A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	89
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	9

Importance

Changes	13
Bugs	2	Features	7

Metric	Value
wmc	14
c	13
b	2
f	7
lcom	2
cbo	9
dl	0
loc	89
rs	10

12 Methods

Rating	Name	Size	Complexity
A	__construct()	4	1
A	addresses()	4	1
A	parcels()	4	1
A	shipments()	4	1
A	rates()	4	1
A	transactions()	4	1
A	refunds()	4	1
A	tracks()	4	1
A	getAccessToken()	4	1
A	setRequestOption()	6	1
A	provider()	10	3
A	mock()	4	1

<?php
namespace ShippoClient;

use ShippoClient\Http\Request;
use ShippoClient\Http\Request\MockCollection;

class ShippoClient
{
    /**
     * @var Request
     */
    private $request;

    /**
     * @var string
     */
    private $accessToken;

    /**
     * @var static|null
     */
    private static $instance = null;

    private function __construct(Request $request)
    {
        $this->request = $request;
    }

    public function addresses()
    {
        return new Addresses($this->request);
    }

    public function parcels()
    {
        return new Parcels($this->request);
    }

    public function shipments()
    {
        return new Shipments($this->request);
    }

    public function rates()
    {
        return new Rates($this->request);
    }

    public function transactions()
    {
        return new Transactions($this->request);
    }

    public function refunds()
    {
        return new Refunds($this->request);
    }

    public function tracks()
    {
        return new Tracks($this->request);
    }

    public function getAccessToken()
    {
        return $this->accessToken;
    }

    public function setRequestOption($keyOrPath, $value)
    {
        $this->request->setDefaultOption($keyOrPath, $value);

        return $this;
    }

    /**
     * @param string $accessToken
     * @return static
     */
    public static function provider($accessToken)
    {
        if (static::$instance !== null && static::$instance->getAccessToken() === $accessToken) {
class YourClass
{
    private static $someVariable;

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

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

        static::$instance = new static(new Request($accessToken));
class YourClass
{
    private static $someVariable;

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

        return static::$instance;
class YourClass
{
    private static $someVariable;

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

    public static function mock()
    {
        return MockCollection::getInstance();
    }
}


1			<?php
2			namespace ShippoClient;
3
4			use ShippoClient\Http\Request;
5			use ShippoClient\Http\Request\MockCollection;
6
7			class ShippoClient
8			{
9			/**
10			* @var Request
11			*/
12			private $request;
13
14			/**
15			* @var string
16			*/
17			private $accessToken;
18
19			/**
20			* @var static\|null
21			*/
22			private static $instance = null;
23
24			private function __construct(Request $request)
25			{
26			$this->request = $request;
27			}
28
29			public function addresses()
30			{
31			return new Addresses($this->request);
32			}
33
34			public function parcels()
35			{
36			return new Parcels($this->request);
37			}
38
39			public function shipments()
40			{
41			return new Shipments($this->request);
42			}
43
44			public function rates()
45			{
46			return new Rates($this->request);
47			}
48
49			public function transactions()
50			{
51			return new Transactions($this->request);
52			}
53
54			public function refunds()
55			{
56			return new Refunds($this->request);
57			}
58
59			public function tracks()
60			{
61			return new Tracks($this->request);
62			}
63
64			public function getAccessToken()
65			{
66			return $this->accessToken;
67			}
68
69			public function setRequestOption($keyOrPath, $value)
70			{
71			$this->request->setDefaultOption($keyOrPath, $value);
72
73			return $this;
74			}
75
76			/**
77			* @param string $accessToken
78			* @return static
79			*/
80			public static function provider($accessToken)
81			{
82			if (static::$instance !== null && static::$instance->getAccessToken() === $accessToken) {
			0 ignored issues – show Bug introduced 2015-12-17 08:34 UTC by Report Bug Copy Issue Report Since `$instance` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$instance` 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...
83			return static::$instance;
			0 ignored issues – show Bug introduced 2015-12-17 08:34 UTC by Report Bug Copy Issue Report Since `$instance` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$instance` 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...
84			}
85
86			static::$instance = new static(new Request($accessToken));
			0 ignored issues – show Bug introduced 2015-12-17 08:34 UTC by Report Bug Copy Issue Report Since `$instance` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$instance` 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...
87
88			return static::$instance;
			0 ignored issues – show Bug introduced 2015-12-17 08:34 UTC by Report Bug Copy Issue Report Since `$instance` is declared private, accessing it with `static` will lead to errors in possible sub-classes; consider using `self`, or increasing the visibility of `$instance` 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...
89			}
90
91			public static function mock()
92			{
93			return MockCollection::getInstance();
94			}
95			}
96

gong023 / shippo-http-client

GitHub Access Token became invalid

Push — master ( d2378f...d01cde )

ShippoClient A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

12 Methods

Duplication Side-by-Side

Filter issues like