Athari / YaLinqo

YaLinqo/Enumerable.php

Doc Comments +4 added lines, -4 removed lines

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

Spacing +7 added lines, -7 removed lines

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

Braces +126 added lines, -92 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();
         }
@@ -677,12 +689,14 @@ 
     {
         return new self(function() use ($value, $key) {
             // TODO Switch to 'yield from' when support for PHP<7.0 is dropped.
-            foreach ($this as $k => $v)
-                yield $k => $v;
-            if ($key !== Utils::UNDEFINED)
-                yield $key => $value;
-            else
-                yield $value;
+            foreach ($this as $k => $v) {
+                            yield $k => $v;
+            }
+            if ($key !== Utils::UNDEFINED) {
+                            yield $key => $value;
+            } else {
+                            yield $value;
+            }
         });
     }
 
@@ -700,10 +714,12 @@ 
 
         return new self(function() use ($other) {
             // TODO Switch to 'yield from' when support for PHP<7.0 is dropped.
-            foreach ($this as $k => $v)
-                yield $k => $v;
-            foreach ($other as $k => $v)
-                yield $k => $v;
+            foreach ($this as $k => $v) {
+                            yield $k => $v;
+            }
+            foreach ($other as $k => $v) {
+                            yield $k => $v;
+            }
         });
     }
 
@@ -718,8 +734,9 @@ 
     public function contains($value)
     {
         foreach ($this as $v) {
-            if ($v === $value)
-                return true;
+            if ($v === $value) {
+                            return true;
+            }
         }
         return false;
     }
@@ -743,8 +760,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;
             }
@@ -776,8 +794,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;
             }
@@ -809,8 +828,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;
             }
@@ -831,13 +851,15 @@ 
     public function prepend($value, $key = Utils::UNDEFINED)
     {
         return new self(function() use ($value, $key) {
-            if ($key !== Utils::UNDEFINED)
-                yield $key => $value;
-            else
-                yield $value;
+            if ($key !== Utils::UNDEFINED) {
+                            yield $key => $value;
+            } else {
+                            yield $value;
+            }
             // TODO Switch to 'yield from' when support for PHP<7.0 is dropped.
-            foreach ($this as $k => $v)
-                yield $k => $v;
+            foreach ($this as $k => $v) {
+                            yield $k => $v;
+            }
         });
     }
 
@@ -863,15 +885,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;
             }
@@ -895,12 +919,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;
     }
 
@@ -927,8 +953,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;
     }
 
@@ -945,12 +972,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;
     }
 
@@ -977,8 +1006,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;
     }
 
@@ -997,8 +1027,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;
     }
 
@@ -1031,8 +1062,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;
     }
 
@@ -1074,8 +1106,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;
     }
 
@@ -1132,8 +1165,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

Doc Comments +12 added lines, -12 removed lines

@@ -22,7 +22,7 @@ 
      * @param array|\Iterator|\IteratorAggregate|Enumerable $source Source sequence.
      * @throws \InvalidArgumentException If source is not array or Traversible or Enumerable.
      * @throws \UnexpectedValueException If source contains no elements (checked during enumeration).
-     * @return Enumerable Endless list of items repeating the source sequence.
+     * @return EnumerableGeneration Endless list of items repeating the source sequence.
      * @package YaLinqo\Generation
      */
     public static function cycle($source)
@@ -45,7 +45,7 @@ 
     /**
      * Returns an empty sequence.
      * <p><b>Syntax</b>: emptyEnum ()
-     * @return Enumerable
+     * @return EnumerableGeneration
      * @package YaLinqo\Generation
      */
     public static function emptyEnum()
@@ -94,7 +94,7 @@ 
      * @param mixed $seedValue Initial state of the generator loop for values. Default: null.
      * @param callable|null $funcKey {(v, k) ==> key} State update function to run on key after every iteration of the generator loop. Default: increment.
      * @param mixed $seedKey Initial state of the generator loop ofr keys. Default: 0.
-     * @return Enumerable
+     * @return EnumerableGeneration
      * @package YaLinqo\Generation
      */
     public static function generate($funcValue, $seedValue = null, $funcKey = null, $seedKey = null)
@@ -121,7 +121,7 @@ 
      * <p><b>Syntax</b>: toInfinity ([start [, step]])
      * @param int $start The first integer in the sequence. Default: 0.
      * @param int $step The difference between adjacent integers. Default: 1.
-     * @return Enumerable
+     * @return EnumerableGeneration
      * @package YaLinqo\Generation
      */
     public static function toInfinity($start = 0, $step = 1)
@@ -139,7 +139,7 @@ 
      * @param string $subject The input string.
      * @param string $pattern The pattern to search for, as a string.
      * @param int $flags Can be a combination of the following flags: PREG_PATTERN_ORDER, PREG_SET_ORDER, PREG_OFFSET_CAPTURE. Default: PREG_SET_ORDER.
-     * @return Enumerable
+     * @return EnumerableGeneration
      * @see preg_match_all
      * @package YaLinqo\Generation
      */
@@ -156,7 +156,7 @@ 
      * <p><b>Syntax</b>: toNegativeInfinity ([start [, step]])
      * @param int $start The first integer in the sequence. Default: 0.
      * @param int $step The difference between adjacent integers. Default: 1.
-     * @return Enumerable
+     * @return EnumerableGeneration
      * @package YaLinqo\Generation
      */
     public static function toNegativeInfinity($start = 0, $step = 1)
@@ -168,7 +168,7 @@ 
      * Returns a sequence that contains a single element with a specified value.
      * <p><b>Syntax</b>: returnEnum (element)
      * @param mixed $element The single element in the resulting sequence.
-     * @return Enumerable Observable sequence containing the single specified element.
+     * @return EnumerableGeneration Observable sequence containing the single specified element.
      * @package YaLinqo\Generation
      */
     public static function returnEnum($element)
@@ -184,7 +184,7 @@ 
      * @param int $start The value of the first integer in the sequence.
      * @param int $count The number of integers to generate.
      * @param int $step The difference between adjacent integers. Default: 1.
-     * @return Enumerable A sequence that contains a range of integral numbers.
+     * @return EnumerableGeneration A sequence that contains a range of integral numbers.
      * @package YaLinqo\Generation
      */
     public static function range($start, $count, $step = 1)
@@ -206,7 +206,7 @@ 
      * @param int $start The value of the first integer in the sequence.
      * @param int $count The number of integers to generate.
      * @param int $step The difference between adjacent integers. Default: 1.
-     * @return Enumerable A sequence that contains a range of integral numbers.
+     * @return EnumerableGeneration A sequence that contains a range of integral numbers.
      * @package YaLinqo\Generation
      */
     public static function rangeDown($start, $count, $step = 1)
@@ -223,7 +223,7 @@ 
      * @param int $end The value of the last integer in the sequence (not included).
      * @param int $step The difference between adjacent integers. Default: 1.
      * @throws \InvalidArgumentException If step is not a positive number.
-     * @return Enumerable A sequence that contains a range of integral numbers.
+     * @return EnumerableGeneration A sequence that contains a range of integral numbers.
      * @package YaLinqo\Generation
      */
     public static function rangeTo($start, $end, $step = 1)
@@ -252,7 +252,7 @@ 
      * @param int $element The value to be repeated.
      * @param int $count The number of times to repeat the value in the generated sequence. Default: null.
      * @throws \InvalidArgumentException If count is less than 0.
-     * @return Enumerable A sequence that contains a repeated value.
+     * @return EnumerableGeneration A sequence that contains a repeated value.
      * @package YaLinqo\Generation
      */
     public static function repeat($element, $count = null)
@@ -271,7 +271,7 @@ 
      * @param string $subject The input string.
      * @param string $pattern The pattern to search for, as a string.
      * @param int $flags flags can be any combination of the following flags: PREG_SPLIT_NO_EMPTY, PREG_SPLIT_DELIM_CAPTURE, PREG_SPLIT_OFFSET_CAPTURE. Default: 0.
-     * @return Enumerable
+     * @return EnumerableGeneration
      * @see preg_split
      * @package YaLinqo\Generation
      */

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)
     {
         $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($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;
+            }
         });
     }
 
@@ -228,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;
+                }
             }
         });
     }
@@ -257,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/EnumerablePagination.php

Doc Comments +4 added lines, -4 removed lines

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

Braces +66 added lines, -44 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,8 +337,9 @@ 
     public function indexOf($value)
     {
         foreach ($this as $k => $v) {
-            if ($v === $value)
-                return $k;
+            if ($v === $value) {
+                            return $k;
+            }
         }
         return null; // not -1
     }
@@ -343,8 +356,9 @@ 
     {
         $key = null;
         foreach ($this as $k => $v) {
-            if ($v === $value)
-                $key = $k;
+            if ($v === $value) {
+                            $key = $k;
+            }
         }
         return $key; // not -1
     }
@@ -362,8 +376,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
     }
@@ -382,8 +397,9 @@ 
 
         $key = null;
         foreach ($this as $k => $v) {
-            if ($predicate($v, $k))
-                $key = $k;
+            if ($predicate($v, $k)) {
+                            $key = $k;
+            }
         }
         return $key; // not -1
     }
@@ -402,8 +418,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();
@@ -427,10 +444,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;
+                }
             }
         });
     }
@@ -446,14 +465,16 @@ 
      */
     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) {
             foreach ($this as $k => $v) {
                 yield $k => $v;
-                if (--$count == 0)
-                    break;
+                if (--$count == 0) {
+                                    break;
+                }
             }
         });
     }
@@ -473,8 +494,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/Functions.php

Doc Comments +1 added lines, -1 removed lines

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

Braces +28 added lines, -24 removed lines

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

YaLinqo/OrderedEnumerable.php

Doc Comments +7 added lines, -1 removed lines

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

Spacing +2 added lines, -2 removed lines

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

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($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) {
@@ -205,8 +212,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) {
@@ -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

Spacing +3 added lines, -3 removed lines

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

Braces +33 added lines, -26 removed lines

@@ -57,16 +57,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);
     }
 
@@ -84,8 +88,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;
@@ -117,14 +120,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;
+        }
     }
 
     /**
@@ -138,24 +143,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;