Collection::find() - Code Metrics - teodoroleckie/collection - Measure and Improve Code Quality continuously with Scrutinizer

Collection::find() A
last analyzed 2021-05-19 13:23 UTC

↳ Parent: Collection

Complexity

Conditions	3
Paths	3

Size

Total Lines	12
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

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

<?php

namespace Tleckie\Collection;

use Closure;
use function array_push;
use function array_reverse;
use function array_shift;
use function array_unshift;
use function current;
use function key;
use function next;
use function reset;
use function shuffle;
use function usort;

/**
 * Class Collection
 *
 * @package Tleckie\Collection
 * @author  Teodoro Leckie Westberg <[email protected]>
 */
class Collection implements CollectionInterface
{
    /**
     * @var array
     */
    protected array $items;

    /**
     * Collection constructor.
     *
     * @param array|CollectionInterface $items
     */
    public function __construct(array|CollectionInterface $items = [])
    {
        $this->items = ($items instanceof CollectionInterface) ? $items->toArray() : $items;
    }

    /**
     * @param callable|Closure $callable
     * @return CollectionInterface
     */
    public function filter(callable|Closure $callable): CollectionInterface
    {
        return $this->internalFilter($callable);
    }

    /**
     * @param callable|Closure $callable
     * @param bool             $keep
     * @return CollectionInterface
     */
    private function internalFilter(callable|Closure $callable, bool $keep = true): CollectionInterface
    {
        $items = [];
        $copy = $this->items;

        foreach ($copy as $key => $value) {
            if ($keep === $callable($key, $value)) {
                $items[$key] = $value;
            }
        }

        return new Collection($items);
    }

    /**
     * @param callable|Closure $callable
     * @return CollectionInterface
     */
    public function filterNot(callable|Closure $callable): CollectionInterface
    {
        return $this->internalFilter($callable, false);
    }

    /**
     * @param callable|Closure $callable
     * @return CollectionInterface
     */
    public function find(callable|Closure $callable): CollectionInterface
    {
        $items = [];
        $copy = $this->items;

        foreach ($copy as $key => $value) {
            if ($callable($key, $value) === true) {
                $items[$key] = $value;
            }
        }

        return new Collection($items);
    }

    /**
     * @param string|int $index
     * @return mixed
     */
    public function findIndex(string|int $index): mixed
    {
        foreach ($this->items as $key => $value) {
            if ($key === $index) {
                return $value;
            }
        }

        return false;
    }

    /**
     * @param callable|Closure $callable
     * @return CollectionInterface
     */
    public function sort(callable|Closure $callable): CollectionInterface
    {
        $items = $this->items;

        usort($items, $callable);

        return new Collection($items);
    }

    /**
     * @return CollectionInterface
     */
    public function shuffle(): CollectionInterface
    {
        $items = $this->items;
        shuffle($items);

        return new Collection($items);
    }

    /**
     * @return CollectionInterface
     */
    public function reverse(): CollectionInterface
    {
        return new Collection(
            array_reverse($this->items, true)
        );
    }

    /**
     * @param mixed $item
     * @return CollectionInterface
     */
    public function prepend(mixed $item): CollectionInterface
    {
        array_unshift($this->items, $item);

        return $this;
    }

    /**
     * @return array
     */
    public function toArray(): array
    {
        return $this->items;
    }

    /**
     * @return mixed
     */
    public function current(): mixed
    {
        return current($this->items);
    }

    public function next(): void
    {
        next($this->items);
    }

    /**
     * @return bool
     */
    public function valid(): bool
    {
        return $this->key() !== null;
    }

    /**
     * @return string|float|int|bool|null
     */
    public function key(): string|float|int|bool|null
    {
        return key($this->items);
    }

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

    /**
     * @return mixed
     */
    public function rewind(): mixed
    {
        return reset($this->items);
    }

    /**
     * @param mixed $item
     * @return CollectionInterface
     */
    public function push(mixed $item): CollectionInterface
    {
        return $this->append($item);
    }

    /**
     * @param mixed $item
     * @return CollectionInterface
     */
    public function append(mixed $item): CollectionInterface
    {
        array_push($this->items, $item);

        return $this;
    }

    /**
     * @return mixed
     */
    public function pull(): mixed
    {
        return array_shift($this->items);
    }
}


1			<?php
2
3			namespace Tleckie\Collection;
4
5			use Closure;
6			use function array_push;
7			use function array_reverse;
8			use function array_shift;
9			use function array_unshift;
10			use function current;
11			use function key;
12			use function next;
13			use function reset;
14			use function shuffle;
15			use function usort;
16
17			/**
18			* Class Collection
19			*
20			* @package Tleckie\Collection
21			* @author Teodoro Leckie Westberg <[email protected]>
22			*/
23			class Collection implements CollectionInterface
24			{
25			/**
26			* @var array
27			*/
28			protected array $items;
29
30			/**
31			* Collection constructor.
32			*
33			* @param array\|CollectionInterface $items
34			*/
35			public function __construct(array\|CollectionInterface $items = [])
36			{
37			$this->items = ($items instanceof CollectionInterface) ? $items->toArray() : $items;
38			}
39
40			/**
41			* @param callable\|Closure $callable
42			* @return CollectionInterface
43			*/
44			public function filter(callable\|Closure $callable): CollectionInterface
45			{
46			return $this->internalFilter($callable);
47			}
48
49			/**
50			* @param callable\|Closure $callable
51			* @param bool $keep
52			* @return CollectionInterface
53			*/
54			private function internalFilter(callable\|Closure $callable, bool $keep = true): CollectionInterface
55			{
56			$items = [];
57			$copy = $this->items;
58
59			foreach ($copy as $key => $value) {
60			if ($keep === $callable($key, $value)) {
61			$items[$key] = $value;
62			}
63			}
64
65			return new Collection($items);
66			}
67
68			/**
69			* @param callable\|Closure $callable
70			* @return CollectionInterface
71			*/
72			public function filterNot(callable\|Closure $callable): CollectionInterface
73			{
74			return $this->internalFilter($callable, false);
75			}
76
77			/**
78			* @param callable\|Closure $callable
79			* @return CollectionInterface
80			*/
81			public function find(callable\|Closure $callable): CollectionInterface
82			{
83			$items = [];
84			$copy = $this->items;
85
86			foreach ($copy as $key => $value) {
87			if ($callable($key, $value) === true) {
88			$items[$key] = $value;
89			}
90			}
91
92			return new Collection($items);
93			}
94
95			/**
96			* @param string\|int $index
97			* @return mixed
98			*/
99			public function findIndex(string\|int $index): mixed
100			{
101			foreach ($this->items as $key => $value) {
102			if ($key === $index) {
103			return $value;
104			}
105			}
106
107			return false;
108			}
109
110			/**
111			* @param callable\|Closure $callable
112			* @return CollectionInterface
113			*/
114			public function sort(callable\|Closure $callable): CollectionInterface
115			{
116			$items = $this->items;
117
118			usort($items, $callable);
119
120			return new Collection($items);
121			}
122
123			/**
124			* @return CollectionInterface
125			*/
126			public function shuffle(): CollectionInterface
127			{
128			$items = $this->items;
129			shuffle($items);
130
131			return new Collection($items);
132			}
133
134			/**
135			* @return CollectionInterface
136			*/
137			public function reverse(): CollectionInterface
138			{
139			return new Collection(
140			array_reverse($this->items, true)
141			);
142			}
143
144			/**
145			* @param mixed $item
146			* @return CollectionInterface
147			*/
148			public function prepend(mixed $item): CollectionInterface
149			{
150			array_unshift($this->items, $item);
151
152			return $this;
153			}
154
155			/**
156			* @return array
157			*/
158			public function toArray(): array
159			{
160			return $this->items;
161			}
162
163			/**
164			* @return mixed
165			*/
166			public function current(): mixed
167			{
168			return current($this->items);
169			}
170
171			public function next(): void
172			{
173			next($this->items);
174			}
175
176			/**
177			* @return bool
178			*/
179			public function valid(): bool
180			{
181			return $this->key() !== null;
182			}
183
184			/**
185			* @return string\|float\|int\|bool\|null
186			*/
187			public function key(): string\|float\|int\|bool\|null
188			{
189			return key($this->items);
190			}
191
192			/**
193			* @return int
194			*/
195			public function count(): int
196			{
197			return count($this->items);
198			}
199
200			/**
201			* @return mixed
202			*/
203			public function rewind(): mixed
204			{
205			return reset($this->items);
206			}
207
208			/**
209			* @param mixed $item
210			* @return CollectionInterface
211			*/
212			public function push(mixed $item): CollectionInterface
213			{
214			return $this->append($item);
215			}
216
217			/**
218			* @param mixed $item
219			* @return CollectionInterface
220			*/
221			public function append(mixed $item): CollectionInterface
222			{
223			array_push($this->items, $item);
224
225			return $this;
226			}
227
228			/**
229			* @return mixed
230			*/
231			public function pull(): mixed
232			{
233			return array_shift($this->items);
234			}
235			}
236

teodoroleckie / collection

Collection::find() A last analyzed 2021-05-19 13:23 UTC

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like

Collection::find() A
last analyzed 2021-05-19 13:23 UTC