Change the task compiler logic to allow resolving of environment variables.

Author: veewee

resources/config/services.yml

@@ -9,8 +9,6 @@ services:
     GrumPHP\Event\Dispatcher\Bridge\SymfonyEventDispatcher:
         arguments:
             - '@Symfony\Component\EventDispatcher\EventDispatcher'
-    GrumPHP\Configuration\Resolver\TaskConfigResolver:
-        synthetic: true
 
     GrumPHP\Event\Dispatcher\EventDispatcherInterface: '@GrumPHP\Event\Dispatcher\Bridge\SymfonyEventDispatcher'
 

src/Collection/TasksCollection.php

@@ -47,6 +47,13 @@ public function filterByTaskNames(array $tasks): self
         });
     }
 
+    public function filterEnabled(): self
+    {
+        return $this->filter(
+            static fn(TaskInterface $task): bool => $task->getConfig()->getMetadata()->isEnabled()
+        );
+    }
+
     /**
      * This method sorts the tasks by highest priority first.
      */

src/Configuration/Compiler/TaskCompilerPass.php

@@ -8,9 +8,6 @@
 use GrumPHP\Configuration\Configurator\TaskConfigurator;
 use GrumPHP\Configuration\Resolver\TaskConfigResolver;
 use GrumPHP\Exception\TaskConfigResolverException;
-use GrumPHP\Task\Config\LazyTaskConfig;
-use GrumPHP\Task\Config\Metadata;
-use GrumPHP\Task\Config\TaskConfig;
 use Symfony\Component\DependencyInjection\Compiler\CompilerPassInterface;
 use Symfony\Component\DependencyInjection\ContainerBuilder;
 use Symfony\Component\DependencyInjection\Definition;
@@ -30,7 +27,7 @@ public function process(ContainerBuilder $container): void
         $availableTasks = $this->fetchAvailableTasksInfo($container);
         $configuredTasks = $container->getParameter('tasks');
         $configuredTasks = is_array($configuredTasks) ? $configuredTasks : [];
-        $taskConfigResolver = $this->buildTaskConfigResolver($availableTasks);
+        $taskResolverConfig = [];
 
         // Configure tasks
         foreach ($configuredTasks as $taskName => $config) {
@@ -46,30 +43,25 @@ public function process(ContainerBuilder $container): void
             ['id' => $taskId, 'class' => $taskClass, 'info' => $taskInfo] = $currentTaskService;
             $configuredTaskKey = $taskId.'.'.$taskName.'.configured';
 
-            // Setup metadata:
-            $metadata = new Metadata(array_merge(
-                ['priority' => $taskInfo['priority']],
-                $metadataConfig
-            ));
-
-            // Disabled tasks can be skipped
-            // This allows to conditionally disable tasks through parameters or by an extension.
-            if (!$metadata->isEnabled()) {
-                continue;
-            }
+            // Store the configuration in the task resolver config:
+            // This way, the resolver knows how to build all task related configurations.
+            // It is stores in a pain array so that environment variables get resolved and can be used in the configuration.
+            $taskResolverConfig[$taskName] = [
+                'class' => $taskClass,
+                'config' => [
+                    ...$taskConfig,
+                    'metadata' => [
+                        'priority' => $taskInfo['priority'],
+                        ...$taskConfig['metadata'] ?? [],
+                    ],
+                ],
+            ];
 
             // Configure task:
             $taskBuilder = new Definition($taskClass, [
                 new Reference($taskId),
-                new LazyTaskConfig(
-                    function () use ($taskName, $taskConfigResolver, $currentTaskName, $taskConfig, $metadata) {
-                        return new TaskConfig(
-                            $taskName,
-                            $taskConfigResolver->resolve($currentTaskName, $taskConfig),
-                            $metadata
-                        );
-                    }
-                )
+                new Reference(TaskConfigResolver::class),
+                $taskName,
             ]);
             $taskBuilder->setFactory([new Reference(TaskConfigurator::class), '__invoke']);
             $taskBuilder->addTag('configured.task');
@@ -80,7 +72,10 @@ function () use ($taskName, $taskConfigResolver, $currentTaskName, $taskConfig,
         }
 
         // Register available and configured tasks for easy data usage in the application:
-        $container->set(TaskConfigResolver::class, $taskConfigResolver);
+        $container->setDefinition(TaskConfigResolver::class, new Definition(
+            TaskConfigResolver::class,
+            [$taskResolverConfig]
+        ));
         $container->setParameter('grumphp.tasks.configured', array_keys($configuredTasks));
     }
 
@@ -127,16 +122,4 @@ private function fetchAvailableTasksInfo(ContainerBuilder $container): array
 
         return $map;
     }
-
-    private function buildTaskConfigResolver(array $availableTasks): TaskConfigResolver
-    {
-        return new TaskConfigResolver(
-            array_map(
-                function ($availableTask): string {
-                    return (string) ($availableTask['class'] ?? '');
-                },
-                $availableTasks
-            )
-        );
-    }
 }

src/Configuration/Configurator/TaskConfigurator.php

@@ -4,13 +4,18 @@
 
 namespace GrumPHP\Configuration\Configurator;
 
-use GrumPHP\Task\Config\TaskConfigInterface;
+use GrumPHP\Configuration\Resolver\TaskConfigResolver;
 use GrumPHP\Task\TaskInterface;
 
 class TaskConfigurator
 {
-    public function __invoke(TaskInterface $task, TaskConfigInterface $config): TaskInterface
-    {
-        return $task->withConfig($config);
+    public function __invoke(
+        TaskInterface $task,
+        TaskConfigResolver $configResolver,
+        string $taskName
+    ): TaskInterface {
+        return $task->withConfig(
+            $configResolver->resolve($taskName)
+        );
     }
 }

src/Configuration/Resolver/TaskConfigResolver.php

@@ -6,12 +6,20 @@
 
 use GrumPHP\Exception\TaskConfigResolverException;
 use GrumPHP\Task\Config\ConfigOptionsResolver;
+use GrumPHP\Task\Config\Metadata;
+use GrumPHP\Task\Config\TaskConfig;
 use GrumPHP\Task\TaskInterface;
 
-class TaskConfigResolver
+/**
+ * @psalm-type TaskConfiguration = array{
+ *     class: string,
+ *     config: array
+ * }
+ */
+final class TaskConfigResolver
 {
     /**
-     * @var array<string, string>
+     * @var array<string, TaskConfiguration>
      */
     private $taskMap;
 
@@ -28,14 +36,21 @@ public function listAvailableTaskNames(): array
         return array_keys($this->taskMap);
     }
 
-    public function resolve(string $taskName, array $config): array
+    public function resolve(string $taskName): TaskConfig
     {
         $resolver = $this->fetchByName($taskName);
 
-        // Make sure metadata is never a part of the task configuration
+        $config = $this->taskMap[$taskName]['config'] ?? [];
+        $metadata = new Metadata($config['metadata'] ?? []);
+
         unset($config['metadata']);
+        $resolvedConfig = $resolver->resolve($config);
 
-        return $resolver->resolve($config);
+        return new TaskConfig(
+            $taskName,
+            $resolvedConfig,
+            $metadata
+        );
     }
 
     public function fetchByName(string $taskName): ConfigOptionsResolver
@@ -44,7 +59,7 @@ public function fetchByName(string $taskName): ConfigOptionsResolver
             throw TaskConfigResolverException::unknownTask($taskName);
         }
 
-        $class = $this->taskMap[$taskName];
+        $class = $this->taskMap[$taskName]['class'];
         if (!class_exists($class) || !is_subclass_of($class, TaskInterface::class)) {
             throw TaskConfigResolverException::unknownClass($class);
         }

src/Runner/TaskRunner.php

@@ -28,7 +28,7 @@ public function __construct(TasksCollection $tasks, MiddlewareStack $middleware)
     public function run(TaskRunnerContext $runnerContext): TaskResultCollection
     {
         return $this->middleware->handle(
-            $runnerContext->withTasks($this->tasks)
+            $runnerContext->withTasks($this->tasks->filterEnabled())
         );
     }
 }