Support load stages

Author: dantleech

lib/Core/PipelineBuilder.php

@@ -5,6 +5,7 @@
 use PhpBench\Pipeline\Extension\Console\ConsoleExtension;
 use Generator;
 use PhpBench\Pipeline\Extension\Core\CoreExtension;
+use PhpBench\Pipeline\Core\Exception\InvalidStage;
 
 final class PipelineBuilder
 {
@@ -47,6 +48,41 @@ public function build(): BuiltPipeline
         return new BuiltPipeline($this->stages, $generatorFactory);
     }
 
+    public function load(array $stages): self
+    {
+        foreach ($stages as $stage) {
+            if (is_callable($stage) || is_string($stage)) {
+                $this->stage($stage);
+                continue;
+            }
+
+            if (is_array($stage)) {
+                switch (count($stage)) {
+                    case 1:
+                        list($stage) = $stage;
+                        $this->stage($stage);
+                        continue 2;
+                    case 2:
+                        list($stage, $config) = $stage;
+                        $this->stage($stage, $config);
+                        continue 2;
+                    default:
+                        throw new InvalidStage(sprintf(
+                            'Stage config element cannot have more than 2 elements, got %s',
+                            count($stage)
+                        ));
+                }
+            }
+
+            throw new InvalidStage(sprintf(
+                'Stage must either be an array config element or a callable, got "%s"',
+                is_object($stage) ? get_class($stage) : gettype($stage)
+            ));
+        }
+
+        return $this;
+    }
+
     /**
      * @var callable|Stage
      */

tests/Unit/Core/PipelineBuilderTest.php

@@ -9,6 +9,8 @@
 use PhpBench\Pipeline\Core\Stage;
 use Prophecy\Argument;
 use PhpBench\Pipeline\Core\Schema;
+use PhpBench\Pipeline\Core\Exception\InvalidStage;
+use stdClass;
 
 class PipelineBuilderTest extends TestCase
 {
@@ -70,6 +72,92 @@ public function testBuildsPipelineWithStageAlias()
         $this->assertEquals(['Test'], $result);
     }
 
+    /**
+     * @dataProvider provideBuildsPipelinesFromStages
+     */
+    public function testBuildsPipelineFromStages(array $stages, array $expected, array $exception = [])
+    {
+        if ($exception) {
+            list($class, $message) = $exception;
+            $this->expectException($class);
+            $this->expectExceptionMessage($message);
+        }
+
+        $this->extension1->stageAliases()->willReturn(['test/foobar']);
+        $this->extension1->stage('test/foobar')->willReturn($this->stage1->reveal());
+
+        $this->stage1->configure(Argument::type(Schema::class))->will(function ($args) {
+            $schema = $args[0];
+            $schema->setDefaults([ 'foo' => 'bar' ]);
+        });
+        $this->stage1->__invoke()->will(function () {
+            yield;
+            yield ['Test'];
+        });
+
+        $builder = PipelineBuilder::create();
+        $builder->addExtension($this->extension1->reveal());
+        $builder->load($stages);
+
+        $pipeline = $builder->build();
+
+        $this->assertInstanceOf(BuiltPipeline::class, $pipeline);
+        $result = $pipeline->run();
+        $this->assertEquals($expected, $result);
+    }
+
+    public function provideBuildsPipelinesFromStages()
+    {
+        yield 'with string alias' => [
+            [ 
+                'test/foobar' 
+            ],
+            [ 'Test' ],
+        ];
+        yield 'with callable' => [
+            [ 
+                function () {
+                    yield;
+                    yield [ 'Hai!' ];
+                },
+            ],
+            [ 'Hai!' ],
+
+        ];
+        yield 'with alias in an array' => [
+            [ 
+                [ 'test/foobar' ]
+            ],
+            [ 'Test' ],
+        ];
+        yield 'with alias and config' => [
+            [ 
+                [ 'test/foobar', ['foo' => 'bar'] ]
+            ],
+            [ 'Test' ],
+        ];
+        yield 'but throws exception if stage has more than 2 elements ' => [
+            [ 
+                [ 'test/foobar', [], [] ]
+            ],
+            [],
+            [
+                InvalidStage::class,
+                'Stage config element cannot have more than 2 elements, got 3'
+            ]
+        ];
+        yield 'but throws exception if stage was neither an array or a callable ' => [
+            [ 
+                new stdClass,
+            ],
+            [],
+            [
+                InvalidStage::class,
+                'Stage must either be an array config element or a callable, got "stdClass"'
+            ]
+        ];
+    }
+
     public function testBuildsPipelineWithMultipleStages()
     {
         $builder = PipelineBuilder::create();