feat: Added Infuse decorator

Author: seebeen

src/Decorators/Filter.php

@@ -25,6 +25,13 @@
  */
 #[\Attribute( \Attribute::IS_REPEATABLE | \Attribute::TARGET_METHOD )]
 class Filter extends Hook implements Can_Invoke {
+    /**
+     * Array of lazy loaded handlers.
+     *
+     * @var array<string,bool>
+     */
+    public static array $lazy = array();
+
     /**
      * The handler.
      *
@@ -143,7 +150,10 @@ protected function init_handler( string $strategy ): bool {
             return $this->can_load();
         }
 
-        \do_action( "{$this->handler->id}_{$strategy}_init" );
+        if ( ! isset( static::$lazy[ $this->handler->id ] ) ) {
+            static::$lazy[ $this->handler->id ] = true;
+            \do_action( "{$this->handler->id}_{$strategy}_init", $this->handler );
+        }
 
         return $this->handler->loaded;
     }
@@ -236,17 +246,27 @@ protected function fire_hook( mixed ...$args ): mixed {
     protected function get_cb_args( array $args ): array {
         if ( $this->params ) {
             foreach ( $this->params as $param ) {
-                $args[] = ! \str_starts_with( $param, '!value:' )
-                    ? $this->container->get( $param )
-                    : \str_replace( '!value:', '', $param );
+                $args[] = $this->get_cb_arg( $param );
             }
-
-            $args[] = $this;
         }
 
         return $args;
     }
 
+    protected function get_cb_arg( string $param ): mixed {
+        if ( '!self.hook' === $param ) {
+            return $this;
+        }
+
+        if ( '!self.handler' === $param ) {
+            return $this->handler;
+        }
+
+        return ! \str_starts_with( $param, '!value:' )
+            ? $this->container->get( $param )
+            : \str_replace( '!value:', '', $param );
+    }
+
     /**
      * Handle an exception.
      *

src/Decorators/Handler.php

@@ -9,7 +9,6 @@
 namespace XWP\DI\Decorators;
 
 use Closure;
-use DI\Attribute\Inject;
 use DI\Container;
 use ReflectionClass;
 use XWP\DI\Interfaces\Can_Handle;
@@ -28,6 +27,13 @@
  */
 #[\Attribute( \Attribute::TARGET_CLASS )]
 class Handler extends Hook implements Can_Handle {
+    /**
+     * Array of handlers that have been initialized.
+     *
+     * @var array<string,bool>
+     */
+    protected static array $did_init = array();
+
     /**
      * Handler classname.
      *
@@ -146,8 +152,9 @@ public function load(): bool {
         }
 
         $this->instance ??= $this->initialize();
+        $this->loaded     = $this->instance::class === $this->classname;
 
-        return $this->on_initialize();
+        return $this->loaded && $this->on_initialize();
     }
 
     /**
@@ -165,35 +172,32 @@ protected function initialize(): object {
      * @return bool
      */
     protected function on_initialize(): bool {
-        $this->loaded = true;
-
-        $method = 'on_initialize';
-
-        if ( \method_exists( $this->classname, $method ) ) {
+        if ( ! \method_exists( $this->instance, 'on_initialize' ) ) {
+            return static::$did_init[ $this->id ] ??= true;
+        }
 
-            $this->container->call(
-                array( $this->classname, $method ),
-                $this->resolve_params( $method ),
-            );
+        if ( isset( static::$did_init[ $this->id ] ) ) {
+            return true;
         }
 
-        return $this->loaded;
+        $this->container->call(
+            array( $this->instance, 'on_initialize' ),
+            $this->resolve_params( 'on_initialize' ),
+        );
+
+        return static::$did_init[ $this->id ] ??= true;
     }
 
     /**
      * Resolve the parameters for a method.
      *
      * @param  string $method     Method name.
-     * @return array<string,mixed>
+     * @return array<mixed>
      */
     protected function resolve_params( string $method ): array {
-        return \array_map(
-            '\DI\get',
-            Reflection::get_decorator(
-                $this->reflector->getMethod( $method ),
-                Inject::class,
-            )?->getParameters() ?? array(),
-        );
+        $injector = Reflection::get_decorator( $this->reflector->getMethod( $method ), Infuse::class );
+
+        return $injector ? $injector->resolve( $this ) : array();
     }
 
     /**

src/Decorators/Infuse.php

@@ -0,0 +1,53 @@
+<?php
+/**
+ * Infuse decorator class file.
+ *
+ * @package eXtended WordPress
+ * @subpackage Dependency Injection
+ */
+
+namespace XWP\DI\Decorators;
+
+use XWP\DI\Interfaces\Can_Handle;
+
+/**
+ * Infuse decorator.
+ */
+#[\Attribute( \Attribute::TARGET_METHOD )]
+class Infuse {
+    /**
+     * The parameters to inject.
+     *
+     * @var array<string>
+     */
+    protected array $params;
+
+    /**
+     * Constructor.
+     *
+     * @param string|array<string> ...$params The parameters to inject.
+     */
+    public function __construct( string|array ...$params, ) {
+        $this->params = \is_array( $params[0] ) ? $params[0] : $params;
+    }
+
+    /**
+     * Resolve the parameters.
+     *
+     * @template T of object
+     * @param  Can_Handle<T> $h The handler.
+     * @return array<mixed>
+     */
+    public function resolve( Can_Handle $h ) {
+        $params  = \array_diff( $this->params, array( '!self.handler' ) );
+        $hook_it = $params !== $this->params;
+
+        $params = \array_map( '\DI\get', $params );
+
+        if ( $hook_it ) {
+            $params[] = \DI\value( $h );
+        }
+
+        return $params;
+    }
+}

src/Invoker.php

@@ -280,7 +280,7 @@ protected function queue_methods( Can_Handle $handler ): static {
                 function () use ( $handler ) {
                     $this->init_handler( $handler );
                 },
-                0,
+                -1,
                 0,
             );
         }