wip

Author: cosmastech

src/Illuminate/Container/Attributes/Bind.php

@@ -3,15 +3,42 @@
 namespace Illuminate\Container\Attributes;
 
 use Attribute;
+use InvalidArgumentException;
 
-#[Attribute(Attribute::TARGET_CLASS)]
+#[Attribute(Attribute::TARGET_CLASS | Attribute::IS_REPEATABLE)]
 class Bind
 {
     /**
-     * @param  class-string  $concrete  The concrete class to bind to.
+     * The concrete class to bind to.
+     *
+     * @var class-string
+     */
+    public string $concrete;
+
+    /**
+     * Only use the bindings in this environment.
+     *
+     * @var array<int, string>
+     */
+    public array $environments = [];
+
+    /**
+     * @param  class-string  $concrete
+     * @param  array<int, string>|string  $environments
+     *
+     * @throws \InvalidArgumentException
      */
     public function __construct(
-        public string $concrete,
+        string $concrete,
+        string|array $environments = ['*'],
     ) {
+        $environments = is_array($environments) ? $environments : [$environments];
+
+        if ($environments === []) {
+            throw new InvalidArgumentException('The environment property must be set and cannot be empty.');
+        }
+
+        $this->concrete = $concrete;
+        $this->environments = $environments;
     }
 }

src/Illuminate/Container/Container.php

@@ -186,6 +186,13 @@ class Container implements ArrayAccess, ContainerContract
      */
     protected $checkedForBindings = [];
 
+    /**
+     * The callback used to determine the Container's environment.
+     *
+     * @var (callable(array<int, string>|string): bool|string)|null
+     */
+    protected $environmentResolver = null;
+
     /**
      * Define a contextual binding.
      *
@@ -998,7 +1005,22 @@ protected function getConcrete($abstract)
      */
     protected function getConcreteBindingFromAttributes($abstract, $reflectedAttributes)
     {
-        $this->bind($abstract, $reflectedAttributes[0]->newInstance()->concrete);
+        $concrete = null;
+
+        foreach($reflectedAttributes as $reflectedAttribute) {
+            $instance = $reflectedAttribute->newInstance();
+            if ($instance->environments === ['*'] || $this->getEnvironment($instance->environments)) {
+                $concrete = $instance->concrete;
+
+                break;
+            }
+        }
+
+        if ($concrete === null) {
+            return $abstract;
+        }
+
+        $this->bind($abstract, $concrete);
 
         return $this->bindings[$abstract]['concrete'];
     }
@@ -1605,6 +1627,27 @@ protected function getExtenders($abstract)
         return $this->extenders[$this->getAlias($abstract)] ?? [];
     }
 
+    /**
+     * @param  (callable(array<int, string>): bool)|null  $callback
+     */
+    public function resolveEnvironmentUsing(?callable $callback)
+    {
+        $this->environmentResolver = $callback;
+    }
+
+    /**
+     * Get the environment for the Container.
+     *
+     * @param  array<int, string>|string  $environments
+     * @return ($environments is array ? bool : string)
+     */
+    public function getEnvironment($environments)
+    {
+        return $this->environmentResolver === null
+            ? false
+            : call_user_func($this->environmentResolver, $environments);
+    }
+
     /**
      * Remove all of the extender callbacks for a given type.
      *
@@ -1674,6 +1717,7 @@ public function flush()
         $this->abstractAliases = [];
         $this->scopedInstances = [];
         $this->checkedForBindings = [];
+        $this->environmentResolver = null;
     }
 
     /**

src/Illuminate/Foundation/Bootstrap/LoadConfiguration.php

@@ -43,6 +43,7 @@ public function bootstrap(Application $app)
         // values that were loaded. We will pass a callback which will be used to get
         // the environment in a web context where an "--env" switch is not present.
         $app->detectEnvironment(fn () => $config->get('app.env', 'production'));
+        $app->resolveEnvironmentUsing($app->environment(...));
 
         date_default_timezone_set($config->get('app.timezone', 'UTC'));
 

tests/Container/ContainerTest.php

@@ -756,11 +756,17 @@ public function testContainerSingletonAttribute()
     public function testContainerScopedAttribute()
     {
         $container = new Container;
+        $container->resolveEnvironmentUsing(fn ($arr) => $arr === 'test');
         $firstInstantiation = $container->get(ContainerScopedAttribute::class);
         $secondInstantiation = $container->get(ContainerScopedAttribute::class);
 
         $this->assertSame($firstInstantiation, $secondInstantiation);
 
+        // With a different environment
+        $container->resolveEnvironmentUsing(fn ($arr) => $arr === 'test2');
+        $thirdInstantiation = $container->get(ContainerScopedAttribute::class);
+        $this->assertSame($firstInstantiation, $thirdInstantiation);
+
         $container->forgetScopedInstances();
 
         $thirdInstantiation = $container->get(ContainerScopedAttribute::class);
@@ -770,6 +776,7 @@ public function testContainerScopedAttribute()
     public function testBindInterfaceToSingleton()
     {
         $container = new Container;
+        $container->resolveEnvironmentUsing(fn ($arr) => true);
         $firstInstantiation = $container->get(ContainerBindSingletonTestInterface::class);
         $secondInstantiation = $container->get(ContainerBindSingletonTestInterface::class);
 
@@ -960,12 +967,13 @@ class ContainerScopedAttribute
 {
 }
 
-#[Bind(ContainerSingletonAttribute::class)]
+#[Bind(ContainerSingletonAttribute::class, environments: ['foo', 'bar'])]
 interface ContainerBindSingletonTestInterface
 {
 }
 
-#[Bind(ContainerScopedAttribute::class)]
+#[Bind(ContainerScopedAttribute::class, environments: ['test'])]
+#[Bind(ContainerScopedAttribute::class, environments: ['test2'])]
 interface ContainerBindScopedTestInterface
 {
 }