AbstractAction - Code Metrics - Inspection of "fixed tests for added plan in Price" - hiqdev/php-billing - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( a5de38...845fca )

by Andrii

created 2017-11-25 16:09 UTC

AbstractAction A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	173
Duplicated Lines	15.61 %

Coupling/Cohesion

Components	2
Dependencies	2

Test Coverage

Coverage

51.06%

Importance

Changes

Metric	Value
wmc	18
lcom	2
cbo	2
dl	27
loc	173
ccs	24
cts	47
cp	0.5106
rs	10
c	0
b	0
f	0

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	17	17	1
A	getId()	0	4	1
A	getCustomer()	0	4	1
A	getTarget()	0	4	1
A	getType()	0	4	1
A	getQuantity()	0	4	1
A	getSale()	0	4	1
A	getTime()	0	4	1
A	setId()	10	10	3
A	setSale()	0	7	2
A	jsonSerialize()	0	4	1
A	calculateCharge()	0	18	4
	isApplicable()	0	1	?

How to fix Duplicated Code

<?php
/**
 * PHP Billing Library
 *
 * @link      https://github.com/hiqdev/php-billing
 * @package   php-billing
 * @license   BSD-3-Clause
 * @copyright Copyright (c) 2017, HiQDev (http://hiqdev.com/)
 */

namespace hiqdev\php\billing\action;

use DateTime;
use hiqdev\php\billing\charge\Charge;
use hiqdev\php\billing\customer\CustomerInterface;
use hiqdev\php\billing\price\PriceInterface;
use hiqdev\php\billing\sale\SaleInterface;
use hiqdev\php\billing\target\TargetInterface;
use hiqdev\php\billing\type\TypeInterface;
use hiqdev\php\units\QuantityInterface;

/**
 * Chargable Action.
 *
 * @see ActionInterface
 *
 * @author Andrii Vasyliev <[email protected]>
 */
abstract class AbstractAction implements ActionInterface
{
    /**
     * @var int
     */
    protected $id;

    /**
     * @var TypeInterface
     */
    protected $type;

    /**
     * @var TargetInterface
     */
    protected $target;

    /**
     * @var QuantityInterface
     */
    protected $quantity;

    /**
     * @var CustomerInterface
     */
    protected $customer;

    /**
     * @var SaleInterface
     */
    protected $sale;

    /**
     * @var DateTime
     */
    protected $time;

    /**
     * @param TypeInterface $type
     * @param TargetInterface $target
     * @param QuantityInterface $quantity
     * @param CustomerInterface $customer
     * @param SaleInterface $sale
     * @param DateTime $time
     */
    public function __construct(

                            $id,
        TypeInterface       $type,
        TargetInterface     $target,
        QuantityInterface   $quantity,
        CustomerInterface   $customer = null,
        SaleInterface       $sale = null,
        DateTime            $time = null
    ) {
        $this->id       = $id;
        $this->type     = $type;
        $this->target   = $target;
        $this->quantity = $quantity;
        $this->customer = $customer;
        $this->sale     = $sale;
        $this->time     = $time;
    }

    /**
     * {@inheritdoc}
     */
    public function getId()
    {
        return $this->id;
    }

    /**
     * {@inheritdoc}
     */
    public function getCustomer()
    {
        return $this->customer;
    }

    /**
     * {@inheritdoc}
     */
    public function getTarget()
    {
        return $this->target;
    }

    /**
     * {@inheritdoc}
     */
    public function getType()
    {
        return $this->type;
    }

    /**
     * {@inheritdoc}
     */
    public function getQuantity()
    {
        return $this->quantity;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * {@inheritdoc}
     */
    public function getSale()
    {
        return $this->sale;
    }

    /**
     * {@inheritdoc}
     */
    public function getTime()
    {
        return $this->time;
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    public function setId($id)

    {
        if ($this->id === $id) {
            return;
        }
        if ($this->id !== null) {
            throw new \Exception('cannot reassign action id');
        }
        $this->id = $id;
    }

    public function setSale(SaleInterface $sale)
    {
        if ($this->sale !== null) {
            throw new \Exception('cannot reassign sale for action');
        }
        $this->sale = $sale;
    }

    /**
     * {@inheritdoc}
     */
    public function jsonSerialize()
    {
        return get_object_vars($this);
    }

    /**
     * {@inheritdoc}
     */
    public function calculateCharge(PriceInterface $price)
    {
        if (!$this->isApplicable($price)) {
            return null;
        }

        $usage = $price->calculateUsage($this->getQuantity());
        if ($usage === null) {
            return null;
        }

        $sum = $price->calculateSum($this->getQuantity());
        if ($sum === null) {
            return null;
        }

        return new Charge(null, $this, $price, $this->getTarget(), $usage, $sum);
class Author {
    private $name;

    public function __construct($name) {
        $this->name = $name;
    }

    public function getName() {
        return $this->name;
    }
}

abstract class Post {
    public function getAuthor() {
        return 'Johannes';
    }
}

class BlogPost extends Post {
    public function getAuthor() {
        return new Author('Johannes');
    }
}

class ForumPost extends Post { /* ... */ }

function my_function(Post $post) {
    echo strtoupper($post->getAuthor());
}
    }

    /**
     * {@inheritdoc}
     */
    abstract public function isApplicable(PriceInterface $price);
}


1			<?php
2			/**
3			* PHP Billing Library
4			*
5			* @link https://github.com/hiqdev/php-billing
6			* @package php-billing
7			* @license BSD-3-Clause
8			* @copyright Copyright (c) 2017, HiQDev (http://hiqdev.com/)
9			*/
10
11			namespace hiqdev\php\billing\action;
12
13			use DateTime;
14			use hiqdev\php\billing\charge\Charge;
15			use hiqdev\php\billing\customer\CustomerInterface;
16			use hiqdev\php\billing\price\PriceInterface;
17			use hiqdev\php\billing\sale\SaleInterface;
18			use hiqdev\php\billing\target\TargetInterface;
19			use hiqdev\php\billing\type\TypeInterface;
20			use hiqdev\php\units\QuantityInterface;
21
22			/**
23			* Chargable Action.
24			*
25			* @see ActionInterface
26			*
27			* @author Andrii Vasyliev <[email protected]>
28			*/
29			abstract class AbstractAction implements ActionInterface
30			{
31			/**
32			* @var int
33			*/
34			protected $id;
35
36			/**
37			* @var TypeInterface
38			*/
39			protected $type;
40
41			/**
42			* @var TargetInterface
43			*/
44			protected $target;
45
46			/**
47			* @var QuantityInterface
48			*/
49			protected $quantity;
50
51			/**
52			* @var CustomerInterface
53			*/
54			protected $customer;
55
56			/**
57			* @var SaleInterface
58			*/
59			protected $sale;
60
61			/**
62			* @var DateTime
63			*/
64			protected $time;
65
66			/**
67			* @param TypeInterface $type
68			* @param TargetInterface $target
69			* @param QuantityInterface $quantity
70			* @param CustomerInterface $customer
71			* @param SaleInterface $sale
72			* @param DateTime $time
73			*/
74	4	View Code Duplication	public function __construct(
			0 ignored issues – show Duplication introduced 2017-09-10 14:07 UTC by Report Bug Copy Issue Report 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...
75			$id,
76			TypeInterface $type,
77			TargetInterface $target,
78			QuantityInterface $quantity,
79			CustomerInterface $customer = null,
80			SaleInterface $sale = null,
81			DateTime $time = null
82			) {
83	4		$this->id = $id;
84	4		$this->type = $type;
85	4		$this->target = $target;
86	4		$this->quantity = $quantity;
87	4		$this->customer = $customer;
88	4		$this->sale = $sale;
89	4		$this->time = $time;
90	4		}
91
92			/**
93			* {@inheritdoc}
94			*/
95			public function getId()
96			{
97			return $this->id;
98			}
99
100			/**
101			* {@inheritdoc}
102			*/
103			public function getCustomer()
104			{
105			return $this->customer;
106			}
107
108			/**
109			* {@inheritdoc}
110			*/
111	3		public function getTarget()
112			{
113	3		return $this->target;
114			}
115
116			/**
117			* {@inheritdoc}
118			*/
119	2		public function getType()
120			{
121	2		return $this->type;
122			}
123
124			/**
125			* {@inheritdoc}
126			*/
127	4		public function getQuantity()
128			{
129	4		return $this->quantity;
			0 ignored issues – show Bug Best Practice introduced 2017-06-06 10:13 UTC by Report Bug Copy Issue Report The return type of `return $this->quantity;` (`hiqdev\php\units\QuantityInterface`) is incompatible with the return type declared by the interface `hiqdev\php\billing\actio...nInterface::getQuantity` of type `hiqdev\php\billing\action\QuantityInterface`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
130			}
131
132			/**
133			* {@inheritdoc}
134			*/
135			public function getSale()
136			{
137			return $this->sale;
138			}
139
140			/**
141			* {@inheritdoc}
142			*/
143			public function getTime()
144			{
145			return $this->time;
			0 ignored issues – show Bug Best Practice introduced 2017-06-06 10:13 UTC by Report Bug Copy Issue Report The return type of `return $this->time;` (`DateTime`) is incompatible with the return type declared by the interface `hiqdev\php\billing\action\ActionInterface::getTime` of type `hiqdev\php\billing\action\DateTime`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
146			}
147
148		View Code Duplication	public function setId($id)
			0 ignored issues – show Duplication introduced 2017-11-25 16:15 UTC by Report Bug Copy Issue Report 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...
149			{
150			if ($this->id === $id) {
151			return;
152			}
153			if ($this->id !== null) {
154			throw new \Exception('cannot reassign action id');
155			}
156			$this->id = $id;
157			}
158
159			public function setSale(SaleInterface $sale)
160			{
161			if ($this->sale !== null) {
162			throw new \Exception('cannot reassign sale for action');
163			}
164			$this->sale = $sale;
165			}
166
167			/**
168			* {@inheritdoc}
169			*/
170			public function jsonSerialize()
171			{
172			return get_object_vars($this);
173			}
174
175			/**
176			* {@inheritdoc}
177			*/
178	4		public function calculateCharge(PriceInterface $price)
179			{
180	4		if (!$this->isApplicable($price)) {
181	2		return null;
182			}
183
184	4		$usage = $price->calculateUsage($this->getQuantity());
185	4		if ($usage === null) {
186	1		return null;
187			}
188
189	3		$sum = $price->calculateSum($this->getQuantity());
190	3		if ($sum === null) {
191			return null;
192			}
193
194	3		return new Charge(null, $this, $price, $this->getTarget(), $usage, $sum);
			0 ignored issues – show Bug Best Practice introduced 2017-11-25 16:15 UTC by Report Bug Copy Issue Report The return type of `return new \hiqdev\php\b...arget(), $usage, $sum);` (`hiqdev\php\billing\charge\Charge`) is incompatible with the return type declared by the interface `hiqdev\php\billing\actio...erface::calculateCharge` of type `hiqdev\php\billing\action\ChargeInterface`. If you return a value from a function or method, it should be a sub-type of the type that is given by the parent type f.e. an interface, or abstract method. This is more formally defined by the Lizkov substitution principle, and guarantees that classes that depend on the parent type can use any instance of a child type interchangably. This principle also belongs to the SOLID principles for object oriented design. Let’s take a look at an example: class Author { private $name; public function __construct($name) { $this->name = $name; } public function getName() { return $this->name; } } abstract class Post { public function getAuthor() { return 'Johannes'; } } class BlogPost extends Post { public function getAuthor() { return new Author('Johannes'); } } class ForumPost extends Post { /* ... */ } function my_function(Post $post) { echo strtoupper($post->getAuthor()); } Our function `my_function` expects a `Post` object, and outputs the author of the post. The base class `Post` returns a simple string and outputting a simple string will work just fine. However, the child class `BlogPost` which is a sub-type of `Post` instead decided to return an `object`, and is therefore violating the SOLID principles. If a `BlogPost` were passed to `my_function`, PHP would not complain, but ultimately fail when executing the `strtoupper` call in its body. Loading history...
195			}
196
197			/**
198			* {@inheritdoc}
199			*/
200			abstract public function isApplicable(PriceInterface $price);
201			}
202

hiqdev / php-billing

Push — master ( a5de38...845fca )

AbstractAction A

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

13 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like