Athari / YaLinqo

YaLinqo/Enumerable.php

Doc Comments +6 added lines, -6 removed lines

@@ -34,7 +34,7 @@ 
 
     /**
      * @internal
-     * @param \Closure|\Iterator $iterator
+     * @param \Closure $iterator
      * @param bool $isClosure
      */
     private function __construct ($iterator, $isClosure = true)
@@ -212,7 +212,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
@@ -448,7 +448,7 @@ 
      * <p>Computes the average of a sequence of numeric values that are obtained by invoking a transform function on each element of the input sequence.
      * @param callable|null $selector {(v, k) ==> result} A transform function to apply to each element. Default: value.
      * @throws \UnexpectedValueException If sequence contains no elements.
-     * @return number The average of the sequence of values.
+     * @return integer The average of the sequence of values.
      * @package YaLinqo\Aggregation
      */
     public function average ($selector = null)
@@ -595,7 +595,7 @@ 
      * <p>Computes the sum of the sequence of values that are obtained by invoking a transform function on each element of the input sequence.
      * <p>This method returns zero if source contains no elements.
      * @param callable|null $selector {(v, k) ==> result} A transform function to apply to each element.
-     * @return number The sum of the values in the sequence.
+     * @return integer The sum of the values in the sequence.
      * @package YaLinqo\Aggregation
      */
     public function sum ($selector = null)
@@ -850,7 +850,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
      */
@@ -900,7 +900,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 +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 (unset)$v; });
+                return $this->select(function($v) { return (unset) $v; });
             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)->toArray() : $this->toArray();
@@ -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);
 

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

YaLinqo/EnumerablePagination.php

Doc Comments +4 added lines, -4 removed lines

@@ -385,7 +385,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)
@@ -408,7 +408,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)
@@ -432,7 +432,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)
@@ -457,7 +457,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)

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

Doc Comments +1 added lines, -1 removed lines

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

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

Doc Comments +7 added lines, -1 removed lines

@@ -67,7 +67,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
@@ -124,6 +124,9 @@ 
         return $this->sortByMultipleFields($array, $canMultisort);
     }
 
+    /**
+     * @param boolean $canMultisort
+     */
     private function trySortBySingleField ($array, $canMultisort)
     {
         if ($this->parent !== null || $array === null) {
@@ -151,6 +154,9 @@ 
         return new \ArrayIterator($array);
     }
 
+    /**
+     * @param boolean $canMultisort
+     */
     private function sortByMultipleFields ($array, $canMultisort)
     {
         $orders = [ ];

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

Spacing +7 added lines, -7 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) {

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 = create_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;
         }

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

Doc Comments +15 added lines, -12 removed lines

@@ -13,7 +13,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)
@@ -36,7 +36,7 @@ 
     /**
      * Returns an empty sequence.
      * <p><b>Syntax</b>: emptyEnum ()
-     * @return Enumerable
+     * @return EnumerableGeneration
      * @package YaLinqo\Generation
      */
     public static function emptyEnum ()
@@ -79,6 +79,9 @@ 
         throw new \InvalidArgumentException('source must be array or Traversable.');
     }
 
+    /**
+     * @param \Traversable $source
+     */
     private static function fromTraversable ($source)
     {
         foreach ($source as $k => $v)
@@ -93,7 +96,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)
@@ -120,7 +123,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)
@@ -138,7 +141,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
      */
@@ -155,7 +158,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)
@@ -167,7 +170,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)
@@ -183,7 +186,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)
@@ -205,7 +208,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)
@@ -222,7 +225,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)
@@ -251,7 +254,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)
@@ -270,7 +273,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
      */

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