Refactor to interface

laravel · inxilpro · Dec 8, 2021 · Dec 8, 2021 · Dec 8, 2021 · Dec 8, 2021
commit 4f1b50f8b9088bf2f5f4c4bfa31ff7c2ad1256d9
diff --git a/src/Illuminate/Contracts/Support/Hook.php b/src/Illuminate/Contracts/Support/Hook.php
@@ -0,0 +1,43 @@
+<?php
+
+namespace Illuminate\Contracts\Support;
+
+interface Hook
+{
+    /**
+     * Indicates this hook should be run with higher priority.
+     *
+     * @var int
+     */
+    public const PRIORITY_HIGH = 100;
+
+    /**
+     * Indicates this hook should be run with normal priority.
+     *
+     * @var int
+     */
+    public const PRIORITY_NORMAL = 200;
+
+    /**
+     * Indicates this hook should be run with lower priority.
+     *
+     * @var int
+     */
+    public const PRIORITY_LOW = 300;
+
+    /**
+     * Run the hook.
+     *
+     * @param  object|string  $instance
+     * @param  array  $arguments
+     */
+    public function run($instance, array $arguments = []);
+
+    /**
+     * Clean up after the hook.
+     *
+     * @param  object|string  $instance
+     * @param  array  $arguments
+     */
+    public function cleanup($instance, array $arguments = []);
+}
diff --git a/src/Illuminate/Database/Console/Seeds/WithoutModelEvents.php b/src/Illuminate/Database/Console/Seeds/WithoutModelEvents.php
@@ -3,17 +3,26 @@
 namespace Illuminate\Database\Console\Seeds;
 
 use Illuminate\Database\Eloquent\Model;
+use Illuminate\Events\NullDispatcher;
+use Illuminate\Support\Hooks\Hook;
 
 trait WithoutModelEvents
 {
     /**
-     * Prevent model events from being dispatched by the given callback.
+     * Prevent model events from being dispatched when the seeder is invoked.
      *
-     * @param  callable  $callback
-     * @return callable
+     * @return Hook
      */
-    public function withoutModelEvents(callable $callback)
+    public static function withoutModelEvents(): Hook
     {
-        return fn () => Model::withoutEvents($callback);
+        return Hook::make('invoke', static function () {
+            if (! $dispatcher = Model::getEventDispatcher()) {
+                return null;
+            }
+
+            Model::setEventDispatcher(new NullDispatcher($dispatcher));
+
+            return static fn() => Model::setEventDispatcher($dispatcher);
+        });
     }
 }
diff --git a/src/Illuminate/Database/Seeder.php b/src/Illuminate/Database/Seeder.php
@@ -6,10 +6,13 @@
 use Illuminate\Container\Container;
 use Illuminate\Database\Console\Seeds\WithoutModelEvents;
 use Illuminate\Support\Arr;
+use Illuminate\Support\Hookable;
 use InvalidArgumentException;
 
 abstract class Seeder
 {
+    use Hookable;
+
     /**
      * The container instance.
      *
@@ -171,16 +174,10 @@ public function __invoke(array $parameters = [])
             throw new InvalidArgumentException('Method [run] missing from '.get_class($this));
         }
 
-        $callback = fn () => isset($this->container)
-            ? $this->container->call([$this, 'run'], $parameters)
-            : $this->run(...$parameters);
-
-        $uses = array_flip(class_uses_recursive(static::class));
-
-        if (isset($uses[WithoutModelEvents::class])) {
-            $callback = $this->withoutModelEvents($callback);
-        }
-
-        return $callback();
+        return $this->runHooks('invoke', $this, function() use ($parameters) {
+            return isset($this->container)
+                ? $this->container->call([$this, 'run'], $parameters)
+                : $this->run(...$parameters);
+        });
     }
 }
diff --git a/src/Illuminate/Support/Hookable.php b/src/Illuminate/Support/Hookable.php
@@ -2,17 +2,59 @@
 
 namespace Illuminate\Support;
 
+use Closure;
 use Illuminate\Support\Hooks\HookCollection;
+use Illuminate\Support\Hooks\TraitHook;
 
 trait Hookable
 {
-    protected static function runStaticHooks($name, ...$arguments)
+    /**
+     * Run hooks statically.
+     *
+     * @param  string  $name
+     * @param  array  $arguments
+     * @param  \Closure|null  $callback
+     * @return mixed
+     */
+    protected static function runStaticHooks($name, $arguments = [], Closure $callback = null)
     {
-        HookCollection::for(static::class)->run($name, null, $arguments);
+        return HookCollection::for(static::class)->run($name, static::class, $arguments, $callback);
     }
 
-    protected function runHooks($name, ...$arguments)
+    /**
+     * Run trait hooks statically.
+     *
+     * @param  string  $prefix
+     * @param  array  $arguments
+     * @return void
+     */
+    protected static function runStaticTraitHooks($prefix, $arguments = [])
     {
-        HookCollection::for(static::class)->run($name, $this, $arguments);
+        (new TraitHook($prefix))->run(static::class, $arguments);
+    }
+
+    /**
+     * Run hooks non-statically.
+     *
+     * @param  string  $name
+     * @param  array  $arguments
+     * @param  \Closure|null  $callback
+     * @return mixed
+     */
+    protected function runHooks($name, $arguments = [], Closure $callback = null)
+    {
+        return HookCollection::for(static::class)->run($name, $this, $arguments, $callback);
+    }
+
+    /**
+     * Run trait hooks.
+     *
+     * @param  string  $prefix
+     * @param  array  $arguments
+     * @return void
+     */
+    protected function runTraitHooks($prefix, $arguments = [])
+    {
+        (new TraitHook($prefix))->run($this, $arguments);
     }
 }
diff --git a/src/Illuminate/Support/Hooks/Hook.php b/src/Illuminate/Support/Hooks/Hook.php
@@ -3,38 +3,105 @@
 namespace Illuminate\Support\Hooks;
 
 use Closure;
+use Illuminate\Contracts\Support\Hook as HookContract;
 
-class Hook
+class Hook implements HookContract
 {
-    public const PRIORITY_HIGH = 100;
-    public const PRIORITY_NORMAL = 200;
-    public const PRIORITY_LOW = 300;
+    /**
+     * A cleanup function that should be run after the hooks are run.
+     *
+     * @var \Closure|null
+     */
+    protected ?Closure $cleanup = null;
 
+    /**
+     * Instantiate a new high-priority hook.
+     *
+     * @param  string  $name
+     * @param  \Closure  $callback
+     * @return \Illuminate\Support\Hooks\Hook
+     */
     public static function highPriority(string $name, Closure $callback): Hook
     {
-        return new static($name, $callback, self::PRIORITY_HIGH);
+        return new static($name, $callback, HookContract::PRIORITY_HIGH);
     }
 
+    /**
+     * Instantiate a new hook.
+     *
+     * @param  string  $name
+     * @param  \Closure  $callback
+     * @return \Illuminate\Support\Hooks\Hook
+     */
     public static function make(string $name, Closure $callback): Hook
     {
-        return new static($name, $callback, self::PRIORITY_NORMAL);
+        return new static($name, $callback, HookContract::PRIORITY_NORMAL);
     }
 
+    /**
+     * Instantiate a new low-priority hook.
+     *
+     * @param  string  $name
+     * @param  \Closure  $callback
+     * @return \Illuminate\Support\Hooks\Hook
+     */
     public static function lowPriority(string $name, Closure $callback): Hook
     {
-        return new static($name, $callback, self::PRIORITY_LOW);
+        return new static($name, $callback, HookContract::PRIORITY_LOW);
     }
 
+    /**
+     * Constructor
+     *
+     * @param  string  $name
+     * @param  \Closure  $callback
+     * @param  int  $priority
+     * @return void
+     */
     public function __construct(
         public string $name,
         public Closure $callback,
-        public int $priority = self::PRIORITY_NORMAL
+        public int $priority = HookContract::PRIORITY_NORMAL
     ) { }
 
-    public function run($instance = null, array $arguments = [])
+    /**
+     * @inheritdoc
+     */
+    public function run($instance, array $arguments = [])
     {
-        return $instance
-            ? $this->callback->call($instance, ...$arguments)
-            : call_user_func_array($this->callback, $arguments);
+        $this->cleanup = null;
+
+        $result = $this->runCallback($this->callback, $instance, $arguments);
+
+        if ($result instanceof Closure) {
+            $this->cleanup = $result;
+        }
+    }
+
+    /**
+     * @inheritdoc
+     */
+    public function cleanup($instance, array $arguments = [])
+    {
+        if (is_null($this->cleanup)) {
+            return;
+        }
+
+        $this->runCallback($this->cleanup, $instance, $arguments);
+    }
+
+    /**
+     * Run a callback that may or may not be static.
+     *
+     * @param  Closure  $callback
+     * @param  object|string  $instance
+     * @param  array  $arguments
+     * @return mixed
+     */
+    protected function runCallback($callback, $instance, $arguments = [])
+    {
+        return is_object($instance)
+            ? $callback->call($instance, $arguments)
+            : $callback(...$arguments);
     }
 }