EnumerableGeneration::fromTraversable() - Code Metrics - Inspection of "Fixed #13 (Enumerable::from throws InvalidArgument..." - Athari/YaLinqo - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 26de6b...bf1e9f )

by Alexander

created 2016-01-11 11:47 UTC

EnumerableGeneration::fromTraversable() A

↳ Parent: EnumerableGeneration

Complexity

Conditions	2
Paths	2

Size

Total Lines	5
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	1	Features	1

Metric	Value
c	1
b	1
f	1
dl	0
loc	5
rs	9.4286
cc	2
eloc	3
nc	2
nop	1

<?php

namespace YaLinqo;

use YaLinqo;

trait EnumerableGeneration
{
    /**
     * Cycles through the source sequence.
     * <p><b>Syntax</b>: cycle (source)
     * <p>Source keys are discarded.
     * @param array|\Iterator|\IteratorAggregate|Enumerable $source Source sequence.
     * @throws \InvalidArgumentException If source is not array or Traversible or Enumerable.
     * @throws \UnexpectedValueException If source contains no elements (checked during enumeration).
     * @return Enumerable Endless list of items repeating the source sequence.
     * @package YaLinqo\Generation
     */
    public static function cycle ($source)
    {
        $source = self::from($source);

        return new self(function () use ($source) {

            $isEmpty = true;
            while (true) {
                foreach ($source as $v) {
                    yield $v;
                    $isEmpty = false;
                }
                if ($isEmpty)
                    throw new \UnexpectedValueException(Errors::NO_ELEMENTS);
            }
        });
    }

    /**
     * Returns an empty sequence.
     * <p><b>Syntax</b>: emptyEnum ()
     * @return Enumerable
     * @package YaLinqo\Generation
     */
    public static function emptyEnum ()
    {
        return new self(new \EmptyIterator, false);

    }

    /**
     * Converts source into Enumerable sequence.
     * <p><b>Syntax</b>: from (source)
     * <p>Result depends on the type of source:
     * <ul>
     * <li><b>array</b>: Enumerable from ArrayIterator;
     * <li><b>Enumerable</b>: Enumerable source itself;
     * <li><b>Iterator</b>: Enumerable from Iterator;
     * <li><b>IteratorAggregate</b>: Enumerable from Iterator returned from getIterator() method;
     * <li><b>Traversable</b>: Enumerable from the result of foreach over source.
     * </ul>
     * @param array|\Iterator|\IteratorAggregate|\Traversable|Enumerable $source Value to convert into Enumerable sequence.
     * @throws \InvalidArgumentException If source is not array or Traversible or Enumerable.
     * @return Enumerable
     * @package YaLinqo\Generation
     */
    public static function from ($source)
    {
        $it = null;
        if ($source instanceof Enumerable)
            return $source;
        else if (is_array($source))
            $it = new \ArrayIterator($source);
        elseif ($source instanceof \Iterator)
            $it = $source;
        elseif ($source instanceof \IteratorAggregate)
            $it = $source->getIterator();
        elseif ($source instanceof \Traversable)
            $it = self::fromTraversable($source);
        if ($it !== null) {
            return new self($it, false);

        }
        throw new \InvalidArgumentException('source must be array or Traversable.');
    }

    private static function fromTraversable ($source)
    {
        foreach ($source as $k => $v)
            yield $k => $v;
    }

    /**
     * Generates a sequence by mimicking a for loop.
     * <p><b>Syntax</b>: generate (funcValue {(v, k) ==> value} [, seedValue [, funcKey {(v, k) ==> key} [, seedKey]]])
     * <p>If seedValue is null, the first value will be the result of calling funcValue on seedValue and seedKey. The same applies for seedKey.
     * @param callable $funcValue {(v, k) ==> value} State update function to run on value after every iteration of the generator loop. Default: value.
     * @param mixed $seedValue Initial state of the generator loop for values. Default: null.
     * @param callable|null $funcKey {(v, k) ==> key} State update function to run on key after every iteration of the generator loop. Default: increment.
     * @param mixed $seedKey Initial state of the generator loop ofr keys. Default: 0.
     * @return Enumerable
     * @package YaLinqo\Generation
     */
    public static function generate ($funcValue, $seedValue = null, $funcKey = null, $seedKey = null)
    {
        $funcValue = Utils::createLambda($funcValue, 'v,k');
        $funcKey = Utils::createLambda($funcKey, 'v,k', false);
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

        return new self(function () use ($funcValue, $funcKey, $seedValue, $seedKey) {

            $key = $seedKey === null ? ($funcKey ? $funcKey($seedValue, $seedKey) : 0) : $seedKey;
            $value = $seedValue === null ? $funcValue($seedValue, $seedKey) : $seedValue;
            yield $key => $value;
            while (true) {
                list($value, $key) = [
                    $funcValue($value, $key),
                    $funcKey ? $funcKey($value, $key) : $key + 1,
                ];
                yield $key => $value;
            }
        });
    }

    /**
     * Generates a sequence of integral numbers to infinity.
     * <p><b>Syntax</b>: toInfinity ([start [, step]])
     * @param int $start The first integer in the sequence. Default: 0.
     * @param int $step The difference between adjacent integers. Default: 1.
     * @return Enumerable
     * @package YaLinqo\Generation
     */
    public static function toInfinity ($start = 0, $step = 1)
    {
        return new self(function () use ($start, $step) {

            $value = $start - $step;
            while (true)
                yield $value += $step;
        });
    }

    /**
     * Searches subject for all matches to the regular expression given in pattern and enumerates them in the order specified by flags. After the first match is found, the subsequent searches are continued on from end of the last match.
     * <p><b>Syntax</b>: matches (subject, pattern [, flags])
     * @param string $subject The input string.
     * @param string $pattern The pattern to search for, as a string.
     * @param int $flags Can be a combination of the following flags: PREG_PATTERN_ORDER, PREG_SET_ORDER, PREG_OFFSET_CAPTURE. Default: PREG_SET_ORDER.
     * @return Enumerable
     * @see preg_match_all
     * @package YaLinqo\Generation
     */
    public static function matches ($subject, $pattern, $flags = PREG_SET_ORDER)
    {
        return new self(function () use ($subject, $pattern, $flags) {

            preg_match_all($pattern, $subject, $matches, $flags);
            return $matches !== false ? self::from($matches)->getIterator() : self::emptyEnum();
/**
 * @return array|string
 */
function returnsDifferentValues($x) {
    if ($x) {
        return 'foo';
    }

    return array();
}

$x = returnsDifferentValues($y);
if (is_array($x)) {
    // $x is an array.
}
        });
    }

    /**
     * Generates a sequence of integral numbers to negative infinity.
     * <p><b>Syntax</b>: toNegativeInfinity ([start [, step]])
     * @param int $start The first integer in the sequence. Default: 0.
     * @param int $step The difference between adjacent integers. Default: 1.
     * @return Enumerable
     * @package YaLinqo\Generation
     */
    public static function toNegativeInfinity ($start = 0, $step = 1)
    {
        return self::toInfinity($start, -$step);
    }

    /**
     * Returns a sequence that contains a single element with a specified value.
     * <p><b>Syntax</b>: returnEnum (element)
     * @param mixed $element The single element in the resulting sequence.
     * @return Enumerable Observable sequence containing the single specified element.
     * @package YaLinqo\Generation
     */
    public static function returnEnum ($element)
    {
        return self::repeat($element, 1);
    }

    /**
     * Generates a sequence of integral numbers, beginning with start and containing count elements.
     * <p><b>Syntax</b>: range (start, count [, step])
     * <p>Keys in the generated sequence are sequental: 0, 1, 2 etc.
     * <p>Example: range(3, 4, 2) = 3, 5, 7, 9.
     * @param int $start The value of the first integer in the sequence.
     * @param int $count The number of integers to generate.
     * @param int $step The difference between adjacent integers. Default: 1.
     * @return Enumerable A sequence that contains a range of integral numbers.
     * @package YaLinqo\Generation
     */
    public static function range ($start, $count, $step = 1)
    {
        if ($count <= 0)
            return self::emptyEnum();
        return new self(function () use ($start, $count, $step) {

            $value = $start - $step;
            while ($count-- > 0)
                yield $value += $step;
        });
    }

    /**
     * Generates a reversed sequence of integral numbers, beginning with start and containing count elements.
     * <p><b>Syntax</b>: rangeDown (start, count [, step])
     * <p>Keys in the generated sequence are sequental: 0, 1, 2 etc.
     * <p>Example: rangeDown(9, 4, 2) = 9, 7, 5, 3.
     * @param int $start The value of the first integer in the sequence.
     * @param int $count The number of integers to generate.
     * @param int $step The difference between adjacent integers. Default: 1.
     * @return Enumerable A sequence that contains a range of integral numbers.
     * @package YaLinqo\Generation
     */
    public static function rangeDown ($start, $count, $step = 1)
    {
        return self::range($start, $count, -$step);
    }

    /**
     * Generates a sequence of integral numbers within a specified range from start to end.
     * <p><b>Syntax</b>: rangeTo (start, end [, step])
     * <p>Keys in the generated sequence are sequental: 0, 1, 2 etc.
     * <p>Example: rangeTo(3, 9, 2) = 3, 5, 7, 9.
     * @param int $start The value of the first integer in the sequence.
     * @param int $end The value of the last integer in the sequence (not included).
     * @param int $step The difference between adjacent integers. Default: 1.
     * @throws \InvalidArgumentException If step is not a positive number.
     * @return Enumerable A sequence that contains a range of integral numbers.
     * @package YaLinqo\Generation
     */
    public static function rangeTo ($start, $end, $step = 1)
    {
        if ($step <= 0)
            throw new \InvalidArgumentException(Errors::STEP_NEGATIVE);
        return new self(function () use ($start, $end, $step) {

            if ($start <= $end) {
                for ($i = $start; $i < $end; $i += $step)
                    yield $i;
            }
            else {
                for ($i = $start; $i > $end; $i -= $step)
                    yield $i;
            }
        });
    }

    /**
     * Generates an sequence that contains one repeated value.
     * <p><b>Syntax</b>: repeat (element)
     * <p>Generates an endless sequence that contains one repeated value.
     * <p><b>Syntax</b>: repeat (element, count)
     * <p>Generates a sequence of specified length that contains one repeated value.
     * <p>Keys in the generated sequence are sequental: 0, 1, 2 etc.
     * @param int $element The value to be repeated.
     * @param int $count The number of times to repeat the value in the generated sequence. Default: null.
     * @throws \InvalidArgumentException If count is less than 0.
     * @return Enumerable A sequence that contains a repeated value.
     * @package YaLinqo\Generation
     */
    public static function repeat ($element, $count = null)
    {
        if ($count < 0)
            throw new \InvalidArgumentException(Errors::COUNT_LESS_THAN_ZERO);
        return new self(function () use ($element, $count) {

            for ($i = 0; $i < $count || $count === null; $i++)
                yield $element;
        });
    }

    /**
     * Split the given string by a regular expression.
     * <p><b>Syntax</b>: split (subject, pattern [, flags])
     * @param string $subject The input string.
     * @param string $pattern The pattern to search for, as a string.
     * @param int $flags flags can be any combination of the following flags: PREG_SPLIT_NO_EMPTY, PREG_SPLIT_DELIM_CAPTURE, PREG_SPLIT_OFFSET_CAPTURE. Default: 0.
     * @return Enumerable
     * @see preg_split
     * @package YaLinqo\Generation
     */
    public static function split ($subject, $pattern, $flags = 0)
    {
        return new self(
            new \ArrayIterator(preg_split($pattern, $subject, -1, $flags)),

            false
        );
    }
}

1			<?php
2
3			namespace YaLinqo;
4
5			use YaLinqo;
6
7			trait EnumerableGeneration
8			{
9			/**
10			* Cycles through the source sequence.
11			* <p><b>Syntax</b>: cycle (source)
12			* <p>Source keys are discarded.
13			* @param array\|\Iterator\|\IteratorAggregate\|Enumerable $source Source sequence.
14			* @throws \InvalidArgumentException If source is not array or Traversible or Enumerable.
15			* @throws \UnexpectedValueException If source contains no elements (checked during enumeration).
16			* @return Enumerable Endless list of items repeating the source sequence.
17			* @package YaLinqo\Generation
18			*/
19			public static function cycle ($source)
20			{
21			$source = self::from($source);
22
23			return new self(function () use ($source) {
			1 ignored issue – show Unused Code introduced 2015-12-31 14:31 UTC by Report Bug Copy Issue Report The call to `EnumerableGeneration::__construct()` has too many arguments starting with `function () use($source)...NTS); } } }`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
24			$isEmpty = true;
25			while (true) {
26			foreach ($source as $v) {
27			yield $v;
28			$isEmpty = false;
29			}
30			if ($isEmpty)
31			throw new \UnexpectedValueException(Errors::NO_ELEMENTS);
32			}
33			});
34			}
35
36			/**
37			* Returns an empty sequence.
38			* <p><b>Syntax</b>: emptyEnum ()
39			* @return Enumerable
40			* @package YaLinqo\Generation
41			*/
42			public static function emptyEnum ()
43			{
44			return new self(new \EmptyIterator, false);
			1 ignored issue – show Unused Code introduced 2015-12-31 14:31 UTC by Report Bug Copy Issue Report The call to `EnumerableGeneration::__construct()` has too many arguments starting with `new \EmptyIterator()`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
45			}
46
47			/**
48			* Converts source into Enumerable sequence.
49			* <p><b>Syntax</b>: from (source)
50			* <p>Result depends on the type of source:
51			* <ul>
52			* <li><b>array</b>: Enumerable from ArrayIterator;
53			* <li><b>Enumerable</b>: Enumerable source itself;
54			* <li><b>Iterator</b>: Enumerable from Iterator;
55			* <li><b>IteratorAggregate</b>: Enumerable from Iterator returned from getIterator() method;
56			* <li><b>Traversable</b>: Enumerable from the result of foreach over source.
57			* </ul>
58			* @param array\|\Iterator\|\IteratorAggregate\|\Traversable\|Enumerable $source Value to convert into Enumerable sequence.
59			* @throws \InvalidArgumentException If source is not array or Traversible or Enumerable.
60			* @return Enumerable
61			* @package YaLinqo\Generation
62			*/
63			public static function from ($source)
64			{
65			$it = null;
66			if ($source instanceof Enumerable)
67			return $source;
68			else if (is_array($source))
69			$it = new \ArrayIterator($source);
70			elseif ($source instanceof \Iterator)
71			$it = $source;
72			elseif ($source instanceof \IteratorAggregate)
73			$it = $source->getIterator();
74			elseif ($source instanceof \Traversable)
75			$it = self::fromTraversable($source);
76			if ($it !== null) {
77			return new self($it, false);
			1 ignored issue – show Unused Code introduced 2015-12-31 14:31 UTC by Report Bug Copy Issue Report The call to `EnumerableGeneration::__construct()` has too many arguments starting with `$it`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
78			}
79			throw new \InvalidArgumentException('source must be array or Traversable.');
80			}
81
82			private static function fromTraversable ($source)
83			{
84			foreach ($source as $k => $v)
85			yield $k => $v;
86			}
87
88			/**
89			* Generates a sequence by mimicking a for loop.
90			* <p><b>Syntax</b>: generate (funcValue {(v, k) ==> value} [, seedValue [, funcKey {(v, k) ==> key} [, seedKey]]])
91			* <p>If seedValue is null, the first value will be the result of calling funcValue on seedValue and seedKey. The same applies for seedKey.
92			* @param callable $funcValue {(v, k) ==> value} State update function to run on value after every iteration of the generator loop. Default: value.
93			* @param mixed $seedValue Initial state of the generator loop for values. Default: null.
94			* @param callable\|null $funcKey {(v, k) ==> key} State update function to run on key after every iteration of the generator loop. Default: increment.
95			* @param mixed $seedKey Initial state of the generator loop ofr keys. Default: 0.
96			* @return Enumerable
97			* @package YaLinqo\Generation
98			*/
99			public static function generate ($funcValue, $seedValue = null, $funcKey = null, $seedKey = null)
100			{
101			$funcValue = Utils::createLambda($funcValue, 'v,k');
102			$funcKey = Utils::createLambda($funcKey, 'v,k', false);
			0 ignored issues – show Documentation introduced 2015-12-31 14:31 UTC by Report Bug Copy Issue Report `false` is of type `boolean`, but the function expects a `callable\|null`. It seems like the type of the argument is not accepted by the function/method which you are calling. In some cases, in particular if PHP’s automatic type-juggling kicks in this might be fine. In other cases, however this might be a bug. We suggest to add an explicit type cast like in the following example: function acceptsInteger($int) { } $x = '123'; // string "123" // Instead of acceptsInteger($x); // we recommend to use acceptsInteger((integer) $x); Loading history...
103
104			return new self(function () use ($funcValue, $funcKey, $seedValue, $seedKey) {
			1 ignored issue – show Unused Code introduced 2015-12-31 14:31 UTC by Report Bug Copy Issue Report The call to `EnumerableGeneration::__construct()` has too many arguments starting with `function () use($funcVal...key => $value); } }`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
105			$key = $seedKey === null ? ($funcKey ? $funcKey($seedValue, $seedKey) : 0) : $seedKey;
106			$value = $seedValue === null ? $funcValue($seedValue, $seedKey) : $seedValue;
107			yield $key => $value;
108			while (true) {
109			list($value, $key) = [
110			$funcValue($value, $key),
111			$funcKey ? $funcKey($value, $key) : $key + 1,
112			];
113			yield $key => $value;
114			}
115			});
116			}
117
118			/**
119			* Generates a sequence of integral numbers to infinity.
120			* <p><b>Syntax</b>: toInfinity ([start [, step]])
121			* @param int $start The first integer in the sequence. Default: 0.
122			* @param int $step The difference between adjacent integers. Default: 1.
123			* @return Enumerable
124			* @package YaLinqo\Generation
125			*/
126			public static function toInfinity ($start = 0, $step = 1)
127			{
128			return new self(function () use ($start, $step) {
			1 ignored issue – show Unused Code introduced 2015-12-31 14:31 UTC by Report Bug Copy Issue Report The call to `EnumerableGeneration::__construct()` has too many arguments starting with `function () use($start, ...alue += $step); } }`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
129			$value = $start - $step;
130			while (true)
131			yield $value += $step;
132			});
133			}
134
135			/**
136			* Searches subject for all matches to the regular expression given in pattern and enumerates them in the order specified by flags. After the first match is found, the subsequent searches are continued on from end of the last match.
137			* <p><b>Syntax</b>: matches (subject, pattern [, flags])
138			* @param string $subject The input string.
139			* @param string $pattern The pattern to search for, as a string.
140			* @param int $flags Can be a combination of the following flags: PREG_PATTERN_ORDER, PREG_SET_ORDER, PREG_OFFSET_CAPTURE. Default: PREG_SET_ORDER.
141			* @return Enumerable
142			* @see preg_match_all
143			* @package YaLinqo\Generation
144			*/
145			public static function matches ($subject, $pattern, $flags = PREG_SET_ORDER)
146			{
147			return new self(function () use ($subject, $pattern, $flags) {
			1 ignored issue – show Unused Code introduced 2015-12-31 14:31 UTC by Report Bug Copy Issue Report The call to `EnumerableGeneration::__construct()` has too many arguments starting with `function () use($subject... : self::emptyEnum(); }`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
148			preg_match_all($pattern, $subject, $matches, $flags);
149			return $matches !== false ? self::from($matches)->getIterator() : self::emptyEnum();
			0 ignored issues – show Bug introduced 2016-01-11 11:53 UTC by Report Bug Copy Issue Report It seems like `$matches` can also be of type `null`; however, `YaLinqo\EnumerableGeneration::from()` does only seem to accept `array\|object<Traversable>`, 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...
150			});
151			}
152
153			/**
154			* Generates a sequence of integral numbers to negative infinity.
155			* <p><b>Syntax</b>: toNegativeInfinity ([start [, step]])
156			* @param int $start The first integer in the sequence. Default: 0.
157			* @param int $step The difference between adjacent integers. Default: 1.
158			* @return Enumerable
159			* @package YaLinqo\Generation
160			*/
161			public static function toNegativeInfinity ($start = 0, $step = 1)
162			{
163			return self::toInfinity($start, -$step);
164			}
165
166			/**
167			* Returns a sequence that contains a single element with a specified value.
168			* <p><b>Syntax</b>: returnEnum (element)
169			* @param mixed $element The single element in the resulting sequence.
170			* @return Enumerable Observable sequence containing the single specified element.
171			* @package YaLinqo\Generation
172			*/
173			public static function returnEnum ($element)
174			{
175			return self::repeat($element, 1);
176			}
177
178			/**
179			* Generates a sequence of integral numbers, beginning with start and containing count elements.
180			* <p><b>Syntax</b>: range (start, count [, step])
181			* <p>Keys in the generated sequence are sequental: 0, 1, 2 etc.
182			* <p>Example: range(3, 4, 2) = 3, 5, 7, 9.
183			* @param int $start The value of the first integer in the sequence.
184			* @param int $count The number of integers to generate.
185			* @param int $step The difference between adjacent integers. Default: 1.
186			* @return Enumerable A sequence that contains a range of integral numbers.
187			* @package YaLinqo\Generation
188			*/
189			public static function range ($start, $count, $step = 1)
190			{
191			if ($count <= 0)
192			return self::emptyEnum();
193			return new self(function () use ($start, $count, $step) {
			1 ignored issue – show Unused Code introduced 2015-12-31 14:31 UTC by Report Bug Copy Issue Report The call to `EnumerableGeneration::__construct()` has too many arguments starting with `function () use($start, ...alue += $step); } }`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
194			$value = $start - $step;
195			while ($count-- > 0)
196			yield $value += $step;
197			});
198			}
199
200			/**
201			* Generates a reversed sequence of integral numbers, beginning with start and containing count elements.
202			* <p><b>Syntax</b>: rangeDown (start, count [, step])
203			* <p>Keys in the generated sequence are sequental: 0, 1, 2 etc.
204			* <p>Example: rangeDown(9, 4, 2) = 9, 7, 5, 3.
205			* @param int $start The value of the first integer in the sequence.
206			* @param int $count The number of integers to generate.
207			* @param int $step The difference between adjacent integers. Default: 1.
208			* @return Enumerable A sequence that contains a range of integral numbers.
209			* @package YaLinqo\Generation
210			*/
211			public static function rangeDown ($start, $count, $step = 1)
212			{
213			return self::range($start, $count, -$step);
214			}
215
216			/**
217			* Generates a sequence of integral numbers within a specified range from start to end.
218			* <p><b>Syntax</b>: rangeTo (start, end [, step])
219			* <p>Keys in the generated sequence are sequental: 0, 1, 2 etc.
220			* <p>Example: rangeTo(3, 9, 2) = 3, 5, 7, 9.
221			* @param int $start The value of the first integer in the sequence.
222			* @param int $end The value of the last integer in the sequence (not included).
223			* @param int $step The difference between adjacent integers. Default: 1.
224			* @throws \InvalidArgumentException If step is not a positive number.
225			* @return Enumerable A sequence that contains a range of integral numbers.
226			* @package YaLinqo\Generation
227			*/
228			public static function rangeTo ($start, $end, $step = 1)
229			{
230			if ($step <= 0)
231			throw new \InvalidArgumentException(Errors::STEP_NEGATIVE);
232			return new self(function () use ($start, $end, $step) {
			1 ignored issue – show Unused Code introduced 2015-12-31 14:31 UTC by Report Bug Copy Issue Report The call to `EnumerableGeneration::__construct()` has too many arguments starting with `function () use($start, ... $i); } } }`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
233			if ($start <= $end) {
234			for ($i = $start; $i < $end; $i += $step)
235			yield $i;
236			}
237			else {
238			for ($i = $start; $i > $end; $i -= $step)
239			yield $i;
240			}
241			});
242			}
243
244			/**
245			* Generates an sequence that contains one repeated value.
246			* <p><b>Syntax</b>: repeat (element)
247			* <p>Generates an endless sequence that contains one repeated value.
248			* <p><b>Syntax</b>: repeat (element, count)
249			* <p>Generates a sequence of specified length that contains one repeated value.
250			* <p>Keys in the generated sequence are sequental: 0, 1, 2 etc.
251			* @param int $element The value to be repeated.
252			* @param int $count The number of times to repeat the value in the generated sequence. Default: null.
253			* @throws \InvalidArgumentException If count is less than 0.
254			* @return Enumerable A sequence that contains a repeated value.
255			* @package YaLinqo\Generation
256			*/
257			public static function repeat ($element, $count = null)
258			{
259			if ($count < 0)
260			throw new \InvalidArgumentException(Errors::COUNT_LESS_THAN_ZERO);
261			return new self(function () use ($element, $count) {
			1 ignored issue – show Unused Code introduced 2015-12-31 14:31 UTC by Report Bug Copy Issue Report The call to `EnumerableGeneration::__construct()` has too many arguments starting with `function () use($element...ield $element); } }`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
262			for ($i = 0; $i < $count \|\| $count === null; $i++)
263			yield $element;
264			});
265			}
266
267			/**
268			* Split the given string by a regular expression.
269			* <p><b>Syntax</b>: split (subject, pattern [, flags])
270			* @param string $subject The input string.
271			* @param string $pattern The pattern to search for, as a string.
272			* @param int $flags flags can be any combination of the following flags: PREG_SPLIT_NO_EMPTY, PREG_SPLIT_DELIM_CAPTURE, PREG_SPLIT_OFFSET_CAPTURE. Default: 0.
273			* @return Enumerable
274			* @see preg_split
275			* @package YaLinqo\Generation
276			*/
277			public static function split ($subject, $pattern, $flags = 0)
278			{
279			return new self(
280			new \ArrayIterator(preg_split($pattern, $subject, -1, $flags)),
			1 ignored issue – show Unused Code introduced 2015-12-31 14:31 UTC by Report Bug Copy Issue Report The call to `EnumerableGeneration::__construct()` has too many arguments starting with `new \ArrayIterator(preg_... $subject, -1, $flags))`. This check compares calls to functions or methods with their respective definitions. If the call has more arguments than are defined, it raises an issue. If a function is defined several times with a different number of parameters, the check may pick up the wrong definition and report false positives. One codebase where this has been known to happen is Wordpress. In this case you can add the `@ignore` PhpDoc annotation to the duplicate definition and it will be ignored. Loading history...
281			false
282			);
283			}
284			}

Athari / YaLinqo

Push — master ( 26de6b...bf1e9f )

EnumerableGeneration::fromTraversable() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like