Athari / YaLinqo

YaLinqo/Enumerable.php

Doc Comments +4 added lines, -4 removed lines

@@ -31,7 +31,7 @@ 
 
     /**
      * @internal
-     * @param \Closure|\Iterator $iterator
+     * @param \Closure $iterator
      * @param bool $isClosure
      */
     private function __construct($iterator, $isClosure = true)
@@ -213,7 +213,7 @@ 
      * <p>Three methods are defined to extend the type {@link OrderedEnumerable}, which is the return type of this method. These three methods, namely {@link OrderedEnumerable::thenBy thenBy}, {@link OrderedEnumerable::thenByDescending thenByDescending} and {@link OrderedEnumerable::thenByDir thenByDir}, enable you to specify additional sort criteria to sort a sequence. These methods also return an OrderedEnumerable, which means any number of consecutive calls to thenBy, thenByDescending or thenByDir can be made.
      * <p>Because OrderedEnumerable inherits from Enumerable, you can call {@link orderBy}, {@link orderByDescending} or {@link orderByDir} on the results of a call to orderBy, orderByDescending, orderByDir, thenBy, thenByDescending or thenByDir. Doing this introduces a new primary ordering that ignores the previously established ordering.
      * <p>This method performs an unstable sort; that is, if the keys of two elements are equal, the order of the elements is not preserved. In contrast, a stable sort preserves the order of elements that have the same key. Internally, {@link usort} is used.
-     * @param int|bool $sortOrder A direction in which to order the elements: false or SORT_DESC for ascending (by increasing value), true or SORT_ASC for descending (by decreasing value).
+     * @param boolean $sortOrder A direction in which to order the elements: false or SORT_DESC for ascending (by increasing value), true or SORT_ASC for descending (by decreasing value).
      * @param callable|null $keySelector {(v, k) ==> key} A function to extract a key from an element. Default: value.
      * @param callable|int|null $comparer {(a, b) ==> diff} Difference between a and b: &lt;0 if a&lt;b; 0 if a==b; &gt;0 if a&gt;b. Can also be a combination of SORT_ flags.
      * @return OrderedEnumerable
@@ -920,7 +920,7 @@ 
 
     /**
      * Proc for {@link toArrayDeep}.
-     * @param $enum \Traversable Source sequence.
+     * @param Enumerable $enum \Traversable Source sequence.
      * @return array An array that contains the elements from the input sequence.
      * @package YaLinqo\Conversion
      */
@@ -970,7 +970,7 @@ 
 
     /**
      * Proc for {@link toListDeep}.
-     * @param $enum \Traversable Source sequence.
+     * @param Enumerable $enum \Traversable Source sequence.
      * @return array An array that contains the elements from the input sequence.
      * @package YaLinqo\Conversion
      */

Spacing +7 added lines, -7 removed lines

@@ -75,22 +75,22 @@ 
     {
         switch ($type) {
             case 'array':
-                return $this->select(function($v) { return (array)$v; });
+                return $this->select(function($v) { return (array) $v; });
             case 'int':
             case 'integer':
             case 'long':
-                return $this->select(function($v) { return (int)$v; });
+                return $this->select(function($v) { return (int) $v; });
             case 'float':
             case 'real':
             case 'double':
-                return $this->select(function($v) { return (float)$v; });
+                return $this->select(function($v) { return (float) $v; });
             case 'null':
             case 'unset':
                 return $this->select(function($v) { return null; });
             case 'object':
-                return $this->select(function($v) { return (object)$v; });
+                return $this->select(function($v) { return (object) $v; });
             case 'string':
-                return $this->select(function($v) { return (string)$v; });
+                return $this->select(function($v) { return (string) $v; });
             default:
                 throw new \InvalidArgumentException(Errors::UNSUPPORTED_BUILTIN_TYPE);
         }
@@ -284,7 +284,7 @@ 
         $outerKeySelector = Utils::createLambda($outerKeySelector, 'v,k', Functions::$key);
         $innerKeySelector = Utils::createLambda($innerKeySelector, 'v,k', Functions::$key);
         /** @noinspection PhpUnusedParameterInspection */
-        $resultSelectorValue = Utils::createLambda($resultSelectorValue, 'v,e,k', function($v, $e, $k) { return [ $v, $e ]; });
+        $resultSelectorValue = Utils::createLambda($resultSelectorValue, 'v,e,k', function($v, $e, $k) { return [$v, $e]; });
         /** @noinspection PhpUnusedParameterInspection */
         $resultSelectorKey = Utils::createLambda($resultSelectorKey, 'v,e,k', function($v, $e, $k) { return $k; });
 
@@ -318,7 +318,7 @@ 
         $outerKeySelector = Utils::createLambda($outerKeySelector, 'v,k', Functions::$key);
         $innerKeySelector = Utils::createLambda($innerKeySelector, 'v,k', Functions::$key);
         /** @noinspection PhpUnusedParameterInspection */
-        $resultSelectorValue = Utils::createLambda($resultSelectorValue, 'v1,v2,k', function($v1, $v2, $k) { return [ $v1, $v2 ]; });
+        $resultSelectorValue = Utils::createLambda($resultSelectorValue, 'v1,v2,k', function($v1, $v2, $k) { return [$v1, $v2]; });
         /** @noinspection PhpUnusedParameterInspection */
         $resultSelectorKey = Utils::createLambda($resultSelectorKey, 'v1,v2,k', function($v1, $v2, $k) { return $k; });
 

Braces +104 added lines, -76 removed lines

@@ -150,8 +150,9 @@ 
         $selectorKey = Utils::createLambda($selectorKey, 'v,k', Functions::$key);
 
         return new self(function() use ($selectorValue, $selectorKey) {
-            foreach ($this as $k => $v)
-                yield $selectorKey($v, $k) => $selectorValue($v, $k);
+            foreach ($this as $k => $v) {
+                            yield $selectorKey($v, $k) => $selectorValue($v, $k);
+            }
         });
     }
 
@@ -175,13 +176,15 @@ 
         $collectionSelector = Utils::createLambda($collectionSelector, 'v,k', Functions::$value);
         $resultSelectorValue = Utils::createLambda($resultSelectorValue, 'v,k1,k2', Functions::$value);
         $resultSelectorKey = Utils::createLambda($resultSelectorKey, 'v,k1,k2', false);
-        if ($resultSelectorKey === false)
-            $resultSelectorKey = Functions::increment();
+        if ($resultSelectorKey === false) {
+                    $resultSelectorKey = Functions::increment();
+        }
 
         return new self(function() use ($collectionSelector, $resultSelectorValue, $resultSelectorKey) {
-            foreach ($this as $ok => $ov)
-                foreach ($collectionSelector($ov, $ok) as $ik => $iv)
+            foreach ($this as $ok => $ov) {
+                            foreach ($collectionSelector($ov, $ok) as $ik => $iv)
                     yield $resultSelectorKey($iv, $ok, $ik) => $resultSelectorValue($iv, $ok, $ik);
+            }
         });
     }
 
@@ -197,9 +200,10 @@ 
         $predicate = Utils::createLambda($predicate, 'v,k');
 
         return new self(function() use ($predicate) {
-            foreach ($this as $k => $v)
-                if ($predicate($v, $k))
+            foreach ($this as $k => $v) {
+                            if ($predicate($v, $k))
                     yield $k => $v;
+            }
         });
     }
 
@@ -326,9 +330,10 @@ 
             $lookup = $inner->toLookup($innerKeySelector);
             foreach ($this as $ok => $ov) {
                 $key = $outerKeySelector($ov, $ok);
-                if (isset($lookup[$key]))
-                    foreach ($lookup[$key] as $iv)
+                if (isset($lookup[$key])) {
+                                    foreach ($lookup[$key] as $iv)
                         yield $resultSelectorKey($ov, $iv, $key) => $resultSelectorValue($ov, $iv, $key);
+                }
             }
         });
     }
@@ -386,20 +391,19 @@ 
             foreach ($this as $k => $v) {
                 $result = $func($result, $v, $k);
             }
-        }
-        else {
+        } else {
             $assigned = false;
             foreach ($this as $k => $v) {
                 if ($assigned) {
                     $result = $func($result, $v, $k);
-                }
-                else {
+                } else {
                     $result = $v;
                     $assigned = true;
                 }
             }
-            if (!$assigned)
-                throw new \UnexpectedValueException(Errors::NO_ELEMENTS);
+            if (!$assigned) {
+                            throw new \UnexpectedValueException(Errors::NO_ELEMENTS);
+            }
         }
         return $result;
     }
@@ -426,13 +430,11 @@ 
                 $result = $func($result, $v, $k);
                 $assigned = true;
             }
-        }
-        else {
+        } else {
             foreach ($this as $k => $v) {
                 if ($assigned) {
                     $result = $func($result, $v, $k);
-                }
-                else {
+                } else {
                     $result = $v;
                     $assigned = true;
                 }
@@ -461,8 +463,9 @@ 
             $sum += $selector($v, $k);
             $count++;
         }
-        if ($count === 0)
-            throw new \UnexpectedValueException(Errors::NO_ELEMENTS);
+        if ($count === 0) {
+                    throw new \UnexpectedValueException(Errors::NO_ELEMENTS);
+        }
         return $sum / $count;
     }
 
@@ -480,15 +483,17 @@ 
     {
         $it = $this->getIterator();
 
-        if ($it instanceof \Countable && $predicate === null)
-            return count($it);
+        if ($it instanceof \Countable && $predicate === null) {
+                    return count($it);
+        }
 
         $predicate = Utils::createLambda($predicate, 'v,k', Functions::$value);
         $count = 0;
 
-        foreach ($it as $k => $v)
-            if ($predicate($v, $k))
+        foreach ($it as $k => $v) {
+                    if ($predicate($v, $k))
                 $count++;
+        }
         return $count;
     }
 
@@ -513,8 +518,9 @@ 
             $max = max($max, $selector($v, $k));
             $assigned = true;
         }
-        if (!$assigned)
-            throw new \UnexpectedValueException(Errors::NO_ELEMENTS);
+        if (!$assigned) {
+                    throw new \UnexpectedValueException(Errors::NO_ELEMENTS);
+        }
         return $max;
     }
 
@@ -535,8 +541,9 @@ 
         $comparer = Utils::createLambda($comparer, 'a,b', Functions::$compareStrict);
         $enum = $this;
 
-        if ($selector !== null)
-            $enum = $enum->select($selector);
+        if ($selector !== null) {
+                    $enum = $enum->select($selector);
+        }
         return $enum->aggregate(function($a, $b) use ($comparer) { return $comparer($a, $b) > 0 ? $a : $b; });
     }
 
@@ -561,8 +568,9 @@ 
             $min = min($min, $selector($v, $k));
             $assigned = true;
         }
-        if (!$assigned)
-            throw new \UnexpectedValueException(Errors::NO_ELEMENTS);
+        if (!$assigned) {
+                    throw new \UnexpectedValueException(Errors::NO_ELEMENTS);
+        }
         return $min;
     }
 
@@ -583,8 +591,9 @@ 
         $comparer = Utils::createLambda($comparer, 'a,b', Functions::$compareStrict);
         $enum = $this;
 
-        if ($selector !== null)
-            $enum = $enum->select($selector);
+        if ($selector !== null) {
+                    $enum = $enum->select($selector);
+        }
         return $enum->aggregate(function($a, $b) use ($comparer) { return $comparer($a, $b) < 0 ? $a : $b; });
     }
 
@@ -604,8 +613,9 @@ 
         $selector = Utils::createLambda($selector, 'v,k', Functions::$value);
 
         $sum = 0;
-        foreach ($this as $k => $v)
-            $sum += $selector($v, $k);
+        foreach ($this as $k => $v) {
+                    $sum += $selector($v, $k);
+        }
         return $sum;
     }
 
@@ -626,8 +636,9 @@ 
         $predicate = Utils::createLambda($predicate, 'v,k');
 
         foreach ($this as $k => $v) {
-            if (!$predicate($v, $k))
-                return false;
+            if (!$predicate($v, $k)) {
+                            return false;
+            }
         }
         return true;
     }
@@ -648,15 +659,16 @@ 
 
         if ($predicate) {
             foreach ($this as $k => $v) {
-                if ($predicate($v, $k))
-                    return true;
+                if ($predicate($v, $k)) {
+                                    return true;
+                }
             }
             return false;
-        }
-        else {
+        } else {
             $it = $this->getIterator();
-            if ($it instanceof \Countable)
-                return count($it) > 0;
+            if ($it instanceof \Countable) {
+                            return count($it) > 0;
+            }
             $it->rewind();
             return $it->valid();
         }
@@ -710,8 +722,9 @@ 
     public function contains($value): bool
     {
         foreach ($this as $v) {
-            if ($v === $value)
-                return true;
+            if ($v === $value) {
+                            return true;
+            }
         }
         return false;
     }
@@ -735,8 +748,9 @@ 
             $set = [];
             foreach ($this as $k => $v) {
                 $key = $keySelector($v, $k);
-                if (isset($set[$key]))
-                    continue;
+                if (isset($set[$key])) {
+                                    continue;
+                }
                 $set[$key] = true;
                 yield $k => $v;
             }
@@ -768,8 +782,9 @@ 
             }
             foreach ($this as $k => $v) {
                 $key = $keySelector($v, $k);
-                if (isset($set[$key]))
-                    continue;
+                if (isset($set[$key])) {
+                                    continue;
+                }
                 $set[$key] = true;
                 yield $k => $v;
             }
@@ -801,8 +816,9 @@ 
             }
             foreach ($this as $k => $v) {
                 $key = $keySelector($v, $k);
-                if (!isset($set[$key]))
-                    continue;
+                if (!isset($set[$key])) {
+                                    continue;
+                }
                 unset($set[$key]);
                 yield $k => $v;
             }
@@ -850,15 +866,17 @@ 
             $set = [];
             foreach ($this as $k => $v) {
                 $key = $keySelector($v, $k);
-                if (isset($set[$key]))
-                    continue;
+                if (isset($set[$key])) {
+                                    continue;
+                }
                 $set[$key] = true;
                 yield $k => $v;
             }
             foreach ($other as $k => $v) {
                 $key = $keySelector($v, $k);
-                if (isset($set[$key]))
-                    continue;
+                if (isset($set[$key])) {
+                                    continue;
+                }
                 $set[$key] = true;
                 yield $k => $v;
             }
@@ -882,12 +900,14 @@ 
     {
         /** @var $it \Iterator|\ArrayIterator */
         $it = $this->getIterator();
-        if ($it instanceof \ArrayIterator)
-            return $it->getArrayCopy();
+        if ($it instanceof \ArrayIterator) {
+                    return $it->getArrayCopy();
+        }
 
         $array = [];
-        foreach ($it as $k => $v)
-            $array[$k] = $v;
+        foreach ($it as $k => $v) {
+                    $array[$k] = $v;
+        }
         return $array;
     }
 
@@ -914,8 +934,9 @@ 
     protected function toArrayDeepProc($enum): array
     {
         $array = [];
-        foreach ($enum as $k => $v)
-            $array[$k] = $v instanceof \Traversable || is_array($v) ? $this->toArrayDeepProc($v) : $v;
+        foreach ($enum as $k => $v) {
+                    $array[$k] = $v instanceof \Traversable || is_array($v) ? $this->toArrayDeepProc($v) : $v;
+        }
         return $array;
     }
 
@@ -932,12 +953,14 @@ 
     {
         /** @var $it \Iterator|\ArrayIterator */
         $it = $this->getIterator();
-        if ($it instanceof \ArrayIterator)
-            return array_values($it->getArrayCopy());
+        if ($it instanceof \ArrayIterator) {
+                    return array_values($it->getArrayCopy());
+        }
 
         $array = [];
-        foreach ($it as $v)
-            $array[] = $v;
+        foreach ($it as $v) {
+                    $array[] = $v;
+        }
         return $array;
     }
 
@@ -964,8 +987,9 @@ 
     protected function toListDeepProc($enum): array
     {
         $array = [];
-        foreach ($enum as $v)
-            $array[] = $v instanceof \Traversable || is_array($v) ? $this->toListDeepProc($v) : $v;
+        foreach ($enum as $v) {
+                    $array[] = $v instanceof \Traversable || is_array($v) ? $this->toListDeepProc($v) : $v;
+        }
         return $array;
     }
 
@@ -984,8 +1008,9 @@ 
         $valueSelector = Utils::createLambda($valueSelector, 'v,k', Functions::$value);
 
         $dic = [];
-        foreach ($this as $k => $v)
-            $dic[$keySelector($v, $k)] = $valueSelector($v, $k);
+        foreach ($this as $k => $v) {
+                    $dic[$keySelector($v, $k)] = $valueSelector($v, $k);
+        }
         return $dic;
     }
 
@@ -1018,8 +1043,9 @@ 
         $valueSelector = Utils::createLambda($valueSelector, 'v,k', Functions::$value);
 
         $lookup = [];
-        foreach ($this as $k => $v)
-            $lookup[$keySelector($v, $k)][] = $valueSelector($v, $k);
+        foreach ($this as $k => $v) {
+                    $lookup[$keySelector($v, $k)][] = $valueSelector($v, $k);
+        }
         return $lookup;
     }
 
@@ -1061,8 +1087,9 @@ 
         $valueSelector = Utils::createLambda($valueSelector, 'v,k', Functions::$value);
 
         $obj = new \stdClass();
-        foreach ($this as $k => $v)
-            $obj->{$propertySelector($v, $k)} = $valueSelector($v, $k);
+        foreach ($this as $k => $v) {
+                    $obj->{$propertySelector($v, $k)} = $valueSelector($v, $k);
+        }
         return $obj;
     }
 
@@ -1119,8 +1146,9 @@ 
     {
         $action = Utils::createLambda($action, 'v,k', Functions::$blank);
 
-        foreach ($this as $k => $v)
-            $action($v, $k);
+        foreach ($this as $k => $v) {
+                    $action($v, $k);
+        }
     }
 
     /**

YaLinqo/Functions.php

Doc Comments +1 added lines, -1 removed lines

@@ -140,7 +140,7 @@
 
     /**
      * Increment function: returns incremental integers starting from 0.
-     * @return callable
+     * @return \Closure
      */
     public static function increment()
     {

Braces +28 added lines, -24 removed lines

@@ -94,39 +94,43 @@
         self::$blank = function() { };
 
         self::$compareStrict = function($a, $b) {
-            if ($a === $b)
-                return 0;
-            elseif ($a > $b)
-                return 1;
-            else
-                return -1;
+            if ($a === $b) {
+                            return 0;
+            } elseif ($a > $b) {
+                            return 1;
+            } else {
+                            return -1;
+            }
         };
 
         self::$compareStrictReversed = function($a, $b) {
-            if ($a === $b)
-                return 0;
-            elseif ($a > $b)
-                return -1;
-            else
-                return 1;
+            if ($a === $b) {
+                            return 0;
+            } elseif ($a > $b) {
+                            return -1;
+            } else {
+                            return 1;
+            }
         };
 
         self::$compareLoose = function($a, $b) {
-            if ($a == $b)
-                return 0;
-            elseif ($a > $b)
-                return 1;
-            else
-                return -1;
+            if ($a == $b) {
+                            return 0;
+            } elseif ($a > $b) {
+                            return 1;
+            } else {
+                            return -1;
+            }
         };
 
         self::$compareLooseReversed = function($a, $b) {
-            if ($a == $b)
-                return 0;
-            elseif ($a > $b)
-                return -1;
-            else
-                return 1;
+            if ($a == $b) {
+                            return 0;
+            } elseif ($a > $b) {
+                            return -1;
+            } else {
+                            return 1;
+            }
         };
 
         self::$compareInt = function($a, $b) {

YaLinqo/Utils.php

Spacing +3 added lines, -3 removed lines

@@ -40,8 +40,8 @@ 
     public static function init()
     {
         self::$lambdaCache = [
-            '$v' => [ 'v,k' => Functions::$value ],
-            '$k' => [ 'v,k' => Functions::$key ],
+            '$v' => ['v,k' => Functions::$value],
+            '$k' => ['v,k' => Functions::$key],
         ];
     }
 
@@ -146,7 +146,7 @@ 
                 $code = substr($closure, $posArrow + 3);
             }
             else {
-                $args = '$' . str_replace(',', '=null,$', $closureArgs) . '=null';
+                $args = '$'.str_replace(',', '=null,$', $closureArgs).'=null';
                 $code = $closure;
             }
             $code = trim($code, " \r\n\t");

Braces +33 added lines, -26 removed lines

@@ -56,16 +56,20 @@ 
     public static function createLambda($closure, string $closureArgs, $default = null)
     {
         if ($closure === null) {
-            if ($default === null)
-                throw new \InvalidArgumentException(self::ERROR_CLOSURE_NULL);
+            if ($default === null) {
+                            throw new \InvalidArgumentException(self::ERROR_CLOSURE_NULL);
+            }
             return $default;
         }
-        if ($closure instanceof \Closure)
-            return $closure;
-        if (is_string($closure) && ($function = self::createLambdaFromString($closure, $closureArgs)))
-            return $function;
-        if (is_callable($closure))
-            return $closure;
+        if ($closure instanceof \Closure) {
+                    return $closure;
+        }
+        if (is_string($closure) && ($function = self::createLambdaFromString($closure, $closureArgs))) {
+                    return $function;
+        }
+        if (is_callable($closure)) {
+                    return $closure;
+        }
         throw new \InvalidArgumentException(self::ERROR_CLOSURE_NOT_CALLABLE);
     }
 
@@ -83,8 +87,7 @@ 
         if ($closure === null) {
             $isReversed = false;
             return $sortOrder === SORT_DESC ? Functions::$compareStrictReversed : Functions::$compareStrict;
-        }
-        elseif (is_int($closure)) {
+        } elseif (is_int($closure)) {
             switch ($closure) {
                 case SORT_REGULAR:
                     return Functions::$compareStrict;
@@ -116,14 +119,16 @@ 
      */
     public static function lambdaToSortFlagsAndOrder($closure, &$sortOrder)
     {
-        if ($sortOrder !== SORT_ASC && $sortOrder !== SORT_DESC)
-            $sortOrder = $sortOrder ? SORT_DESC : SORT_ASC;
-        if (is_int($closure))
-            return $closure;
-        elseif (($closure === null || is_string($closure)) && isset(self::$compareFunctionToSortFlags[$closure]))
-            return self::$compareFunctionToSortFlags[$closure];
-        else
-            return null;
+        if ($sortOrder !== SORT_ASC && $sortOrder !== SORT_DESC) {
+                    $sortOrder = $sortOrder ? SORT_DESC : SORT_ASC;
+        }
+        if (is_int($closure)) {
+                    return $closure;
+        } elseif (($closure === null || is_string($closure)) && isset(self::$compareFunctionToSortFlags[$closure])) {
+                    return self::$compareFunctionToSortFlags[$closure];
+        } else {
+                    return null;
+        }
     }
 
     /**
@@ -137,24 +142,26 @@ 
     {
         $posDollar = strpos($closure, '$');
         if ($posDollar !== false) {
-            if (isset(self::$lambdaCache[$closure][$closureArgs]))
-                return self::$lambdaCache[$closure][$closureArgs];
+            if (isset(self::$lambdaCache[$closure][$closureArgs])) {
+                            return self::$lambdaCache[$closure][$closureArgs];
+            }
             $posArrow = strpos($closure, '==>', $posDollar);
             if ($posArrow !== false) {
                 $args = trim(substr($closure, 0, $posArrow), "() \r\n\t");
                 $code = substr($closure, $posArrow + 3);
-            }
-            else {
+            } else {
                 $args = '$' . str_replace(',', '=null,$', $closureArgs) . '=null';
                 $code = $closure;
             }
             $code = trim($code, " \r\n\t");
-            if (strlen($code) > 0 && $code[0] != '{')
-                $code = "return {$code};";
+            if (strlen($code) > 0 && $code[0] != '{') {
+                            $code = "return {$code};";
+            }
             $fun = @create_function($args, $code);
             // @codeCoverageIgnoreStart
-            if (!$fun)
-                throw new \InvalidArgumentException(self::ERROR_CANNOT_PARSE_LAMBDA);
+            if (!$fun) {
+                            throw new \InvalidArgumentException(self::ERROR_CANNOT_PARSE_LAMBDA);
+            }
             // @codeCoverageIgnoreEnd
             self::$lambdaCache[$closure][$closureArgs] = $fun;
             return $fun;

YaLinqo/OrderedEnumerable.php

Spacing +2 added lines, -2 removed lines

@@ -206,7 +206,7 @@ 
     {
         /** @var $order OrderedEnumerable */
         foreach ($this->source as $k => $v)
-            $enum[] = [ $k, $v ];
+            $enum[] = [$k, $v];
 
         $args = [];
         foreach ($orders as $order) {
@@ -228,7 +228,7 @@ 
     {
         /** @var $order OrderedEnumerable */
         foreach ($this->source as $k => $v) {
-            $element = [ $k, $v ];
+            $element = [$k, $v];
             foreach ($orders as $order) {
                 $keySelector = $order->keySelector;
                 $element[] = $keySelector($v, $k);

Doc Comments +1 added lines, -1 removed lines

@@ -65,7 +65,7 @@
      * <p>Three methods are defined to extend the type OrderedEnumerable, which is the return type of this method. These three methods, namely {@link thenBy}, {@link thenByDescending} and {@link thenByDir}, enable you to specify additional sort criteria to sort a sequence. These methods also return an OrderedEnumerable, which means any number of consecutive calls to thenBy, thenByDescending or thenByDir can be made.
      * <p>Because OrderedEnumerable inherits from {@link Enumerable}, you can call {@link Enumerable::orderBy orderBy}, {@link Enumerable::orderByDescending orderByDescending} or {@link Enumerable::orderByDir orderByDir} on the results of a call to orderBy, orderByDescending, orderByDir, thenBy, thenByDescending or thenByDir. Doing this introduces a new primary ordering that ignores the previously established ordering.
      * <p>This method performs an unstable sort; that is, if the keys of two elements are equal, the order of the elements is not preserved. In contrast, a stable sort preserves the order of elements that have the same key. Internally, {@link usort} is used.
-     * @param int|bool $sortOrder A direction in which to order the elements: false or SORT_DESC for ascending (by increasing value), true or SORT_ASC for descending (by decreasing value).
+     * @param boolean $sortOrder A direction in which to order the elements: false or SORT_DESC for ascending (by increasing value), true or SORT_ASC for descending (by decreasing value).
      * @param callable|null $keySelector {(v, k) ==> key} A function to extract a key from an element. Default: value.
      * @param callable|int|null $comparer {(a, b) ==> diff} Difference between a and b: &lt;0 if a&lt;b; 0 if a==b; &gt;0 if a&gt;b. Can also be a combination of SORT_ flags.
      * @return \YaLinqo\OrderedEnumerable

Braces +47 added lines, -38 removed lines

@@ -54,8 +54,10 @@ 
     private function getSingleComparer()
     {
         $comparer = $this->comparer;
-        if ($this->isReversed)
-            $comparer = function($a, $b) use ($comparer) { return -$comparer($a, $b); };
+        if ($this->isReversed) {
+                    $comparer = function($a, $b) use ($comparer) { return -$comparer($a, $b);
+        }
+        };
         return $comparer;
     }
 
@@ -116,8 +118,9 @@ 
         $array = $this->source->tryGetArrayCopy();
 
         $it = $this->trySortBySingleField($array, $canMultisort);
-        if ($it !== null)
-            return $it;
+        if ($it !== null) {
+                    return $it;
+        }
 
         return $this->sortByMultipleFields($array, $canMultisort);
     }
@@ -126,24 +129,23 @@ 
     {
         if ($this->parent !== null || $array === null) {
             return null;
-        }
-        elseif ($this->keySelector === Functions::$value) {
-            if (!$canMultisort)
-                uasort($array, $this->getSingleComparer());
-            elseif ($this->sortOrder == SORT_ASC)
-                asort($array, $this->sortFlags);
-            else
-                arsort($array, $this->sortFlags);
-        }
-        elseif ($this->keySelector === Functions::$key) {
-            if ($canMultisort)
-                uksort($array, $this->getSingleComparer());
-            elseif ($this->sortOrder == SORT_ASC)
-                ksort($array, $this->sortFlags);
-            else
-                krsort($array, $this->sortFlags);
-        }
-        else {
+        } elseif ($this->keySelector === Functions::$value) {
+            if (!$canMultisort) {
+                            uasort($array, $this->getSingleComparer());
+            } elseif ($this->sortOrder == SORT_ASC) {
+                            asort($array, $this->sortFlags);
+            } else {
+                            arsort($array, $this->sortFlags);
+            }
+        } elseif ($this->keySelector === Functions::$key) {
+            if ($canMultisort) {
+                            uksort($array, $this->getSingleComparer());
+            } elseif ($this->sortOrder == SORT_ASC) {
+                            ksort($array, $this->sortFlags);
+            } else {
+                            krsort($array, $this->sortFlags);
+            }
+        } else {
             return null;
         }
         return new \ArrayIterator($array);
@@ -154,14 +156,16 @@ 
         $orders = [];
         for ($order = $this; $order !== null; $order = $order->parent) {
             $orders[] = $order;
-            if ($order->sortFlags === null)
-                $canMultisort = false;
+            if ($order->sortFlags === null) {
+                            $canMultisort = false;
+            }
         }
         $orders = array_reverse($orders);
 
         $it = $this->trySortArrayWithMultisort($array, $orders, $canMultisort);
-        if ($it !== null)
-            return $it;
+        if ($it !== null) {
+                    return $it;
+        }
 
         return $this->sortIterator($orders, $canMultisort);
     }
@@ -169,20 +173,23 @@ 
     private function sortIterator(array $orders, bool $canMultisort)
     {
         $enum = [];
-        if ($canMultisort)
-            $this->sortIteratorWithMultisort($enum, $orders);
-        else
-            $this->sortIteratorWithUsort($enum, $orders);
+        if ($canMultisort) {
+                    $this->sortIteratorWithMultisort($enum, $orders);
+        } else {
+                    $this->sortIteratorWithUsort($enum, $orders);
+        }
 
-        foreach ($enum as $pair)
-            yield $pair[0] => $pair[1];
+        foreach ($enum as $pair) {
+                    yield $pair[0] => $pair[1];
+        }
     }
 
     private function trySortArrayWithMultisort($array, array $orders, bool $canMultisort)
     {
         /** @var $order OrderedEnumerable */
-        if ($array === null || !$canMultisort)
-            return null;
+        if ($array === null || !$canMultisort) {
+                    return null;
+        }
 
         $args = [];
         foreach ($orders as $order) {
@@ -205,8 +212,9 @@ 
     private function sortIteratorWithMultisort(&$enum, array $orders)
     {
         /** @var $order OrderedEnumerable */
-        foreach ($this->source as $k => $v)
-            $enum[] = [ $k, $v ];
+        foreach ($this->source as $k => $v) {
+                    $enum[] = [ $k, $v ];
+        }
 
         $args = [];
         foreach ($orders as $order) {
@@ -243,8 +251,9 @@ 
                 $order = $orders[$i];
                 $comparer = $order->comparer;
                 $diff = $comparer($a[$i + 2], $b[$i + 2]);
-                if ($diff != 0)
-                    return $order->isReversed ? -$diff : $diff;
+                if ($diff != 0) {
+                                    return $order->isReversed ? -$diff : $diff;
+                }
             }
             return 0;
         });

YaLinqo/EnumerablePagination.php

Doc Comments +4 added lines, -4 removed lines

@@ -394,7 +394,7 @@ 
      * <p>If source contains fewer than count elements, an empty sequence is returned. If count is less than or equal to zero, all elements of source are yielded.
      * <p>The {@link take} and skip methods are functional complements. Given a sequence coll and an integer n, concatenating the results of coll->take(n) and coll->skip(n) yields the same sequence as coll.
      * @param int $count The number of elements to skip before returning the remaining elements.
-     * @return Enumerable A sequence that contains the elements that occur after the specified index in the input sequence.
+     * @return EnumerablePagination A sequence that contains the elements that occur after the specified index in the input sequence.
      * @package YaLinqo\Pagination
      */
     public function skip(int $count)
@@ -417,7 +417,7 @@ 
      * <p>This method tests each element of source by using predicate and skips the element if the result is true. After the predicate function returns false for an element, that element and the remaining elements in source are yielded and there are no more invocations of predicate. If predicate returns true for all elements in the sequence, an empty sequence is returned.
      * <p>The {@link takeWhile} and skipWhile methods are functional complements. Given a sequence coll and a pure function p, concatenating the results of coll->takeWhile(p) and coll->skipWhile(p) yields the same sequence as coll.
      * @param callable $predicate {(v, k) ==> result} A function to test each element for a condition.
-     * @return Enumerable A sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate.
+     * @return EnumerablePagination A sequence that contains the elements from the input sequence starting at the first element in the linear series that does not pass the test specified by predicate.
      * @package YaLinqo\Pagination
      */
     public function skipWhile($predicate)
@@ -441,7 +441,7 @@ 
      * <p>Take enumerates source and yields elements until count elements have been yielded or source contains no more elements. If count is less than or equal to zero, source is not enumerated and an empty sequence is returned.
      * <p>The take and {@link skip} methods are functional complements. Given a sequence coll and an integer n, concatenating the results of coll->take(n) and coll->skip(n) yields the same sequence as coll.
      * @param int $count The number of elements to return.
-     * @return Enumerable A sequence that contains the specified number of elements from the start of the input sequence.
+     * @return EnumerablePagination A sequence that contains the specified number of elements from the start of the input sequence.
      * @package YaLinqo\Pagination
      */
     public function take(int $count)
@@ -464,7 +464,7 @@ 
      * <p>The takeWhile method tests each element of source by using predicate and yields the element if the result is true. Enumeration stops when the predicate function returns false for an element or when source contains no more elements.
      * <p>The takeWhile and {@link skipWhile} methods are functional complements. Given a sequence coll and a pure function p, concatenating the results of coll->takeWhile(p) and coll->skipWhile(p) yields the same sequence as coll.
      * @param callable $predicate {(v, k) ==> result} A function to test each element for a condition.
-     * @return Enumerable A sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes.
+     * @return EnumerablePagination A sequence that contains the elements from the input sequence that occur before the element at which the test no longer passes.
      * @package YaLinqo\Pagination
      */
     public function takeWhile($predicate)

Braces +69 added lines, -47 removed lines

@@ -32,14 +32,16 @@ 
         $it = $this->getIterator();
 
         if ($it instanceof \ArrayAccess) {
-            if (!$it->offsetExists($key))
-                throw new \UnexpectedValueException(Errors::NO_KEY);
+            if (!$it->offsetExists($key)) {
+                            throw new \UnexpectedValueException(Errors::NO_KEY);
+            }
             return $it->offsetGet($key);
         }
 
         foreach ($it as $k => $v) {
-            if ($k === $key)
-                return $v;
+            if ($k === $key) {
+                            return $v;
+            }
         }
         throw new \UnexpectedValueException(Errors::NO_KEY);
     }
@@ -58,12 +60,14 @@ 
         /** @var $it \Iterator|\ArrayAccess */
         $it = $this->getIterator();
 
-        if ($it instanceof \ArrayAccess)
-            return $it->offsetExists($key) ? $it->offsetGet($key) : $default;
+        if ($it instanceof \ArrayAccess) {
+                    return $it->offsetExists($key) ? $it->offsetGet($key) : $default;
+        }
 
         foreach ($it as $k => $v) {
-            if ($k === $key)
-                return $v;
+            if ($k === $key) {
+                            return $v;
+            }
         }
         return $default;
     }
@@ -86,8 +90,9 @@ 
         $predicate = Utils::createLambda($predicate, 'v,k', Functions::$true);
 
         foreach ($this as $k => $v) {
-            if ($predicate($v, $k))
-                return $v;
+            if ($predicate($v, $k)) {
+                            return $v;
+            }
         }
         throw new \UnexpectedValueException(Errors::NO_MATCHES);
     }
@@ -109,8 +114,9 @@ 
         $predicate = Utils::createLambda($predicate, 'v,k', Functions::$true);
 
         foreach ($this as $k => $v) {
-            if ($predicate($v, $k))
-                return $v;
+            if ($predicate($v, $k)) {
+                            return $v;
+            }
         }
         return $default;
     }
@@ -132,8 +138,9 @@ 
         $predicate = Utils::createLambda($predicate, 'v,k', Functions::$true);
 
         foreach ($this as $k => $v) {
-            if ($predicate($v, $k))
-                return $v;
+            if ($predicate($v, $k)) {
+                            return $v;
+            }
         }
         return $fallback();
     }
@@ -163,8 +170,9 @@ 
                 $value = $v;
             }
         }
-        if (!$found)
-            throw new \UnexpectedValueException(Errors::NO_MATCHES);
+        if (!$found) {
+                    throw new \UnexpectedValueException(Errors::NO_MATCHES);
+        }
         return $value;
     }
 
@@ -243,14 +251,16 @@ 
         $value = null;
         foreach ($this as $k => $v) {
             if ($predicate($v, $k)) {
-                if ($found)
-                    throw new \UnexpectedValueException(Errors::MANY_MATCHES);
+                if ($found) {
+                                    throw new \UnexpectedValueException(Errors::MANY_MATCHES);
+                }
                 $found = true;
                 $value = $v;
             }
         }
-        if (!$found)
-            throw new \UnexpectedValueException(Errors::NO_MATCHES);
+        if (!$found) {
+                    throw new \UnexpectedValueException(Errors::NO_MATCHES);
+        }
         return $value;
     }
 
@@ -275,8 +285,9 @@ 
         $value = null;
         foreach ($this as $k => $v) {
             if ($predicate($v, $k)) {
-                if ($found)
-                    throw new \UnexpectedValueException(Errors::MANY_MATCHES);
+                if ($found) {
+                                    throw new \UnexpectedValueException(Errors::MANY_MATCHES);
+                }
                 $found = true;
                 $value = $v;
             }
@@ -305,8 +316,9 @@ 
         $value = null;
         foreach ($this as $k => $v) {
             if ($predicate($v, $k)) {
-                if ($found)
-                    throw new \UnexpectedValueException(Errors::MANY_MATCHES);
+                if ($found) {
+                                    throw new \UnexpectedValueException(Errors::MANY_MATCHES);
+                }
                 $found = true;
                 $value = $v;
             }
@@ -325,12 +337,13 @@ 
     public function indexOf($value)
     {
         $array = $this->tryGetArrayCopy();
-        if ($array !== null)
-            return array_search($value, $array, true);
-        else {
+        if ($array !== null) {
+                    return array_search($value, $array, true);
+        } else {
             foreach ($this as $k => $v) {
-                if ($v === $value)
-                    return $k;
+                if ($v === $value) {
+                                    return $k;
+                }
             }
             return false;
         }
@@ -348,8 +361,9 @@ 
     {
         $key = null;
         foreach ($this as $k => $v) {
-            if ($v === $value)
-                $key = $k;
+            if ($v === $value) {
+                            $key = $k;
+            }
         }
         return $key; // not -1
     }
@@ -367,8 +381,9 @@ 
         $predicate = Utils::createLambda($predicate, 'v,k');
 
         foreach ($this as $k => $v) {
-            if ($predicate($v, $k))
-                return $k;
+            if ($predicate($v, $k)) {
+                            return $k;
+            }
         }
         return null; // not -1
     }
@@ -387,8 +402,9 @@ 
 
         $key = null;
         foreach ($this as $k => $v) {
-            if ($predicate($v, $k))
-                $key = $k;
+            if ($predicate($v, $k)) {
+                            $key = $k;
+            }
         }
         return $key; // not -1
     }
@@ -407,8 +423,9 @@ 
         return new self(function() use ($count) {
             $it = $this->getIterator();
             $it->rewind();
-            for ($i = 0; $i < $count && $it->valid(); ++$i)
-                $it->next();
+            for ($i = 0; $i < $count && $it->valid(); ++$i) {
+                            $it->next();
+            }
             while ($it->valid()) {
                 yield $it->key() => $it->current();
                 $it->next();
@@ -432,10 +449,12 @@ 
         return new self(function() use ($predicate) {
             $yielding = false;
             foreach ($this as $k => $v) {
-                if (!$yielding && !$predicate($v, $k))
-                    $yielding = true;
-                if ($yielding)
-                    yield $k => $v;
+                if (!$yielding && !$predicate($v, $k)) {
+                                    $yielding = true;
+                }
+                if ($yielding) {
+                                    yield $k => $v;
+                }
             }
         });
     }
@@ -451,14 +470,16 @@ 
      */
     public function take(int $count)
     {
-        if ($count <= 0)
-            return new self(new \EmptyIterator, false);
+        if ($count <= 0) {
+                    return new self(new \EmptyIterator, false);
+        }
 
         return new self(function() use ($count) {
             foreach ($this as $k => $v) {
                 yield $k => $v;
-                if (--$count == 0)
-                    break;
+                if (--$count == 0) {
+                                    break;
+                }
             }
         });
     }
@@ -478,8 +499,9 @@ 
 
         return new self(function() use ($predicate) {
             foreach ($this as $k => $v) {
-                if (!$predicate($v, $k))
-                    break;
+                if (!$predicate($v, $k)) {
+                                    break;
+                }
                 yield $k => $v;
             }
         });

YaLinqo/EnumerableGeneration.php

Braces +37 added lines, -28 removed lines

@@ -36,8 +36,9 @@ 
                     yield $v;
                     $isEmpty = false;
                 }
-                if ($isEmpty)
-                    throw new \UnexpectedValueException(Errors::NO_ELEMENTS);
+                if ($isEmpty) {
+                                    throw new \UnexpectedValueException(Errors::NO_ELEMENTS);
+                }
             }
         });
     }
@@ -72,14 +73,15 @@ 
     public static function from($source): Enumerable
     {
         $it = null;
-        if ($source instanceof Enumerable)
-            return $source;
-        elseif (is_array($source))
-            $it = new \ArrayIterator($source);
-        elseif ($source instanceof \IteratorAggregate)
-            $it = $source->getIterator();
-        elseif ($source instanceof \Traversable)
-            $it = $source;
+        if ($source instanceof Enumerable) {
+                    return $source;
+        } elseif (is_array($source)) {
+                    $it = new \ArrayIterator($source);
+        } elseif ($source instanceof \IteratorAggregate) {
+                    $it = $source->getIterator();
+        } elseif ($source instanceof \Traversable) {
+                    $it = $source;
+        }
         if ($it !== null) {
             return new self($it, false);
         }
@@ -128,8 +130,9 @@ 
     {
         return new self(function() use ($start, $step) {
             $value = $start - $step;
-            while (true)
-                yield $value += $step;
+            while (true) {
+                            yield $value += $step;
+            }
         });
     }
 
@@ -189,12 +192,14 @@ 
      */
     public static function range(int $start, int $count, int $step = 1): Enumerable
     {
-        if ($count <= 0)
-            return self::emptyEnum();
+        if ($count <= 0) {
+                    return self::emptyEnum();
+        }
         return new self(function() use ($start, $count, $step) {
             $value = $start - $step;
-            while ($count-- > 0)
-                yield $value += $step;
+            while ($count-- > 0) {
+                            yield $value += $step;
+            }
         });
     }
 
@@ -228,16 +233,18 @@ 
      */
     public static function rangeTo(int $start, int $end, $step = 1): Enumerable
     {
-        if ($step <= 0)
-            throw new \InvalidArgumentException(Errors::STEP_NEGATIVE);
+        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;
+                for ($i = $start; $i < $end; $i += $step) {
+                                    yield $i;
+                }
+            } else {
+                for ($i = $start; $i > $end; $i -= $step) {
+                                    yield $i;
+                }
             }
         });
     }
@@ -257,11 +264,13 @@ 
      */
     public static function repeat($element, $count = null): Enumerable
     {
-        if ($count < 0)
-            throw new \InvalidArgumentException(Errors::COUNT_LESS_THAN_ZERO);
+        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;
+            for ($i = 0; $i < $count || $count === null; $i++) {
+                            yield $element;
+            }
         });
     }