Athari / YaLinqo

YaLinqo/Linq.php

Spacing +1 added lines, -1 removed lines

@@ -18,7 +18,7 @@
      * @return \YaLinqo\Enumerable
      * @see \YaLinqo\Enumerable::from
      */
-    function from ($source)
+    function from($source)
     {
         return \YaLinqo\Enumerable::from($source);
     }

YaLinqo/OrderedEnumerable.php

Spacing +22 added lines, -22 removed lines

@@ -42,7 +42,7 @@ 
      * @param callable $comparer {(a, b) ==> diff} Difference between a and b: <0 if a<b; 0 if a==b; >0 if a>b
      * @param \YaLinqo\OrderedEnumerable $parent
      */
-    public function __construct ($source, $sortOrder, $sortFlags, $isReversed, $keySelector, $comparer, $parent = null)
+    public function __construct($source, $sortOrder, $sortFlags, $isReversed, $keySelector, $comparer, $parent = null)
     {
         $this->source = $source;
         $this->sortOrder = $sortOrder;
@@ -53,11 +53,11 @@ 
         $this->parent = $parent;
     }
 
-    private function getSingleComparer ()
+    private function getSingleComparer()
     {
         $comparer = $this->comparer;
         if ($this->isReversed)
-            $comparer = function ($a, $b) use ($comparer) { return -$comparer($a, $b); };
+            $comparer = function($a, $b) use ($comparer) { return -$comparer($a, $b); };
         return $comparer;
     }
 
@@ -72,7 +72,7 @@ 
      * @param callable|int|null $comparer {(a, b) ==> diff} Difference between a and b: <0 if a<b; 0 if a==b; >0 if a>b. Can also be a combination of SORT_ flags.
      * @return \YaLinqo\OrderedEnumerable
      */
-    public function thenByDir ($sortOrder, $keySelector = null, $comparer = null)
+    public function thenByDir($sortOrder, $keySelector = null, $comparer = null)
     {
         $sortFlags = Utils::lambdaToSortFlagsAndOrder($comparer, $sortOrder);
         $keySelector = Utils::createLambda($keySelector, 'v,k', Functions::$value);
@@ -91,7 +91,7 @@ 
      * @param callable|int|null $comparer {(a, b) ==> diff} Difference between a and b: <0 if a<b; 0 if a==b; >0 if a>b. Can also be a combination of SORT_ flags.
      * @return \YaLinqo\OrderedEnumerable
      */
-    public function thenBy ($keySelector = null, $comparer = null)
+    public function thenBy($keySelector = null, $comparer = null)
     {
         return $this->thenByDir(false, $keySelector, $comparer);
     }
@@ -106,13 +106,13 @@ 
      * @param callable|int|null $comparer {(a, b) ==> diff} Difference between a and b: <0 if a<b; 0 if a==b; >0 if a>b. Can also be a combination of SORT_ flags.
      * @return \YaLinqo\OrderedEnumerable
      */
-    public function thenByDescending ($keySelector = null, $comparer = null)
+    public function thenByDescending($keySelector = null, $comparer = null)
     {
         return $this->thenByDir(true, $keySelector, $comparer);
     }
 
     /** {@inheritdoc} */
-    public function getIterator ()
+    public function getIterator()
     {
         $canMultisort = $this->sortFlags !== null;
         $array = $this->source->tryGetArrayCopy();
@@ -124,7 +124,7 @@ 
         return $this->sortByMultipleFields($array, $canMultisort);
     }
 
-    private function trySortBySingleField ($array, $canMultisort)
+    private function trySortBySingleField($array, $canMultisort)
     {
         if ($this->parent !== null || $array === null) {
             return null;
@@ -151,9 +151,9 @@ 
         return new \ArrayIterator($array);
     }
 
-    private function sortByMultipleFields ($array, $canMultisort)
+    private function sortByMultipleFields($array, $canMultisort)
     {
-        $orders = [ ];
+        $orders = [];
         for ($order = $this; $order !== null; $order = $order->parent) {
             $orders[] = $order;
             if ($order->sortFlags === null)
@@ -168,9 +168,9 @@ 
         return $this->sortIterator($orders, $canMultisort);
     }
 
-    private function sortIterator ($orders, $canMultisort)
+    private function sortIterator($orders, $canMultisort)
     {
-        $enum = [ ];
+        $enum = [];
         if ($canMultisort)
             $this->sortIteratorWithMultisort($enum, $orders);
         else
@@ -180,15 +180,15 @@ 
             yield $pair[0] => $pair[1];
     }
 
-    private function trySortArrayWithMultisort ($array, $orders, $canMultisort)
+    private function trySortArrayWithMultisort($array, $orders, $canMultisort)
     {
         /** @var $order OrderedEnumerable */
         if ($array === null || !$canMultisort)
             return null;
 
-        $args = [ ];
+        $args = [];
         foreach ($orders as $order) {
-            $column = [ ];
+            $column = [];
             foreach ($array as $k => $v) {
                 $keySelector = $order->keySelector;
                 $column[$k] = $keySelector($v, $k);
@@ -204,15 +204,15 @@ 
         return new \ArrayIterator($array);
     }
 
-    private function sortIteratorWithMultisort (&$enum, $orders)
+    private function sortIteratorWithMultisort(&$enum, $orders)
     {
         /** @var $order OrderedEnumerable */
         foreach ($this->source as $k => $v)
-            $enum[] = [ $k, $v ];
+            $enum[] = [$k, $v];
 
-        $args = [ ];
+        $args = [];
         foreach ($orders as $order) {
-            $column = [ ];
+            $column = [];
             foreach ($enum as $k => $pair) {
                 $keySelector = $order->keySelector;
                 $column[$k] = $keySelector($pair[1], $pair[0]);
@@ -226,11 +226,11 @@ 
         call_user_func_array('array_multisort', $args);
     }
 
-    private function sortIteratorWithUsort (&$enum, $orders)
+    private function sortIteratorWithUsort(&$enum, $orders)
     {
         /** @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);
@@ -238,7 +238,7 @@ 
             $enum[] = $element;
         }
 
-        usort($enum, function ($a, $b) use ($orders) {
+        usort($enum, function($a, $b) use ($orders) {
             /** @var $order OrderedEnumerable */
             $count = count($orders);
             for ($i = 0; $i < $count; $i++) {

Braces +47 added lines, -38 removed lines

@@ -56,8 +56,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;
     }
 
@@ -118,8 +120,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);
     }
@@ -128,24 +131,23 @@ 
     {
         if ($this->parent !== null || $array === null) {
             return null;
-        }
-        else if ($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 {
+        } else if ($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);
@@ -156,14 +158,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);
     }
@@ -171,20 +175,23 @@ 
     private function sortIterator ($orders, $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, $orders, $canMultisort)
     {
         /** @var $order OrderedEnumerable */
-        if ($array === null || !$canMultisort)
-            return null;
+        if ($array === null || !$canMultisort) {
+                    return null;
+        }
 
         $args = [ ];
         foreach ($orders as $order) {
@@ -207,8 +214,9 @@ 
     private function sortIteratorWithMultisort (&$enum, $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) {
@@ -245,8 +253,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

Spacing +24 added lines, -24 removed lines

@@ -17,7 +17,7 @@ 
      * @return mixed The value at the key in the source sequence.
      * @package YaLinqo\Pagination
      */
-    public function elementAt ($key)
+    public function elementAt($key)
     {
         /** @var $it \Iterator|\ArrayAccess */
         $it = $this->getIterator();
@@ -44,7 +44,7 @@ 
      * @return mixed default value if the key is not found in the source sequence; otherwise, the value at the specified key in the source sequence.
      * @package YaLinqo\Pagination
      */
-    public function elementAtOrDefault ($key, $default = null)
+    public function elementAtOrDefault($key, $default = null)
     {
         /** @var $it \Iterator|\ArrayAccess */
         $it = $this->getIterator();
@@ -72,7 +72,7 @@ 
      * @return mixed If predicate is null: the first element in the specified sequence. If predicate is not null: The first element in the sequence that passes the test in the specified predicate function.
      * @package YaLinqo\Pagination
      */
-    public function first ($predicate = null)
+    public function first($predicate = null)
     {
         $predicate = Utils::createLambda($predicate, 'v,k', Functions::$true);
 
@@ -95,7 +95,7 @@ 
      * @return mixed If predicate is null: default value if source is empty; otherwise, the first element in source. If predicate is not null: default value if source is empty or if no element passes the test specified by predicate; otherwise, the first element in source that passes the test specified by predicate.
      * @package YaLinqo\Pagination
      */
-    public function firstOrDefault ($default = null, $predicate = null)
+    public function firstOrDefault($default = null, $predicate = null)
     {
         $predicate = Utils::createLambda($predicate, 'v,k', Functions::$true);
 
@@ -118,7 +118,7 @@ 
      * @return mixed If predicate is null: the result of calling a fallback function if source is empty; otherwise, the first element in source. If predicate is not null: the result of calling a fallback function if source is empty or if no element passes the test specified by predicate; otherwise, the first element in source that passes the test specified by predicate.
      * @package YaLinqo\Pagination
      */
-    public function firstOrFallback ($fallback, $predicate = null)
+    public function firstOrFallback($fallback, $predicate = null)
     {
         $predicate = Utils::createLambda($predicate, 'v,k', Functions::$true);
 
@@ -142,7 +142,7 @@ 
      * @return mixed If predicate is null: the last element in the specified sequence. If predicate is not null: The last element in the sequence that passes the test in the specified predicate function.
      * @package YaLinqo\Pagination
      */
-    public function last ($predicate = null)
+    public function last($predicate = null)
     {
         $predicate = Utils::createLambda($predicate, 'v,k', Functions::$true);
 
@@ -171,7 +171,7 @@ 
      * @return mixed If predicate is null: default value if source is empty; otherwise, the last element in source. If predicate is not null: default value if source is empty or if no element passes the test specified by predicate; otherwise, the last element in source that passes the test specified by predicate.
      * @package YaLinqo\Pagination
      */
-    public function lastOrDefault ($default = null, $predicate = null)
+    public function lastOrDefault($default = null, $predicate = null)
     {
         $predicate = Utils::createLambda($predicate, 'v,k', Functions::$true);
 
@@ -198,7 +198,7 @@ 
      * @return mixed If predicate is null: the result of calling a fallback function if source is empty; otherwise, the last element in source. If predicate is not null: the result of calling a fallback function if source is empty or if no element passes the test specified by predicate; otherwise, the last element in source that passes the test specified by predicate.
      * @package YaLinqo\Pagination
      */
-    public function lastOrFallback ($fallback, $predicate = null)
+    public function lastOrFallback($fallback, $predicate = null)
     {
         $predicate = Utils::createLambda($predicate, 'v,k', Functions::$true);
 
@@ -226,7 +226,7 @@ 
      * @return mixed If predicate is null: the single element of the input sequence. If predicate is not null: The single element of the sequence that passes the test in the specified predicate function.
      * @package YaLinqo\Pagination
      */
-    public function single ($predicate = null)
+    public function single($predicate = null)
     {
         $predicate = Utils::createLambda($predicate, 'v,k', Functions::$true);
 
@@ -258,7 +258,7 @@ 
      * @return mixed If predicate is null: default value if source is empty; otherwise, the single element of the source. If predicate is not null: default value if source is empty or if no element passes the test specified by predicate; otherwise, the single element of the source that passes the test specified by predicate.
      * @package YaLinqo\Pagination
      */
-    public function singleOrDefault ($default = null, $predicate = null)
+    public function singleOrDefault($default = null, $predicate = null)
     {
         $predicate = Utils::createLambda($predicate, 'v,k', Functions::$true);
 
@@ -288,7 +288,7 @@ 
      * @return mixed If predicate is null: the result of calling a fallback function if source is empty; otherwise, the single element of the source. If predicate is not null: the result of calling a fallback function if source is empty or if no element passes the test specified by predicate; otherwise, the single element of the source that passes the test specified by predicate.
      * @package YaLinqo\Pagination
      */
-    public function singleOrFallback ($fallback, $predicate = null)
+    public function singleOrFallback($fallback, $predicate = null)
     {
         $predicate = Utils::createLambda($predicate, 'v,k', Functions::$true);
 
@@ -313,7 +313,7 @@ 
      * @return mixed The key of the first occurrence of value, if found; otherwise, null.
      * @package YaLinqo\Pagination
      */
-    public function indexOf ($value)
+    public function indexOf($value)
     {
         foreach ($this as $k => $v) {
             if ($v === $value)
@@ -330,7 +330,7 @@ 
      * @return mixed The key of the last occurrence of value, if found; otherwise, null.
      * @package YaLinqo\Pagination
      */
-    public function lastIndexOf ($value)
+    public function lastIndexOf($value)
     {
         $key = null;
         foreach ($this as $k => $v) {
@@ -348,7 +348,7 @@ 
      * @return mixed The key of the first occurrence of an element that matches the conditions defined by predicate, if found; otherwise, null.
      * @package YaLinqo\Pagination
      */
-    public function findIndex ($predicate)
+    public function findIndex($predicate)
     {
         $predicate = Utils::createLambda($predicate, 'v,k');
 
@@ -367,7 +367,7 @@ 
      * @return mixed The key of the last occurrence of an element that matches the conditions defined by predicate, if found; otherwise, null.
      * @package YaLinqo\Pagination
      */
-    public function findLastIndex ($predicate)
+    public function findLastIndex($predicate)
     {
         $predicate = Utils::createLambda($predicate, 'v,k');
 
@@ -388,9 +388,9 @@ 
      * @return Enumerable A sequence that contains the elements that occur after the specified index in the input sequence.
      * @package YaLinqo\Pagination
      */
-    public function skip ($count)
+    public function skip($count)
     {
-        return new self(function () use ($count) {
+        return new self(function() use ($count) {
             $it = $this->getIterator();
             $it->rewind();
             for ($i = 0; $i < $count && $it->valid(); ++$i)
@@ -411,11 +411,11 @@ 
      * @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.
      * @package YaLinqo\Pagination
      */
-    public function skipWhile ($predicate)
+    public function skipWhile($predicate)
     {
         $predicate = Utils::createLambda($predicate, 'v,k');
 
-        return new self(function () use ($predicate) {
+        return new self(function() use ($predicate) {
             $yielding = false;
             foreach ($this as $k => $v) {
                 if (!$yielding && !$predicate($v, $k))
@@ -435,12 +435,12 @@ 
      * @return Enumerable A sequence that contains the specified number of elements from the start of the input sequence.
      * @package YaLinqo\Pagination
      */
-    public function take ($count)
+    public function take($count)
     {
         if ($count <= 0)
             return new self(new \EmptyIterator, false);
 
-        return new self(function () use ($count) {
+        return new self(function() use ($count) {
             if ($count <= 0)
                 return;
             foreach ($this as $k => $v) {
@@ -460,11 +460,11 @@ 
      * @return Enumerable 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)
+    public function takeWhile($predicate)
     {
         $predicate = Utils::createLambda($predicate, 'v,k');
 
-        return new self(function () use ($predicate) {
+        return new self(function() use ($predicate) {
             foreach ($this as $k => $v) {
                 if (!$predicate($v, $k))
                     break;
@@ -476,5 +476,5 @@ 
     /**
      * @return \Iterator
      */
-    public abstract function getIterator ();
+    public abstract function getIterator();
 }
\ No newline at end of file

Braces +69 added lines, -46 removed lines

@@ -23,14 +23,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);
     }
@@ -49,12 +51,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;
     }
@@ -77,8 +81,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);
     }
@@ -100,8 +105,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;
     }
@@ -123,8 +129,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();
     }
@@ -154,8 +161,9 @@ 
                 $value = $v;
             }
         }
-        if (!$found)
-            throw new \UnexpectedValueException(Errors::NO_MATCHES);
+        if (!$found) {
+                    throw new \UnexpectedValueException(Errors::NO_MATCHES);
+        }
         return $value;
     }
 
@@ -234,14 +242,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;
     }
 
@@ -266,8 +276,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;
             }
@@ -296,8 +307,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;
             }
@@ -316,8 +328,9 @@ 
     public function indexOf ($value)
     {
         foreach ($this as $k => $v) {
-            if ($v === $value)
-                return $k;
+            if ($v === $value) {
+                            return $k;
+            }
         }
         return null; // not -1
     }
@@ -334,8 +347,9 @@ 
     {
         $key = null;
         foreach ($this as $k => $v) {
-            if ($v === $value)
-                $key = $k;
+            if ($v === $value) {
+                            $key = $k;
+            }
         }
         return $key; // not -1
     }
@@ -353,8 +367,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
     }
@@ -373,8 +388,9 @@ 
 
         $key = null;
         foreach ($this as $k => $v) {
-            if ($predicate($v, $k))
-                $key = $k;
+            if ($predicate($v, $k)) {
+                            $key = $k;
+            }
         }
         return $key; // not -1
     }
@@ -393,8 +409,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();
@@ -418,10 +435,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;
+                }
             }
         });
     }
@@ -437,16 +456,19 @@ 
      */
     public function take ($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) {
-            if ($count <= 0)
-                return;
+            if ($count <= 0) {
+                            return;
+            }
             foreach ($this as $k => $v) {
                 yield $k => $v;
-                if (--$count == 0)
-                    break;
+                if (--$count == 0) {
+                                    break;
+                }
             }
         });
     }
@@ -466,8 +488,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/Enumerable.php

Braces +104 added lines, -76 removed lines

@@ -149,8 +149,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);
+            }
         });
     }
 
@@ -174,13 +175,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);
+            }
         });
     }
 
@@ -196,9 +199,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;
+            }
         });
     }
 
@@ -325,9 +329,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);
+                }
             }
         });
     }
@@ -385,20 +390,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;
     }
@@ -425,13 +429,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;
                 }
@@ -460,8 +462,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;
     }
 
@@ -479,15 +482,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;
     }
 
@@ -512,8 +517,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;
     }
 
@@ -534,8 +540,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; });
     }
 
@@ -560,8 +567,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;
     }
 
@@ -582,8 +590,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; });
     }
 
@@ -603,8 +612,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;
     }
 
@@ -625,8 +635,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;
     }
@@ -647,15 +658,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();
         }
@@ -672,8 +684,9 @@ 
     public function contains ($value)
     {
         foreach ($this as $v) {
-            if ($v === $value)
-                return true;
+            if ($v === $value) {
+                            return true;
+            }
         }
         return false;
     }
@@ -697,8 +710,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;
             }
@@ -730,8 +744,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;
             }
@@ -763,8 +778,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;
             }
@@ -793,15 +809,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;
             }
@@ -825,12 +843,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;
     }
 
@@ -857,8 +877,9 @@ 
     protected function toArrayDeepProc ($enum)
     {
         $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;
     }
 
@@ -875,12 +896,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;
     }
 
@@ -907,8 +930,9 @@ 
     protected function toListDeepProc ($enum)
     {
         $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;
     }
 
@@ -927,8 +951,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;
     }
 
@@ -961,8 +986,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;
     }
 
@@ -1004,8 +1030,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;
     }
 
@@ -1062,8 +1089,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);
+        }
     }
 
     /**

Spacing +89 added lines, -89 removed lines

@@ -37,7 +37,7 @@ 
      * @param \Closure|\Iterator $iterator
      * @param bool $isClosure
      */
-    private function __construct ($iterator, $isClosure = true)
+    private function __construct($iterator, $isClosure = true)
     {
         $this->iterator = $isClosure ? $iterator() : $iterator;
     }
@@ -47,12 +47,12 @@ 
      * {@inheritdoc}
      * @return \Iterator
      */
-    public function getIterator ()
+    public function getIterator()
     {
         return $this->iterator;
     }
 
-    protected function tryGetArrayCopy ()
+    protected function tryGetArrayCopy()
     {
         /** @var $it \Iterator|\ArrayIterator */
         $it = $this->iterator;
@@ -70,26 +70,26 @@ 
      * @link http://php.net/manual/language.types.type-juggling.php Type Juggling
      * @package YaLinqo\Projection and filtering
      */
-    public function cast ($type)
+    public function cast($type)
     {
         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; });
+                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);
         }
@@ -103,34 +103,34 @@ 
      * @return Enumerable A sequence that contains elements from the input sequence of the specified type.
      * @package YaLinqo\Projection and filtering
      */
-    public function ofType ($type)
+    public function ofType($type)
     {
         switch ($type) {
             case 'array':
-                return $this->where(function ($v) { return is_array($v); });
+                return $this->where(function($v) { return is_array($v); });
             case 'int':
             case 'integer':
             case 'long':
-                return $this->where(function ($v) { return is_int($v); });
+                return $this->where(function($v) { return is_int($v); });
             case 'callable':
             case 'callback':
-                return $this->where(function ($v) { return is_callable($v); });
+                return $this->where(function($v) { return is_callable($v); });
             case 'float':
             case 'real':
             case 'double':
-                return $this->where(function ($v) { return is_float($v); });
+                return $this->where(function($v) { return is_float($v); });
             case 'null':
-                return $this->where(function ($v) { return is_null($v); });
+                return $this->where(function($v) { return is_null($v); });
             case 'numeric':
-                return $this->where(function ($v) { return is_numeric($v); });
+                return $this->where(function($v) { return is_numeric($v); });
             case 'object':
-                return $this->where(function ($v) { return is_object($v); });
+                return $this->where(function($v) { return is_object($v); });
             case 'scalar':
-                return $this->where(function ($v) { return is_scalar($v); });
+                return $this->where(function($v) { return is_scalar($v); });
             case 'string':
-                return $this->where(function ($v) { return is_string($v); });
+                return $this->where(function($v) { return is_string($v); });
             default:
-                return $this->where(function ($v) use ($type) { return is_object($v) && get_class($v) === $type; });
+                return $this->where(function($v) use ($type) { return is_object($v) && get_class($v) === $type; });
         }
     }
 
@@ -143,12 +143,12 @@ 
      * @return Enumerable A sequence whose elements are the result of invoking the transform functions on each element of source.
      * @package YaLinqo\Projection and filtering
      */
-    public function select ($selectorValue, $selectorKey = null)
+    public function select($selectorValue, $selectorKey = null)
     {
         $selectorValue = Utils::createLambda($selectorValue, 'v,k');
         $selectorKey = Utils::createLambda($selectorKey, 'v,k', Functions::$key);
 
-        return new self(function () use ($selectorValue, $selectorKey) {
+        return new self(function() use ($selectorValue, $selectorKey) {
             foreach ($this as $k => $v)
                 yield $selectorKey($v, $k) => $selectorValue($v, $k);
         });
@@ -169,7 +169,7 @@ 
      * @return Enumerable A sequence whose elements are the result of invoking the one-to-many transform function on each element of the input sequence.
      * @package YaLinqo\Projection and filtering
      */
-    public function selectMany ($collectionSelector = null, $resultSelectorValue = null, $resultSelectorKey = null)
+    public function selectMany($collectionSelector = null, $resultSelectorValue = null, $resultSelectorKey = null)
     {
         $collectionSelector = Utils::createLambda($collectionSelector, 'v,k', Functions::$value);
         $resultSelectorValue = Utils::createLambda($resultSelectorValue, 'v,k1,k2', Functions::$value);
@@ -177,7 +177,7 @@ 
         if ($resultSelectorKey === false)
             $resultSelectorKey = Functions::increment();
 
-        return new self(function () use ($collectionSelector, $resultSelectorValue, $resultSelectorKey) {
+        return new self(function() use ($collectionSelector, $resultSelectorValue, $resultSelectorKey) {
             foreach ($this as $ok => $ov)
                 foreach ($collectionSelector($ov, $ok) as $ik => $iv)
                     yield $resultSelectorKey($iv, $ok, $ik) => $resultSelectorValue($iv, $ok, $ik);
@@ -191,11 +191,11 @@ 
      * @return Enumerable A sequence that contains elements from the input sequence that satisfy the condition.
      * @package YaLinqo\Projection and filtering
      */
-    public function where ($predicate)
+    public function where($predicate)
     {
         $predicate = Utils::createLambda($predicate, 'v,k');
 
-        return new self(function () use ($predicate) {
+        return new self(function() use ($predicate) {
             foreach ($this as $k => $v)
                 if ($predicate($v, $k))
                     yield $k => $v;
@@ -218,7 +218,7 @@ 
      * @return OrderedEnumerable
      * @package YaLinqo\Ordering
      */
-    public function orderByDir ($sortOrder, $keySelector = null, $comparer = null)
+    public function orderByDir($sortOrder, $keySelector = null, $comparer = null)
     {
         $sortFlags = Utils::lambdaToSortFlagsAndOrder($comparer, $sortOrder);
         $keySelector = Utils::createLambda($keySelector, 'v,k', Functions::$value);
@@ -238,7 +238,7 @@ 
      * @return OrderedEnumerable
      * @package YaLinqo\Ordering
      */
-    public function orderBy ($keySelector = null, $comparer = null)
+    public function orderBy($keySelector = null, $comparer = null)
     {
         return $this->orderByDir(false, $keySelector, $comparer);
     }
@@ -254,7 +254,7 @@ 
      * @return OrderedEnumerable
      * @package YaLinqo\Ordering
      */
-    public function orderByDescending ($keySelector = null, $comparer = null)
+    public function orderByDescending($keySelector = null, $comparer = null)
     {
         return $this->orderByDir(true, $keySelector, $comparer);
     }
@@ -277,17 +277,17 @@ 
      * @return Enumerable A sequence that contains elements that are obtained by performing a grouped join on two sequences.
      * @package YaLinqo\Joining and grouping
      */
-    public function groupJoin ($inner, $outerKeySelector = null, $innerKeySelector = null, $resultSelectorValue = null, $resultSelectorKey = null)
+    public function groupJoin($inner, $outerKeySelector = null, $innerKeySelector = null, $resultSelectorValue = null, $resultSelectorKey = null)
     {
         $inner = self::from($inner);
         $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; });
+        $resultSelectorKey = Utils::createLambda($resultSelectorKey, 'v,e,k', function($v, $e, $k) { return $k; });
 
-        return new self(function () use ($inner, $outerKeySelector, $innerKeySelector, $resultSelectorValue, $resultSelectorKey) {
+        return new self(function() use ($inner, $outerKeySelector, $innerKeySelector, $resultSelectorValue, $resultSelectorKey) {
             $lookup = $inner->toLookup($innerKeySelector);
             foreach ($this as $k => $v) {
                 $key = $outerKeySelector($v, $k);
@@ -311,17 +311,17 @@ 
      * @return Enumerable
      * @package YaLinqo\Joining and grouping
      */
-    public function join ($inner, $outerKeySelector = null, $innerKeySelector = null, $resultSelectorValue = null, $resultSelectorKey = null)
+    public function join($inner, $outerKeySelector = null, $innerKeySelector = null, $resultSelectorValue = null, $resultSelectorKey = null)
     {
         $inner = self::from($inner);
         $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; });
+        $resultSelectorKey = Utils::createLambda($resultSelectorKey, 'v1,v2,k', function($v1, $v2, $k) { return $k; });
 
-        return new self(function () use ($inner, $outerKeySelector, $innerKeySelector, $resultSelectorValue, $resultSelectorKey) {
+        return new self(function() use ($inner, $outerKeySelector, $innerKeySelector, $resultSelectorValue, $resultSelectorKey) {
             $lookup = $inner->toLookup($innerKeySelector);
             foreach ($this as $ok => $ov) {
                 $key = $outerKeySelector($ov, $ok);
@@ -350,7 +350,7 @@ 
      * @return Enumerable A sequence of sequences indexed by a key.
      * @package YaLinqo\Joining and grouping
      */
-    public function groupBy ($keySelector = null, $valueSelector = null, $resultSelectorValue = null, $resultSelectorKey = null)
+    public function groupBy($keySelector = null, $valueSelector = null, $resultSelectorValue = null, $resultSelectorKey = null)
     {
         $keySelector = Utils::createLambda($keySelector, 'v,k', Functions::$key);
         $valueSelector = Utils::createLambda($valueSelector, 'v,k', Functions::$value);
@@ -376,7 +376,7 @@ 
      * @return mixed The final accumulator value.
      * @package YaLinqo\Aggregation
      */
-    public function aggregate ($func, $seed = null)
+    public function aggregate($func, $seed = null)
     {
         $func = Utils::createLambda($func, 'a,v,k');
 
@@ -414,7 +414,7 @@ 
      * @return mixed The final accumulator value, or default if sequence is empty.
      * @package YaLinqo\Aggregation
      */
-    public function aggregateOrDefault ($func, $seed = null, $default = null)
+    public function aggregateOrDefault($func, $seed = null, $default = null)
     {
         $func = Utils::createLambda($func, 'a,v,k');
         $result = $seed;
@@ -451,7 +451,7 @@ 
      * @return number The average of the sequence of values.
      * @package YaLinqo\Aggregation
      */
-    public function average ($selector = null)
+    public function average($selector = null)
     {
         $selector = Utils::createLambda($selector, 'v,k', Functions::$value);
         $sum = $count = 0;
@@ -475,7 +475,7 @@ 
      * @return int The number of elements in the input sequence.
      * @package YaLinqo\Aggregation
      */
-    public function count ($predicate = null)
+    public function count($predicate = null)
     {
         $it = $this->getIterator();
 
@@ -502,7 +502,7 @@ 
      * @return number The maximum value in the sequence.
      * @package YaLinqo\Aggregation
      */
-    public function max ($selector = null)
+    public function max($selector = null)
     {
         $selector = Utils::createLambda($selector, 'v,k', Functions::$value);
 
@@ -529,14 +529,14 @@ 
      * @return number The maximum value in the sequence.
      * @package YaLinqo\Aggregation
      */
-    public function maxBy ($comparer, $selector = null)
+    public function maxBy($comparer, $selector = null)
     {
         $comparer = Utils::createLambda($comparer, 'a,b', Functions::$compareStrict);
         $enum = $this;
 
         if ($selector !== null)
             $enum = $enum->select($selector);
-        return $enum->aggregate(function ($a, $b) use ($comparer) { return $comparer($a, $b) > 0 ? $a : $b; });
+        return $enum->aggregate(function($a, $b) use ($comparer) { return $comparer($a, $b) > 0 ? $a : $b; });
     }
 
     /**
@@ -550,7 +550,7 @@ 
      * @return number The minimum value in the sequence.
      * @package YaLinqo\Aggregation
      */
-    public function min ($selector = null)
+    public function min($selector = null)
     {
         $selector = Utils::createLambda($selector, 'v,k', Functions::$value);
 
@@ -577,14 +577,14 @@ 
      * @return number The minimum value in the sequence.
      * @package YaLinqo\Aggregation
      */
-    public function minBy ($comparer, $selector = null)
+    public function minBy($comparer, $selector = null)
     {
         $comparer = Utils::createLambda($comparer, 'a,b', Functions::$compareStrict);
         $enum = $this;
 
         if ($selector !== null)
             $enum = $enum->select($selector);
-        return $enum->aggregate(function ($a, $b) use ($comparer) { return $comparer($a, $b) < 0 ? $a : $b; });
+        return $enum->aggregate(function($a, $b) use ($comparer) { return $comparer($a, $b) < 0 ? $a : $b; });
     }
 
     /**
@@ -598,7 +598,7 @@ 
      * @return number The sum of the values in the sequence.
      * @package YaLinqo\Aggregation
      */
-    public function sum ($selector = null)
+    public function sum($selector = null)
     {
         $selector = Utils::createLambda($selector, 'v,k', Functions::$value);
 
@@ -620,7 +620,7 @@ 
      * @return bool true if every element of the source sequence passes the test in the specified predicate, or if the sequence is empty; otherwise, false.
      * @package YaLinqo\Sets
      */
-    public function all ($predicate)
+    public function all($predicate)
     {
         $predicate = Utils::createLambda($predicate, 'v,k');
 
@@ -641,7 +641,7 @@ 
      * @return bool If predicate is null: true if the source sequence contains any elements; otherwise, false. If predicate is not null: true if any elements in the source sequence pass the test in the specified predicate; otherwise, false.
      * @package YaLinqo\Sets
      */
-    public function any ($predicate = null)
+    public function any($predicate = null)
     {
         $predicate = Utils::createLambda($predicate, 'v,k', false);
 
@@ -669,7 +669,7 @@ 
      * @return bool true if the source sequence contains an element that has the specified value; otherwise, false.
      * @package YaLinqo\Sets
      */
-    public function contains ($value)
+    public function contains($value)
     {
         foreach ($this as $v) {
             if ($v === $value)
@@ -689,12 +689,12 @@ 
      * @return Enumerable A sequence that contains distinct elements of the input sequence.
      * @package YaLinqo\Sets
      */
-    public function distinct ($keySelector = null)
+    public function distinct($keySelector = null)
     {
         $keySelector = Utils::createLambda($keySelector, 'v,k', Functions::$value);
 
-        return new self(function () use ($keySelector) {
-            $set = [ ];
+        return new self(function() use ($keySelector) {
+            $set = [];
             foreach ($this as $k => $v) {
                 $key = $keySelector($v, $k);
                 if (isset($set[$key]))
@@ -717,13 +717,13 @@ 
      * @return Enumerable A sequence that contains the set difference of the elements of two sequences.
      * @package YaLinqo\Sets
      */
-    public function except ($other, $keySelector = null)
+    public function except($other, $keySelector = null)
     {
         $other = self::from($other);
         $keySelector = Utils::createLambda($keySelector, 'v,k', Functions::$value);
 
-        return new self(function () use ($other, $keySelector) {
-            $set = [ ];
+        return new self(function() use ($other, $keySelector) {
+            $set = [];
             foreach ($other as $k => $v) {
                 $key = $keySelector($v, $k);
                 $set[$key] = true;
@@ -750,13 +750,13 @@ 
      * @return Enumerable A sequence that contains the elements that form the set intersection of two sequences.
      * @package YaLinqo\Sets
      */
-    public function intersect ($other, $keySelector = null)
+    public function intersect($other, $keySelector = null)
     {
         $other = self::from($other);
         $keySelector = Utils::createLambda($keySelector, 'v,k', Functions::$value);
 
-        return new self(function () use ($other, $keySelector) {
-            $set = [ ];
+        return new self(function() use ($other, $keySelector) {
+            $set = [];
             foreach ($other as $k => $v) {
                 $key = $keySelector($v, $k);
                 $set[$key] = true;
@@ -784,13 +784,13 @@ 
      * @return Enumerable A sequence that contains the elements from both input sequences, excluding duplicates.
      * @package YaLinqo\Sets
      */
-    public function union ($other, $keySelector = null)
+    public function union($other, $keySelector = null)
     {
         $other = self::from($other);
         $keySelector = Utils::createLambda($keySelector, 'v,k', Functions::$value);
 
-        return new self(function () use ($other, $keySelector) {
-            $set = [ ];
+        return new self(function() use ($other, $keySelector) {
+            $set = [];
             foreach ($this as $k => $v) {
                 $key = $keySelector($v, $k);
                 if (isset($set[$key]))
@@ -821,14 +821,14 @@ 
      * @return array An array that contains the elements from the input sequence.
      * @package YaLinqo\Conversion
      */
-    public function toArray ()
+    public function toArray()
     {
         /** @var $it \Iterator|\ArrayIterator */
         $it = $this->getIterator();
         if ($it instanceof \ArrayIterator)
             return $it->getArrayCopy();
 
-        $array = [ ];
+        $array = [];
         foreach ($it as $k => $v)
             $array[$k] = $v;
         return $array;
@@ -843,7 +843,7 @@ 
      * @return array An array that contains the elements from the input sequence.
      * @package YaLinqo\Conversion
      */
-    public function toArrayDeep ()
+    public function toArrayDeep()
     {
         return $this->toArrayDeepProc($this);
     }
@@ -854,9 +854,9 @@ 
      * @return array An array that contains the elements from the input sequence.
      * @package YaLinqo\Conversion
      */
-    protected function toArrayDeepProc ($enum)
+    protected function toArrayDeepProc($enum)
     {
-        $array = [ ];
+        $array = [];
         foreach ($enum as $k => $v)
             $array[$k] = $v instanceof \Traversable || is_array($v) ? $this->toArrayDeepProc($v) : $v;
         return $array;
@@ -871,14 +871,14 @@ 
      * @return array An array that contains the elements from the input sequence.
      * @package YaLinqo\Conversion
      */
-    public function toList ()
+    public function toList()
     {
         /** @var $it \Iterator|\ArrayIterator */
         $it = $this->getIterator();
         if ($it instanceof \ArrayIterator)
             return array_values($it->getArrayCopy());
 
-        $array = [ ];
+        $array = [];
         foreach ($it as $v)
             $array[] = $v;
         return $array;
@@ -893,7 +893,7 @@ 
      * @return array An array that contains the elements from the input sequence.
      * @package YaLinqo\Conversion
      */
-    public function toListDeep ()
+    public function toListDeep()
     {
         return $this->toListDeepProc($this);
     }
@@ -904,9 +904,9 @@ 
      * @return array An array that contains the elements from the input sequence.
      * @package YaLinqo\Conversion
      */
-    protected function toListDeepProc ($enum)
+    protected function toListDeepProc($enum)
     {
-        $array = [ ];
+        $array = [];
         foreach ($enum as $v)
             $array[] = $v instanceof \Traversable || is_array($v) ? $this->toListDeepProc($v) : $v;
         return $array;
@@ -921,12 +921,12 @@ 
      * @return array An array that contains keys and values selected from the input sequence.
      * @package YaLinqo\Conversion
      */
-    public function toDictionary ($keySelector = null, $valueSelector = null)
+    public function toDictionary($keySelector = null, $valueSelector = null)
     {
         $keySelector = Utils::createLambda($keySelector, 'v,k', Functions::$key);
         $valueSelector = Utils::createLambda($valueSelector, 'v,k', Functions::$value);
 
-        $dic = [ ];
+        $dic = [];
         foreach ($this as $k => $v)
             $dic[$keySelector($v, $k)] = $valueSelector($v, $k);
         return $dic;
@@ -941,7 +941,7 @@ 
      * @see json_encode
      * @package YaLinqo\Conversion
      */
-    public function toJSON ($options = 0)
+    public function toJSON($options = 0)
     {
         return json_encode($this->toArrayDeep(), $options);
     }
@@ -955,12 +955,12 @@ 
      * @return array An array that contains keys and value arrays selected from the input sequence.
      * @package YaLinqo\Conversion
      */
-    public function toLookup ($keySelector = null, $valueSelector = null)
+    public function toLookup($keySelector = null, $valueSelector = null)
     {
         $keySelector = Utils::createLambda($keySelector, 'v,k', Functions::$key);
         $valueSelector = Utils::createLambda($valueSelector, 'v,k', Functions::$value);
 
-        $lookup = [ ];
+        $lookup = [];
         foreach ($this as $k => $v)
             $lookup[$keySelector($v, $k)][] = $valueSelector($v, $k);
         return $lookup;
@@ -973,7 +973,7 @@ 
      * @see array_keys
      * @package YaLinqo\Conversion
      */
-    public function toKeys ()
+    public function toKeys()
     {
         return $this->select(Functions::$key, Functions::increment());
     }
@@ -985,7 +985,7 @@ 
      * @see array_values
      * @package YaLinqo\Conversion
      */
-    public function toValues ()
+    public function toValues()
     {
         return $this->select(Functions::$value, Functions::increment());
     }
@@ -998,7 +998,7 @@ 
      * @return \stdClass
      * @package YaLinqo\Conversion
      */
-    public function toObject ($propertySelector = null, $valueSelector = null)
+    public function toObject($propertySelector = null, $valueSelector = null)
     {
         $propertySelector = Utils::createLambda($propertySelector, 'v,k', Functions::$key);
         $valueSelector = Utils::createLambda($valueSelector, 'v,k', Functions::$value);
@@ -1018,7 +1018,7 @@ 
      * @see implode
      * @package YaLinqo\Conversion
      */
-    public function toString ($separator = '', $valueSelector = null)
+    public function toString($separator = '', $valueSelector = null)
     {
         $valueSelector = Utils::createLambda($valueSelector, 'v,k', false);
         $array = $valueSelector ? $this->select($valueSelector)->toList() : $this->toList();
@@ -1038,11 +1038,11 @@ 
      * @return Enumerable The source sequence with the side-effecting behavior applied.
      * @package YaLinqo\Actions
      */
-    public function call ($action)
+    public function call($action)
     {
         $action = Utils::createLambda($action, 'v,k');
 
-        return new self(function () use ($action) {
+        return new self(function() use ($action) {
             foreach ($this as $k => $v) {
                 $action($v, $k);
                 yield $k => $v;
@@ -1058,7 +1058,7 @@ 
      * @param callable $action {(v, k) ==> void} The action to invoke for each element in the sequence.
      * @package YaLinqo\Actions
      */
-    public function each ($action = null)
+    public function each($action = null)
     {
         $action = Utils::createLambda($action, 'v,k', Functions::$blank);
 
@@ -1074,7 +1074,7 @@ 
      * @see implode, echo
      * @package YaLinqo\Actions
      */
-    public function write ($separator = '', $selector = null)
+    public function write($separator = '', $selector = null)
     {
         echo $this->toString($separator, $selector);
     }
@@ -1087,7 +1087,7 @@ 
      * @see echo, PHP_EOL
      * @package YaLinqo\Actions
      */
-    public function writeLine ($selector = null)
+    public function writeLine($selector = null)
     {
         $selector = Utils::createLambda($selector, 'v,k', Functions::$value);
 

YaLinqo/Functions.php

Spacing +15 added lines, -15 removed lines

@@ -79,23 +79,23 @@ 
     public static $compareIntReversed;
 
     /** @internal */
-    public static function init ()
+    public static function init()
     {
-        self::$identity = function ($x) { return $x; };
+        self::$identity = function($x) { return $x; };
 
         /** @noinspection PhpUnusedParameterInspection */
-        self::$key = function ($v, $k) { return $k; };
+        self::$key = function($v, $k) { return $k; };
 
         /** @noinspection PhpUnusedParameterInspection */
-        self::$value = function ($v, $k) { return $v; };
+        self::$value = function($v, $k) { return $v; };
 
-        self::$true = function () { return true; };
+        self::$true = function() { return true; };
 
-        self::$false = function () { return false; };
+        self::$false = function() { return false; };
 
-        self::$blank = function () { };
+        self::$blank = function() { };
 
-        self::$compareStrict = function ($a, $b) {
+        self::$compareStrict = function($a, $b) {
             if ($a === $b)
                 return 0;
             elseif ($a > $b)
@@ -104,7 +104,7 @@ 
                 return -1;
         };
 
-        self::$compareStrictReversed = function ($a, $b) {
+        self::$compareStrictReversed = function($a, $b) {
             if ($a === $b)
                 return 0;
             elseif ($a > $b)
@@ -113,7 +113,7 @@ 
                 return 1;
         };
 
-        self::$compareLoose = function ($a, $b) {
+        self::$compareLoose = function($a, $b) {
             if ($a == $b)
                 return 0;
             elseif ($a > $b)
@@ -122,7 +122,7 @@ 
                 return -1;
         };
 
-        self::$compareLooseReversed = function ($a, $b) {
+        self::$compareLooseReversed = function($a, $b) {
             if ($a == $b)
                 return 0;
             elseif ($a > $b)
@@ -131,11 +131,11 @@ 
                 return 1;
         };
 
-        self::$compareInt = function ($a, $b) {
+        self::$compareInt = function($a, $b) {
             return $a - $b;
         };
 
-        self::$compareIntReversed = function ($a, $b) {
+        self::$compareIntReversed = function($a, $b) {
             return $b - $a;
         };
     }
@@ -144,9 +144,9 @@ 
      * Increment function: returns incremental integers starting from 0.
      * @return callable
      */
-    public static function increment ()
+    public static function increment()
     {
         $i = 0;
-        return function () use (&$i) { return $i++; };
+        return function() use (&$i) { return $i++; };
     }
 }

Braces +28 added lines, -24 removed lines

@@ -96,39 +96,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/EnumerableGeneration.php

Spacing +21 added lines, -21 removed lines

@@ -16,11 +16,11 @@ 
      * @return Enumerable Endless list of items repeating the source sequence.
      * @package YaLinqo\Generation
      */
-    public static function cycle ($source)
+    public static function cycle($source)
     {
         $source = self::from($source);
 
-        return new self(function () use ($source) {
+        return new self(function() use ($source) {
             $isEmpty = true;
             while (true) {
                 foreach ($source as $v) {
@@ -39,7 +39,7 @@ 
      * @return Enumerable
      * @package YaLinqo\Generation
      */
-    public static function emptyEnum ()
+    public static function emptyEnum()
     {
         return new self(new \EmptyIterator, false);
     }
@@ -60,7 +60,7 @@ 
      * @return Enumerable
      * @package YaLinqo\Generation
      */
-    public static function from ($source)
+    public static function from($source)
     {
         $it = null;
         if ($source instanceof Enumerable)
@@ -79,7 +79,7 @@ 
         throw new \InvalidArgumentException('source must be array or Traversable.');
     }
 
-    private static function fromTraversable ($source)
+    private static function fromTraversable($source)
     {
         foreach ($source as $k => $v)
             yield $k => $v;
@@ -96,12 +96,12 @@ 
      * @return Enumerable
      * @package YaLinqo\Generation
      */
-    public static function generate ($funcValue, $seedValue = null, $funcKey = null, $seedKey = null)
+    public static function generate($funcValue, $seedValue = null, $funcKey = null, $seedKey = null)
     {
         $funcValue = Utils::createLambda($funcValue, 'v,k');
         $funcKey = Utils::createLambda($funcKey, 'v,k', false);
 
-        return new self(function () use ($funcValue, $funcKey, $seedValue, $seedKey) {
+        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;
@@ -123,9 +123,9 @@ 
      * @return Enumerable
      * @package YaLinqo\Generation
      */
-    public static function toInfinity ($start = 0, $step = 1)
+    public static function toInfinity($start = 0, $step = 1)
     {
-        return new self(function () use ($start, $step) {
+        return new self(function() use ($start, $step) {
             $value = $start - $step;
             while (true)
                 yield $value += $step;
@@ -142,9 +142,9 @@ 
      * @see preg_match_all
      * @package YaLinqo\Generation
      */
-    public static function matches ($subject, $pattern, $flags = PREG_SET_ORDER)
+    public static function matches($subject, $pattern, $flags = PREG_SET_ORDER)
     {
-        return new self(function () use ($subject, $pattern, $flags) {
+        return new self(function() use ($subject, $pattern, $flags) {
             preg_match_all($pattern, $subject, $matches, $flags);
             return $matches !== false ? self::from($matches)->getIterator() : self::emptyEnum();
         });
@@ -158,7 +158,7 @@ 
      * @return Enumerable
      * @package YaLinqo\Generation
      */
-    public static function toNegativeInfinity ($start = 0, $step = 1)
+    public static function toNegativeInfinity($start = 0, $step = 1)
     {
         return self::toInfinity($start, -$step);
     }
@@ -170,7 +170,7 @@ 
      * @return Enumerable Observable sequence containing the single specified element.
      * @package YaLinqo\Generation
      */
-    public static function returnEnum ($element)
+    public static function returnEnum($element)
     {
         return self::repeat($element, 1);
     }
@@ -186,11 +186,11 @@ 
      * @return Enumerable A sequence that contains a range of integral numbers.
      * @package YaLinqo\Generation
      */
-    public static function range ($start, $count, $step = 1)
+    public static function range($start, $count, $step = 1)
     {
         if ($count <= 0)
             return self::emptyEnum();
-        return new self(function () use ($start, $count, $step) {
+        return new self(function() use ($start, $count, $step) {
             $value = $start - $step;
             while ($count-- > 0)
                 yield $value += $step;
@@ -208,7 +208,7 @@ 
      * @return Enumerable A sequence that contains a range of integral numbers.
      * @package YaLinqo\Generation
      */
-    public static function rangeDown ($start, $count, $step = 1)
+    public static function rangeDown($start, $count, $step = 1)
     {
         return self::range($start, $count, -$step);
     }
@@ -225,11 +225,11 @@ 
      * @return Enumerable A sequence that contains a range of integral numbers.
      * @package YaLinqo\Generation
      */
-    public static function rangeTo ($start, $end, $step = 1)
+    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) {
+        return new self(function() use ($start, $end, $step) {
             if ($start <= $end) {
                 for ($i = $start; $i < $end; $i += $step)
                     yield $i;
@@ -254,11 +254,11 @@ 
      * @return Enumerable A sequence that contains a repeated value.
      * @package YaLinqo\Generation
      */
-    public static function repeat ($element, $count = null)
+    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) {
+        return new self(function() use ($element, $count) {
             for ($i = 0; $i < $count || $count === null; $i++)
                 yield $element;
         });
@@ -274,7 +274,7 @@ 
      * @see preg_split
      * @package YaLinqo\Generation
      */
-    public static function split ($subject, $pattern, $flags = 0)
+    public static function split($subject, $pattern, $flags = 0)
     {
         return new self(
             new \ArrayIterator(preg_split($pattern, $subject, -1, $flags)),

Braces +42 added lines, -32 removed lines

@@ -27,8 +27,9 @@ 
                     yield $v;
                     $isEmpty = false;
                 }
-                if ($isEmpty)
-                    throw new \UnexpectedValueException(Errors::NO_ELEMENTS);
+                if ($isEmpty) {
+                                    throw new \UnexpectedValueException(Errors::NO_ELEMENTS);
+                }
             }
         });
     }
@@ -63,16 +64,17 @@ 
     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 ($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);
         }
@@ -81,8 +83,9 @@ 
 
     private static function fromTraversable ($source)
     {
-        foreach ($source as $k => $v)
-            yield $k => $v;
+        foreach ($source as $k => $v) {
+                    yield $k => $v;
+        }
     }
 
     /**
@@ -127,8 +130,9 @@ 
     {
         return new self(function () use ($start, $step) {
             $value = $start - $step;
-            while (true)
-                yield $value += $step;
+            while (true) {
+                            yield $value += $step;
+            }
         });
     }
 
@@ -188,12 +192,14 @@ 
      */
     public static function range ($start, $count, $step = 1)
     {
-        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;
+            }
         });
     }
 
@@ -227,16 +233,18 @@ 
      */
     public static function rangeTo ($start, $end, $step = 1)
     {
-        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;
+                }
             }
         });
     }
@@ -256,11 +264,13 @@ 
      */
     public static function repeat ($element, $count = null)
     {
-        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/Utils.php

Spacing +8 added lines, -8 removed lines

@@ -35,11 +35,11 @@ 
     ];
 
     /** @internal */
-    public static function init ()
+    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],
         ];
     }
 
@@ -52,7 +52,7 @@ 
      * @throws \InvalidArgumentException Incorrect lambda syntax.
      * @return callable|null
      */
-    public static function createLambda ($closure, $closureArgs, $default = null)
+    public static function createLambda($closure, $closureArgs, $default = null)
     {
         if ($closure === null) {
             if ($default === null)
@@ -77,7 +77,7 @@ 
      * @throws \InvalidArgumentException Incorrect lambda syntax.
      * @throws \InvalidArgumentException Incorrect SORT_ flags.
      */
-    public static function createComparer ($closure, $sortOrder, &$isReversed)
+    public static function createComparer($closure, $sortOrder, &$isReversed)
     {
         if ($closure === null) {
             $isReversed = false;
@@ -113,7 +113,7 @@ 
      * @param int|bool $sortOrder
      * @return callable|string|int|null
      */
-    public static function lambdaToSortFlagsAndOrder ($closure, &$sortOrder)
+    public static function lambdaToSortFlagsAndOrder($closure, &$sortOrder)
     {
         if ($sortOrder !== SORT_ASC && $sortOrder !== SORT_DESC)
             $sortOrder = $sortOrder ? SORT_DESC : SORT_ASC;
@@ -132,7 +132,7 @@ 
      * @throws \InvalidArgumentException Incorrect lambda syntax.
      * @return string|null
      */
-    private static function createLambdaFromString ($closure, $closureArgs)
+    private static function createLambdaFromString($closure, $closureArgs)
     {
         $posDollar = strpos($closure, '$');
         if ($posDollar !== false) {
@@ -144,7 +144,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

@@ -55,16 +55,20 @@ 
     public static function createLambda ($closure, $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);
     }
 
@@ -82,8 +86,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;
@@ -115,14 +118,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;
+        }
     }
 
     /**
@@ -136,23 +141,25 @@ 
     {
         $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 = eval("return function($args) { $code };");
-            if (!$fun)
-                throw new \InvalidArgumentException(self::ERROR_CANNOT_PARSE_LAMBDA);
+            if (!$fun) {
+                            throw new \InvalidArgumentException(self::ERROR_CANNOT_PARSE_LAMBDA);
+            }
             self::$lambdaCache[$closure][$closureArgs] = $fun;
             return $fun;
         }