Merge pull request #11 from pitchart/feature/optional-iterable

Allows reducing functions to directly handle iterables

Author: pitchart

src/Transducer/transducers.php

@@ -40,6 +40,8 @@ function identity($value)
 }
 
 /**
+ * Transforms a function into a pure function
+ *
  * @param callable $function
  * @param array ...$arguments
  *

src/transform.php

@@ -3,11 +3,17 @@
 namespace Pitchart\Transformer\Tests\Reducer;
 
 use PHPUnit\Framework\TestCase;
-use Pitchart\Transformer\Reducer\Cat;
+use Pitchart\Transformer\Reducer;
 use Pitchart\Transformer\Transformer;
+use Pitchart\Transformer\Transducer as t;
 
 class CatTest extends TestCase
 {
+    public function test_is_a_reducer()
+    {
+        self::assertInstanceOf(Reducer::class, t\cat()(t\to_array()));
+    }
+
     public function test_concatenates_items_from_nested_lists()
     {
         $concatenated = (new Transformer([0 ,1, [2, 3], [[4, 5], 6]]))
@@ -23,4 +29,16 @@ public function test_removes_empty_nested_lists()
 
         self::assertEquals([0, 1, 2, 3, [4, 5], 6], $concatenated);
     }
+
+    public function test_applies_to_arrays()
+    {
+        $concatenated = t\cat([0 ,1, [], [2, 3], [[4, 5], 6]]);
+        self::assertEquals([0, 1, 2, 3, [4, 5], 6], $concatenated);
+    }
+
+    public function test_applies_to_iterators()
+    {
+        $concatenated = t\cat(new \ArrayIterator([0 ,1, [], [2, 3], [[4, 5], 6]]));
+        self::assertEquals([0, 1, 2, 3, [4, 5], 6], $concatenated);
+    }
 }

tests/Reducer/CatTest.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace Pitchart\Transformer\Tests\Reducer;
+
+use Pitchart\Transformer\Reducer;
+use Pitchart\Transformer\Reducer\Dedupe;
+use Pitchart\Transformer\Transducer as t;
+use PHPUnit\Framework\TestCase;
+use Pitchart\Transformer\Transformer;
+
+class DedupeTest extends TestCase
+{
+    public function test_is_a_reducer()
+    {
+        self::assertInstanceOf(Reducer::class, t\dedupe()(t\to_array()));
+    }
+
+    public function test_removes_consecutive_equals_items()
+    {
+        $deduped = (new Transformer([1, 2, 3, 2, 2, 4, 6, 5, 1, 0, 0, 1]))
+            ->dedupe()->toArray();
+
+        self::assertEquals([1, 2, 3, 2, 4, 6, 5, 1, 0, 1], $deduped);
+    }
+
+    public function test_applies_to_arrays()
+    {
+        $deduped = t\dedupe([1, 2, 3, 2, 2, 4, 6, 5, 1, 0, 0, 1]);
+        self::assertEquals([1, 2, 3, 2, 4, 6, 5, 1, 0, 1], $deduped);
+    }
+
+    public function test_applies_to_iterators()
+    {
+        $deduped = t\dedupe(new \ArrayIterator([1, 2, 3, 2, 2, 4, 6, 5, 1, 0, 0, 1]));
+        self::assertEquals([1, 2, 3, 2, 4, 6, 5, 1, 0, 1], $deduped);
+    }
+
+}

tests/Reducer/DedupeTest.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace Pitchart\Transformer\Tests\Reducer;
+
+use Pitchart\Transformer\Reducer;
+use Pitchart\Transformer\Reducer\Drop;
+use PHPUnit\Framework\TestCase;
+use Pitchart\Transformer\Transformer;
+use Pitchart\Transformer\Transducer as t;
+
+class DropTest extends TestCase
+{
+    public function test_is_a_reducer()
+    {
+        self::assertInstanceOf(Reducer::class, t\drop(3)(t\to_array()));
+    }
+
+    public function test_drops_a_number_of_values_from_a_collection()
+    {
+        $dropped = (new Transformer(range(1, 6)))
+            ->drop(4)->toArray();
+
+        self::assertEquals([5,6], $dropped);
+    }
+
+    public function test_applies_to_arrays()
+    {
+        $dropped = t\drop(4, range(1, 6));
+        self::assertEquals([5,6], $dropped);
+    }
+
+    public function test_applies_to_iterators()
+    {
+        $dropped = t\drop(4, new \ArrayIterator(range(1, 6)));
+        self::assertEquals([5, 6], $dropped);
+    }
+
+}

tests/Reducer/DropTest.php

@@ -0,0 +1,38 @@
+<?php
+
+namespace Pitchart\Transformer\Tests\Reducer;
+
+use Pitchart\Transformer\Reducer;
+use Pitchart\Transformer\Reducer\DropWhile;
+use PHPUnit\Framework\TestCase;
+use function Pitchart\Transformer\Tests\is_lower_than_four;
+use Pitchart\Transformer\Transformer;
+use Pitchart\Transformer\Transducer as t;
+
+class DropWhileTest extends TestCase
+{
+    public function test_is_a_reducer()
+    {
+        self::assertInstanceOf(Reducer::class, t\drop_while(is_lower_than_four())(t\to_array()));
+    }
+
+    public function test_drops_items_while_a_predicat_is_true()
+    {
+        $dropped = (new Transformer(range(1, 6)))
+            ->dropWhile(is_lower_than_four())->toArray();
+        self::assertEquals([4, 5, 6], $dropped);
+    }
+
+    public function test_applies_to_arrays()
+    {
+        $dropped = t\drop_while(is_lower_than_four(), range(1, 6));
+        self::assertEquals([4, 5, 6], $dropped);
+    }
+
+    public function test_applies_to_iterators()
+    {
+        $dropped = t\drop_while(is_lower_than_four(), new \ArrayIterator(range(1, 6)));
+        self::assertEquals([4, 5, 6], $dropped);
+    }
+
+}

tests/Reducer/DropWhileTest.php

@@ -2,7 +2,6 @@
 
 namespace Pitchart\Transformer\Tests\Reducer;
 
-use Pitchart\Transformer\Reducer\Filter;
 use PHPUnit\Framework\TestCase;
 use Pitchart\Transformer\Reducer;
 use Pitchart\Transformer\Transformer;
@@ -26,4 +25,16 @@ public function test_filters_items_with_a_callback()
 
         $this->assertEquals([2, 4], $squared);
     }
+
+    public function test_applies_to_arrays()
+    {
+        $evens = t\filter(is_even(), [1, 2, 3, 4]);
+        self::assertEquals([2, 4], $evens);
+    }
+
+    public function test_applies_to_iterators()
+    {
+        $evens = t\filter(is_even(), new \ArrayIterator([1, 2, 3, 4]));
+        self::assertEquals([2, 4], $evens);
+    }
 }

tests/Reducer/FilterTest.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace Pitchart\Transformer\Tests\Reducer;
+
+use PHPUnit\Framework\TestCase;
+use function Pitchart\Transformer\Tests\is_greater_than_three;
+use Pitchart\Transformer\Transformer;
+use Pitchart\Transformer\Transducer as t;
+
+class FirstTest extends TestCase
+{
+
+    public function test_gets_first_matching_item_of_iterable()
+    {
+        $first = (new Transformer(range(1,6)))
+            ->first(is_greater_than_three())->single();
+
+        self::assertEquals(4, $first);
+    }
+
+    public function test_gets_first_matching_item_of_arrays()
+    {
+        $first = t\first(is_greater_than_three(), range(1, 6));
+        self::assertEquals(4, $first);
+    }
+
+    public function test_gets_first_matching_item_of_iterator()
+    {
+        $first = t\first(is_greater_than_three(), range(1, 6));
+        self::assertEquals(4, $first);
+    }
+}

tests/Reducer/FirstTest.php

@@ -2,12 +2,19 @@
 
 namespace Pitchart\Transformer\Tests\Reducer;
 
+use Pitchart\Transformer\Reducer;
 use Pitchart\Transformer\Reducer\Flatten;
 use PHPUnit\Framework\TestCase;
 use Pitchart\Transformer\Transformer;
+use Pitchart\Transformer\Transducer as t;
 
 class FlattenTest extends TestCase
 {
+    public function test_is_a_reducer()
+    {
+        self::assertInstanceOf(Reducer::class, t\flatten()(t\to_array()));
+    }
+
     public function test_converts_nested_sequences_to_a_single_flat_sequence()
     {
         $flat = (new Transformer([0 ,1, [2, 3], [[4, 5], 6]]))
@@ -16,12 +23,24 @@ public function test_converts_nested_sequences_to_a_single_flat_sequence()
         self::assertEquals([0, 1, 2, 3, 4, 5, 6], $flat);
     }
 
-    public function test_flatten_is_immutable()
+    public function test_is_immutable()
     {
         $flatten = (new Transformer([0 ,1, [2, 3], [[4, 5], 6]]))
             ->flatten();
 
         self::assertEquals([0, 1, 2, 3, 4, 5, 6], $flatten->toArray());
         self::assertEquals([0, 1, 2, 3, 4, 5, 6], $flatten->toArray());
     }
+
+    public function test_applies_to_arrays()
+    {
+        $flat = t\flatten([0 ,1, [2, 3], [[4, 5], 6]]);
+        self::assertEquals([0, 1, 2, 3, 4, 5, 6], $flat);
+    }
+
+    public function test_applies_to_iterators()
+    {
+        $flat = t\flatten(new \ArrayIterator([0 ,1, [2, 3], [[4, 5], 6]]));
+        self::assertEquals([0, 1, 2, 3, 4, 5, 6], $flat);
+    }
 }

tests/Reducer/FlattenTest.php

@@ -0,0 +1,82 @@
+<?php
+
+namespace Pitchart\Transformer\Tests\Reducer;
+
+use Pitchart\Transformer\Reducer;
+use Pitchart\Transformer\Reducer\GroupBy;
+use PHPUnit\Framework\TestCase;
+use Pitchart\Transformer\Transducer as t;
+use Pitchart\Transformer\Transformer;
+
+class GroupByTest extends TestCase
+{
+    public function test_is_a_reducer()
+    {
+        self::assertInstanceOf(Reducer::class, t\group_by(function ($item) {return $item['group'];})(t\to_single()));
+    }
+
+    /**
+     * @param array $data
+     * @param \Closure $callable
+     * @param array $expected
+     *
+     * @dataProvider groupableDataProvider
+     */
+    public function test_groups_items_by_a_callback($data, $callable, $expected)
+    {
+        $grouped = (new Transformer($data))
+            ->groupBy($callable)
+            ->single()
+        ;
+
+        self::assertEquals($expected, $grouped);
+    }
+
+    /**
+     * @param array $data
+     * @param \Closure $callable
+     * @param array $expected
+     *
+     * @dataProvider groupableDataProvider
+     */
+    public function test_applies_to_arrays($data, $callable, $expected)
+    {
+        $grouped = t\group_by($callable, $data);
+        self::assertEquals($expected, $grouped);
+    }
+
+    /**
+     * @param array $data
+     * @param \Closure $callable
+     * @param array $expected
+     *
+     * @dataProvider groupableDataProvider
+     */
+    public function test_applies_to_iterators($data, $callable, $expected)
+    {
+        $grouped = t\group_by($callable, new \ArrayIterator($data));
+        self::assertEquals($expected, $grouped);
+    }
+
+    public function groupableDataProvider()
+    {
+        return [
+            [
+                [
+                    ['group' => 'foo', 'value' => 'bar'],
+                    ['group' => 'bar', 'value' => 'foo'],
+                    ['group' => 'fizz', 'value' => 'bar'],
+                    ['group' => 'foo', 'value' => 'test'],
+                    ['group' => 'fizz', 'value' => 'foo'],
+                    ['group' => 'bar', 'value' => 'foo'],
+                ],
+                function ($item) {return $item['group'];},
+                [
+                    'foo' => [['group' => 'foo', 'value' => 'bar'], ['group' => 'foo', 'value' => 'test'],],
+                    'bar' => [['group' => 'bar', 'value' => 'foo'], ['group' => 'bar', 'value' => 'foo'],],
+                    'fizz' => [['group' => 'fizz', 'value' => 'bar'], ['group' => 'fizz', 'value' => 'foo'],],
+                ]
+            ]
+        ];
+    }
+}