EntryCollection - Code Metrics - Inspection of "Merge development" - directus/directus-sdk-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Pull Request — master (#3)

by Welling

created 2016-12-11 17:54 UTC

EntryCollection A

↳ Parent: Project

Complexity

Total Complexity

Size/Duplication

Total Lines	157
Duplicated Lines	6.37 %

Coupling/Cohesion

Components	1
Dependencies	2

Importance

Changes	4
Bugs	1	Features	2

Metric	Value
dl	10
loc	157
rs	10
c	4
b	1
f	2
wmc	18
lcom	1
cbo	2

13 Methods

Rating	Name	Duplication	Size	Complexity
A	__construct()	0	13	2
A	pickMetadata()	5	11	3
A	pickRows()	5	11	3
A	getRawData()	0	4	1
A	getData()	0	4	1
A	getMetaData()	0	4	1
A	getIterator()	0	4	1
A	offsetExists()	0	4	1
A	offsetGet()	0	4	1
A	offsetSet()	0	4	1
A	offsetUnset()	0	4	1
A	count()	0	4	1
A	jsonSerialize()	0	7	1

How to fix Duplicated Code

<?php

/**
 * Directus – <http://getdirectus.com>
 *
 * @link      The canonical repository – <https://github.com/directus/directus>
 * @copyright Copyright 2006-2016 RANGER Studio, LLC – <http://rangerstudio.com>
 * @license   GNU General Public License (v3) – <http://www.gnu.org/copyleft/gpl.html>
 */

namespace Directus\SDK\Response;

use Directus\Util\ArrayUtils;

/**
 * Entry Collection
 *
 * @author Welling Guzmán <[email protected]>
 */
class EntryCollection implements ResponseInterface, \IteratorAggregate, \ArrayAccess, \Countable
{
    /**
     * @var array
     */
    protected $items = [];

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

    /**
     * @var Entry
     */
    protected $metadata = [];

    /**
     * EntryCollection constructor.
     *
     * @param $data
     */
    public function __construct($data)
    {
        $this->rawData = $data;
        $this->metadata = $this->pickMetadata($data);

        $rows = $this->pickRows($data);
        $items = [];
        foreach($rows as $row) {
            $items[] = new Entry($row);
        }

        $this->items = $items;
    }

    /**
     * Pick the metadata out of the raw data
     *
     * @param $data
     *
     * @return Entry
     */
    protected function pickMetadata($data)
    {
        $metadata = [];
        if (ArrayUtils::has($data, 'rows')) {

            $metadata = ArrayUtils::omit($data, 'rows');
        } else if (ArrayUtils::has($data, 'meta')) {
            $metadata = ArrayUtils::get($data, 'meta');
        }

        return new Entry($metadata);
    }

    /**
     * Pick the "rows" (items) out of the raw data
     *
     * @param $data
     *
     * @return array
     */
    protected function pickRows($data)
    {
        $rows = [];
        if (ArrayUtils::has($data, 'rows')) {

            $rows = ArrayUtils::get($data, 'rows', []);
        } else if (ArrayUtils::has($data, 'data')) {
            $rows = ArrayUtils::get($data, 'data', []);
        }

        return $rows;
    }

    /**
     * Get the response raw data
     *
     * @return array
     */
    public function getRawData()
    {
        return $this->rawData;
    }

    /**
     * Get the response entries
     *
     * @return array
     */
    public function getData()
    {
        return $this->items;
    }

    /**
     * Get the response metadata
     *
     * @return Entry
     */
    public function getMetaData()
    {
        return $this->metadata;
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());
}
    }

    /**
     * Create a new iterator based on this collection
     *
     * @return \ArrayIterator
     */
    public function getIterator()
    {
        return new \ArrayIterator($this->items);
    }

    public function offsetExists($offset)
    {
        return array_key_exists($offset, $this->items);
    }

    public function offsetGet($offset)
    {
        return $this->items[$offset];
    }

    public function offsetSet($offset, $value)
    {
        throw new \BadMethodCallException('EntryCollection is read only');
    }

    public function offsetUnset($offset)
    {
        throw new \BadMethodCallException('EntryCollection is read only');
    }

    /**
     * Gets the number of entries in this collection
     *
     * @return int
     */
    public function count()
    {
        return count($this->items);
    }

    /**
     * Gets an object representation of this collection
     *
     * @return object
     */
    public function jsonSerialize()
    {
        return (object) [
            'meta' => $this->metadata,
            'data' => $this->items
        ];
    }
}

1		<?php
2
3		/**
4		* Directus – <http://getdirectus.com>
5		*
6		* @link The canonical repository – <https://github.com/directus/directus>
7		* @copyright Copyright 2006-2016 RANGER Studio, LLC – <http://rangerstudio.com>
8		* @license GNU General Public License (v3) – <http://www.gnu.org/copyleft/gpl.html>
9		*/
10
11		namespace Directus\SDK\Response;
12
13		use Directus\Util\ArrayUtils;
14
15		/**
16		* Entry Collection
17		*
18		* @author Welling Guzmán <[email protected]>
19		*/
20		class EntryCollection implements ResponseInterface, \IteratorAggregate, \ArrayAccess, \Countable
21		{
22		/**
23		* @var array
24		*/
25		protected $items = [];
26
27		/**
28		* @var array
29		*/
30		protected $rawData = [];
31
32		/**
33		* @var Entry
34		*/
35		protected $metadata = [];
36
37		/**
38		* EntryCollection constructor.
39		*
40		* @param $data
41		*/
42		public function __construct($data)
43		{
44		$this->rawData = $data;
45		$this->metadata = $this->pickMetadata($data);
46
47		$rows = $this->pickRows($data);
48		$items = [];
49		foreach($rows as $row) {
50		$items[] = new Entry($row);
51		}
52
53		$this->items = $items;
54		}
55
56		/**
57		* Pick the metadata out of the raw data
58		*
59		* @param $data
60		*
61		* @return Entry
62		*/
63		protected function pickMetadata($data)
64		{
65		$metadata = [];
66	View Code Duplication	if (ArrayUtils::has($data, 'rows')) {
		0 ignored issues – show Duplication introduced 2016-11-16 18:40 UTC by Report Bug Copy Issue Report This code seems to be duplicated across 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...
67		$metadata = ArrayUtils::omit($data, 'rows');
68		} else if (ArrayUtils::has($data, 'meta')) {
69		$metadata = ArrayUtils::get($data, 'meta');
70		}
71
72		return new Entry($metadata);
73		}
74
75		/**
76		* Pick the "rows" (items) out of the raw data
77		*
78		* @param $data
79		*
80		* @return array
81		*/
82		protected function pickRows($data)
83		{
84		$rows = [];
85	View Code Duplication	if (ArrayUtils::has($data, 'rows')) {
		0 ignored issues – show Duplication introduced 2016-11-16 18:40 UTC by Report Bug Copy Issue Report This code seems to be duplicated across 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...
86		$rows = ArrayUtils::get($data, 'rows', []);
87		} else if (ArrayUtils::has($data, 'data')) {
88		$rows = ArrayUtils::get($data, 'data', []);
89		}
90
91		return $rows;
92		}
93
94		/**
95		* Get the response raw data
96		*
97		* @return array
98		*/
99		public function getRawData()
100		{
101		return $this->rawData;
102		}
103
104		/**
105		* Get the response entries
106		*
107		* @return array
108		*/
109		public function getData()
110		{
111		return $this->items;
112		}
113
114		/**
115		* Get the response metadata
116		*
117		* @return Entry
118		*/
119		public function getMetaData()
120		{
121		return $this->metadata;
		0 ignored issues – show Bug Best Practice introduced 2016-11-17 02:54 UTC by Report Bug Copy Issue Report The return type of `return $this->metadata;` (`Directus\SDK\Response\Entry`) is incompatible with the return type declared by the interface `Directus\SDK\Response\Re...eInterface::getMetaData` of type `array`. 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...
122		}
123
124		/**
125		* Create a new iterator based on this collection
126		*
127		* @return \ArrayIterator
128		*/
129		public function getIterator()
130		{
131		return new \ArrayIterator($this->items);
132		}
133
134		public function offsetExists($offset)
135		{
136		return array_key_exists($offset, $this->items);
137		}
138
139		public function offsetGet($offset)
140		{
141		return $this->items[$offset];
142		}
143
144		public function offsetSet($offset, $value)
145		{
146		throw new \BadMethodCallException('EntryCollection is read only');
147		}
148
149		public function offsetUnset($offset)
150		{
151		throw new \BadMethodCallException('EntryCollection is read only');
152		}
153
154		/**
155		* Gets the number of entries in this collection
156		*
157		* @return int
158		*/
159		public function count()
160		{
161		return count($this->items);
162		}
163
164		/**
165		* Gets an object representation of this collection
166		*
167		* @return object
168		*/
169		public function jsonSerialize()
170		{
171		return (object) [
172		'meta' => $this->metadata,
173		'data' => $this->items
174		];
175		}
176		}

directus / directus-sdk-php

Pull Request — master (#3)

EntryCollection A

Complexity

Size/Duplication

Coupling/Cohesion

Importance

13 Methods

How to fix Duplicated Code

Duplicated Code

Duplication Side-by-Side

Filter issues like