Athari / YaLinqo

YaLinqo/Functions.php

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/OrderedEnumerable.php

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/Utils.php

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/Enumerable.php

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/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;
+            }
         });
     }
 

YaLinqo/EnumerablePagination.php

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;
             }
         });