Create a service adapter for drush.services.yml

src/Boot/DrupalBoot8.php

@@ -20,6 +20,7 @@
 use Symfony\Component\HttpFoundation\Response;
 use Consolidation\AnnotatedCommand\CommandFileDiscovery;
 use Robo\Robo;
+use Drush\Runtime\ServiceInstantiator;
 
 class DrupalBoot8 extends DrupalBoot implements AutoloaderAwareInterface
 {
@@ -247,13 +248,22 @@ public function bootstrapDrupalFull(BootstrapManager $manager): void
     public function addDrupalModuleDrushCommands($manager): void
     {
         $application = Drush::getApplication();
+        $drushContainer = Drush::getContainer();
+
+        $this->logger->debug(dt("Loading drupal module drush commands & etc.", []));
 
         // We have to get the service command list from the container, because
         // it is constructed in an indirect way during the container initialization.
         // The upshot is that the list of console commands is not available
         // until after $kernel->boot() is called.
         $container = \Drupal::getContainer();
 
+        // Drush services adapter
+        $drushServiceFiles = $this->kernel->getDrushServiceFiles();
+        $serviceInstantiator = new ServiceInstantiator($container, $drushContainer);
+        $serviceInstantiator->loadServiceFiles($drushServiceFiles);
+        $drushCommandHandlers = $serviceInstantiator->taggedServices('drush.command');
+
         // Find the containerless commands, generators and command info alterers
         $bootstrapCommandClasses = $application->bootstrapCommandClasses();
         $commandInfoAlterers = [];
@@ -309,7 +319,7 @@ public function addDrupalModuleDrushCommands($manager): void
                 // of double-instantiating Drush service commands, if anyone decided
                 // to put those in the same namespace (\Drupal\modulename\Drush\Commands)
                 if ($this->hasStaticCreateFactory($class)) {
-                    $commandHandler = $class::create($container);
+                    $commandHandler = $class::create($container, $drushContainer);
                 }
             } catch (\Exception $e) {
             }
@@ -321,6 +331,10 @@ public function addDrupalModuleDrushCommands($manager): void
                 Robo::register($application, $commandHandler);
             }
         }
+        foreach ($drushCommandHandlers as $commandHandler) {
+            $manager->inflect($commandHandler);
+            Robo::register($application, $commandHandler);
+        }
     }
 
     protected function hasStaticCreateFactory($class)

src/Drupal/DrupalKernelTrait.php

@@ -17,6 +17,13 @@ trait DrupalKernelTrait
 {
     /** @var ServiceModifierInterface[] */
     protected $serviceModifiers = [];
+    protected $serviceFinder;
+    protected $drushServiceYamls = [];
+
+    public function getDrushServiceFiles()
+    {
+        return $this->drushServiceYamls;
+    }
 
     /**
      * Add a service modifier to the container builder.
@@ -209,7 +216,11 @@ protected function findAppropriateServicesFile($module, $services, $dir)
     protected function addDrushServiceProvider($serviceProviderName, $serviceYmlPath = '')
     {
         if (($serviceYmlPath !== null) && file_exists($serviceYmlPath)) {
-            $this->serviceYamls['app'][$serviceProviderName] = $serviceYmlPath;
+            // Keep our own list of service files
+            $this->drushServiceYamls[$serviceProviderName] = $serviceYmlPath;
+            // This is how we used to add our drush.services.yml file
+            // to the Drush service container. This is no longer necessary.
+            //$this->serviceYamls['app'][$serviceProviderName] = $serviceYmlPath;
         }
     }
 }

src/Runtime/DrushServiceFinder.php

@@ -0,0 +1,24 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drush\Runtime;
+
+use Drush\Log\Logger;
+use League\Container\Container;
+use Drush\Drush;
+use Symfony\Component\Console\Application;
+use Composer\Autoload\ClassLoader;
+use League\Container\ContainerInterface;
+use Drush\Command\DrushCommandInfoAlterer;
+
+use Psr\Container\ContainerInterface;
+use League\Container\Container as DrushContainer;
+
+/**
+ * Find drush.services.yml files.
+ */
+class DrushServiceFinder
+{
+
+}

src/Runtime/ServiceInstantiator.php

@@ -0,0 +1,204 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Drush\Runtime;
+
+use Drush\Log\Logger;
+use League\Container\Container;
+use Drush\Drush;
+use Symfony\Component\Console\Application;
+use Composer\Autoload\ClassLoader;
+use Drush\Command\DrushCommandInfoAlterer;
+
+use Psr\Container\ContainerInterface;
+use League\Container\Container as DrushContainer;
+use Symfony\Component\Yaml\Yaml;
+use Robo\Robo;
+
+/**
+ * Use Dependency Injection Container to instantiate services.
+ */
+class ServiceInstantiator
+{
+    protected ContainerInterface $drushServicesContainer;
+    protected array $tags = [];
+
+    public function __construct(protected ContainerInterface $container, protected ContainerInterface $drushContainer)
+    {
+        $this->drushServicesContainer = new DrushContainer();
+    }
+
+    public function loadServiceFiles(array $serviceFiles)
+    {
+        foreach ($serviceFiles as $serviceFile) {
+            $serviceFileContents = '';
+            $serviceFileData = [];
+
+            if(file_exists($serviceFile)) {
+                $serviceFileContents = file_get_contents($serviceFile);
+            }
+            if (!empty($serviceFileContents)) {
+                $serviceFileData = Yaml::parse($serviceFileContents);
+            }
+
+            if (isset($serviceFileData['services'])) {
+                $this->instantiateServices($serviceFileData['services']);
+            }
+        }
+    }
+
+    /**
+     * Given a drush.services.yml file (parsed into an array),
+     * instantiate all of the services referenced therein, and
+     * cache them in our dynamic service container.
+     */
+    public function instantiateServices(array $services)
+    {
+        foreach ($services as $serviceName => $info) {
+            $service = $this->create(
+                $info['class'],
+                $info['arguments'] ?? [],
+                $info['calls'] ?? []
+            );
+
+            Robo::addShared($this->drushServicesContainer, $serviceName, $service);
+
+            // If `tags` to contains an item with `name: drush.command`,
+            // then we should do something special with it
+
+            if (isset($info['tags'])) {
+                foreach ($info['tags'] as $tag) {
+                    if (isset($tag['name'])) {
+                        $this->tags[$tag['name']][$serviceName] = $service;
+                    }
+                }
+            }
+        }
+    }
+
+    public function taggedServices($tagName)
+    {
+        return $this->tags[$tagName] ?? [];
+    }
+
+    /**
+     * Create one named service.
+     */
+    public function create($class, array $arguments, array $calls)
+    {
+        $instance = $this->instantiateObject($class, $arguments);
+        foreach ($calls as $callInfo) {
+            $this->call($instance, $callInfo[0], $callInfo[1]);
+        }
+        return $instance;
+    }
+
+    /**
+     * Instantiate an object with the given arguments.
+     * Arguments are first looked up from the Drupal container
+     * or from our dynamic service container if they begin
+     * with an `@`. Items from the Drush container may be
+     * retreived by prepending the Drush service name with `*`.
+     */
+    public function instantiateObject($class, array $arguments)
+    {
+        $refl = new \ReflectionClass($class);
+        return $refl->newInstanceArgs($this->resolveArguments($arguments));
+    }
+
+    /**
+     * Call a method of an object with the provided arguments.
+     * Arguments are resolved against the container first.
+     */
+    public function call($object, $method, array $arguments)
+    {
+        $resolved = $this->resolveArguments($arguments);
+        if ($this->atLeastOneValue($resolved)) {
+            call_user_func_array([$object, $method], $resolved);
+        }
+    }
+
+    /**
+     * Resolve arguments against our containers. Arguments that
+     * do not map to one of our containers are returned unchanged.
+     */
+    protected function resolveArguments(array $arguments)
+    {
+        return array_map([$this, 'resolveArgument'], $arguments);
+    }
+
+    /**
+     * Look up one argument in the appropriate container, or
+     * return it as-is.
+     */
+    protected function resolveArgument($arg)
+    {
+        if (!is_string($arg)) {
+            return $arg;
+        }
+
+        if ($arg[0] == '@') {
+            // Check to see if a previous drush.services.yml instantiated
+            // this service; return any service found.
+            $result = $this->resolveFromContainer($this->drushServicesContainer, substr($arg, 1), false);
+            if ($result) {
+                return $result;
+            }
+
+            // If the service is not found in the dynamic container
+            return $this->resolveFromContainer($this->container, substr($arg, 1));
+        }
+
+        // Use '*' instead of '@' to pull from the Drush container.
+        if ($arg[0] == '*') {
+            return $this->resolveFromContainer($this->drushContainer, substr($arg, 1));
+        }
+
+        return $arg;
+    }
+
+    /**
+     * Look up in the provided container; throw an exception if
+     * not found, unless the service name begins with `?` (e.g.
+     * `@?drupal.service` or `*?drush.service`).
+     */
+    protected function resolveFromContainer($container, string $arg, bool $checkRequired = true)
+    {
+        [$required, $arg] = $this->isRequired($arg);
+
+        // Exit early if the container does not have the service
+        if (!$container->has($arg)) {
+            if ($checkRequired && $required) {
+                throw new \Exception("Big badda boom! This should be the same thing that the Drupal / Symfony DI container throws.");
+            }
+
+            return null;
+        }
+
+        return $container->get($arg);
+    }
+
+    /**
+     * Check to see if the provided argument begins with a `?`;
+     * those that do not are required.
+     */
+    protected function isRequired(string $arg)
+    {
+        if ($arg[0] == '?') {
+            return [false, substr($arg, 1)];
+        }
+
+        return [true, $arg];        
+    }
+
+    protected function atLeastOneValue($args)
+    {
+        foreach ($args as $arg) {
+            if ($arg) {
+                return true;
+            }
+        }
+        return false;
+    }
+}