Collection::getPaginationNbPages() - Code Metrics - Inspection of "feat: expose helper for pagination" - suricate-php/framework - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — release/0.4.15 ( 32dbb2 )

by Mathieu

created 2022-09-03 08:34 UTC

Collection::getPaginationNbPages() A

↳ Parent: Collection

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	1
nc	1
nop	0
dl	0
loc	3
rs	10
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace Suricate;

class Collection implements
    \Iterator,
    \Countable,
    \ArrayAccess,
    Interfaces\ICollection
{
    protected $iteratorPosition = 0;

    protected $items = [];
    public $pagination = [
        'nbPages' => 0,
        'page' => 1,
        'nbItems' => 0
    ];

    public function __construct($items = [])
    {
        $this->items = $items;
    }

    public function paginate($nbItemPerPage, $currentPage = 1)
    {
        $this->pagination['page'] = $currentPage;
        $this->pagination['nbItems'] = count($this->items);
        $this->pagination['nbPages'] = (int) ceil(
            $this->pagination['nbItems'] / $nbItemPerPage
        );

        $this->items = array_slice(
            $this->items,
            ($currentPage - 1) * $nbItemPerPage,
            $nbItemPerPage
        );

        return $this;
    }

    /**
     * Get current page number
     *
     * @return integer
     */
    public function getPaginationCurrentPage(): int
    {
        return $this->pagination['page'];
    }

    /**
     * Get total number of pages
     *
     * @return integer
     */
    public function getPaginationNbPages(): int
    {
        return $this->pagination['nbPages'];
    }

    public function getPossibleValuesFor($args, $key = null)
    {
        if (!is_array($args)) {
            $args = [
                'format' => '%s',
                'data' => [$args]
            ];
        }

        $values = [];
        foreach ($this->items as $item) {
            $itemValues = [];
            foreach ($args['data'] as $arg) {
                $itemValues[] = dataGet($item, $arg);
            }

            $arrayKey = $key !== null ? dataGet($item, $key) : null;
            if (is_null($arrayKey)) {
                $values[] = vsprintf($args['format'], $itemValues);
            } else {
                $values[$arrayKey] = vsprintf($args['format'], $itemValues);
            }
        }

        return $values;
    }

    public function getValuesFor($name)
    {
        $values = [];
        foreach ($this->items as $item) {
            $values[] = dataGet($item, $name);
        }

        return $values;
    }

    public function getItems()
    {
        return $this->items;
    }

    /**
     * Implementation of countable interface
     *
     * @return int
     */
    public function count(): int
    {
        return count($this->items);
    }

    public function key()
    {
        return $this->iteratorPosition;
    }

    public function next()
    {
        ++$this->iteratorPosition;
    }
    public function current()
    {
        return $this->offsetGet($this->iteratorPosition);
    }
    public function rewind()
    {
        $this->iteratorPosition = 0;
    }
    public function valid()
    {
        return isset($this->items[$this->iteratorPosition]);
    }
    /**
     * Implementation of ArrayAccess interface
     *
     * @param  mixed $offset Offset to verify
     * @return bool
     */
    public function offsetExists($offset): bool
    {
        return \array_key_exists($offset, $this->items);
    }

    /**
     * Implementation of ArrayAccess Interface
     *
     * @param  mixed $offset Offset to get
     * @return mixed
     */
    public function offsetGet($offset)
    {
        if (array_key_exists($offset, $this->items)) {
            return $this->items[$offset];
        }
        return null;
    }

    /**
     * Implementation of ArrayAccess Interface
     *
     * @param mixed $offset Offset to set
     * @param mixed $value  Value to set
     */
    public function offsetSet($offset, $value)
    {
        if (is_null($offset)) {
            $this->items[] = $value;
        } else {
            $this->items[$offset] = $value;
        }
    }

    /**
     * Implementation of ArrayAccess Interface
     *
     * @param mixed $offset Offset to unset
     */
    public function offsetUnset($offset)
    {
        unset($this->items[$offset]);
    }

    // Helpers

    /**
     * Get first item of the collection
     *
     * @return mixed
     */
    public function first()
    {
        foreach ($this->items as $currentItem) {
            return $currentItem;
        }
    }

    /**
     * Get last item of the collection
     *
     * @return mixed
     */
    public function last()
    {
        if (count($this->items)) {
            return end($this->items);
        }

        return null;
    }

    /**
     * Check if collection is empty
     *
     * @return bool
     */
    public function isEmpty(): bool
    {
        return empty($this->items);
    }

    /**
     * Return the sum of the collection
     *
     * @param mixed $field Field to use for sum
     * @return double|integer
     */
    public function sum($field = null)
    {
        if ($field === null) {
            return array_sum($this->items);
        }
        $result = 0;
        foreach ($this->items as $item) {
            $result += dataGet($item, $field);
        }
        return $result;
    }

    public function random($nbItems = 1)
    {
        if ($this->isEmpty()) {
            return null;
        }

        $keys = array_rand($this->items, $nbItems);

        if (is_array($keys)) {
            return array_intersect_key($this->items, array_flip($keys));
        }

        return $this->items[$keys];
    }

    public function shuffle()
    {
        shuffle($this->items);

        return $this;
    }

    public function unique()
    {
        return new static(array_unique($this->items));
    }

    /**
     * Apply a closure to each element of the collection
     *
     * @param \Closure $callback Closure to apply
     * @return Collection
     */
    public function each(\Closure $callback): Collection
    {
        array_map($callback, $this->items);
        return $this;
    }

    /**
     * Sort a collection using a closure
     *
     * @param \Closure $closure Closure to apply for sorting, similar to uasort() closure
     * @return Collection
     */
    public function sort(\Closure $closure): Collection
    {
        uasort($this->items, $closure);

        return $this;
    }

    public function sortBy($field, $reverse = false)
    {
        if ($reverse) {
            $sortFunction = function ($a, $b) use ($field) {
                $first = dataGet($a, $field);
                $second = dataGet($b, $field);
                if ($first == $second) {
                    return 0;
                }
                return $first > $second ? -1 : 1;
            };
        } else {
            $sortFunction = function ($a, $b) use ($field) {
                $first = dataGet($a, $field);
                $second = dataGet($b, $field);
                if ($first == $second) {
                    return 0;
                }
                return $first < $second ? -1 : 1;
            };
        }

        usort($this->items, $sortFunction);

        return $this;
    }

    public function filter(\Closure $closure)
    {
        return new static(array_filter($this->items, $closure));
    }

    public function search($value, $strict = false)
    {
        return array_search($value, $this->items, $strict);
    }

    public function has($key)
    {
        return $this->offsetExists($key);
    }

    public function keys()
    {
        return array_keys($this->items);
    }

    public function prepend($item)
    {
        array_unshift($this->items, $item);

        return $this;
    }

    public function push($item)
    {
        $this->items[] = $item;

        return $this;
    }

    public function put($key, $val)
    {
        $this->items[$key] = $val;

        return $this;
    }
    public function shift()
    {
        return array_shift($this->items);
    }

    public function pop()
    {
        return array_pop($this->items);
    }

    public function reverse()
    {
        return new static(array_reverse($this->items));
    }

    public function reduce(callable $callback, $initial = null)
    {
        return array_reduce($this->items, $callback, $initial);
    }

    public function slice($offset, $length = null, $preserveKeys = false)
    {
        return new static(
            array_slice($this->items, $offset, $length, $preserveKeys)
        );
    }

    public function take($limit = null)
    {
        if ($limit < 0) {
            return $this->slice(abs($limit), $limit);
        }

        return $this->slice(0, $limit);
    }

    public function splice($offset, $length = null, $replacement = [])
    {
        return new static(
            array_splice($this->items, $offset, $length, $replacement)
        );
    }

    public function chunk($size, $preserveKeys = false)
    {
        $result = new static();
        foreach (array_chunk($this->items, $size, $preserveKeys) as $chunk) {
            $result->push(new static($chunk));
        }
        return $result;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Suricate;
6
7			class Collection implements
8			\Iterator,
9			\Countable,
10			\ArrayAccess,
11			Interfaces\ICollection
12			{
13			protected $iteratorPosition = 0;
14
15			protected $items = [];
16			public $pagination = [
17			'nbPages' => 0,
18			'page' => 1,
19			'nbItems' => 0
20			];
21
22			public function __construct($items = [])
23			{
24			$this->items = $items;
25			}
26
27			public function paginate($nbItemPerPage, $currentPage = 1)
28			{
29			$this->pagination['page'] = $currentPage;
30			$this->pagination['nbItems'] = count($this->items);
31			$this->pagination['nbPages'] = (int) ceil(
32			$this->pagination['nbItems'] / $nbItemPerPage
33			);
34
35			$this->items = array_slice(
36			$this->items,
37			($currentPage - 1) * $nbItemPerPage,
38			$nbItemPerPage
39			);
40
41			return $this;
42			}
43
44			/**
45			* Get current page number
46			*
47			* @return integer
48			*/
49			public function getPaginationCurrentPage(): int
50			{
51			return $this->pagination['page'];
52			}
53
54			/**
55			* Get total number of pages
56			*
57			* @return integer
58			*/
59			public function getPaginationNbPages(): int
60			{
61			return $this->pagination['nbPages'];
62			}
63
64			public function getPossibleValuesFor($args, $key = null)
65			{
66			if (!is_array($args)) {
67			$args = [
68			'format' => '%s',
69			'data' => [$args]
70			];
71			}
72
73			$values = [];
74			foreach ($this->items as $item) {
75			$itemValues = [];
76			foreach ($args['data'] as $arg) {
77			$itemValues[] = dataGet($item, $arg);
78			}
79
80			$arrayKey = $key !== null ? dataGet($item, $key) : null;
81			if (is_null($arrayKey)) {
82			$values[] = vsprintf($args['format'], $itemValues);
83			} else {
84			$values[$arrayKey] = vsprintf($args['format'], $itemValues);
85			}
86			}
87
88			return $values;
89			}
90
91			public function getValuesFor($name)
92			{
93			$values = [];
94			foreach ($this->items as $item) {
95			$values[] = dataGet($item, $name);
96			}
97
98			return $values;
99			}
100
101			public function getItems()
102			{
103			return $this->items;
104			}
105
106			/**
107			* Implementation of countable interface
108			*
109			* @return int
110			*/
111			public function count(): int
112			{
113			return count($this->items);
114			}
115
116			public function key()
117			{
118			return $this->iteratorPosition;
119			}
120
121			public function next()
122			{
123			++$this->iteratorPosition;
124			}
125			public function current()
126			{
127			return $this->offsetGet($this->iteratorPosition);
128			}
129			public function rewind()
130			{
131			$this->iteratorPosition = 0;
132			}
133			public function valid()
134			{
135			return isset($this->items[$this->iteratorPosition]);
136			}
137			/**
138			* Implementation of ArrayAccess interface
139			*
140			* @param mixed $offset Offset to verify
141			* @return bool
142			*/
143			public function offsetExists($offset): bool
144			{
145			return \array_key_exists($offset, $this->items);
146			}
147
148			/**
149			* Implementation of ArrayAccess Interface
150			*
151			* @param mixed $offset Offset to get
152			* @return mixed
153			*/
154			public function offsetGet($offset)
155			{
156			if (array_key_exists($offset, $this->items)) {
157			return $this->items[$offset];
158			}
159			return null;
160			}
161
162			/**
163			* Implementation of ArrayAccess Interface
164			*
165			* @param mixed $offset Offset to set
166			* @param mixed $value Value to set
167			*/
168			public function offsetSet($offset, $value)
169			{
170			if (is_null($offset)) {
171			$this->items[] = $value;
172			} else {
173			$this->items[$offset] = $value;
174			}
175			}
176
177			/**
178			* Implementation of ArrayAccess Interface
179			*
180			* @param mixed $offset Offset to unset
181			*/
182			public function offsetUnset($offset)
183			{
184			unset($this->items[$offset]);
185			}
186
187			// Helpers
188
189			/**
190			* Get first item of the collection
191			*
192			* @return mixed
193			*/
194			public function first()
195			{
196			foreach ($this->items as $currentItem) {
197			return $currentItem;
198			}
199			}
200
201			/**
202			* Get last item of the collection
203			*
204			* @return mixed
205			*/
206			public function last()
207			{
208			if (count($this->items)) {
209			return end($this->items);
210			}
211
212			return null;
213			}
214
215			/**
216			* Check if collection is empty
217			*
218			* @return bool
219			*/
220			public function isEmpty(): bool
221			{
222			return empty($this->items);
223			}
224
225			/**
226			* Return the sum of the collection
227			*
228			* @param mixed $field Field to use for sum
229			* @return double\|integer
230			*/
231			public function sum($field = null)
232			{
233			if ($field === null) {
234			return array_sum($this->items);
235			}
236			$result = 0;
237			foreach ($this->items as $item) {
238			$result += dataGet($item, $field);
239			}
240			return $result;
241			}
242
243			public function random($nbItems = 1)
244			{
245			if ($this->isEmpty()) {
246			return null;
247			}
248
249			$keys = array_rand($this->items, $nbItems);
250
251			if (is_array($keys)) {
252			return array_intersect_key($this->items, array_flip($keys));
253			}
254
255			return $this->items[$keys];
256			}
257
258			public function shuffle()
259			{
260			shuffle($this->items);
261
262			return $this;
263			}
264
265			public function unique()
266			{
267			return new static(array_unique($this->items));
268			}
269
270			/**
271			* Apply a closure to each element of the collection
272			*
273			* @param \Closure $callback Closure to apply
274			* @return Collection
275			*/
276			public function each(\Closure $callback): Collection
277			{
278			array_map($callback, $this->items);
279			return $this;
280			}
281
282			/**
283			* Sort a collection using a closure
284			*
285			* @param \Closure $closure Closure to apply for sorting, similar to uasort() closure
286			* @return Collection
287			*/
288			public function sort(\Closure $closure): Collection
289			{
290			uasort($this->items, $closure);
291
292			return $this;
293			}
294
295			public function sortBy($field, $reverse = false)
296			{
297			if ($reverse) {
298			$sortFunction = function ($a, $b) use ($field) {
299			$first = dataGet($a, $field);
300			$second = dataGet($b, $field);
301			if ($first == $second) {
302			return 0;
303			}
304			return $first > $second ? -1 : 1;
305			};
306			} else {
307			$sortFunction = function ($a, $b) use ($field) {
308			$first = dataGet($a, $field);
309			$second = dataGet($b, $field);
310			if ($first == $second) {
311			return 0;
312			}
313			return $first < $second ? -1 : 1;
314			};
315			}
316
317			usort($this->items, $sortFunction);
318
319			return $this;
320			}
321
322			public function filter(\Closure $closure)
323			{
324			return new static(array_filter($this->items, $closure));
325			}
326
327			public function search($value, $strict = false)
328			{
329			return array_search($value, $this->items, $strict);
330			}
331
332			public function has($key)
333			{
334			return $this->offsetExists($key);
335			}
336
337			public function keys()
338			{
339			return array_keys($this->items);
340			}
341
342			public function prepend($item)
343			{
344			array_unshift($this->items, $item);
345
346			return $this;
347			}
348
349			public function push($item)
350			{
351			$this->items[] = $item;
352
353			return $this;
354			}
355
356			public function put($key, $val)
357			{
358			$this->items[$key] = $val;
359
360			return $this;
361			}
362			public function shift()
363			{
364			return array_shift($this->items);
365			}
366
367			public function pop()
368			{
369			return array_pop($this->items);
370			}
371
372			public function reverse()
373			{
374			return new static(array_reverse($this->items));
375			}
376
377			public function reduce(callable $callback, $initial = null)
378			{
379			return array_reduce($this->items, $callback, $initial);
380			}
381
382			public function slice($offset, $length = null, $preserveKeys = false)
383			{
384			return new static(
385			array_slice($this->items, $offset, $length, $preserveKeys)
386			);
387			}
388
389			public function take($limit = null)
390			{
391			if ($limit < 0) {
392			return $this->slice(abs($limit), $limit);
393			}
394
395			return $this->slice(0, $limit);
396			}
397
398			public function splice($offset, $length = null, $replacement = [])
399			{
400			return new static(
401			array_splice($this->items, $offset, $length, $replacement)
402			);
403			}
404
405			public function chunk($size, $preserveKeys = false)
406			{
407			$result = new static();
408			foreach (array_chunk($this->items, $size, $preserveKeys) as $chunk) {
409			$result->push(new static($chunk));
410			}
411			return $result;
412			}
413			}
414

suricate-php / framework

Push — release/0.4.15 ( 32dbb2 )

Collection::getPaginationNbPages() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like