Filters::after() - Code Metrics - zicht/itertools - Measure and Improve Code Quality continuously with Scrutinizer

Filters::after() C
last analyzed 2021-03-29 13:12 UTC

↳ Parent: Filters

Complexity

Conditions	12
Paths	3

Size

Total Lines

Duplication

Lines	19
Ratio	59.38 %

Code Coverage

Tests	15
CRAP Score	12

Importance

Changes

Metric	Value
cc	12
nc	3
nop	3
dl	19
loc	32
rs	6.9666
c	0
b	0
f	0
ccs	15
cts	15
cp	1
crap	12

How to fix Complexity

<?php
/**
 * @copyright Zicht Online <http://zicht.nl>
 */

namespace Zicht\Itertools\util;

use function Zicht\Itertools\iterable;

class Filters
{
    /**
     * Returns a filter closure that only accepts values that are instances of $class.
     *
     * For example, the following will return a list where all items
     * are instances of class Bar:
     * > $list = iterable([new Foo(), new Bar(), new Moo()]);
     * > $result = $list->filter(Filters::type(Bar::class));
     * > // {1: Bar}
     *
     * For example, the following will return a list where all items
     * have a property or array index 'key' that is an instance
     * of class Foo:
     * > $list = iterable([['key' => new Foo()], ['key' => new Bar()], ['key' => new Moo()]]);
     * > $result = $list->filter(Filters::type(Bar::class, 'key'));
     * > // {1: ['key' => Bar]}
     *
     * @param string $class
     * @param null|string|\Closure $strategy
     * @return \Closure
     */
    public static function type($class, $strategy = null)

    {
        $strategy = Conversions::mixedToValueGetter($strategy);
        return function ($value, $key = null) use ($class, $strategy) {
            return $strategy($value, $key) instanceof $class;
        };
    }

    /**
     * Returns a filter closure that only accepts values that are in $haystack.
     *
     * For example, the following will return a list where all items
     * are either 'b' or 'c':
     * > $list = iterable(['a', 'b', 'c', 'd', 'e']);
     * > $result = $list->filter(Filters::in(['b', 'c']));
     * > // {1: 'b', 2: 'c'}
     *
     * For example, the following will return a list where all items
     * have a property or array index 'key' that is either 'b' or 'c':
     * > $list = iterable([['key' => 'a'], ['key' => 'b'], ['key' => 'c'], ['key' => 'd'], ['key' => 'e']]);
     * > $result = $list->filter(Filters::in(['b', 'c'], 'key'));
     * > // {1: ['key' => 'b'], 2: ['key' => 'c']}
     *
     * @param null|array|string|\Iterator $haystack
     * @param null|string|\Closure $strategy
     * @param boolean $strict
     * @return \Closure
     */
    public static function in($haystack, $strategy = null, $strict = false)

    {
        if (!is_bool($strict)) {
            throw new \InvalidArgumentException('$STRICT must be a boolean');
        }
        if (!is_array($haystack)) {
            $haystack = iterable($haystack)->values();
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        }
        $strategy = Conversions::mixedToValueGetter($strategy);
        return function ($value, $key = null) use ($haystack, $strategy, $strict) {
            return in_array($strategy($value, $key), $haystack, $strict);
        };
    }

    /**
     * Returns a filter closure that only accepts values that are equal to $expected
     *
     * For example, the following will return a list where all items
     * equal 'bar':
     * > $list = iterable(['foo', 'bar']);
     * > $result = $list->filter(Filters::equals('bar'));
     * > // {1: 'bar'}
     *
     * For example, the following will return a list where all items
     * have a property or array index 'foo' that equals 'bar':
     * > $list = iterable([['key' => 'foo'], ['key' => 'bar']]);
     * > $result = $list->filter(Filters::equals('bar', 'key'));
     * > // {1: ['key' => 'bar']}
     *
     * @param mixed $expected
     * @param null|string|\Closure $strategy
     * @param boolean $strict
     * @return \Closure
     */
    public static function equals($expected, $strategy = null, $strict = false)
    {
        if (!is_bool($strict)) {
            throw new \InvalidArgumentException('$strict must be a boolean');
        }
        $strategy = Conversions::mixedToValueGetter($strategy);
        if ($strict) {
            return function ($value, $key = null) use ($expected, $strategy) {
                return $expected === $strategy($value, $key);
            };
        } else {
            return function ($value, $key = null) use ($expected, $strategy) {
                return $expected == $strategy($value, $key);
            };
        }
    }

    /**
     * Returns a filter closure that only accepts values that are after $expected
     *
     * For example, the following will return a list where only
     * returns entries that are after 2020-04-01:
     * > $list = iterable([new \DateTime('2020-01-01'), new \DateTime('2020-03-01'), new \DateTime('2020-05-01')])
     * > $result = $list->filer(Filters::after(new \DateTimeImmutable('2020-04-01')));
     * > // [new \DateTime('2020-05-01')]
     *
     * @param \DateTimeInterface|int|float $expected
     * @param null|string|\Closure $strategy
     * @param bool $orEqual
     * @return \Closure
     */
    public static function after($expected, $strategy = null, $orEqual = false)
    {
        $strategy = Conversions::mixedToValueGetter($strategy);

        // Support DateTimeInterface
        if ($expected instanceof \DateTimeInterface) {

            return function ($value, $key = null) use ($expected, $strategy, $orEqual) {
                $value = $strategy($value, $key);
                // Try to convert strings that look like ISO date format
                if (is_string($value) && preg_match('/^[0-9]{4}-[0-9]{2}-[0-9]{2}/', $value)) {
                    try {
                        $value = new \DateTimeImmutable($value);
                    } catch (\Exception $exception) {

                    }
                }
                return $value instanceof \DateTimeInterface && ($orEqual ? $expected <= $value : $expected < $value);
            };
        }

        // Support numbers
        if (is_int($expected) || is_float($expected)) {

            return function ($value, $key = null) use ($expected, $strategy, $orEqual) {
                $value = $strategy($value, $key);
                return (is_int($value) || is_float($value)) && ($orEqual ? $expected <= $value : $expected < $value);
            };
        }

        // Everything else fails
        return function () {
            return false;
        };
    }

    /**
     * Returns a filter closure that only accepts values that are before $expected
     *
     * For example, the following will return a list where only
     * returns entries that are before 2020-04-01:
     * > $list = iterable([new \DateTime('2020-01-01'), new \DateTime('2020-03-01'), new \DateTime('2020-05-01')])
     * > $result = $list->filer(Filters::before(new \DateTimeImmutable('2020-04-01')));
     * > // [new \DateTime('2020-01-01'), new \DateTime('2020-03-01')]
     *
     * @param \DateTimeInterface|int|float $expected
     * @param null|string|\Closure $strategy
     * @param bool $orEqual
     * @return \Closure
     */
    public static function before($expected, $strategy = null, $orEqual = false)
    {
        $strategy = Conversions::mixedToValueGetter($strategy);

        // Support DateTimeInterface
        if ($expected instanceof \DateTimeInterface) {

            return function ($value, $key = null) use ($expected, $strategy, $orEqual) {
                $value = $strategy($value, $key);
                // Try to convert strings that look like ISO date format
                if (is_string($value) && preg_match('/^[0-9]{4}-[0-9]{2}-[0-9]{2}/', $value)) {
                    try {
                        $value = new \DateTimeImmutable($value);
                    } catch (\Exception $exception) {

                    }
                }
                return $value instanceof \DateTimeInterface && ($orEqual ? $expected >= $value : $expected > $value);
            };
        }

        // Support numbers
        if (is_int($expected) || is_float($expected)) {

            return function ($value, $key = null) use ($expected, $strategy, $orEqual) {
                $value = $strategy($value, $key);
                return (is_int($value) || is_float($value)) && ($orEqual ? $expected >= $value : $expected > $value);
            };
        }

        // Everything else fails
        return function () {
            return false;
        };
    }

    /**
     * Returns a filter closure that inverts the value
     *
     * For example, the following will return a list where none
     * of the items equal 'bar'
     * > $list = iterable(['foo', 'bar']);
     * > $result = $list->filter(Filters::not(equals('bar')));
     * > // {0: 'foo'}
     *
     * @param null|string|\Closure $strategy
     * @return \Closure
     */
    public static function not($strategy = null)

    {
        $strategy = Conversions::mixedToValueGetter($strategy);
        return function ($value, $key = null) use ($strategy) {
            return !($strategy($value, $key));
        };
    }

    /**
     * Returns a filter closure that only accepts values that match the given regular expression.
     *
     * For example, the following will return a list where all items
     * match 'bar':
     * > $list = iterable(['-= foo =-', '-= bar =-']);
     * > $result = $list->filter(Filters::match('/bar/i'));
     * > // {1: '-= bar =-'}
     *
     * @param string $pattern
     * @param null|string|\Closure $strategy
     * @return \Closure
     */
    public static function match($pattern, $strategy = null)
    {
        if (!is_string($pattern)) {
            throw new \InvalidArgumentException('$PATTERN must be a string');
        }

        $strategy = Conversions::mixedToValueGetter($strategy);
        return function ($value, $key = null) use ($pattern, $strategy) {
            return (bool)preg_match($pattern, $strategy($value, $key));
        };
    }
}


1			<?php
2			/**
3			* @copyright Zicht Online <http://zicht.nl>
4			*/
5
6			namespace Zicht\Itertools\util;
7
8			use function Zicht\Itertools\iterable;
9
10			class Filters
11			{
12			/**
13			* Returns a filter closure that only accepts values that are instances of $class.
14			*
15			* For example, the following will return a list where all items
16			* are instances of class Bar:
17			* > $list = iterable([new Foo(), new Bar(), new Moo()]);
18			* > $result = $list->filter(Filters::type(Bar::class));
19			* > // {1: Bar}
20			*
21			* For example, the following will return a list where all items
22			* have a property or array index 'key' that is an instance
23			* of class Foo:
24			* > $list = iterable([['key' => new Foo()], ['key' => new Bar()], ['key' => new Moo()]]);
25			* > $result = $list->filter(Filters::type(Bar::class, 'key'));
26			* > // {1: ['key' => Bar]}
27			*
28			* @param string $class
29			* @param null\|string\|\Closure $strategy
30			* @return \Closure
31			*/
32	4	View Code Duplication	public static function type($class, $strategy = null)
			0 ignored issues – show Duplication introduced 2021-03-25 08:37 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...
33			{
34	4		$strategy = Conversions::mixedToValueGetter($strategy);
35			return function ($value, $key = null) use ($class, $strategy) {
36	3		return $strategy($value, $key) instanceof $class;
37	4		};
38			}
39
40			/**
41			* Returns a filter closure that only accepts values that are in $haystack.
42			*
43			* For example, the following will return a list where all items
44			* are either 'b' or 'c':
45			* > $list = iterable(['a', 'b', 'c', 'd', 'e']);
46			* > $result = $list->filter(Filters::in(['b', 'c']));
47			* > // {1: 'b', 2: 'c'}
48			*
49			* For example, the following will return a list where all items
50			* have a property or array index 'key' that is either 'b' or 'c':
51			* > $list = iterable([['key' => 'a'], ['key' => 'b'], ['key' => 'c'], ['key' => 'd'], ['key' => 'e']]);
52			* > $result = $list->filter(Filters::in(['b', 'c'], 'key'));
53			* > // {1: ['key' => 'b'], 2: ['key' => 'c']}
54			*
55			* @param null\|array\|string\|\Iterator $haystack
56			* @param null\|string\|\Closure $strategy
57			* @param boolean $strict
58			* @return \Closure
59			*/
60	14	View Code Duplication	public static function in($haystack, $strategy = null, $strict = false)
			0 ignored issues – show Duplication introduced 2021-03-25 08:37 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...
61			{
62	14		if (!is_bool($strict)) {
63	5		throw new \InvalidArgumentException('$STRICT must be a boolean');
64			}
65	9		if (!is_array($haystack)) {
66	5		$haystack = iterable($haystack)->values();
			0 ignored issues – show Bug introduced 2021-03-25 08:37 UTC by Report Bug Copy Issue Report It seems like `$haystack` can also be of type `null`; however, `Zicht\Itertools\iterable()` does only seem to accept `array\|string\|object<Iterator>`, maybe add an additional type check? If a method or function can return multiple different values and unless you are sure that you only can receive a single value in this context, we recommend to add an additional type check: /** * @return array\|string */ function returnsDifferentValues($x) { if ($x) { return 'foo'; } return array(); } $x = returnsDifferentValues($y); if (is_array($x)) { // $x is an array. } If this a common case that PHP Analyzer should handle natively, please let us know by opening an issue. Loading history...
67			}
68	6		$strategy = Conversions::mixedToValueGetter($strategy);
69			return function ($value, $key = null) use ($haystack, $strategy, $strict) {
70	6		return in_array($strategy($value, $key), $haystack, $strict);
71	6		};
72			}
73
74			/**
75			* Returns a filter closure that only accepts values that are equal to $expected
76			*
77			* For example, the following will return a list where all items
78			* equal 'bar':
79			* > $list = iterable(['foo', 'bar']);
80			* > $result = $list->filter(Filters::equals('bar'));
81			* > // {1: 'bar'}
82			*
83			* For example, the following will return a list where all items
84			* have a property or array index 'foo' that equals 'bar':
85			* > $list = iterable([['key' => 'foo'], ['key' => 'bar']]);
86			* > $result = $list->filter(Filters::equals('bar', 'key'));
87			* > // {1: ['key' => 'bar']}
88			*
89			* @param mixed $expected
90			* @param null\|string\|\Closure $strategy
91			* @param boolean $strict
92			* @return \Closure
93			*/
94	11		public static function equals($expected, $strategy = null, $strict = false)
95			{
96	11		if (!is_bool($strict)) {
97	5		throw new \InvalidArgumentException('$strict must be a boolean');
98			}
99	6		$strategy = Conversions::mixedToValueGetter($strategy);
100	6		if ($strict) {
101			return function ($value, $key = null) use ($expected, $strategy) {
102	1		return $expected === $strategy($value, $key);
103	1		};
104			} else {
105			return function ($value, $key = null) use ($expected, $strategy) {
106	6		return $expected == $strategy($value, $key);
107	6		};
108			}
109			}
110
111			/**
112			* Returns a filter closure that only accepts values that are after $expected
113			*
114			* For example, the following will return a list where only
115			* returns entries that are after 2020-04-01:
116			* > $list = iterable([new \DateTime('2020-01-01'), new \DateTime('2020-03-01'), new \DateTime('2020-05-01')])
117			* > $result = $list->filer(Filters::after(new \DateTimeImmutable('2020-04-01')));
118			* > // [new \DateTime('2020-05-01')]
119			*
120			* @param \DateTimeInterface\|int\|float $expected
121			* @param null\|string\|\Closure $strategy
122			* @param bool $orEqual
123			* @return \Closure
124			*/
125	26		public static function after($expected, $strategy = null, $orEqual = false)
126			{
127	26		$strategy = Conversions::mixedToValueGetter($strategy);
128
129			// Support DateTimeInterface
130	26	View Code Duplication	if ($expected instanceof \DateTimeInterface) {
			0 ignored issues – show Duplication introduced 2020-01-08 15:52 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...
131			return function ($value, $key = null) use ($expected, $strategy, $orEqual) {
132	14		$value = $strategy($value, $key);
133			// Try to convert strings that look like ISO date format
134	14		if (is_string($value) && preg_match('/^[0-9]{4}-[0-9]{2}-[0-9]{2}/', $value)) {
135			try {
136	4		$value = new \DateTimeImmutable($value);
137	2		} catch (\Exception $exception) {
			0 ignored issues – show Coding Style Comprehensibility introduced 2020-01-31 10:04 UTC by Report Bug Copy Issue Report Consider adding a comment why this CATCH block is empty. Loading history...
138			}
139			}
140	14		return $value instanceof \DateTimeInterface && ($orEqual ? $expected <= $value : $expected < $value);
141	14		};
142			}
143
144			// Support numbers
145	12	View Code Duplication	if (is_int($expected) \|\| is_float($expected)) {
			0 ignored issues – show Duplication introduced 2020-01-08 15:52 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...
146			return function ($value, $key = null) use ($expected, $strategy, $orEqual) {
147	11		$value = $strategy($value, $key);
148	11		return (is_int($value) \|\| is_float($value)) && ($orEqual ? $expected <= $value : $expected < $value);
149	11		};
150			}
151
152			// Everything else fails
153			return function () {
154	1		return false;
155	1		};
156			}
157
158			/**
159			* Returns a filter closure that only accepts values that are before $expected
160			*
161			* For example, the following will return a list where only
162			* returns entries that are before 2020-04-01:
163			* > $list = iterable([new \DateTime('2020-01-01'), new \DateTime('2020-03-01'), new \DateTime('2020-05-01')])
164			* > $result = $list->filer(Filters::before(new \DateTimeImmutable('2020-04-01')));
165			* > // [new \DateTime('2020-01-01'), new \DateTime('2020-03-01')]
166			*
167			* @param \DateTimeInterface\|int\|float $expected
168			* @param null\|string\|\Closure $strategy
169			* @param bool $orEqual
170			* @return \Closure
171			*/
172	26		public static function before($expected, $strategy = null, $orEqual = false)
173			{
174	26		$strategy = Conversions::mixedToValueGetter($strategy);
175
176			// Support DateTimeInterface
177	26	View Code Duplication	if ($expected instanceof \DateTimeInterface) {
			0 ignored issues – show Duplication introduced 2020-01-08 15:52 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...
178			return function ($value, $key = null) use ($expected, $strategy, $orEqual) {
179	14		$value = $strategy($value, $key);
180			// Try to convert strings that look like ISO date format
181	14		if (is_string($value) && preg_match('/^[0-9]{4}-[0-9]{2}-[0-9]{2}/', $value)) {
182			try {
183	4		$value = new \DateTimeImmutable($value);
184	2		} catch (\Exception $exception) {
			0 ignored issues – show Coding Style Comprehensibility introduced 2020-01-31 10:04 UTC by Report Bug Copy Issue Report Consider adding a comment why this CATCH block is empty. Loading history...
185			}
186			}
187	14		return $value instanceof \DateTimeInterface && ($orEqual ? $expected >= $value : $expected > $value);
188	14		};
189			}
190
191			// Support numbers
192	12	View Code Duplication	if (is_int($expected) \|\| is_float($expected)) {
			0 ignored issues – show Duplication introduced 2020-01-08 15:52 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...
193			return function ($value, $key = null) use ($expected, $strategy, $orEqual) {
194	11		$value = $strategy($value, $key);
195	11		return (is_int($value) \|\| is_float($value)) && ($orEqual ? $expected >= $value : $expected > $value);
196	11		};
197			}
198
199			// Everything else fails
200			return function () {
201	1		return false;
202	1		};
203			}
204
205			/**
206			* Returns a filter closure that inverts the value
207			*
208			* For example, the following will return a list where none
209			* of the items equal 'bar'
210			* > $list = iterable(['foo', 'bar']);
211			* > $result = $list->filter(Filters::not(equals('bar')));
212			* > // {0: 'foo'}
213			*
214			* @param null\|string\|\Closure $strategy
215			* @return \Closure
216			*/
217	2	View Code Duplication	public static function not($strategy = null)
			0 ignored issues – show Duplication introduced 2021-03-25 08:37 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...
218			{
219	2		$strategy = Conversions::mixedToValueGetter($strategy);
220			return function ($value, $key = null) use ($strategy) {
221	2		return !($strategy($value, $key));
222	2		};
223			}
224
225			/**
226			* Returns a filter closure that only accepts values that match the given regular expression.
227			*
228			* For example, the following will return a list where all items
229			* match 'bar':
230			* > $list = iterable(['-= foo =-', '-= bar =-']);
231			* > $result = $list->filter(Filters::match('/bar/i'));
232			* > // {1: '-= bar =-'}
233			*
234			* @param string $pattern
235			* @param null\|string\|\Closure $strategy
236			* @return \Closure
237			*/
238	7		public static function match($pattern, $strategy = null)
239			{
240	7		if (!is_string($pattern)) {
241	4		throw new \InvalidArgumentException('$PATTERN must be a string');
242			}
243
244	3		$strategy = Conversions::mixedToValueGetter($strategy);
245	3		return function ($value, $key = null) use ($pattern, $strategy) {
246	3		return (bool)preg_match($pattern, $strategy($value, $key));
247	3		};
248			}
249			}
250

zicht / itertools

Filters::after() C last analyzed 2021-03-29 13:12 UTC

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like

Filters::after() C
last analyzed 2021-03-29 13:12 UTC