Support output formatter wordwraping.

README.md

@@ -163,6 +163,10 @@ It is also possible to add InputInterface or OutputInterface parameters to any a
 
 ## API Usage
 
+If you would like to use Annotated Commands to build a commandline tool, it is recommended that you use [Robo as a framework](http://robo.li/framework.md), as it will set up all of the various command classes for you. If you would like to integrate Annotated Commands into some other framework, see the sections below.
+
+### Set up Command Factory and Instantiate Commands
+
 To use annotated commands in an application, pass an instance of your command class in to AnnotatedCommandFactory::createCommandsFromClass(). The result will be a list of Commands that may be added to your application.
 ```php
 $myCommandClassInstance = new MyCommandClass();
@@ -182,6 +186,8 @@ Note that the `setFormatterManager()` operation is optional; omit this if not us
 
 A CommandInfoAltererInterface can be added via AnnotatedCommandFactory::addCommandInfoAlterer(); it will be given the opportunity to adjust every CommandInfo object parsed from a command file prior to the creation of commands.
 
+### Command File Discovery
+
 A discovery class, CommandFileDiscovery, is also provided to help find command files on the filesystem. Usage is as follows:
 ```php
 $discovery = new CommandFileDiscovery();
@@ -199,6 +205,20 @@ $myCommandFiles = $discovery->discover(['\Ns1' => $path1, '\Ns2' => $path2]);
 ```
 As a shortcut for the above, the method `discoverNamespaced()` will take the last directory name of each path, and append it to the base namespace provided. This matches the conventions used by Drupal modules, for example.
 
+### Configuring Output Formatts (e.g. to enable wordwrap)
+
+The Output Formatters project supports automatic formatting of tabular output. In order for wordwrapping to work correctly, the terminal width must be passed in to the Output Formatters handlers via `FormatterOptions::setWidth()`.
+
+In the Annotated Commands project, this is done via dependency injection. If a `PrepareFormatter` object is passed to `CommandProcessor::addPrepareFormatter()`, then it will be given an opportunity to set properties on the `FormatterOptions` when it is created.
+
+A `PrepareTerminalWidthOption` class is provided to use the Symfony Application class to fetch the terminal width, and provide it to the FormatterOptions. It is injected as follows:
+```php
+$terminalWidthOption = new PrepareTerminalWidthOption();
+$terminalWidthOption->setApplication($application);
+$commandFactory->commandProcessor()->addPrepareFormatter($terminalWidthOption);
+```
+To provide greater control over the width used, create your own `PrepareTerminalWidthOption` subclass, and adjust the width as needed.
+
 ## Other Callbacks
 
 In addition to the hooks provided by the hook manager, there are additional callbacks available to alter the way the annotated command library operates.

composer.json

@@ -20,7 +20,7 @@
     },
     "require": {
         "php": ">=5.4.0",
-        "consolidation/output-formatters": "~2|~3",
+        "consolidation/output-formatters": "^3.1",
         "psr/log": "~1",
         "symfony/console": "^2.8|~3",
         "symfony/event-dispatcher": "^2.5|~3",

src/CommandProcessor.php

@@ -9,6 +9,7 @@
 use Consolidation\OutputFormatters\FormatterManager;
 use Consolidation\OutputFormatters\Options\FormatterOptions;
 use Consolidation\AnnotatedCommand\Hooks\HookManager;
+use Consolidation\AnnotatedCommand\Options\PrepareFormatter;
 
 /**
  * Process a command, including hooks and other callbacks.
@@ -24,6 +25,8 @@ class CommandProcessor
     protected $formatterManager;
     /** var callable */
     protected $displayErrorFunction;
+    /** var PrepareFormatterOptions[] */
+    protected $prepareOptionsList = [];
 
     public function __construct(HookManager $hookManager)
     {
@@ -39,6 +42,11 @@ public function hookManager()
         return $this->hookManager;
     }
 
+    public function addPrepareFormatter(PrepareFormatter $preparer)
+    {
+        $this->prepareOptionsList[] = $preparer;
+    }
+
     public function setFormatterManager(FormatterManager $formatterManager)
     {
         $this->formatterManager = $formatterManager;
@@ -236,9 +244,8 @@ protected function chooseOutputStream(OutputInterface $output, $status)
      */
     protected function writeUsingFormatter(OutputInterface $output, $structuredOutput, CommandData $commandData)
     {
-        $options = $commandData->input()->getOptions();
-        $format = $this->getFormat($options);
-        $formatterOptions = new FormatterOptions($commandData->annotationData()->getArrayCopy(), $options);
+        $format = $this->getFormat($commandData->input()->getOptions());
+        $formatterOptions = $this->createFormatterOptions($commandData);
         $this->formatterManager->write(
             $output,
             $format,
@@ -248,6 +255,21 @@ protected function writeUsingFormatter(OutputInterface $output, $structuredOutpu
         return 0;
     }
 
+    /**
+     * Create a FormatterOptions object for use in writing the formatted output.
+     * @param CommandData $commandData
+     * @return FormatterOptions
+     */
+    protected function createFormatterOptions($commandData)
+    {
+        $options = $commandData->input()->getOptions();
+        $formatterOptions = new FormatterOptions($commandData->annotationData()->getArrayCopy(), $options);
+        foreach ($this->prepareOptionsList as $preparer) {
+            $preparer->prepare($commandData, $formatterOptions);
+        }
+        return $formatterOptions;
+    }
+
     /**
      * Description
      * @param OutputInterface $output

src/Options/PrepareFormatter.php

@@ -0,0 +1,10 @@
+<?php
+namespace Consolidation\AnnotatedCommand\Options;
+
+use Consolidation\AnnotatedCommand\CommandData;
+use Consolidation\OutputFormatters\Options\FormatterOptions;
+
+interface PrepareFormatter
+{
+    public function prepare(CommandData $commandData, FormatterOptions $options);
+}

src/Options/PrepareTerminalWidthOption.php

@@ -0,0 +1,69 @@
+<?php
+namespace Consolidation\AnnotatedCommand\Options;
+
+use Symfony\Component\Console\Application;
+use Consolidation\AnnotatedCommand\CommandData;
+use Consolidation\OutputFormatters\Options\FormatterOptions;
+
+class PrepareTerminalWidthOption implements PrepareFormatter
+{
+    /** var Application */
+    protected $application;
+
+    /** var int */
+    protected $defaultWidth;
+
+    /** var int */
+    protected $maxWidth = PHP_INT_MAX;
+
+    /** var int */
+    protected $minWidth = 0;
+
+    public function __construct($defaultWidth = 0)
+    {
+        $this->defaultWidth = $defaultWidth;
+    }
+
+    public function setApplication(Application $application)
+    {
+        $this->application = $application;
+    }
+
+    public function prepare(CommandData $commandData, FormatterOptions $options)
+    {
+        $width = $this->getTerminalWidth();
+        if (!$width) {
+            $width = $this->defaultWidth;
+        }
+
+        // Enforce minimum and maximum widths
+        $width = min($width, $this->getMaxWidth($commandData));
+        $width = max($width, $this->getMinWidth($commandData));
+
+        $options->setWidth($width);
+    }
+
+    protected function getTerminalWidth()
+    {
+        if (!$this->application) {
+            return 0;
+        }
+
+        $dimensions = $this->application->getTerminalDimensions();
+        if ($dimensions[0] == null) {
+            return 0;
+        }
+
+        return $dimensions[0];
+    }
+
+    protected function getMaxWidth(CommandData $commandData)
+    {
+        return $this->maxWidth;
+    }
+
+    protected function getMinWidth(CommandData $commandData)
+    {
+        return $this->minWidth;
+    }
+}

tests/src/ApplicationWithTerminalWidth.php

@@ -0,0 +1,26 @@
+<?php
+namespace Consolidation\TestUtils;
+
+use Symfony\Component\Console\Application;
+
+class ApplicationWithTerminalWidth extends Application
+{
+    protected $width = 0;
+    protected $height = 0;
+
+    public function __construct($name = 'UNKNOWN', $version = 'UNKNOWN')
+    {
+        parent::__construct($name, $version);
+    }
+
+    public function setWidthAndHeight($width, $height)
+    {
+        $this->width = $width;
+        $this->height = $height;
+    }
+
+    public function getTerminalDimensions()
+    {
+        return [ $this->width, $this->height ];
+    }
+}

tests/src/alpha/AlphaCommandFile.php

@@ -93,6 +93,27 @@ public function exampleTable($options = ['format' => 'table', 'fields' => ''])
         return new RowsOfFields($outputData);
     }
 
+    /**
+     * Test word wrapping
+     *
+     * @command example:wrap
+     * @field-labels
+     *   first: First
+     *   second: Second
+     *
+     * @return \Consolidation\OutputFormatters\StructuredData\RowsOfFields
+     */
+    public function exampleWrap()
+    {
+        $data = [
+            [
+                'first' => 'This is a really long cell that contains a lot of data. When it is rendered, it should be wrapped across multiple lines.',
+                'second' => 'This is the second column of the same table. It is also very long, and should be wrapped across multiple lines, just like the first column.',
+            ]
+        ];
+        return new RowsOfFields($data);
+    }
+
     /**
      * @hook option example:table
      */