EntryCollection::pickRows() - Code Metrics - Inspection of "add branch alias" - directus/directus-sdk-php - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — d64 ( b18498...be696f )

by Welling

created 2016-11-16 18:15 UTC

EntryCollection::pickRows() A

↳ Parent: EntryCollection

Complexity

Conditions	3
Paths	3

Size

Total Lines	11
Code Lines	7

Duplication

Lines	5
Ratio	45.45 %

Code Coverage

Tests	2
CRAP Score	3

Importance

Changes

Metric	Value
cc	3
eloc	7
nc	3
nop	1
dl	5
loc	11
rs	9.4285
c	0
b	0
f	0
ccs	2
cts	2
cp	1
crap	3

<?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 array
     */
    protected $metadata = [];

    /**
     * EntryCollection constructor.
     *
     * @param $data
     */
    public function __construct($data)
    {
        $this->rawData = $data;
        $this->metadata = $this->pickMetadata($data);
function aContainsB(array $needle = null, array  $haystack) {
    if (!$needle) {
        return false;
    }

    return array_intersect($haystack, $needle) == $haystack;
}

        $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 array|null
     */
    protected function pickMetadata($data)
    {
        $metadata = null;
        if (ArrayUtils::has($data, 'rows')) {

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

        return $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 array
     */
    public function getMetaData()
    {
        return $this->metadata;
    }

    /**
     * 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) [
            'metadata' => $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 array
34			*/
35			protected $metadata = [];
36
37			/**
38			* EntryCollection constructor.
39			*
40			* @param $data
41			*/
42	8		public function __construct($data)
43			{
44	8		$this->rawData = $data;
45	8		$this->metadata = $this->pickMetadata($data);
			0 ignored issues – show Documentation Bug introduced 2016-11-16 18:40 UTC by Report Bug Copy Issue Report It seems like `$this->pickMetadata($data)` can be `null`. However, the property `$metadata` is declared as `array`. Maybe change the type of the property to `array\|null` or add a type check? Our type inference engine has found an assignment of a scalar value (like a string, an integer or null) to a property which is an array. Either this assignment is in error or the assigned type should be added to the documentation/type hint for that property. To type hint that a parameter can be either an array or null, you can set a type hint of array and a default value of null. The PHP interpreter will then accept both an array or null for that parameter. function aContainsB(array $needle = null, array $haystack) { if (!$needle) { return false; } return array_intersect($haystack, $needle) == $haystack; } The function can be called with either null or an array for the parameter `$needle` but will only accept an array as `$haystack`. Loading history...
46
47	8		$rows = $this->pickRows($data);
48	8		$items = [];
49	8		foreach($rows as $row) {
50	8		$items[] = new Entry($row);
51	8		}
52
53	8		$this->items = $items;
54	8		}
55
56			/**
57			* Pick the metadata out of the raw data
58			*
59			* @param $data
60			*
61	2		* @return array\|null
62			*/
63	2		protected function pickMetadata($data)
64			{
65			$metadata = null;
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, 'metadata')) {
69			$metadata = ArrayUtils::get($data, 'metadata');
70			}
71	2
72			return $metadata;
73	2		}
74
75			/**
76			* Pick the "rows" (items) out of the raw data
77			*
78			* @param $data
79			*
80			* @return array
81	2		*/
82			protected function pickRows($data)
83	2		{
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	2		return $rows;
92			}
93	2
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 array
118			*/
119			public function getMetaData()
120			{
121	2		return $this->metadata;
122			}
123	2
124			/**
125			* Create a new iterator based on this collection
126			*
127			* @return \ArrayIterator
128			*/
129			public function getIterator()
130			{
131	2		return new \ArrayIterator($this->items);
132			}
133
134	2		public function offsetExists($offset)
135	2		{
136	2		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			'metadata' => $this->metadata,
173			'data' => $this->items
174			];
175			}
176			}

directus / directus-sdk-php

Push — d64 ( b18498...be696f )

EntryCollection::pickRows() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like