InMemory::execute() - Code Metrics - Inspection of "Implemented initial untested queryable in-memory s..." - darya/framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( f7755d...fe6ccb )

by Chris

created 2016-03-13 13:17 UTC

InMemory::execute() B

↳ Parent: InMemory

Complexity

Conditions	5
Paths	5

Size

Total Lines	37
Code Lines	29

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	1

Metric	Value
c	1
b	0
f	1
dl	0
loc	37
rs	8.439
nc	5
cc	5
eloc	29
nop	1

<?php
namespace Darya\Storage;

use Darya\Storage\Aggregational;
use Darya\Storage\Filterer;
use Darya\Storage\Readable;
use Darya\Storage\Modifiable;
use Darya\Storage\Query;
use Darya\Storage\Queryable;
use Darya\Storage\Result;
use Darya\Storage\Searchable;
use Darya\Storage\Sorter;

/**
 * Darya's in-memory storage interface.
 * 
 * Useful for unit testing!
 * 
 * @author Chris Andrew <[email protected]>
 */
class InMemory implements Readable, Modifiable, Searchable, Aggregational, Queryable {
	
	/**
	 * The in-memory data.
	 * 
	 * @var array
	 */
	protected $data;
	
	/**
	 * Filters results in-memory.
	 * 
	 * @var Filterer
	 */
	protected $filterer;
	
	/**
	 * Sorts results in-memory.
	 * 
	 * @var Sorter
	 */
	protected $sorter;
	
	/**
	 * Create a new in-memory storage interface with the given data.
	 * 
	 * @param array $data [optional]
	 */
	public function __construct(array $data = array()) {
		$this->data = $data;
		$this->filterer = new Filterer;
		$this->sorter = new Sorter;
	}
	
	/**
	 * Limit the given data to the given length and offset.
	 * 
	 * @param array $data
	 * @param int   $limit  [optional]
	 * @param int   $offset [optional]
	 * @return array
	 */
	protected static function limit(array $data, $limit = 0, $offset = 0) {
		return array_slice($data, $offset, $limit ?: null);
	}
	
	/**
	 * Retrieve resource data using the given criteria.
	 * 
	 * Returns an array of associative arrays.
	 * 
	 * @param string       $resource
	 * @param array        $filter   [optional]
	 * @param array|string $order    [optional]
	 * @param int          $limit    [optional]
	 * @param int          $offset   [optional]
	 * @return array
	 */
	public function read($resource, array $filter = array(), $order = array(), $limit = 0, $offset = 0) {
		if (empty($this->data[$resource])) {
			return array();
		}
		
		$data = $this->filterer->filter($this->data[$resource], $filter);
		
		$data = $this->sorter->sort($data, $order);
		
		$data = static::limit($data, $limit, $offset);
		
		return $data;
	}
	
	/**
	 * Retrieve specific fields of a resource.
	 * 
	 * Returns an array of associative arrays.
	 * 
	 * @param string       $resource
	 * @param array|string $fields
	 * @param array        $filter   [optional]
	 * @param array|string $order    [optional]
	 * @param int          $limit    [optional]
	 * @param int          $offset   [optional]
	 * @return array
	 */
	public function listing($resource, $fields, array $filter = array(), $order = array(), $limit = 0, $offset = 0) {
		$data = $this->read($resource, $filter, $order, $limit, $offset);
		
		$fields = (array) $fields;
		
		$result = array();
		
		foreach ($data as $row) {
			$new = array();
			
			foreach ($row as $field => $value) {
				if (in_array($field, $fields)) {
					$new[$field] = $value;
				}
			}
			
			if (!empty($new)) {
				$result[] = $new;
			}
		}
		
		return $result;
	}
	
	/**
	 * Count the given resource with an optional filter.
	 * 
	 * @param string $resource
	 * @param array  $filter   [optional]
	 * @return int
	 */
	public function count($resource, array $filter = array()) {

		if (empty($this->data[$resource])) {
			return 0;
		}
		
		return count($this->filterer->filter($this->data[$resource], $filter));
	}
	
	/**
	 * Create resource instances in the data store.
	 * 
	 * @param string $resource
	 * @param array  $data
	 * @return bool
	 */
	public function create($resource, $data) {
		if (!isset($this->data[$resource])) {
			$this->data[$resource] = array();
		}
		
		$this->data[$resource][] = $data;
		
		return true;
	}
	
	/**
	 * Update resource instances in the data store.
	 * 
	 * @param string $resource
	 * @param array  $data
	 * @param array  $filter   [optional]
	 * @param int    $limit    [optional]
	 * @return int|bool
	 */
	public function update($resource, $data, array $filter = array(), $limit = 0) {
		if (empty($this->data[$resource])) {
			return;
		}
		
		$affected = 0;
		
		$this->data[$resource] = $this->filterer->map(
			$this->data[$resource],
			$filter,
			function ($row) use ($data, &$affected) {
				foreach ($data as $key => $value) {
					$row[$key] = $value;
				}
				
				$affected++;
				
				return $row;
			},
			$limit
		);
		
		return $affected;
	}
	
	/**
	 * Delete resource instances from the data store.
	 * 
	 * @param string $resource
	 * @param array  $filter   [optional]
	 * @param int    $limit    [optional]
	 * @return int|bool
	 */
	public function delete($resource, array $filter = array(), $limit = null) {

		if (empty($this->data[$resource])) {
			return;
		}
		
		$this->data[$resource] = $this->filterer->reject($this->data[$resource], $filter);
	}
	
	/**
	 * Search for resource data with fields that match the given query and
	 * criteria.
	 * 
	 * @param string       $resource
	 * @param string       $query
	 * @param array|string $fields
	 * @param array        $filter   [optional]
	 * @param array|string $order    [optional]
	 * @param int          $limit    [optional]
	 * @param int          $offset   [optional]
	 * @return array
	 */
	public function search($resource, $query, $fields, array $filter = array(), $order = array(), $limit = null, $offset = 0) {
		if (empty($query) || empty($resource)) {
			return $this->read($resource, $filter, $order, $limit, $offset);
		}
		
		$fields = (array) $fields;
		$search = array('or' => array());
		
		foreach ($fields as $field) {
			$search['or']["$field like"] = "%$query%";
		}
		
		$filter = array_merge($filter, $search);
		
		return $this->read($resource, $filter, $order, $limit, $offset);
	}
	
	/**
	 * Retrieve the distinct values of the given resource's field.
	 * 
	 * Returns a flat array of values.
	 * 
	 * @param string $resource
	 * @param string $field
	 * @param array  $filter   [optional]
	 * @param array  $order    [optional]
	 * @param int    $limit    [optional]
	 * @param int    $offset   [optional]
	 * @return array
	 */
	public function distinct($resource, $field, array $filter = array(), $order = array(), $limit = 0, $offset = 0) {
		$list = array();
		
		$listing = $this->listing($resource, $field, $filter, $order, $limit, $offset);
		
		foreach ($listing as $item) {
			$list[] = $item[$field];
		}
		
		return array_unique($list);
	}
	
	/**
	 * Execute the given query.
	 * 
	 * @param Query $query
	 * @return Result
	 */
	public function execute(Query $query)
	{
		$data = array();
		$info = array();
		
		switch ($query->type) {
			case Query::CREATE:
				$this->create($query->resource, $query->data);
				break;
			case Query::READ:
				$data = $this->read(
					$query->resource,
					$query->filter,
					$query->order,
					$query->limit,
					$query->offset
				);
				break;
			case Query:UPDATE:
switch ($expr) {
case "A":
    doSomething(); //right
    break;
case "B":

    doSomethingElse(); //wrong
    break;
				$info['affected'] = $this->update(
					$query->resource,
					$query->data,
					$query->filter,
					$query->limit
				);
				break;
			case Query::DELETE:
				$this->delete(
					$query->resource,
					$query->filter,
					$query->limit
				);
				break;
		}
		
		return new Result($query, $data, $info);
	}
	
	/**
	 * Open a query on the given resource.
	 * 
	 * @param string $resource
	 * @param array  $fields   [optional]
	 * @return Query\Builder
	 */
	public function query($resource, $fields = array())
	{
		return new Query\Builder(new Query($resource, $fields), $this);
	}
	
	/**
	 * Retrieve the error that occured with the last operation.
	 * 
	 * Returns false if there was no error.
	 * 
	 * @return string|bool
	 */
	public function error() {
		return false;
	}
	
}


1		<?php
2		namespace Darya\Storage;
3
4		use Darya\Storage\Aggregational;
5		use Darya\Storage\Filterer;
6		use Darya\Storage\Readable;
7		use Darya\Storage\Modifiable;
8		use Darya\Storage\Query;
9		use Darya\Storage\Queryable;
10		use Darya\Storage\Result;
11		use Darya\Storage\Searchable;
12		use Darya\Storage\Sorter;
13
14		/**
15		* Darya's in-memory storage interface.
16		*
17		* Useful for unit testing!
18		*
19		* @author Chris Andrew <[email protected]>
20		*/
21		class InMemory implements Readable, Modifiable, Searchable, Aggregational, Queryable {
22
23		/**
24		* The in-memory data.
25		*
26		* @var array
27		*/
28		protected $data;
29
30		/**
31		* Filters results in-memory.
32		*
33		* @var Filterer
34		*/
35		protected $filterer;
36
37		/**
38		* Sorts results in-memory.
39		*
40		* @var Sorter
41		*/
42		protected $sorter;
43
44		/**
45		* Create a new in-memory storage interface with the given data.
46		*
47		* @param array $data [optional]
48		*/
49		public function __construct(array $data = array()) {
50		$this->data = $data;
51		$this->filterer = new Filterer;
52		$this->sorter = new Sorter;
53		}
54
55		/**
56		* Limit the given data to the given length and offset.
57		*
58		* @param array $data
59		* @param int $limit [optional]
60		* @param int $offset [optional]
61		* @return array
62		*/
63		protected static function limit(array $data, $limit = 0, $offset = 0) {
64		return array_slice($data, $offset, $limit ?: null);
65		}
66
67		/**
68		* Retrieve resource data using the given criteria.
69		*
70		* Returns an array of associative arrays.
71		*
72		* @param string $resource
73		* @param array $filter [optional]
74		* @param array\|string $order [optional]
75		* @param int $limit [optional]
76		* @param int $offset [optional]
77		* @return array
78		*/
79		public function read($resource, array $filter = array(), $order = array(), $limit = 0, $offset = 0) {
80		if (empty($this->data[$resource])) {
81		return array();
82		}
83
84		$data = $this->filterer->filter($this->data[$resource], $filter);
85
86		$data = $this->sorter->sort($data, $order);
87
88		$data = static::limit($data, $limit, $offset);
89
90		return $data;
91		}
92
93		/**
94		* Retrieve specific fields of a resource.
95		*
96		* Returns an array of associative arrays.
97		*
98		* @param string $resource
99		* @param array\|string $fields
100		* @param array $filter [optional]
101		* @param array\|string $order [optional]
102		* @param int $limit [optional]
103		* @param int $offset [optional]
104		* @return array
105		*/
106		public function listing($resource, $fields, array $filter = array(), $order = array(), $limit = 0, $offset = 0) {
107		$data = $this->read($resource, $filter, $order, $limit, $offset);
108
109		$fields = (array) $fields;
110
111		$result = array();
112
113		foreach ($data as $row) {
114		$new = array();
115
116		foreach ($row as $field => $value) {
117		if (in_array($field, $fields)) {
118		$new[$field] = $value;
119		}
120		}
121
122		if (!empty($new)) {
123		$result[] = $new;
124		}
125		}
126
127		return $result;
128		}
129
130		/**
131		* Count the given resource with an optional filter.
132		*
133		* @param string $resource
134		* @param array $filter [optional]
135		* @return int
136		*/
137	View Code Duplication	public function count($resource, array $filter = array()) {
		0 ignored issues – show Duplication introduced 2015-11-24 14:38 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...
138		if (empty($this->data[$resource])) {
139		return 0;
140		}
141
142		return count($this->filterer->filter($this->data[$resource], $filter));
143		}
144
145		/**
146		* Create resource instances in the data store.
147		*
148		* @param string $resource
149		* @param array $data
150		* @return bool
151		*/
152		public function create($resource, $data) {
153		if (!isset($this->data[$resource])) {
154		$this->data[$resource] = array();
155		}
156
157		$this->data[$resource][] = $data;
158
159		return true;
160		}
161
162		/**
163		* Update resource instances in the data store.
164		*
165		* @param string $resource
166		* @param array $data
167		* @param array $filter [optional]
168		* @param int $limit [optional]
169		* @return int\|bool
170		*/
171		public function update($resource, $data, array $filter = array(), $limit = 0) {
172		if (empty($this->data[$resource])) {
173		return;
174		}
175
176		$affected = 0;
177
178		$this->data[$resource] = $this->filterer->map(
179		$this->data[$resource],
180		$filter,
181		function ($row) use ($data, &$affected) {
182		foreach ($data as $key => $value) {
183		$row[$key] = $value;
184		}
185
186		$affected++;
187
188		return $row;
189		},
190		$limit
191		);
192
193		return $affected;
194		}
195
196		/**
197		* Delete resource instances from the data store.
198		*
199		* @param string $resource
200		* @param array $filter [optional]
201		* @param int $limit [optional]
202		* @return int\|bool
203		*/
204	View Code Duplication	public function delete($resource, array $filter = array(), $limit = null) {
		0 ignored issues – show Duplication introduced 2015-11-24 14:38 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...
205		if (empty($this->data[$resource])) {
206		return;
207		}
208
209		$this->data[$resource] = $this->filterer->reject($this->data[$resource], $filter);
210		}
211
212		/**
213		* Search for resource data with fields that match the given query and
214		* criteria.
215		*
216		* @param string $resource
217		* @param string $query
218		* @param array\|string $fields
219		* @param array $filter [optional]
220		* @param array\|string $order [optional]
221		* @param int $limit [optional]
222		* @param int $offset [optional]
223		* @return array
224		*/
225		public function search($resource, $query, $fields, array $filter = array(), $order = array(), $limit = null, $offset = 0) {
226		if (empty($query) \|\| empty($resource)) {
227		return $this->read($resource, $filter, $order, $limit, $offset);
228		}
229
230		$fields = (array) $fields;
231		$search = array('or' => array());
232
233		foreach ($fields as $field) {
234		$search['or']["$field like"] = "%$query%";
235		}
236
237		$filter = array_merge($filter, $search);
238
239		return $this->read($resource, $filter, $order, $limit, $offset);
240		}
241
242		/**
243		* Retrieve the distinct values of the given resource's field.
244		*
245		* Returns a flat array of values.
246		*
247		* @param string $resource
248		* @param string $field
249		* @param array $filter [optional]
250		* @param array $order [optional]
251		* @param int $limit [optional]
252		* @param int $offset [optional]
253		* @return array
254		*/
255		public function distinct($resource, $field, array $filter = array(), $order = array(), $limit = 0, $offset = 0) {
256		$list = array();
257
258		$listing = $this->listing($resource, $field, $filter, $order, $limit, $offset);
259
260		foreach ($listing as $item) {
261		$list[] = $item[$field];
262		}
263
264		return array_unique($list);
265		}
266
267		/**
268		* Execute the given query.
269		*
270		* @param Query $query
271		* @return Result
272		*/
273		public function execute(Query $query)
274		{
275		$data = array();
276		$info = array();
277
278		switch ($query->type) {
279		case Query::CREATE:
280		$this->create($query->resource, $query->data);
281		break;
282		case Query::READ:
283		$data = $this->read(
284		$query->resource,
285		$query->filter,
286		$query->order,
287		$query->limit,
288		$query->offset
289		);
290		break;
291		case Query:UPDATE:
		1 ignored issue – show Coding Style introduced 2016-03-13 13:20 UTC by Report Bug Copy Issue Report The case body in a switch statement must start on the line following the statement. According to the PSR-2, the body of a case statement must start on the line immediately following the case statement. switch ($expr) { case "A": doSomething(); //right break; case "B": doSomethingElse(); //wrong break; } To learn more about the PSR-2 coding standard, please refer to the PHP-Fig. Loading history...
292		$info['affected'] = $this->update(
293		$query->resource,
294		$query->data,
295		$query->filter,
296		$query->limit
297		);
298		break;
299		case Query::DELETE:
300		$this->delete(
301		$query->resource,
302		$query->filter,
303		$query->limit
304		);
305		break;
306		}
307
308		return new Result($query, $data, $info);
309		}
310
311		/**
312		* Open a query on the given resource.
313		*
314		* @param string $resource
315		* @param array $fields [optional]
316		* @return Query\Builder
317		*/
318		public function query($resource, $fields = array())
319		{
320		return new Query\Builder(new Query($resource, $fields), $this);
321		}
322
323		/**
324		* Retrieve the error that occured with the last operation.
325		*
326		* Returns false if there was no error.
327		*
328		* @return string\|bool
329		*/
330		public function error() {
331		return false;
332		}
333
334		}
335

darya / framework

Push — master ( f7755d...fe6ccb )

InMemory::execute() B

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like