AbstractDataType - Code Metrics - Inspection of "Code improvements and fixes." - wszetko/sitemap - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( b035c8...ddcf44 )

by Paweł

created 2019-09-09 16:27 UTC

AbstractDataType A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	125
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	2

Test Coverage

Coverage

100%

Importance

Changes

Metric	Value
dl	0
loc	125
rs	10
c	0
b	0
f	0
ccs	41
cts	41
cp	1
wmc	20
lcom	1
cbo	2

9 Methods

Rating	Name	Size	Complexity
A	__construct()	4	1
A	getName()	4	1
A	getValue()	11	2
A	setValue()	17	4
A	addAttributes()	8	2
A	getAttribute()	4	2
A	getAttributes()	14	3
A	propagateDomain()	6	2
A	__clone()	8	3

<?php
declare(strict_types=1);

namespace Wszetko\Sitemap\Items\DataTypes;

use Wszetko\Sitemap\Interfaces\DataType;
use Wszetko\Sitemap\Traits\Domain;
use Wszetko\Sitemap\Traits\Required;

/**
 * Class AbstractDataType
 *
 * @package Wszetko\Sitemap\Items\DataTypes
 */
abstract class AbstractDataType implements DataType
{
    use Required;
    use Domain;

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

    /**
     * @var
     */
    protected $value;

    /**
     * @var array
     */
    protected $attributes = [];

    /**
     * AbstractDataType constructor.
     *
     * @param $name
     */
    public function __construct($name)
    {
        $this->name = $name;
    }

    /**
     * @return string
     */
    public function getName(): string
    {
        return $this->name;
    }

    /**
     * @return mixed
     */
    public function getValue()
    {
        $value = $this->value;
        $attributes = $this->getAttributes();

        if (!empty($attributes)) {
            return [$value => $attributes];
        } else {
            return $value;
        }
    }

    /**
     * @param       $value
     * @param mixed ...$parameters
     *
     * @return \Wszetko\Sitemap\Interfaces\DataType
     */
    public function setValue($value, ...$parameters): DataType
    {
        $this->value = $value;

        foreach ($parameters[0] as $key => $attribute) {

            if (!empty($attribute)) {
                $attr = array_keys($this->attributes)[$key] ?? null;

                if ($attr) {
                    $this->attributes[$attr]->setValue($attribute);
                }
            }
        }

        return $this;
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 addAttributes($attributes): self
    {
        foreach ($attributes as $name => $dataType) {
            $this->attributes[$name] = new $dataType($name);
        }

        return $this;
    }

    public function getAttribute($name)
    {
        return isset($this->attributes[$name]) ? $this->attributes[$name] : null;
    }

    public function getAttributes(): array
    {
        $attributes = [];

        foreach ($this->attributes as $name => $value) {
            $this->propagateDomain($value);
//            var_dump($this->getDomain(), $value->getDomain());
            if (!empty($value->getValue())) {
                $attributes[$name] = $value->getValue();
            }
        }

        return $attributes;
    }

    public function propagateDomain(object &$target): void
    {
        if ($this->getDomain() !== null) {
            $target->setDomain($this->getDomain());
        }
    }

    /**
     * To clone properties of object with no reference
     */
    public function __clone()
    {
        foreach ($this->attributes as $attribute => $value) {
            if (gettype($value) == 'object') {
                $this->attributes[$attribute] = clone $this->attributes[$attribute];
            }
        }
    }
}

1		<?php
2		declare(strict_types=1);
3
4		namespace Wszetko\Sitemap\Items\DataTypes;
5
6		use Wszetko\Sitemap\Interfaces\DataType;
7		use Wszetko\Sitemap\Traits\Domain;
8		use Wszetko\Sitemap\Traits\Required;
9
10		/**
11		* Class AbstractDataType
12		*
13		* @package Wszetko\Sitemap\Items\DataTypes
14		*/
15		abstract class AbstractDataType implements DataType
16		{
17		use Required;
18		use Domain;
19
20		/**
21		* @var string
22		*/
23		private $name;
24
25		/**
26		* @var
27		*/
28		protected $value;
29
30		/**
31		* @var array
32		*/
33		protected $attributes = [];
34
35		/**
36		* AbstractDataType constructor.
37		*
38		* @param $name
39		*/
40	57	public function __construct($name)
41		{
42	57	$this->name = $name;
43	57	}
44
45		/**
46		* @return string
47		*/
48	41	public function getName(): string
49		{
50	41	return $this->name;
51		}
52
53		/**
54		* @return mixed
55		*/
56	38	public function getValue()
57		{
58	38	$value = $this->value;
59	38	$attributes = $this->getAttributes();
60
61	38	if (!empty($attributes)) {
62	8	return [$value => $attributes];
63		} else {
64	37	return $value;
65		}
66		}
67
68		/**
69		* @param $value
70		* @param mixed ...$parameters
71		*
72		* @return \Wszetko\Sitemap\Interfaces\DataType
73		*/
74	56	public function setValue($value, ...$parameters): DataType
75		{
76	56	$this->value = $value;
77
78	56	foreach ($parameters[0] as $key => $attribute) {
79
80	10	if (!empty($attribute)) {
81	9	$attr = array_keys($this->attributes)[$key] ?? null;
82
83	9	if ($attr) {
84	10	$this->attributes[$attr]->setValue($attribute);
85		}
86		}
87		}
88
89	56	return $this;
		0 ignored issues – show Bug Best Practice introduced 2019-09-09 16:29 UTC by Report Bug Copy Issue Report The return type of `return $this;` (`Wszetko\Sitemap\Items\DataTypes\AbstractDataType`) is incompatible with the return type declared by the interface `Wszetko\Sitemap\Interfaces\DataType::setValue` of type `self`. 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...
90		}
91
92	57	public function addAttributes($attributes): self
93		{
94	57	foreach ($attributes as $name => $dataType) {
95	27	$this->attributes[$name] = new $dataType($name);
96		}
97
98	57	return $this;
99		}
100
101	27	public function getAttribute($name)
102		{
103	27	return isset($this->attributes[$name]) ? $this->attributes[$name] : null;
104		}
105
106	44	public function getAttributes(): array
107		{
108	44	$attributes = [];
109
110	44	foreach ($this->attributes as $name => $value) {
111	9	$this->propagateDomain($value);
112		// var_dump($this->getDomain(), $value->getDomain());
113	9	if (!empty($value->getValue())) {
114	9	$attributes[$name] = $value->getValue();
115		}
116		}
117
118	44	return $attributes;
119		}
120
121	14	public function propagateDomain(object &$target): void
122		{
123	14	if ($this->getDomain() !== null) {
124	5	$target->setDomain($this->getDomain());
125		}
126	14	}
127
128		/**
129		* To clone properties of object with no reference
130		*/
131	9	public function __clone()
132		{
133	9	foreach ($this->attributes as $attribute => $value) {
134	3	if (gettype($value) == 'object') {
135	3	$this->attributes[$attribute] = clone $this->attributes[$attribute];
136		}
137		}
138		}
139		}

wszetko / sitemap

Push — master ( b035c8...ddcf44 )

AbstractDataType A

Complexity

Size/Duplication

Coupling/Cohesion

Test Coverage

Importance

9 Methods

Duplication Side-by-Side

Filter issues like