Task assembly

.travis.yml

@@ -1,7 +1,6 @@
 language: php
 
 php:
-  - 5.4
   - 5.5
   - 5.6
   - 7.0

RoboFile.php

@@ -346,4 +346,46 @@ public function trySuccess()
     {
         $result = $this->taskExec('pwd')->run();
     }
+
+    public function tryDeprecated()
+    {
+        $result = (new \Robo\Task\Base\Exec('pwd'))->run();
+    }
+
+    public function tryTmpDir()
+    {
+        // Set up a collection to add tasks to
+        $collection = $this->collection();
+
+        // Get a temporary directory to work in. Note that we get a
+        // name back, but the directory is not created until the task
+        // runs.  This technically is not thread-safe, but we create
+        // a random name, so it is unlikely to conflict.
+        $tmpPath = $this->taskTmpDir()
+            ->addToCollection($collection)
+            ->getPath();
+
+        // We can create the temporary directory early by running
+        // 'runWithoutCompletion()'.  n.b. if we called 'run()' at
+        // this point, the collection's 'complete()' method would be
+        // called, and the temporary directory would be deleted.
+        $mktmpResult = $collection->runWithoutCompletion();
+
+        if (is_dir($tmpPath)) {
+            $this->say("Created a temporary directory at $tmpPath");
+        }
+        else {
+            $this->say("Requested a temporary directory at $tmpPath, but it was not created");
+        }
+
+        // Run the task collection
+        $result = $collection->run();
+
+        if (is_dir($tmpPath)) {
+            $this->say("The temporary directory at $tmpPath was not cleaned up after the collection completed.");
+        }
+        else {
+            $this->say("The temporary directory at $tmpPath was automatically deleted.");
+        }
+    }
 }

composer.json

@@ -15,13 +15,13 @@
     },
     "bin":["robo"],
     "require": {
-        "php": ">=5.4.0",
+        "php": ">=5.5.0",
         "consolidation/log": "~0",
         "symfony/finder": "~2.5|~3.0",
         "symfony/console": "~2.5|~3.0",
         "symfony/process": "~2.5|~3.0",
         "symfony/filesystem": "~2.5|~3.0",
-        "symfony/dependency-injection": "~2.5|~3.0"
+        "league/container": "~2.1"
     },
     "require-dev": {
         "patchwork/jsqueeze": "~1.0",

src/Application.php

@@ -7,27 +7,51 @@
 use Symfony\Component\Console\Input\InputInterface;
 use Symfony\Component\Console\Input\InputOption;
 
-class Application extends  SymfonyApplication
+use League\Container\ContainerAwareInterface;
+use League\Container\ContainerAwareTrait;
+
+class Application extends SymfonyApplication implements ContainerAwareInterface
 {
+    use ContainerAwareTrait;
+
+    public function __construct($name, $version)
+    {
+        parent::__construct($name, $version);
+
+        $this->getDefinition()->addOption(
+            new InputOption('--simulate', null, InputOption::VALUE_NONE, 'Run in simulated mode (show what would have happened).')
+        );
+    }
 
     public function addCommandsFromClass($className, $passThrough = null)
     {
+        $container = $this->getContainer();
         $roboTasks = new $className;
+        if ($roboTasks instanceof ContainerAwareInterface) {
+            $roboTasks->setContainer($container);
+        }
 
-        $commandNames = array_filter(get_class_methods($className), function($m) {
-            return !in_array($m, ['__construct']);
+        // Ignore special functions, such as __construct() and __call(), and
+        // accessor methods such as getFoo() and setFoo(), while allowing
+        // set or setup.
+        $commandNames = array_filter(get_class_methods($className), function ($m) {
+            return !preg_match('#^(_|get[A-Z]|set[A-Z])#', $m);
         });
 
         foreach ($commandNames as $commandName) {
             $command = $this->createCommand(new TaskInfo($className, $commandName));
-            $command->setCode(function(InputInterface $input) use ($roboTasks, $commandName, $passThrough) {
+            $command->setCode(function (InputInterface $input) use ($roboTasks, $commandName, $passThrough, $container) {
                 // get passthru args
                 $args = $input->getArguments();
                 array_shift($args);
                 if ($passThrough) {
                     $args[key(array_slice($args, -1, 1, TRUE))] = $passThrough;
                 }
                 $args[] = $input->getOptions();
+                // Need a better way to handle global options
+                // Also, this is not necessarily the best place to do this
+                Config::setGlobalOptions($input);
+                $container->setSimulated(Config::isSimulated());
 
                 $res = call_user_func_array([$roboTasks, $commandName], $args);
                 if (is_int($res)) exit($res);
@@ -97,4 +121,4 @@ public function addInitRoboFileCommand($roboFile, $roboClass)
         });
         $this->add($createRoboFile);
     }
-}
+}

src/Collection/Collection.php

@@ -4,6 +4,9 @@
 use Robo\Result;
 use Robo\Contract\TaskInterface;
 
+use League\Container\ContainerAwareInterface;
+use League\Container\ContainerAwareTrait;
+
 /**
  * Group tasks into a collection that run together. Supports
  * rollback operations for handling error conditions.
@@ -30,8 +33,10 @@
  * ?>
  * ```
  */
-class Collection implements TaskInterface
+class Collection implements TaskInterface, ContainerAwareInterface
 {
+    use ContainerAwareTrait;
+
     // Unnamed tasks are assigned an arbitrary numeric index
     // in the task list. Any numeric value may be used, but the
     // UNNAMEDTASK constant is recommended for clarity.
@@ -274,7 +279,8 @@ protected function addTask($name, $task)
     {
         // Wrap the task as necessary.
         $task = $this->wrapTask($task);
-        $this->addToTaskStack($name, new TaskWrapper($this, $task));
+        $task = $this->getContainer()->get('completionWrapper', [$this, $task]);
+        $this->addToTaskStack($name, $task);
         return $this;
     }
 

src/Collection/TaskWrapper.php → src/Collection/CompletionWrapper.php

@@ -6,45 +6,46 @@
 use Robo\Contract\TaskInterface;
 use Robo\Contract\RollbackInterface;
 use Robo\Contract\CompletionInterface;
+use Robo\Contract\WrappedTaskInterface;
 
 /**
  * Creates a task wrapper that will manage rollback and collection
  * management to a task when it runs.  Tasks are automatically
- * wrapped in a TaskWrapper when added to a task collection.
+ * wrapped in a CompletionWrapper when added to a task collection.
  *
- * Clients may need to wrap their task in a TaskWrapper if it
+ * Clients may need to wrap their task in a CompletionWrapper if it
  * creates temporary objects.  This is usually best done via
  * Temporary::wrap().
  *
  * @see Robo\Task\FileSystem\loadTasks::taskTmpDir
  */
-class TaskWrapper extends BaseTask
+class CompletionWrapper extends BaseTask implements WrappedTaskInterface
 {
     private $collection;
     private $task;
     private $rollbackTask;
 
     /**
-     * Create a TaskWrapper.
+     * Create a CompletionWrapper.
      *
-     * Temporary tasks are always wrapped in a TaskWrapper, as are
+     * Temporary tasks are always wrapped in a CompletionWrapper, as are
      * any tasks that are added to a collection.  If a temporary task
      * is added to a collection, then it is first unwrapped from its
-     * TaskWrapper (via its getTask method), and then added to a
-     * new TaskWrapper for the collection it is added to.
+     * CompletionWrapper (via its original() method), and then added to a
+     * new CompletionWrapper for the collection it is added to.
      *
-     * In this way, when the TaskWrapper is finally executed, the
+     * In this way, when the CompletionWrapper is finally executed, the
      * task's rollback and completion handlers will be registered on
      * whichever collection it was registered on.
      */
     public function __construct(Collection $collection, TaskInterface $task, TaskInterface $rollbackTask = null)
     {
         $this->collection = $collection;
-        $this->task = ($task instanceof self) ? $task->getTask() : $task;
+        $this->task = ($task instanceof WrappedTaskInterface) ? $task->original() : $task;
         $this->rollbackTask = $rollbackTask;
     }
 
-    public function getTask()
+    public function original()
     {
         return $this->task;
     }