Completed
Push — master ( 3ae448...950d78 )
by Alexander
01:47
created
YaLinqo/Enumerable.php 1 patch
Braces   +104 added lines, -76 removed lines patch added patch discarded remove patch
@@ -150,8 +150,9 @@  discard block
 block discarded – undo
150 150
         $selectorKey = Utils::createLambda($selectorKey, 'v,k', Functions::$key);
151 151
 
152 152
         return new self(function() use ($selectorValue, $selectorKey) {
153
-            foreach ($this as $k => $v)
154
-                yield $selectorKey($v, $k) => $selectorValue($v, $k);
153
+            foreach ($this as $k => $v) {
154
+                            yield $selectorKey($v, $k) => $selectorValue($v, $k);
155
+            }
155 156
         });
156 157
     }
157 158
 
@@ -175,13 +176,15 @@  discard block
 block discarded – undo
175 176
         $collectionSelector = Utils::createLambda($collectionSelector, 'v,k', Functions::$value);
176 177
         $resultSelectorValue = Utils::createLambda($resultSelectorValue, 'v,k1,k2', Functions::$value);
177 178
         $resultSelectorKey = Utils::createLambda($resultSelectorKey, 'v,k1,k2', false);
178
-        if ($resultSelectorKey === false)
179
-            $resultSelectorKey = Functions::increment();
179
+        if ($resultSelectorKey === false) {
180
+                    $resultSelectorKey = Functions::increment();
181
+        }
180 182
 
181 183
         return new self(function() use ($collectionSelector, $resultSelectorValue, $resultSelectorKey) {
182
-            foreach ($this as $ok => $ov)
183
-                foreach ($collectionSelector($ov, $ok) as $ik => $iv)
184
+            foreach ($this as $ok => $ov) {
185
+                            foreach ($collectionSelector($ov, $ok) as $ik => $iv)
184 186
                     yield $resultSelectorKey($iv, $ok, $ik) => $resultSelectorValue($iv, $ok, $ik);
187
+            }
185 188
         });
186 189
     }
187 190
 
@@ -197,9 +200,10 @@  discard block
 block discarded – undo
197 200
         $predicate = Utils::createLambda($predicate, 'v,k');
198 201
 
199 202
         return new self(function() use ($predicate) {
200
-            foreach ($this as $k => $v)
201
-                if ($predicate($v, $k))
203
+            foreach ($this as $k => $v) {
204
+                            if ($predicate($v, $k))
202 205
                     yield $k => $v;
206
+            }
203 207
         });
204 208
     }
205 209
 
@@ -326,9 +330,10 @@  discard block
 block discarded – undo
326 330
             $lookup = $inner->toLookup($innerKeySelector);
327 331
             foreach ($this as $ok => $ov) {
328 332
                 $key = $outerKeySelector($ov, $ok);
329
-                if (isset($lookup[$key]))
330
-                    foreach ($lookup[$key] as $iv)
333
+                if (isset($lookup[$key])) {
334
+                                    foreach ($lookup[$key] as $iv)
331 335
                         yield $resultSelectorKey($ov, $iv, $key) => $resultSelectorValue($ov, $iv, $key);
336
+                }
332 337
             }
333 338
         });
334 339
     }
@@ -386,20 +391,19 @@  discard block
 block discarded – undo
386 391
             foreach ($this as $k => $v) {
387 392
                 $result = $func($result, $v, $k);
388 393
             }
389
-        }
390
-        else {
394
+        } else {
391 395
             $assigned = false;
392 396
             foreach ($this as $k => $v) {
393 397
                 if ($assigned) {
394 398
                     $result = $func($result, $v, $k);
395
-                }
396
-                else {
399
+                } else {
397 400
                     $result = $v;
398 401
                     $assigned = true;
399 402
                 }
400 403
             }
401
-            if (!$assigned)
402
-                throw new \UnexpectedValueException(Errors::NO_ELEMENTS);
404
+            if (!$assigned) {
405
+                            throw new \UnexpectedValueException(Errors::NO_ELEMENTS);
406
+            }
403 407
         }
404 408
         return $result;
405 409
     }
@@ -426,13 +430,11 @@  discard block
 block discarded – undo
426 430
                 $result = $func($result, $v, $k);
427 431
                 $assigned = true;
428 432
             }
429
-        }
430
-        else {
433
+        } else {
431 434
             foreach ($this as $k => $v) {
432 435
                 if ($assigned) {
433 436
                     $result = $func($result, $v, $k);
434
-                }
435
-                else {
437
+                } else {
436 438
                     $result = $v;
437 439
                     $assigned = true;
438 440
                 }
@@ -461,8 +463,9 @@  discard block
 block discarded – undo
461 463
             $sum += $selector($v, $k);
462 464
             $count++;
463 465
         }
464
-        if ($count === 0)
465
-            throw new \UnexpectedValueException(Errors::NO_ELEMENTS);
466
+        if ($count === 0) {
467
+                    throw new \UnexpectedValueException(Errors::NO_ELEMENTS);
468
+        }
466 469
         return $sum / $count;
467 470
     }
468 471
 
@@ -480,15 +483,17 @@  discard block
 block discarded – undo
480 483
     {
481 484
         $it = $this->getIterator();
482 485
 
483
-        if ($it instanceof \Countable && $predicate === null)
484
-            return count($it);
486
+        if ($it instanceof \Countable && $predicate === null) {
487
+                    return count($it);
488
+        }
485 489
 
486 490
         $predicate = Utils::createLambda($predicate, 'v,k', Functions::$value);
487 491
         $count = 0;
488 492
 
489
-        foreach ($it as $k => $v)
490
-            if ($predicate($v, $k))
493
+        foreach ($it as $k => $v) {
494
+                    if ($predicate($v, $k))
491 495
                 $count++;
496
+        }
492 497
         return $count;
493 498
     }
494 499
 
@@ -513,8 +518,9 @@  discard block
 block discarded – undo
513 518
             $max = max($max, $selector($v, $k));
514 519
             $assigned = true;
515 520
         }
516
-        if (!$assigned)
517
-            throw new \UnexpectedValueException(Errors::NO_ELEMENTS);
521
+        if (!$assigned) {
522
+                    throw new \UnexpectedValueException(Errors::NO_ELEMENTS);
523
+        }
518 524
         return $max;
519 525
     }
520 526
 
@@ -535,8 +541,9 @@  discard block
 block discarded – undo
535 541
         $comparer = Utils::createLambda($comparer, 'a,b', Functions::$compareStrict);
536 542
         $enum = $this;
537 543
 
538
-        if ($selector !== null)
539
-            $enum = $enum->select($selector);
544
+        if ($selector !== null) {
545
+                    $enum = $enum->select($selector);
546
+        }
540 547
         return $enum->aggregate(function($a, $b) use ($comparer) { return $comparer($a, $b) > 0 ? $a : $b; });
541 548
     }
542 549
 
@@ -561,8 +568,9 @@  discard block
 block discarded – undo
561 568
             $min = min($min, $selector($v, $k));
562 569
             $assigned = true;
563 570
         }
564
-        if (!$assigned)
565
-            throw new \UnexpectedValueException(Errors::NO_ELEMENTS);
571
+        if (!$assigned) {
572
+                    throw new \UnexpectedValueException(Errors::NO_ELEMENTS);
573
+        }
566 574
         return $min;
567 575
     }
568 576
 
@@ -583,8 +591,9 @@  discard block
 block discarded – undo
583 591
         $comparer = Utils::createLambda($comparer, 'a,b', Functions::$compareStrict);
584 592
         $enum = $this;
585 593
 
586
-        if ($selector !== null)
587
-            $enum = $enum->select($selector);
594
+        if ($selector !== null) {
595
+                    $enum = $enum->select($selector);
596
+        }
588 597
         return $enum->aggregate(function($a, $b) use ($comparer) { return $comparer($a, $b) < 0 ? $a : $b; });
589 598
     }
590 599
 
@@ -604,8 +613,9 @@  discard block
 block discarded – undo
604 613
         $selector = Utils::createLambda($selector, 'v,k', Functions::$value);
605 614
 
606 615
         $sum = 0;
607
-        foreach ($this as $k => $v)
608
-            $sum += $selector($v, $k);
616
+        foreach ($this as $k => $v) {
617
+                    $sum += $selector($v, $k);
618
+        }
609 619
         return $sum;
610 620
     }
611 621
 
@@ -626,8 +636,9 @@  discard block
 block discarded – undo
626 636
         $predicate = Utils::createLambda($predicate, 'v,k');
627 637
 
628 638
         foreach ($this as $k => $v) {
629
-            if (!$predicate($v, $k))
630
-                return false;
639
+            if (!$predicate($v, $k)) {
640
+                            return false;
641
+            }
631 642
         }
632 643
         return true;
633 644
     }
@@ -648,15 +659,16 @@  discard block
 block discarded – undo
648 659
 
649 660
         if ($predicate) {
650 661
             foreach ($this as $k => $v) {
651
-                if ($predicate($v, $k))
652
-                    return true;
662
+                if ($predicate($v, $k)) {
663
+                                    return true;
664
+                }
653 665
             }
654 666
             return false;
655
-        }
656
-        else {
667
+        } else {
657 668
             $it = $this->getIterator();
658
-            if ($it instanceof \Countable)
659
-                return count($it) > 0;
669
+            if ($it instanceof \Countable) {
670
+                            return count($it) > 0;
671
+            }
660 672
             $it->rewind();
661 673
             return $it->valid();
662 674
         }
@@ -710,8 +722,9 @@  discard block
 block discarded – undo
710 722
     public function contains($value): bool
711 723
     {
712 724
         foreach ($this as $v) {
713
-            if ($v === $value)
714
-                return true;
725
+            if ($v === $value) {
726
+                            return true;
727
+            }
715 728
         }
716 729
         return false;
717 730
     }
@@ -735,8 +748,9 @@  discard block
 block discarded – undo
735 748
             $set = [];
736 749
             foreach ($this as $k => $v) {
737 750
                 $key = $keySelector($v, $k);
738
-                if (isset($set[$key]))
739
-                    continue;
751
+                if (isset($set[$key])) {
752
+                                    continue;
753
+                }
740 754
                 $set[$key] = true;
741 755
                 yield $k => $v;
742 756
             }
@@ -768,8 +782,9 @@  discard block
 block discarded – undo
768 782
             }
769 783
             foreach ($this as $k => $v) {
770 784
                 $key = $keySelector($v, $k);
771
-                if (isset($set[$key]))
772
-                    continue;
785
+                if (isset($set[$key])) {
786
+                                    continue;
787
+                }
773 788
                 $set[$key] = true;
774 789
                 yield $k => $v;
775 790
             }
@@ -801,8 +816,9 @@  discard block
 block discarded – undo
801 816
             }
802 817
             foreach ($this as $k => $v) {
803 818
                 $key = $keySelector($v, $k);
804
-                if (!isset($set[$key]))
805
-                    continue;
819
+                if (!isset($set[$key])) {
820
+                                    continue;
821
+                }
806 822
                 unset($set[$key]);
807 823
                 yield $k => $v;
808 824
             }
@@ -850,15 +866,17 @@  discard block
 block discarded – undo
850 866
             $set = [];
851 867
             foreach ($this as $k => $v) {
852 868
                 $key = $keySelector($v, $k);
853
-                if (isset($set[$key]))
854
-                    continue;
869
+                if (isset($set[$key])) {
870
+                                    continue;
871
+                }
855 872
                 $set[$key] = true;
856 873
                 yield $k => $v;
857 874
             }
858 875
             foreach ($other as $k => $v) {
859 876
                 $key = $keySelector($v, $k);
860
-                if (isset($set[$key]))
861
-                    continue;
877
+                if (isset($set[$key])) {
878
+                                    continue;
879
+                }
862 880
                 $set[$key] = true;
863 881
                 yield $k => $v;
864 882
             }
@@ -882,12 +900,14 @@  discard block
 block discarded – undo
882 900
     {
883 901
         /** @var $it \Iterator|\ArrayIterator */
884 902
         $it = $this->getIterator();
885
-        if ($it instanceof \ArrayIterator)
886
-            return $it->getArrayCopy();
903
+        if ($it instanceof \ArrayIterator) {
904
+                    return $it->getArrayCopy();
905
+        }
887 906
 
888 907
         $array = [];
889
-        foreach ($it as $k => $v)
890
-            $array[$k] = $v;
908
+        foreach ($it as $k => $v) {
909
+                    $array[$k] = $v;
910
+        }
891 911
         return $array;
892 912
     }
893 913
 
@@ -914,8 +934,9 @@  discard block
 block discarded – undo
914 934
     protected function toArrayDeepProc($enum): array
915 935
     {
916 936
         $array = [];
917
-        foreach ($enum as $k => $v)
918
-            $array[$k] = $v instanceof \Traversable || is_array($v) ? $this->toArrayDeepProc($v) : $v;
937
+        foreach ($enum as $k => $v) {
938
+                    $array[$k] = $v instanceof \Traversable || is_array($v) ? $this->toArrayDeepProc($v) : $v;
939
+        }
919 940
         return $array;
920 941
     }
921 942
 
@@ -932,12 +953,14 @@  discard block
 block discarded – undo
932 953
     {
933 954
         /** @var $it \Iterator|\ArrayIterator */
934 955
         $it = $this->getIterator();
935
-        if ($it instanceof \ArrayIterator)
936
-            return array_values($it->getArrayCopy());
956
+        if ($it instanceof \ArrayIterator) {
957
+                    return array_values($it->getArrayCopy());
958
+        }
937 959
 
938 960
         $array = [];
939
-        foreach ($it as $v)
940
-            $array[] = $v;
961
+        foreach ($it as $v) {
962
+                    $array[] = $v;
963
+        }
941 964
         return $array;
942 965
     }
943 966
 
@@ -964,8 +987,9 @@  discard block
 block discarded – undo
964 987
     protected function toListDeepProc($enum): array
965 988
     {
966 989
         $array = [];
967
-        foreach ($enum as $v)
968
-            $array[] = $v instanceof \Traversable || is_array($v) ? $this->toListDeepProc($v) : $v;
990
+        foreach ($enum as $v) {
991
+                    $array[] = $v instanceof \Traversable || is_array($v) ? $this->toListDeepProc($v) : $v;
992
+        }
969 993
         return $array;
970 994
     }
971 995
 
@@ -984,8 +1008,9 @@  discard block
 block discarded – undo
984 1008
         $valueSelector = Utils::createLambda($valueSelector, 'v,k', Functions::$value);
985 1009
 
986 1010
         $dic = [];
987
-        foreach ($this as $k => $v)
988
-            $dic[$keySelector($v, $k)] = $valueSelector($v, $k);
1011
+        foreach ($this as $k => $v) {
1012
+                    $dic[$keySelector($v, $k)] = $valueSelector($v, $k);
1013
+        }
989 1014
         return $dic;
990 1015
     }
991 1016
 
@@ -1018,8 +1043,9 @@  discard block
 block discarded – undo
1018 1043
         $valueSelector = Utils::createLambda($valueSelector, 'v,k', Functions::$value);
1019 1044
 
1020 1045
         $lookup = [];
1021
-        foreach ($this as $k => $v)
1022
-            $lookup[$keySelector($v, $k)][] = $valueSelector($v, $k);
1046
+        foreach ($this as $k => $v) {
1047
+                    $lookup[$keySelector($v, $k)][] = $valueSelector($v, $k);
1048
+        }
1023 1049
         return $lookup;
1024 1050
     }
1025 1051
 
@@ -1061,8 +1087,9 @@  discard block
 block discarded – undo
1061 1087
         $valueSelector = Utils::createLambda($valueSelector, 'v,k', Functions::$value);
1062 1088
 
1063 1089
         $obj = new \stdClass();
1064
-        foreach ($this as $k => $v)
1065
-            $obj->{$propertySelector($v, $k)} = $valueSelector($v, $k);
1090
+        foreach ($this as $k => $v) {
1091
+                    $obj->{$propertySelector($v, $k)} = $valueSelector($v, $k);
1092
+        }
1066 1093
         return $obj;
1067 1094
     }
1068 1095
 
@@ -1119,8 +1146,9 @@  discard block
 block discarded – undo
1119 1146
     {
1120 1147
         $action = Utils::createLambda($action, 'v,k', Functions::$blank);
1121 1148
 
1122
-        foreach ($this as $k => $v)
1123
-            $action($v, $k);
1149
+        foreach ($this as $k => $v) {
1150
+                    $action($v, $k);
1151
+        }
1124 1152
     }
1125 1153
 
1126 1154
     /**
Please login to merge, or discard this patch.
YaLinqo/Utils.php 1 patch
Spacing   +3 added lines, -3 removed lines patch added patch discarded remove patch
@@ -39,8 +39,8 @@  discard block
 block discarded – undo
39 39
     public static function init(): void
40 40
     {
41 41
         self::$lambdaCache = [
42
-            '$v' => [ 'v,k' => Functions::$value ],
43
-            '$k' => [ 'v,k' => Functions::$key ],
42
+            '$v' => ['v,k' => Functions::$value],
43
+            '$k' => ['v,k' => Functions::$key],
44 44
         ];
45 45
     }
46 46
 
@@ -145,7 +145,7 @@  discard block
 block discarded – undo
145 145
                 $code = substr($closure, $posArrow + 3);
146 146
             }
147 147
             else {
148
-                $args = '$' . str_replace(',', '=null,$', $closureArgs) . '=null';
148
+                $args = '$'.str_replace(',', '=null,$', $closureArgs).'=null';
149 149
                 $code = $closure;
150 150
             }
151 151
             $code = trim($code, " \r\n\t");
Please login to merge, or discard this patch.
YaLinqo/EnumerableGeneration.php 1 patch
Braces   +37 added lines, -28 removed lines patch added patch discarded remove patch
@@ -36,8 +36,9 @@  discard block
 block discarded – undo
36 36
                     yield $v;
37 37
                     $isEmpty = false;
38 38
                 }
39
-                if ($isEmpty)
40
-                    throw new \UnexpectedValueException(Errors::NO_ELEMENTS);
39
+                if ($isEmpty) {
40
+                                    throw new \UnexpectedValueException(Errors::NO_ELEMENTS);
41
+                }
41 42
             }
42 43
         });
43 44
     }
@@ -72,14 +73,15 @@  discard block
 block discarded – undo
72 73
     public static function from($source): Enumerable
73 74
     {
74 75
         $it = null;
75
-        if ($source instanceof Enumerable)
76
-            return $source;
77
-        elseif (is_array($source))
78
-            $it = new \ArrayIterator($source);
79
-        elseif ($source instanceof \IteratorAggregate)
80
-            $it = $source->getIterator();
81
-        elseif ($source instanceof \Traversable)
82
-            $it = $source;
76
+        if ($source instanceof Enumerable) {
77
+                    return $source;
78
+        } elseif (is_array($source)) {
79
+                    $it = new \ArrayIterator($source);
80
+        } elseif ($source instanceof \IteratorAggregate) {
81
+                    $it = $source->getIterator();
82
+        } elseif ($source instanceof \Traversable) {
83
+                    $it = $source;
84
+        }
83 85
         if ($it !== null) {
84 86
             return new self($it, false);
85 87
         }
@@ -128,8 +130,9 @@  discard block
 block discarded – undo
128 130
     {
129 131
         return new self(function() use ($start, $step) {
130 132
             $value = $start - $step;
131
-            while (true)
132
-                yield $value += $step;
133
+            while (true) {
134
+                            yield $value += $step;
135
+            }
133 136
         });
134 137
     }
135 138
 
@@ -189,12 +192,14 @@  discard block
 block discarded – undo
189 192
      */
190 193
     public static function range(int $start, int $count, int $step = 1): Enumerable
191 194
     {
192
-        if ($count <= 0)
193
-            return self::emptyEnum();
195
+        if ($count <= 0) {
196
+                    return self::emptyEnum();
197
+        }
194 198
         return new self(function() use ($start, $count, $step) {
195 199
             $value = $start - $step;
196
-            while ($count-- > 0)
197
-                yield $value += $step;
200
+            while ($count-- > 0) {
201
+                            yield $value += $step;
202
+            }
198 203
         });
199 204
     }
200 205
 
@@ -228,16 +233,18 @@  discard block
 block discarded – undo
228 233
      */
229 234
     public static function rangeTo(int $start, int $end, $step = 1): Enumerable
230 235
     {
231
-        if ($step <= 0)
232
-            throw new \InvalidArgumentException(Errors::STEP_NEGATIVE);
236
+        if ($step <= 0) {
237
+                    throw new \InvalidArgumentException(Errors::STEP_NEGATIVE);
238
+        }
233 239
         return new self(function() use ($start, $end, $step) {
234 240
             if ($start <= $end) {
235
-                for ($i = $start; $i < $end; $i += $step)
236
-                    yield $i;
237
-            }
238
-            else {
239
-                for ($i = $start; $i > $end; $i -= $step)
240
-                    yield $i;
241
+                for ($i = $start; $i < $end; $i += $step) {
242
+                                    yield $i;
243
+                }
244
+            } else {
245
+                for ($i = $start; $i > $end; $i -= $step) {
246
+                                    yield $i;
247
+                }
241 248
             }
242 249
         });
243 250
     }
@@ -257,11 +264,13 @@  discard block
 block discarded – undo
257 264
      */
258 265
     public static function repeat($element, $count = null): Enumerable
259 266
     {
260
-        if ($count < 0)
261
-            throw new \InvalidArgumentException(Errors::COUNT_LESS_THAN_ZERO);
267
+        if ($count < 0) {
268
+                    throw new \InvalidArgumentException(Errors::COUNT_LESS_THAN_ZERO);
269
+        }
262 270
         return new self(function() use ($element, $count) {
263
-            for ($i = 0; $i < $count || $count === null; $i++)
264
-                yield $element;
271
+            for ($i = 0; $i < $count || $count === null; $i++) {
272
+                            yield $element;
273
+            }
265 274
         });
266 275
     }
267 276
 
Please login to merge, or discard this patch.