Merge pull request #5 from michael-rubel/feature/events

Events

src/EnhancedPipelineServiceProvider.php

@@ -4,6 +4,7 @@
 
 namespace MichaelRubel\EnhancedPipeline;
 
+use Illuminate\Events\EventServiceProvider;
 use Spatie\LaravelPackageTools\Package;
 use Spatie\LaravelPackageTools\PackageServiceProvider;
 
@@ -20,4 +21,14 @@ public function configurePackage(Package $package): void
  {
  $package->name('laravel-enhanced-pipeline');
  }
+
+ /**
+ * @return void
+ */
+ public function registeringPackage(): void
+ {
+ if (! $this->app->bound('events')) {
+ $this->app->register(EventServiceProvider::class, true);
+ }
+ }
 }

src/Events/PipePassed.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace MichaelRubel\EnhancedPipeline\Events;
+
+class PipePassed
+{
+ /**
+ * @param mixed $pipe
+ * @param mixed $passable
+ */
+ public function __construct(public $pipe, public $passable)
+ {
+ //
+ }
+}

src/Events/PipeStarted.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace MichaelRubel\EnhancedPipeline\Events;
+
+class PipeStarted
+{
+ /**
+ * @param mixed $pipe
+ * @param mixed $passable
+ */
+ public function __construct(public $pipe, public $passable)
+ {
+ //
+ }
+}

src/Pipeline.php

@@ -6,13 +6,16 @@
 use Illuminate\Container\Container as ContainerConcrete;
 use Illuminate\Contracts\Container\Container;
 use Illuminate\Contracts\Pipeline\Pipeline as PipelineContract;
-use MichaelRubel\EnhancedPipeline\Traits\HandlesDatabaseTransactions;
+use MichaelRubel\EnhancedPipeline\Events\PipePassed;
+use MichaelRubel\EnhancedPipeline\Events\PipeStarted;
+use MichaelRubel\EnhancedPipeline\Traits\HasDatabaseTransactions;
+use MichaelRubel\EnhancedPipeline\Traits\HasEvents;
 use RuntimeException;
 use Throwable;
 
 class Pipeline implements PipelineContract
 {
- use HandlesDatabaseTransactions;
+ use HasDatabaseTransactions, HasEvents;
 
  /**
  * The container implementation.
@@ -191,11 +194,17 @@ protected function carry()
  {
  return function ($stack, $pipe) {
  return function ($passable) use ($stack, $pipe) {
+ $this->fireEvent(PipeStarted::class, $pipe, $passable);
+
  if (is_callable($pipe)) {
  // If the pipe is a callable, then we will call it directly, but otherwise we
  // will resolve the pipes out of the dependency container and call it with
  // the appropriate method and arguments, returning the results back out.
- return $pipe($passable, $stack);
+ $result = $pipe($passable, $stack);
+
+ $this->fireEvent(PipePassed::class, $pipe, $passable);
+
+ return $result;
  } elseif (! is_object($pipe)) {
  [$name, $parameters] = $this->parsePipeString($pipe);
 
@@ -216,6 +225,8 @@ protected function carry()
  ? $pipe->{$this->method}(...$parameters)
  : $pipe(...$parameters);
 
+ $this->fireEvent(PipePassed::class, $pipe, $passable);
+
  return $this->handleCarry($carry);
  };
  };

src/Traits/HandlesDatabaseTransactions.php → src/Traits/HasDatabaseTransactions.php

@@ -6,7 +6,7 @@
 
 use Illuminate\Support\Facades\DB;
 
-trait HandlesDatabaseTransactions
+trait HasDatabaseTransactions
 {
  /**
  * Determines whether class uses transaction.

src/Traits/HasEvents.php

@@ -0,0 +1,50 @@
+<?php
+
+declare(strict_types=1);
+
+namespace MichaelRubel\EnhancedPipeline\Traits;
+
+trait HasEvents
+{
+ /**
+ * Determines whether pipeline uses events.
+ *
+ * @var bool
+ */
+ protected bool $useEvents = false;
+
+ /**
+ * Enable events in pipeline.
+ *
+ * @return static
+ */
+ public function withEvents(): static
+ {
+ $this->useEvents = true;
+
+ return $this;
+ }
+
+ /**
+ * Fire the event if enabled.
+ *
+ * @param string $event
+ * @param string|callable|mixed $pipe
+ * @param mixed $passable
+ *
+ * @return void
+ */
+ protected function fireEvent(string $event, $pipe, $passable): void
+ {
+ if (! $this->useEvents) {
+ return;
+ }
+
+ if (is_object($pipe)) {
+ /** @var object $pipe */
+ $pipe = $pipe::class;
+ }
+
+ event(new $event($pipe, $passable));
+ }
+}

tests/PipelineEventsTest.php

@@ -0,0 +1,78 @@
+<?php
+
+namespace MichaelRubel\EnhancedPipeline\Tests;
+
+use Illuminate\Support\Facades\Event;
+use MichaelRubel\EnhancedPipeline\Events\PipePassed;
+use MichaelRubel\EnhancedPipeline\Events\PipeStarted;
+use MichaelRubel\EnhancedPipeline\Pipeline;
+
+class PipelineEventsTest extends TestCase
+{
+ public function setUp(): void
+ {
+ parent::setUp();
+
+ Event::fake();
+ }
+
+ /** @test */
+ public function testFiresPipeStartedEvents()
+ {
+ app(Pipeline::class)
+ ->withEvents()
+ ->send('data')
+ ->through([
+ TestPipe::class,
+ TestPipe::class,
+ ])
+ ->thenReturn();
+
+ Event::assertDispatched(function (PipeStarted $event) {
+ $this->assertInstanceOf(TestPipe::class, app($event->pipe));
+ $this->assertSame('data', $event->passable);
+
+ return true;
+ }, 2);
+ }
+
+ /** @test */
+ public function testFiresPipeStartedEventsButFailsToPass()
+ {
+ app(Pipeline::class)
+ ->withEvents()
+ ->send('data')
+ ->through(PipelineWithException::class)
+ ->onFailure(fn () => true)
+ ->thenReturn();
+
+ Event::assertDispatched(function (PipeStarted $event) {
+ $this->assertInstanceOf(PipelineWithException::class, app($event->pipe));
+ $this->assertSame('data', $event->passable);
+
+ return true;
+ });
+
+ Event::assertNotDispatched(PipePassed::class);
+ }
+
+ /** @test */
+ public function testFiresPipePassedEvents()
+ {
+ app(Pipeline::class)
+ ->withEvents()
+ ->send('data')
+ ->through([
+ TestPipe::class,
+ TestPipe::class,
+ ])
+ ->thenReturn();
+
+ Event::assertDispatched(function (PipePassed $event) {
+ $this->assertInstanceOf(TestPipe::class, app($event->pipe));
+ $this->assertSame('data', $event->passable);
+
+ return true;
+ }, 2);
+ }
+}