Entry_Collection::count() - Code Metrics - Inspection of "Revert "Let's move GF_Query out of \GV\View alread..." - gravityview/GravityView - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — develop ( a04d80...725627 )

by Zack

created 2020-07-16 16:32 UTC

Entry_Collection::count() A

↳ Parent: Entry_Collection::all()

Complexity

Conditions	1
Paths	1

Size

Total Lines

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
cc	1
nc	1
nop	0
dl	0
loc	3
ccs	2
cts	2
cp	1
crap	1
rs	10
c	0
b	0
f	0

<?php
namespace GV;

/** If this file is called directly, abort. */
if ( ! defined( 'GRAVITYVIEW_DIR' ) ) {
	die();
}

/**
 * A collection of \GV\Entry objects.
 */
class Entry_Collection extends Collection {
	/**
	 * Lazy fetching and counting of data defers
	 *  all processing of entries and entry data until
	 *  it is really requested.
	 *
	 * @see \GV\Entry_Collection::add_fetch_callback
	 * @see \GV\Entry_Collection::add_count_callback
	 *
	 * @var array Lazy data loading callbacks.
	 */
	private $callbacks = array();

	/**
	 * @var \GV\Entry_Filter[] Filtering criteria.
	 */
	public $filters = array();

	/**
	 * @var \GV\Entry_Sort[] Sorting criteria.
	 */
	public $sorts = array();

	/**
	 * @var int The offset.
	 */
	public $offset = 0;

	/**
	 * @var int The limit.
	 */
	public $limit = 20;

	/**
	 * @var int The current page.
	 */
	public $current_page = 1;

	/**
	 * @var int The number of entries fetched.
	 */
	private $fetched = -1;

	/**
	 * Add an \GV\Entry to this collection.
	 *
	 * @param \GV\Entry $entry The entry to add to the internal array.
	 *
	 * @api
	 * @since 2.0
	 * @return void
	 */
	public function add( $entry ) {
		if ( ! $entry instanceof Entry ) {
			$this->fetched = max( 0, $this->fetched );
			gravityview()->log->error( 'Entry_Collections can only contain objects of type \GV\Entry.' );
			return;
		}
		parent::add( $entry );
		$this->fetched = max( 1, $this->fetched + 1 );
	}

	/**
	 * Get a \GV\Entry from this list.
	 *
	 * @param int $entry_id The ID of the entry to get.
	 * @param string $backend The form backend identifier, allows for multiple form backends in the future. Unused until then.
	 *
	 * @api
	 * @since 2.0
	 *
	 * @return \GV\Entry|null The \GV\entry with the $entry_id as the ID, or null if not found.
	 */
	public function get( $entry_id, $backend = 'gravityforms' ) {

		foreach ( $this->all() as $entry ) {
			if ( $entry->ID == $entry_id ) {
				return $entry;
			}
		}
		return null;
	}

	/**
	 * Count the total number of \GV\Entry objects that are possible to get.
	 *
	 * @api
	 * @since 2.0
	 *
	 * @return int The total number of entries that are fetchable.
	 */
	public function total() {
		$total = 0;

		/** Call all lazy callbacks. */
		foreach ( $this->callbacks as $callback ) {
			if ( $callback[0] != 'count' ) {
				continue;
			}

			$total += $callback[1]( $this->filters );
		}

		if ( ! $total ) {
			$total = parent::count();
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}
		}

		return $total - $this->offset;
	}

	/**
	 * Get the entries as an array.
	 *
	 * @api
	 * @since 2.0
	 *
	 * @return \GV\Entry[] The entries as an array.
	 */
	public function all() {
		if ( $this->fetched >= 0 || parent::count() ) {
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}
			return parent::all();
		}
		return $this->fetch()->all();
	}

	/**
	 * Pluck by key.
	 *
	 * @api
	 * @since develop
	 *
	 * @param string $key The key to pluck by.
	 *
	 * @return array The plucked values.
	 */
	public function pluck( $key ) {
		$result = array();

		foreach ( $this->all() as $entry ) {
			$entry = $entry->as_entry();
			$result[] = Utils::get( $entry, $key, null );
		}

		return $result;
	}

	/**
	 * Get the last \GV\Entry in this collection.
	 *
	 * @api
	 * @since 2.0
	 *
	 * @return \GV\Entry|null The last entry or null.
	 */
	public function last() {
		if ( $this->fetched >= 0 || parent::count() ) {
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}
			return parent::last();
		}
		return $this->fetch()->last();
	}

	/**
	 * Get the first \GV\Entry in this collection.
	 *
	 * @api
	 * @since 2.0
	 *
	 * @return \GV\Entry|null The first entry or null.
	 */
	public function first() {
		if ( $this->fetched >= 0 || parent::count() ) {
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}
			return parent::first();
		}
		return $this->fetch()->first();
	}

	/**
	 * Hydrate this collection now.
	 *
	 * @api
	 * @since 2.0
	 *
	 * @return \GV\Entry_Collection This collection, now hydrated.
	 */
	public function fetch() {
		if ( $this->fetched >= 0 ) {
			return $this;
		}

		$this->clear();

		/** Calculate the offsets. */
		$offset = new \GV\Entry_Offset();
		$offset->limit = $this->limit;
		$offset->offset = ( $this->limit * ( $this->current_page - 1 ) ) + $this->offset;

		/** Call all lazy callbacks. */
		foreach ( $this->callbacks as $i => $callback ) {
			if ( $callback[0] != 'fetch' ) {
				continue;
			}

			$this->merge( $callback[1]( $this->filters, $this->sorts, $offset ) );
		}

		$this->fetched = parent::count();
class Daddy
{
    protected function getFirstName()
    {
        return "Eidur";
    }

    protected function getSurName()
    {
        return "Gudjohnsen";
    }
}

class Son
{
    public function getFirstName()
    {
        return parent::getSurname();
    }
}

		return $this;
	}

	/**
	 * Apply a filter to the current collection.
	 *
	 * This operation is non-destructive as a copy of the collection is returned.
	 *
	 * @param \GV\Entry_Filter $filter The filter to be applied.
	 *
	 * @api
	 * @since 2.0
	 *
	 * @return \GV\Entry_Collection A copy of the this collection with the filter applied.
	 */
	public function filter( \GV\Entry_Filter $filter ) {
		$collection = clone $this;
		$collection->clear();

		array_push( $collection->filters, $filter );

		return $collection;
	}

	/**
	 * Sort.
	 *
	 * @param \GV\Entry_Sort $sort The sort to apply to this collection.
	 *
	 * @api
	 * @since 2.0
	 *
	 * @return \GV\Entry_Collection A copy of the this collection with the sort applied.
	 */
	public function sort( $sort ) {
		$collection = clone $this;
		$collection->clear();

		array_push( $collection->sorts, $sort );

		return $collection;
	}

	/**
	 * Limit the fetch to a specified window.
	 *
	 * @param int $limit The limit.
	 *
	 * @api
	 * @since 2.0
	 *
	 * @return \GV\Entry_Collection A copy of the this collection with the limit applied.
	 */
	public function limit( $limit ) {
		$collection = clone $this;
		$collection->clear();
		$collection->limit = $limit;
		return $collection;
	}

	/**
	 * Add an $offset to these entries.
	 *
	 * Useful, you know, for pagination and stuff. Not too useful directly.
	 *
	 * @see \GV\Entry_Collection::page()
	 *
	 * @param int $offset The number of entries to skip in the database.
	 *
	 * @api
	 * @since 2.0
	 *
	 * @return \GV\Entry_Collection A copy of the this collection with the offset applied.
	 */
	public function offset( $offset ) {
		$collection = clone $this;
		$collection->clear();
		$collection->offset = $offset;
		return $collection;
	}

	/**
	 * Set the current page.
	 *
	 * @param int $page Set the current page to this page. Ends up agumenting the $offset in \GV\Entry_Offset
	 *
	 * @return \GV\Entry_Collection A copy of the this collection with the offset applied.
	 */
	public function page( $page ) {
		$collection = clone $this;
		$collection->clear();
		$collection->current_page = $page;
		return $collection;
	}

	/**
	 * Defer fetching of data to the provided callable.
	 *
	 * The callback signature should be as follows:
	 *  \GV\Entry_Collection callback( \GV\Entry_Filter $filter, \GV\Entry_Sort $sort, \GV\Entry_Offset $offset );
	 *
	 * The methods that trigger the callback are:
	 * - \GV\Entry_Collection::fetch
	 *
	 * ::fetch is triggered via:
	 * - \GV\Entry_Collection::all
	 * - \GV\Entry_Collection::last
	 *
	 * @param callable $callback The callback to call when needed.
	 *
	 * @internal
	 * @since 2.0
	 *
	 * @return void
	 */
	public function add_fetch_callback( $callback ) {
		$this->add_callback( 'fetch', $callback );
	}

	/**
	 * Defer counting of data to the provided callable.
	 *
	 * The callback signature should be as follows:
	 *  int callback( \GV\Entry_Filter $filter );
	 *
	 * The methods that trigger the callback are:
	 * - \GV\Entry_Collection::count
	 *
	 * @param callable $callback The callback to call when needed.
	 *
	 * @internal
	 * @since 2.0
	 *
	 * @return void
	 */
	public function add_count_callback( $callback ) {
		$this->add_callback( 'count', $callback );
	}

	/**
	 * Add a callback for lazy loading/counting.
	 *
	 * @param callable $callback The callback to call when needed.
	 *
	 * @return void
	 */
	private function add_callback( $type, $callback ) {
		if ( ! is_callable( $callback ) ) {
			return;
		}

		$this->callbacks []= array( $type, $callback );
	}

	/**
	 * @inheritdoc
	 */
	public function clear() {
		$this->fetched = -1;
		parent::clear();
	}
}


1		<?php
2		namespace GV;
3
4		/** If this file is called directly, abort. */
5		if ( ! defined( 'GRAVITYVIEW_DIR' ) ) {
6		die();
7		}
8
9		/**
10		* A collection of \GV\Entry objects.
11		*/
12		class Entry_Collection extends Collection {
13		/**
14		* Lazy fetching and counting of data defers
15		* all processing of entries and entry data until
16		* it is really requested.
17		*
18		* @see \GV\Entry_Collection::add_fetch_callback
19		* @see \GV\Entry_Collection::add_count_callback
20		*
21		* @var array Lazy data loading callbacks.
22		*/
23		private $callbacks = array();
24
25		/**
26		* @var \GV\Entry_Filter[] Filtering criteria.
27		*/
28		public $filters = array();
29
30		/**
31		* @var \GV\Entry_Sort[] Sorting criteria.
32		*/
33		public $sorts = array();
34
35		/**
36		* @var int The offset.
37		*/
38		public $offset = 0;
39
40		/**
41		* @var int The limit.
42		*/
43		public $limit = 20;
44
45		/**
46		* @var int The current page.
47		*/
48		public $current_page = 1;
49
50		/**
51		* @var int The number of entries fetched.
52		*/
53		private $fetched = -1;
54
55		/**
56		* Add an \GV\Entry to this collection.
57		*
58		* @param \GV\Entry $entry The entry to add to the internal array.
59		*
60		* @api
61		* @since 2.0
62		* @return void
63		*/
64	76	public function add( $entry ) {
65	76	if ( ! $entry instanceof Entry ) {
66		$this->fetched = max( 0, $this->fetched );
67		gravityview()->log->error( 'Entry_Collections can only contain objects of type \GV\Entry.' );
68		return;
69		}
70	76	parent::add( $entry );
71	76	$this->fetched = max( 1, $this->fetched + 1 );
72	76	}
73
74		/**
75		* Get a \GV\Entry from this list.
76		*
77		* @param int $entry_id The ID of the entry to get.
78		* @param string $backend The form backend identifier, allows for multiple form backends in the future. Unused until then.
79		*
80		* @api
81		* @since 2.0
82		*
83		* @return \GV\Entry\|null The \GV\entry with the $entry_id as the ID, or null if not found.
84		*/
85		public function get( $entry_id, $backend = 'gravityforms' ) {
		0 ignored issues – show Unused Code introduced 2017-08-01 22:04 UTC by Report Bug Copy Issue Report The parameter `$backend` is not used and could be removed. This check looks from parameters that have been defined for a function or method, but which are not used in the method body. Loading history...
86		foreach ( $this->all() as $entry ) {
87		if ( $entry->ID == $entry_id ) {
88		return $entry;
89		}
90		}
91		return null;
92		}
93
94		/**
95		* Count the total number of \GV\Entry objects that are possible to get.
96		*
97		* @api
98		* @since 2.0
99		*
100		* @return int The total number of entries that are fetchable.
101		*/
102	49	public function total() {
103	49	$total = 0;
104
105		/** Call all lazy callbacks. */
106	49	foreach ( $this->callbacks as $callback ) {
107	33	if ( $callback[0] != 'count' ) {
108	1	continue;
109		}
110
111	33	$total += $callback[1]( $this->filters );
112		}
113
114	49	if ( ! $total ) {
115	28	$total = parent::count();
		0 ignored issues – show Comprehensibility Bug introduced 2018-05-08 22:39 UTC by Report Bug Copy Issue Report It seems like you call parent on a different method (`count()` instead of `total()`). Are you sure this is correct? If so, you might want to change this to `$this->count()`. This check looks for a call to a parent method whose name is different than the method from which it is called. Consider the following code: class Daddy { protected function getFirstName() { return "Eidur"; } protected function getSurName() { return "Gudjohnsen"; } } class Son { public function getFirstName() { return parent::getSurname(); } } The `getFirstName()` method in the `Son` calls the wrong method in the parent class. Loading history...
116		}
117
118	49	return $total - $this->offset;
119		}
120
121		/**
122		* Get the entries as an array.
123		*
124		* @api
125		* @since 2.0
126		*
127		* @return \GV\Entry[] The entries as an array.
128		*/
129	70	public function all() {
130	70	if ( $this->fetched >= 0 \|\| parent::count() ) {
		0 ignored issues – show Comprehensibility Bug introduced 2017-03-29 06:38 UTC by Report Bug Copy Issue Report It seems like you call parent on a different method (`count()` instead of `all()`). Are you sure this is correct? If so, you might want to change this to `$this->count()`. This check looks for a call to a parent method whose name is different than the method from which it is called. Consider the following code: class Daddy { protected function getFirstName() { return "Eidur"; } protected function getSurName() { return "Gudjohnsen"; } } class Son { public function getFirstName() { return parent::getSurname(); } } The `getFirstName()` method in the `Son` calls the wrong method in the parent class. Loading history...
131	70	return parent::all();
132		}
133	20	return $this->fetch()->all();
134		}
135
136		/**
137		* Pluck by key.
138		*
139		* @api
140		* @since develop
141		*
142		* @param string $key The key to pluck by.
143		*
144		* @return array The plucked values.
145		*/
146	1	public function pluck( $key ) {
147	1	$result = array();
148
149	1	foreach ( $this->all() as $entry ) {
150	1	$entry = $entry->as_entry();
151	1	$result[] = Utils::get( $entry, $key, null );
152		}
153
154	1	return $result;
155		}
156
157		/**
158		* Get the last \GV\Entry in this collection.
159		*
160		* @api
161		* @since 2.0
162		*
163		* @return \GV\Entry\|null The last entry or null.
164		*/
165		public function last() {
166		if ( $this->fetched >= 0 \|\| parent::count() ) {
		0 ignored issues – show Comprehensibility Bug introduced 2017-03-29 06:38 UTC by Report Bug Copy Issue Report It seems like you call parent on a different method (`count()` instead of `last()`). Are you sure this is correct? If so, you might want to change this to `$this->count()`. This check looks for a call to a parent method whose name is different than the method from which it is called. Consider the following code: class Daddy { protected function getFirstName() { return "Eidur"; } protected function getSurName() { return "Gudjohnsen"; } } class Son { public function getFirstName() { return parent::getSurname(); } } The `getFirstName()` method in the `Son` calls the wrong method in the parent class. Loading history...
167		return parent::last();
168		}
169		return $this->fetch()->last();
170		}
171
172		/**
173		* Get the first \GV\Entry in this collection.
174		*
175		* @api
176		* @since 2.0
177		*
178		* @return \GV\Entry\|null The first entry or null.
179		*/
180	4	public function first() {
181	4	if ( $this->fetched >= 0 \|\| parent::count() ) {
		0 ignored issues – show Comprehensibility Bug introduced 2018-05-08 22:39 UTC by Report Bug Copy Issue Report It seems like you call parent on a different method (`count()` instead of `first()`). Are you sure this is correct? If so, you might want to change this to `$this->count()`. This check looks for a call to a parent method whose name is different than the method from which it is called. Consider the following code: class Daddy { protected function getFirstName() { return "Eidur"; } protected function getSurName() { return "Gudjohnsen"; } } class Son { public function getFirstName() { return parent::getSurname(); } } The `getFirstName()` method in the `Son` calls the wrong method in the parent class. Loading history...
182	4	return parent::first();
183		}
184	2	return $this->fetch()->first();
185		}
186
187		/**
188		* Hydrate this collection now.
189		*
190		* @api
191		* @since 2.0
192		*
193		* @return \GV\Entry_Collection This collection, now hydrated.
194		*/
195	27	public function fetch() {
196	27	if ( $this->fetched >= 0 ) {
197	6	return $this;
198		}
199
200	24	$this->clear();
201
202		/** Calculate the offsets. */
203	24	$offset = new \GV\Entry_Offset();
204	24	$offset->limit = $this->limit;
205	24	$offset->offset = ( $this->limit * ( $this->current_page - 1 ) ) + $this->offset;
206
207		/** Call all lazy callbacks. */
208	24	foreach ( $this->callbacks as $i => $callback ) {
209	20	if ( $callback[0] != 'fetch' ) {
210	20	continue;
211		}
212
213		$this->merge( $callback[1]( $this->filters, $this->sorts, $offset ) );
214		}
215
216	24	$this->fetched = parent::count();
		0 ignored issues – show Comprehensibility Bug introduced 2018-11-21 14:42 UTC by Report Bug Copy Issue Report It seems like you call parent on a different method (`count()` instead of `fetch()`). Are you sure this is correct? If so, you might want to change this to `$this->count()`. This check looks for a call to a parent method whose name is different than the method from which it is called. Consider the following code: class Daddy { protected function getFirstName() { return "Eidur"; } protected function getSurName() { return "Gudjohnsen"; } } class Son { public function getFirstName() { return parent::getSurname(); } } The `getFirstName()` method in the `Son` calls the wrong method in the parent class. Loading history...
217
218	24	return $this;
219		}
220
221		/**
222		* Apply a filter to the current collection.
223		*
224		* This operation is non-destructive as a copy of the collection is returned.
225		*
226		* @param \GV\Entry_Filter $filter The filter to be applied.
227		*
228		* @api
229		* @since 2.0
230		*
231		* @return \GV\Entry_Collection A copy of the this collection with the filter applied.
232		*/
233	1	public function filter( \GV\Entry_Filter $filter ) {
234	1	$collection = clone $this;
235	1	$collection->clear();
236
237	1	array_push( $collection->filters, $filter );
238
239	1	return $collection;
240		}
241
242		/**
243		* Sort.
244		*
245		* @param \GV\Entry_Sort $sort The sort to apply to this collection.
246		*
247		* @api
248		* @since 2.0
249		*
250		* @return \GV\Entry_Collection A copy of the this collection with the sort applied.
251		*/
252	1	public function sort( $sort ) {
253	1	$collection = clone $this;
254	1	$collection->clear();
255
256	1	array_push( $collection->sorts, $sort );
257
258	1	return $collection;
259		}
260
261		/**
262		* Limit the fetch to a specified window.
263		*
264		* @param int $limit The limit.
265		*
266		* @api
267		* @since 2.0
268		*
269		* @return \GV\Entry_Collection A copy of the this collection with the limit applied.
270		*/
271	1	public function limit( $limit ) {
272	1	$collection = clone $this;
273	1	$collection->clear();
274	1	$collection->limit = $limit;
275	1	return $collection;
276		}
277
278		/**
279		* Add an $offset to these entries.
280		*
281		* Useful, you know, for pagination and stuff. Not too useful directly.
282		*
283		* @see \GV\Entry_Collection::page()
284		*
285		* @param int $offset The number of entries to skip in the database.
286		*
287		* @api
288		* @since 2.0
289		*
290		* @return \GV\Entry_Collection A copy of the this collection with the offset applied.
291		*/
292	1	public function offset( $offset ) {
293	1	$collection = clone $this;
294	1	$collection->clear();
295	1	$collection->offset = $offset;
296	1	return $collection;
297		}
298
299		/**
300		* Set the current page.
301		*
302		* @param int $page Set the current page to this page. Ends up agumenting the $offset in \GV\Entry_Offset
303		*
304		* @return \GV\Entry_Collection A copy of the this collection with the offset applied.
305		*/
306	1	public function page( $page ) {
307	1	$collection = clone $this;
308	1	$collection->clear();
309	1	$collection->current_page = $page;
310	1	return $collection;
311		}
312
313		/**
314		* Defer fetching of data to the provided callable.
315		*
316		* The callback signature should be as follows:
317		* \GV\Entry_Collection callback( \GV\Entry_Filter $filter, \GV\Entry_Sort $sort, \GV\Entry_Offset $offset );
318		*
319		* The methods that trigger the callback are:
320		* - \GV\Entry_Collection::fetch
321		*
322		* ::fetch is triggered via:
323		* - \GV\Entry_Collection::all
324		* - \GV\Entry_Collection::last
325		*
326		* @param callable $callback The callback to call when needed.
327		*
328		* @internal
329		* @since 2.0
330		*
331		* @return void
332		*/
333		public function add_fetch_callback( $callback ) {
334		$this->add_callback( 'fetch', $callback );
335		}
336
337		/**
338		* Defer counting of data to the provided callable.
339		*
340		* The callback signature should be as follows:
341		* int callback( \GV\Entry_Filter $filter );
342		*
343		* The methods that trigger the callback are:
344		* - \GV\Entry_Collection::count
345		*
346		* @param callable $callback The callback to call when needed.
347		*
348		* @internal
349		* @since 2.0
350		*
351		* @return void
352		*/
353	73	public function add_count_callback( $callback ) {
354	73	$this->add_callback( 'count', $callback );
355	73	}
356
357		/**
358		* Add a callback for lazy loading/counting.
359		*
360		* @param callable $callback The callback to call when needed.
361		*
362		* @return void
363		*/
364	73	private function add_callback( $type, $callback ) {
365	73	if ( ! is_callable( $callback ) ) {
366		return;
367		}
368
369	73	$this->callbacks []= array( $type, $callback );
370	73	}
371
372		/**
373		* @inheritdoc
374		*/
375	24	public function clear() {
376	24	$this->fetched = -1;
377	24	parent::clear();
378	24	}
379		}
380

gravityview / GravityView

Push — develop ( a04d80...725627 )

Entry_Collection::count() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like