[2.0] Added Symfony Components dependencies

lib/vendor/Symfony/Components/Console/Command/HelpCommand.php

+<?php
+
+namespace Symfony\Components\Console\Command;
+
+use Symfony\Components\Console\Input\InputArgument;
+use Symfony\Components\Console\Input\InputOption;
+use Symfony\Components\Console\Input\InputInterface;
+use Symfony\Components\Console\Output\OutputInterface;
+use Symfony\Components\Console\Output\Output;
+use Symfony\Components\Console\Command\Command;
+
+/*
+ * This file is part of the symfony framework.
+ *
+ * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+/**
+ * HelpCommand displays the help for a given command.
+ *
+ * @package    symfony
+ * @subpackage console
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ */
+class HelpCommand extends Command
+{
+  protected $command;
+
+  /**
+   * @see Command
+   */
+  protected function configure()
+  {
+    $this->ignoreValidationErrors = true;
+
+    $this
+      ->setDefinition(array(
+        new InputArgument('command_name', InputArgument::OPTIONAL, 'The command name', 'help'),
+        new InputOption('xml', null, InputOption::PARAMETER_NONE, 'To output help as XML'),
+      ))
+      ->setName('help')
+      ->setAliases(array('?'))
+      ->setDescription('Displays help for a command')
+      ->setHelp(<<<EOF
+The <info>help</info> command displays help for a given command:
+
+  <info>./symfony help test:all</info>
+
+You can also output the help as XML by using the <comment>--xml</comment> option:
+
+  <info>./symfony help --xml test:all</info>
+EOF
+      );
+  }
+
+  public function setCommand(Command $command)
+  {
+    $this->command = $command;
+  }
+
+  /**
+   * @see Command
+   */
+  protected function execute(InputInterface $input, OutputInterface $output)
+  {
+    if (null === $this->command)
+    {
+      $this->command = $this->application->getCommand($input->getArgument('command_name'));
+    }
+
+    if ($input->getOption('xml'))
+    {
+      $output->writeln($this->command->asXml(), Output::OUTPUT_RAW);
+    }
+    else
+    {
+      $output->writeln($this->command->asText());
+    }
+  }
+}

lib/vendor/Symfony/Components/Console/Command/ListCommand.php

+<?php
+
+namespace Symfony\Components\Console\Command;
+
+use Symfony\Components\Console\Input\InputArgument;
+use Symfony\Components\Console\Input\InputOption;
+use Symfony\Components\Console\Input\InputInterface;
+use Symfony\Components\Console\Output\OutputInterface;
+use Symfony\Components\Console\Output\Output;
+use Symfony\Components\Console\Command\Command;
+
+/*
+ * This file is part of the symfony framework.
+ *
+ * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+/**
+ * ListCommand displays the list of all available commands for the application.
+ *
+ * @package    symfony
+ * @subpackage console
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ */
+class ListCommand extends Command
+{
+  /**
+   * @see Command
+   */
+  protected function configure()
+  {
+    $this
+      ->setDefinition(array(
+        new InputArgument('namespace', InputArgument::OPTIONAL, 'The namespace name'),
+        new InputOption('xml', null, InputOption::PARAMETER_NONE, 'To output help as XML'),
+      ))
+      ->setName('list')
+      ->setDescription('Lists commands')
+      ->setHelp(<<<EOF
+The <info>list</info> command lists all commands:
+
+  <info>./symfony list</info>
+
+You can also display the commands for a specific namespace:
+
+  <info>./symfony list test</info>
+
+You can also output the information as XML by using the <comment>--xml</comment> option:
+
+  <info>./symfony list --xml</info>
+EOF
+      );
+  }
+
+  /**
+   * @see Command
+   */
+  protected function execute(InputInterface $input, OutputInterface $output)
+  {
+    if ($input->getOption('xml'))
+    {
+      $output->writeln($this->application->asXml($input->getArgument('namespace')), Output::OUTPUT_RAW);
+    }
+    else
+    {
+      $output->writeln($this->application->asText($input->getArgument('namespace')));
+    }
+  }
+}

lib/vendor/Symfony/Components/Console/Helper/DialogHelper.php

+<?php
+
+namespace Symfony\Components\Console\Helper;
+
+use Symfony\Components\Console\Output\OutputInterface;
+
+/*
+ * This file is part of the symfony framework.
+ *
+ * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+/**
+ * The Dialog class provides helpers to interact with the user.
+ *
+ * @package    symfony
+ * @subpackage console
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ */
+class DialogHelper extends Helper
+{
+  /**
+   * Asks a question to the user.
+   *
+   * @param OutputInterface $output
+   * @param string|array    $question The question to ask
+   * @param string          $default  The default answer if none is given by the user
+   *
+   * @param string The user answer
+   */
+  public function ask(OutputInterface $output, $question, $default = null)
+  {
+    // @codeCoverageIgnoreStart
+    $output->writeln($question);
+
+    $ret = trim(fgets(STDIN));
+
+    return $ret ? $ret : $default;
+    // @codeCoverageIgnoreEnd
+  }
+
+  /**
+   * Asks a confirmation to the user.
+   *
+   * The question will be asked until the user answer by nothing, yes, or no.
+   *
+   * @param OutputInterface $output
+   * @param string|array    $question The question to ask
+   * @param Boolean         $default  The default answer if the user enters nothing
+   *
+   * @param Boolean true if the user has confirmed, false otherwise
+   */
+  public function askConfirmation(OutputInterface $output, $question, $default = true)
+  {
+    // @codeCoverageIgnoreStart
+    $answer = 'z';
+    while ($answer && !in_array(strtolower($answer[0]), array('y', 'n')))
+    {
+      $answer = $this->ask($output, $question);
+    }
+
+    if (false === $default)
+    {
+      return $answer && 'y' == strtolower($answer[0]);
+    }
+    else
+    {
+      return !$answer || 'y' == strtolower($answer[0]);
+    }
+    // @codeCoverageIgnoreEnd
+  }
+
+  /**
+   * Asks for a value and validates the response.
+   *
+   * @param OutputInterface $output
+   * @param string|array    $question
+   * @param Closure         $validator
+   * @param integer         $attempts Max number of times to ask before giving up (false by default, which means infinite)
+   *
+   * @return mixed
+   */
+  public function askAndValidate(OutputInterface $output, $question, \Closure $validator, $attempts = false)
+  {
+    // @codeCoverageIgnoreStart
+    $error = null;
+    while (false === $attempts || $attempts--)
+    {
+      if (null !== $error)
+      {
+        $output->writeln($this->getHelperSet()->get('formatter')->formatBlock($error->getMessage(), 'error'));
+      }
+
+      $value = $this->ask($output, $question, null);
+
+      try
+      {
+        return $validator($value);
+      }
+      catch (\Exception $error)
+      {
+      }
+    }
+
+    throw $error;
+    // @codeCoverageIgnoreEnd
+  }
+
+  /**
+   * Returns the helper's canonical name
+   */
+  public function getName()
+  {
+    return 'dialog';
+  }
+}

lib/vendor/Symfony/Components/Console/Helper/FormatterHelper.php

+<?php
+
+namespace Symfony\Components\Console\Helper;
+
+/*
+ * This file is part of the symfony framework.
+ *
+ * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+/**
+ * The Formatter class provides helpers to format messages.
+ *
+ * @package    symfony
+ * @subpackage console
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ */
+class FormatterHelper extends Helper
+{
+  /**
+   * Formats a message within a section.
+   *
+   * @param string  $section The section name
+   * @param string  $message The message
+   * @param string  $style   The style to apply to the section
+   */
+  public function formatSection($section, $message, $style = 'info')
+  {
+    return sprintf("<%s>[%s]</%s> %s", $style, $section, $style, $message);
+  }
+
+  /**
+   * Formats a message as a block of text.
+   *
+   * @param string|array $messages The message to write in the block
+   * @param string       $style    The style to apply to the whole block
+   * @param Boolean      $large    Whether to return a large block
+   *
+   * @return string The formatter message
+   */
+  public function formatBlock($messages, $style, $large = false)
+  {
+    if (!is_array($messages))
+    {
+      $messages = array($messages);
+    }
+
+    $len = 0;
+    $lines = array();
+    foreach ($messages as $message)
+    {
+      $lines[] = sprintf($large ? '  %s  ' : ' %s ', $message);
+      $len = max($this->strlen($message) + ($large ? 4 : 2), $len);
+    }
+
+    $messages = $large ? array(str_repeat(' ', $len)) : array();
+    foreach ($lines as $line)
+    {
+      $messages[] = $line.str_repeat(' ', $len - $this->strlen($line));
+    }
+    if ($large)
+    {
+      $messages[] = str_repeat(' ', $len);
+    }
+
+    foreach ($messages as &$message)
+    {
+      $message = sprintf('<%s>%s</%s>', $style, $message, $style);
+    }
+
+    return implode("\n", $messages);
+  }
+
+  protected function strlen($string)
+  {
+    return function_exists('mb_strlen') ? mb_strlen($string) : strlen($string);
+  }
+
+  /**
+   * Returns the helper's canonical name
+   */
+  public function getName()
+  {
+    return 'formatter';
+  }
+}

lib/vendor/Symfony/Components/Console/Helper/Helper.php

+<?php
+
+namespace Symfony\Components\Console\Helper;
+
+/*
+ * This file is part of the symfony framework.
+ *
+ * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+/**
+ * Helper is the base class for all helper classes.
+ *
+ * @package    symfony
+ * @subpackage console
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ */
+abstract class Helper implements HelperInterface
+{
+  protected
+    $helperSet = null;
+
+  /**
+   * Sets the helper set associated with this helper.
+   *
+   * @param HelperSet $helperSet A HelperSet instance
+   */
+  public function setHelperSet(HelperSet $helperSet = null)
+  {
+    $this->helperSet = $helperSet;
+  }
+
+  /**
+   * Gets the helper set associated with this helper.
+   *
+   * @return HelperSet A HelperSet instance
+   */
+  public function getHelperSet()
+  {
+    return $this->helperSet;
+  }
+}

lib/vendor/Symfony/Components/Console/Helper/HelperInterface.php

+<?php
+
+namespace Symfony\Components\Console\Helper;
+
+/*
+ * This file is part of the symfony framework.
+ *
+ * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+/**
+ * HelperInterface is the interface all helpers must implement.
+ *
+ * @package    symfony
+ * @subpackage console
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ */
+interface HelperInterface
+{
+  /**
+   * Sets the helper set associated with this helper.
+   *
+   * @param HelperSet $helperSet A HelperSet instance
+   */
+  function setHelperSet(HelperSet $helperSet = null);
+
+  /**
+   * Gets the helper set associated with this helper.
+   *
+   * @return HelperSet A HelperSet instance
+   */
+  function getHelperSet();
+
+  /**
+   * Returns the canonical name of this helper.
+   *
+   * @return string The canonical name
+   */
+  function getName();
+}

lib/vendor/Symfony/Components/Console/Helper/HelperSet.php

+<?php
+
+namespace Symfony\Components\Console\Helper;
+
+use Symfony\Components\Console\Command\Command;
+
+/*
+ * This file is part of the symfony framework.
+ *
+ * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+/**
+ * HelperSet represents a set of helpers to be used with a command.
+ *
+ * @package    symfony
+ * @subpackage console
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ */
+class HelperSet
+{
+  protected
+    $helpers = array(),
+    $command = null;
+
+  public function __construct(array $helpers = array())
+  {
+    foreach ($helpers as $alias => $helper)
+    {
+      $this->set($helper, is_int($alias) ? null : $alias);
+    }
+  }
+
+  /**
+   * Sets a helper.
+   *
+   * @param HelperInterface $value The helper instance
+   * @param string                    $alias An alias
+   */
+  public function set(HelperInterface $helper, $alias = null)
+  {
+    $this->helpers[$helper->getName()] = $helper;
+    if (null !== $alias)
+    {
+      $this->helpers[$alias] = $helper;
+    }
+
+    $helper->setHelperSet($this);
+  }
+
+  /**
+   * Returns true if the helper if defined.
+   *
+   * @param string  $name The helper name
+   *
+   * @return Boolean true if the helper is defined, false otherwise
+   */
+  public function has($name)
+  {
+    return isset($this->helpers[$name]);
+  }
+
+  /**
+   * Gets a helper value.
+   *
+   * @param string $name The helper name
+   *
+   * @return HelperInterface The helper instance
+   *
+   * @throws \InvalidArgumentException if the helper is not defined
+   */
+  public function get($name)
+  {
+    if (!$this->has($name))
+    {
+      throw new \InvalidArgumentException(sprintf('The helper "%s" is not defined.', $name));
+    }
+
+    return $this->helpers[$name];
+  }
+
+  /**
+   * Sets the command associated with this helper set.
+   *
+   * @param Command $command A Command instance
+   */
+  public function setCommand(Command $command = null)
+  {
+    $this->command = $command;
+  }
+
+  /**
+   * Gets the command associated with this helper set.
+   *
+   * @return Command A Command instance
+   */
+  public function getCommand()
+  {
+    return $this->command;
+  }
+}

lib/vendor/Symfony/Components/Console/Input/ArgvInput.php

+<?php
+
+namespace Symfony\Components\Console\Input;
+
+/*
+ * This file is part of the symfony framework.
+ *
+ * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+/**
+ * ArgvInput represents an input coming from the CLI arguments.
+ *
+ * Usage:
+ *
+ *     $input = new ArgvInput();
+ *
+ * By default, the `$_SERVER['argv']` array is used for the input values.
+ *
+ * This can be overriden by explicitly passing the input values in the constructor:
+ *
+ *     $input = new ArgvInput($_SERVER['argv']);
+ *
+ * If you pass it yourself, don't forget that the first element of the array
+ * is the name of the running program.
+ *
+ * When passing an argument to the constructor, be sure that it respects
+ * the same rules as the argv one. It's almost always better to use the
+ * `StringInput` when you want to provide your own input.
+ *
+ * @package    symfony
+ * @subpackage console
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * @see http://www.gnu.org/software/libc/manual/html_node/Argument-Syntax.html
+ * @see http://www.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap12.html#tag_12_02
+ */
+class ArgvInput extends Input
+{
+  protected $tokens;
+  protected $parsed;
+
+  /**
+   * Constructor.
+   *
+   * @param array      $argv An array of parameters from the CLI (in the argv format)
+   * @param InputDefinition $definition A InputDefinition instance
+   */
+  public function __construct(array $argv = null, InputDefinition $definition = null)
+  {
+    if (null === $argv)
+    {
+      $argv = $_SERVER['argv'];
+    }
+
+    // strip the program name
+    array_shift($argv);
+
+    $this->tokens = $argv;
+
+    parent::__construct($definition);
+  }
+
+  /**
+   * Processes command line arguments.
+   */
+  protected function parse()
+  {
+    $this->parsed = $this->tokens;
+    while ($token = array_shift($this->parsed))
+    {
+      if ('--' === substr($token, 0, 2))
+      {
+        $this->parseLongOption($token);
+      }
+      elseif ('-' === $token[0])
+      {
+        $this->parseShortOption($token);
+      }
+      else
+      {
+        $this->parseArgument($token);
+      }
+    }
+  }
+
+  /**
+   * Parses a short option.
+   *
+   * @param string $token The current token.
+   */
+  protected function parseShortOption($token)
+  {
+    $name = substr($token, 1);
+
+    if (strlen($name) > 1)
+    {
+      if ($this->definition->hasShortcut($name[0]) && $this->definition->getOptionForShortcut($name[0])->acceptParameter())
+      {
+        // an option with a value (with no space)
+        $this->addShortOption($name[0], substr($name, 1));
+      }
+      else
+      {
+        $this->parseShortOptionSet($name);
+      }
+    }
+    else
+    {
+      $this->addShortOption($name, null);
+    }
+  }
+
+  /**
+   * Parses a short option set.
+   *
+   * @param string $token The current token
+   */
+  protected function parseShortOptionSet($name)
+  {
+    $len = strlen($name);
+    for ($i = 0; $i < $len; $i++)
+    {
+      if (!$this->definition->hasShortcut($name[$i]))
+      {
+        throw new \RuntimeException(sprintf('The "-%s" option does not exist.', $name[$i]));
+      }
+
+      $option = $this->definition->getOptionForShortcut($name[$i]);
+      if ($option->acceptParameter())
+      {
+        $this->addLongOption($option->getName(), $i === $len - 1 ? null : substr($name, $i + 1));
+
+        break;
+      }
+      else
+      {
+        $this->addLongOption($option->getName(), true);
+      }
+    }
+  }
+
+  /**
+   * Parses a long option.
+   *
+   * @param string $token The current token
+   */
+  protected function parseLongOption($token)
+  {
+    $name = substr($token, 2);
+
+    if (false !== $pos = strpos($name, '='))
+    {
+      $this->addLongOption(substr($name, 0, $pos), substr($name, $pos + 1));
+    }
+    else
+    {
+      $this->addLongOption($name, null);
+    }
+  }
+
+  /**
+   * Parses an argument.
+   *
+   * @param string $token The current token
+   */
+  protected function parseArgument($token)
+  {
+    if (!$this->definition->hasArgument(count($this->arguments)))
+    {
+      throw new \RuntimeException('Too many arguments.');
+    }
+
+    $this->arguments[$this->definition->getArgument(count($this->arguments))->getName()] = $token;
+  }
+
+  /**
+   * Adds a short option value.
+   *
+   * @param string $shortcut The short option key
+   * @param mixed  $value    The value for the option
+   */
+  protected function addShortOption($shortcut, $value)
+  {
+    if (!$this->definition->hasShortcut($shortcut))
+    {
+      throw new \RuntimeException(sprintf('The "-%s" option does not exist.', $shortcut));
+    }
+
+    $this->addLongOption($this->definition->getOptionForShortcut($shortcut)->getName(), $value);
+  }
+
+  /**
+   * Adds a long option value.
+   *
+   * @param string $name  The long option key
+   * @param mixed  $value The value for the option
+   */
+  protected function addLongOption($name, $value)
+  {
+    if (!$this->definition->hasOption($name))
+    {
+      throw new \RuntimeException(sprintf('The "--%s" option does not exist.', $name));
+    }
+
+    $option = $this->definition->getOption($name);
+
+    if (null === $value && $option->acceptParameter())
+    {
+      // if option accepts an optional or mandatory argument
+      // let's see if there is one provided
+      $next = array_shift($this->parsed);
+      if ('-' !== $next[0])
+      {
+        $value = $next;
+      }
+      else
+      {
+        array_unshift($this->parsed, $next);
+      }
+    }
+
+    if (null === $value)
+    {
+      if ($option->isParameterRequired())
+      {
+        throw new \RuntimeException(sprintf('The "--%s" option requires a value.', $name));
+      }
+
+      $value = $option->isParameterOptional() ? $option->getDefault() : true;
+    }
+
+    $this->options[$name] = $value;
+  }
+
+  /**
+   * Returns the first argument from the raw parameters (not parsed).
+   *
+   * @return string The value of the first argument or null otherwise
+   */
+  public function getFirstArgument()
+  {
+    foreach ($this->tokens as $token)
+    {
+      if ($token && '-' === $token[0])
+      {
+        continue;
+      }
+
+      return $token;
+    }
+  }
+
+  /**
+   * Returns true if the raw parameters (not parsed) contains a value.
+   *
+   * This method is to be used to introspect the input parameters
+   * before it has been validated. It must be used carefully.
+   *
+   * @param string|array $values The value(s) to look for in the raw parameters (can be an array)
+   *
+   * @return Boolean true if the value is contained in the raw parameters
+   */
+  public function hasParameterOption($values)
+  {
+    if (!is_array($values))
+    {
+      $values = array($values);
+    }
+
+    foreach ($this->tokens as $v)
+    {
+      if (in_array($v, $values))
+      {
+        return true;
+      }
+    }
+
+    return false;
+  }
+}

lib/vendor/Symfony/Components/Console/Input/ArrayInput.php

+<?php
+
+namespace Symfony\Components\Console\Input;
+
+/*
+ * This file is part of the symfony framework.
+ *
+ * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+/**
+ * ArrayInput represents an input provided as an array.
+ *
+ * Usage:
+ *
+ *     $input = new ArrayInput(array('name' => 'foo', '--bar' => 'foobar'));
+ *
+ * @package    symfony
+ * @subpackage console
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ */
+class ArrayInput extends Input
+{
+  protected $parameters;
+
+  /**
+   * Constructor.
+   *
+   * @param array      $param An array of parameters
+   * @param InputDefinition $definition A InputDefinition instance
+   */
+  public function __construct(array $parameters, InputDefinition $definition = null)
+  {
+    $this->parameters = $parameters;
+
+    parent::__construct($definition);
+  }
+
+  /**
+   * Returns the first argument from the raw parameters (not parsed).
+   *
+   * @return string The value of the first argument or null otherwise
+   */
+  public function getFirstArgument()
+  {
+    foreach ($this->parameters as $key => $value)
+    {
+      if ($key && '-' === $key[0])
+      {
+        continue;
+      }
+
+      return $value;
+    }
+  }
+
+  /**
+   * Returns true if the raw parameters (not parsed) contains a value.
+   *
+   * This method is to be used to introspect the input parameters
+   * before it has been validated. It must be used carefully.
+   *
+   * @param string|array $value The values to look for in the raw parameters (can be an array)
+   *
+   * @return Boolean true if the value is contained in the raw parameters
+   */
+  public function hasParameterOption($values)
+  {
+    if (!is_array($values))
+    {
+      $values = array($values);
+    }
+
+    foreach ($this->parameters as $k => $v)
+    {
+      if (!is_int($k))
+      {
+        $v = $k;
+      }
+
+      if (in_array($v, $values))
+      {
+        return true;
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Processes command line arguments.
+   */
+  protected function parse()
+  {
+    foreach ($this->parameters as $key => $value)
+    {
+      if ('--' === substr($key, 0, 2))
+      {
+        $this->addLongOption(substr($key, 2), $value);
+      }
+      elseif ('-' === $key[0])
+      {
+        $this->addShortOption(substr($key, 1), $value);
+      }
+      else
+      {
+        $this->addArgument($key, $value);
+      }
+    }
+  }
+
+  /**
+   * Adds a short option value.
+   *
+   * @param string $shortcut The short option key
+   * @param mixed  $value    The value for the option
+   */
+  protected function addShortOption($shortcut, $value)
+  {
+    if (!$this->definition->hasShortcut($shortcut))
+    {
+      throw new \RuntimeException(sprintf('The "-%s" option does not exist.', $shortcut));
+    }
+
+    $this->addLongOption($this->definition->getOptionForShortcut($shortcut)->getName(), $value);
+  }
+
+  /**
+   * Adds a long option value.
+   *
+   * @param string $name  The long option key
+   * @param mixed  $value The value for the option
+   */
+  protected function addLongOption($name, $value)
+  {
+    if (!$this->definition->hasOption($name))
+    {
+      throw new \RuntimeException(sprintf('The "--%s" option does not exist.', $name));
+    }
+
+    $option = $this->definition->getOption($name);
+
+    if (null === $value)
+    {
+      if ($option->isParameterRequired())
+      {
+        throw new \RuntimeException(sprintf('The "--%s" option requires a value.', $name));
+      }
+
+      $value = $option->isParameterOptional() ? $option->getDefault() : true;
+    }
+
+    $this->options[$name] = $value;
+  }
+
+  /**
+   * Adds an argument value.
+   *
+   * @param string $name  The argument name
+   * @param mixed  $value The value for the argument
+   */
+  protected function addArgument($name, $value)
+  {
+    if (!$this->definition->hasArgument($name))
+    {
+      throw new \RuntimeException(sprintf('The "%s" argument does not exist.', $name));
+    }
+
+    $this->arguments[$name] = $value;
+  }
+}

lib/vendor/Symfony/Components/Console/Input/Input.php

+<?php
+
+namespace Symfony\Components\Console\Input;
+
+/*
+ * This file is part of the symfony framework.
+ *
+ * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+/**
+ * Input is the base class for all concrete Input classes.
+ *
+ * Three concrete classes are provided by default:
+ *
+ *  * `ArgvInput`: The input comes from the CLI arguments (argv)
+ *  * `StringInput`: The input is provided as a string
+ *  * `ArrayInput`: The input is provided as an array
+ *
+ * @package    symfony
+ * @subpackage console
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ */
+abstract class Input implements InputInterface
+{
+  protected $definition;
+  protected $options;
+  protected $arguments;
+  protected $interactive = true;
+
+  /**
+   * Constructor.
+   *
+   * @param InputDefinition $definition A InputDefinition instance
+   */
+  public function __construct(InputDefinition $definition = null)
+  {
+    if (null === $definition)
+    {
+      $this->definition = new InputDefinition();
+    }
+    else
+    {
+      $this->bind($definition);
+      $this->validate();
+    }
+  }
+
+  /**
+   * Binds the current Input instance with the given arguments and options.
+   *
+   * @param InputDefinition $definition A InputDefinition instance
+   */
+  public function bind(InputDefinition $definition)
+  {
+    $this->arguments = array();
+    $this->options = array();
+    $this->definition = $definition;
+
+    $this->parse();
+  }
+
+  /**
+   * Processes command line arguments.
+   */
+  abstract protected function parse();
+
+  public function validate()
+  {
+    if (count($this->arguments) < $this->definition->getArgumentRequiredCount())
+    {
+      throw new \RuntimeException('Not enough arguments.');
+    }
+  }
+
+  public function isInteractive()
+  {
+    return $this->interactive;
+  }
+
+  public function setInteractive($interactive)
+  {
+    $this->interactive = (Boolean) $interactive;
+  }
+
+  /**
+   * Returns the argument values.
+   *
+   * @return array An array of argument values
+   */
+  public function getArguments()
+  {
+    return array_merge($this->definition->getArgumentDefaults(), $this->arguments);
+  }
+
+  /**
+   * Returns the argument value for a given argument name.
+   *
+   * @param string $name The argument name
+   *
+   * @return mixed The argument value
+   */
+  public function getArgument($name)
+  {
+    if (!$this->definition->hasArgument($name))
+    {
+      throw new \InvalidArgumentException(sprintf('The "%s" argument does not exist.', $name));
+    }
+
+    return isset($this->arguments[$name]) ? $this->arguments[$name] : $this->definition->getArgument($name)->getDefault();
+  }
+
+  /**
+   * Sets an argument value by name.
+   *
+   * @param string $name  The argument name
+   * @param string $value The argument value
+   */
+  public function setArgument($name, $value)
+  {
+    if (!$this->definition->hasArgument($name))
+    {
+      throw new \InvalidArgumentException(sprintf('The "%s" argument does not exist.', $name));
+    }
+
+    $this->arguments[$name] = $value;
+  }
+
+  /**
+   * Returns true if an InputArgument object exists by name or position.
+   *
+   * @param string|integer $name The InputArgument name or position
+   *
+   * @return Boolean true if the InputArgument object exists, false otherwise
+   */
+  public function hasArgument($name)
+  {
+    return $this->definition->hasArgument($name);
+  }
+
+  /**
+   * Returns the options values.
+   *
+   * @return array An array of option values
+   */
+  public function getOptions()
+  {
+    return array_merge($this->definition->getOptionDefaults(), $this->options);
+  }
+
+  /**
+   * Returns the option value for a given option name.
+   *
+   * @param string $name The option name
+   *
+   * @return mixed The option value
+   */
+  public function getOption($name)
+  {
+    if (!$this->definition->hasOption($name))
+    {
+      throw new \InvalidArgumentException(sprintf('The "%s" option does not exist.', $name));
+    }
+
+    return isset($this->options[$name]) ? $this->options[$name] : $this->definition->getOption($name)->getDefault();
+  }
+
+  /**
+   * Sets an option value by name.
+   *
+   * @param string $name  The option name
+   * @param string $value The option value
+   */
+  public function setOption($name, $value)
+  {
+    if (!$this->definition->hasOption($name))
+    {
+      throw new \InvalidArgumentException(sprintf('The "%s" option does not exist.', $name));
+    }
+
+    $this->options[$name] = $value;
+  }
+
+  /**
+   * Returns true if an InputOption object exists by name.
+   *
+   * @param string $name The InputOption name
+   *
+   * @return Boolean true if the InputOption object exists, false otherwise
+   */
+  public function hasOption($name)
+  {
+    return $this->definition->hasOption($name);
+  }
+}

lib/vendor/Symfony/Components/Console/Input/InputArgument.php

+<?php
+
+namespace Symfony\Components\Console\Input;
+
+/*
+ * This file is part of the symfony framework.
+ *
+ * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+/**
+ * Represents a command line argument.
+ *
+ * @package    symfony
+ * @subpackage console
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ */
+class InputArgument
+{
+  const REQUIRED = 1;
+  const OPTIONAL = 2;
+  const IS_ARRAY = 4;
+
+  protected $name;
+  protected $mode;
+  protected $default;
+  protected $description;
+
+  /**
+   * Constructor.
+   *
+   * @param string  $name        The argument name
+   * @param integer $mode        The argument mode: self::REQUIRED or self::OPTIONAL
+   * @param string  $description A description text
+   * @param mixed   $default     The default value (for self::OPTIONAL mode only)
+   */
+  public function __construct($name, $mode = null, $description = '', $default = null)
+  {
+    if (null === $mode)
+    {
+      $mode = self::OPTIONAL;
+    }
+    else if (is_string($mode) || $mode > 7)
+    {
+      throw new \InvalidArgumentException(sprintf('Argument mode "%s" is not valid.', $mode));
+    }
+
+    $this->name        = $name;
+    $this->mode        = $mode;
+    $this->description = $description;
+
+    $this->setDefault($default);
+  }
+
+  /**
+   * Returns the argument name.
+   *
+   * @return string The argument name
+   */
+  public function getName()
+  {
+    return $this->name;
+  }
+
+  /**
+   * Returns true if the argument is required.
+   *
+   * @return Boolean true if parameter mode is self::REQUIRED, false otherwise
+   */
+  public function isRequired()
+  {
+    return self::REQUIRED === (self::REQUIRED & $this->mode);
+  }
+
+  /**
+   * Returns true if the argument can take multiple values.
+   *
+   * @return Boolean true if mode is self::IS_ARRAY, false otherwise
+   */
+  public function isArray()
+  {
+    return self::IS_ARRAY === (self::IS_ARRAY & $this->mode);
+  }
+
+  /**
+   * Sets the default value.
+   *
+   * @param mixed $default The default value
+   */
+  public function setDefault($default = null)
+  {
+    if (self::REQUIRED === $this->mode && null !== $default)
+    {
+      throw new \LogicException('Cannot set a default value except for Parameter::OPTIONAL mode.');
+    }
+
+    if ($this->isArray())
+    {
+      if (null === $default)
+      {
+        $default = array();
+      }
+      else if (!is_array($default))
+      {
+        throw new \LogicException('A default value for an array argument must be an array.');
+      }
+    }
+
+    $this->default = $default;
+  }
+
+  /**
+   * Returns the default value.
+   *
+   * @return mixed The default value
+   */
+  public function getDefault()
+  {
+    return $this->default;
+  }
+
+  /**
+   * Returns the description text.
+   *
+   * @return string The description text
+   */
+  public function getDescription()
+  {
+    return $this->description;
+  }
+}

lib/vendor/Symfony/Components/Console/Input/InputInterface.php

+<?php
+
+namespace Symfony\Components\Console\Input;
+
+/*
+ * This file is part of the symfony framework.
+ *
+ * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+/**
+ * InputInterface is the interface implemented by all input classes.
+ *
+ * @package    symfony
+ * @subpackage console
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ */
+interface InputInterface
+{
+  /**
+   * Returns the first argument from the raw parameters (not parsed).
+   *
+   * @return string The value of the first argument or null otherwise
+   */
+  function getFirstArgument();
+
+  /**
+   * Returns true if the raw parameters (not parsed) contains a value.
+   *
+   * This method is to be used to introspect the input parameters
+   * before it has been validated. It must be used carefully.
+   *
+   * @param string $value The value to look for in the raw parameters
+   *
+   * @return Boolean true if the value is contained in the raw parameters
+   */
+  function hasParameterOption($value);
+
+  /**
+   * Binds the current Input instance with the given arguments and options.
+   *
+   * @param InputDefinition $definition A InputDefinition instance
+   */
+  function bind(InputDefinition $definition);
+
+  function validate();
+
+  function getArguments();
+
+  function getArgument($name);
+
+  function getOptions();
+
+  function getOption($name);
+}

lib/vendor/Symfony/Components/Console/Input/InputOption.php

+<?php
+
+namespace Symfony\Components\Console\Input;
+
+/*
+ * This file is part of the symfony framework.
+ *
+ * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+/**
+ * Represents a command line option.
+ *
+ * @package    symfony
+ * @subpackage console
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ */
+class InputOption
+{
+  const PARAMETER_NONE     = 1;
+  const PARAMETER_REQUIRED = 2;
+  const PARAMETER_OPTIONAL = 4;
+  const PARAMETER_IS_ARRAY = 8;
+
+  protected $name;
+  protected $shortcut;
+  protected $mode;
+  protected $default;
+  protected $description;
+
+  /**
+   * Constructor.
+   *
+   * @param string  $name        The option name
+   * @param string  $shortcut    The shortcut (can be null)
+   * @param integer $mode        The option mode: self::PARAMETER_REQUIRED, self::PARAMETER_NONE or self::PARAMETER_OPTIONAL
+   * @param string  $description A description text
+   * @param mixed   $default     The default value (must be null for self::PARAMETER_REQUIRED or self::PARAMETER_NONE)
+   */
+  public function __construct($name, $shortcut = null, $mode = null, $description = '', $default = null)
+  {
+    if ('--' === substr($name, 0, 2))
+    {
+      $name = substr($name, 2);
+    }
+
+    if (empty($shortcut))
+    {
+      $shortcut = null;
+    }
+
+    if (null !== $shortcut)
+    {
+      if ('-' === $shortcut[0])
+      {
+        $shortcut = substr($shortcut, 1);
+      }
+    }
+
+    if (null === $mode)
+    {
+      $mode = self::PARAMETER_NONE;
+    }
+    else if (!is_int($mode) || $mode > 15)
+    {
+      throw new \InvalidArgumentException(sprintf('Option mode "%s" is not valid.', $mode));
+    }
+
+    $this->name        = $name;
+    $this->shortcut    = $shortcut;
+    $this->mode        = $mode;
+    $this->description = $description;
+
+    if ($this->isArray() && !$this->acceptParameter())
+    {
+      throw new \InvalidArgumentException('Impossible to have an option mode PARAMETER_IS_ARRAY if the option does not accept a parameter.');
+    }
+
+    $this->setDefault($default);
+  }
+
+  /**
+   * Returns the shortcut.
+   *
+   * @return string The shortcut
+   */
+  public function getShortcut()
+  {
+    return $this->shortcut;
+  }
+
+  /**
+   * Returns the name.
+   *
+   * @return string The name
+   */
+  public function getName()
+  {
+    return $this->name;
+  }
+
+  /**
+   * Returns true if the option accept a parameter.
+   *
+   * @return Boolean true if parameter mode is not self::PARAMETER_NONE, false otherwise
+   */
+  public function acceptParameter()
+  {
+    return $this->isParameterRequired() || $this->isParameterOptional();
+  }
+
+  /**
+   * Returns true if the option requires a parameter.
+   *
+   * @return Boolean true if parameter mode is self::PARAMETER_REQUIRED, false otherwise
+   */
+  public function isParameterRequired()
+  {
+    return self::PARAMETER_REQUIRED === (self::PARAMETER_REQUIRED & $this->mode);
+  }
+
+  /**
+   * Returns true if the option takes an optional parameter.
+   *
+   * @return Boolean true if parameter mode is self::PARAMETER_OPTIONAL, false otherwise
+   */
+  public function isParameterOptional()
+  {
+    return self::PARAMETER_OPTIONAL === (self::PARAMETER_OPTIONAL & $this->mode);
+  }
+
+  /**
+   * Returns true if the option can take multiple values.
+   *
+   * @return Boolean true if mode is self::PARAMETER_IS_ARRAY, false otherwise
+   */
+  public function isArray()
+  {
+    return self::PARAMETER_IS_ARRAY === (self::PARAMETER_IS_ARRAY & $this->mode);
+  }
+
+  /**
+   * Sets the default value.
+   *
+   * @param mixed $default The default value
+   */
+  public function setDefault($default = null)
+  {
+    if (self::PARAMETER_NONE === (self::PARAMETER_NONE & $this->mode) && null !== $default)
+    {
+      throw new \LogicException('Cannot set a default value when using Option::PARAMETER_NONE mode.');
+    }
+
+    if ($this->isArray())
+    {
+      if (null === $default)
+      {
+        $default = array();
+      }
+      elseif (!is_array($default))
+      {
+        throw new \LogicException('A default value for an array option must be an array.');
+      }
+    }
+
+    $this->default = $this->acceptParameter() ? $default : false;
+  }
+
+  /**
+   * Returns the default value.
+   *
+   * @return mixed The default value
+   */
+  public function getDefault()
+  {
+    return $this->default;
+  }
+
+  /**
+   * Returns the description text.
+   *
+   * @return string The description text
+   */
+  public function getDescription()
+  {
+    return $this->description;
+  }
+}

lib/vendor/Symfony/Components/Console/Input/StringInput.php

+<?php
+
+namespace Symfony\Components\Console\Input;
+
+/*
+ * This file is part of the symfony framework.
+ *
+ * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+/**
+ * StringInput represents an input provided as a string.
+ *
+ * Usage:
+ *
+ *     $input = new StringInput('foo --bar="foobar"');
+ *
+ * @package    symfony
+ * @subpackage console
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ */
+class StringInput extends ArgvInput
+{
+  const REGEX_STRING = '([^ ]+?)(?: |(?<!\\\\)"|(?<!\\\\)\'|$)';
+  const REGEX_QUOTED_STRING = '(?:"([^"\\\\]*(?:\\\\.[^"\\\\]*)*)"|\'([^\'\\\\]*(?:\\\\.[^\'\\\\]*)*)\')';
+
+  /**
+   * Constructor.
+   *
+   * @param string     $input An array of parameters from the CLI (in the argv format)
+   * @param InputDefinition $definition A InputDefinition instance
+   */
+  public function __construct($input, InputDefinition $definition = null)
+  {
+    parent::__construct(array(), $definition);
+
+    $this->tokens = $this->tokenize($input);
+  }
+
+  protected function tokenize($input)
+  {
+    $input = preg_replace('/(\r\n|\r|\n|\t)/', ' ', $input);
+
+    $tokens = array();
+    $length = strlen($input);
+    $cursor = 0;
+    while ($cursor < $length)
+    {
+      if (preg_match('/\s+/A', $input, $match, null, $cursor))
+      {
+      }
+      elseif (preg_match('/([^="\' ]+?)(=?)('.self::REGEX_QUOTED_STRING.'+)/A', $input, $match, null, $cursor))
+      {
+        $tokens[] = $match[1].$match[2].stripcslashes(str_replace(array('"\'', '\'"', '\'\'', '""'), '', substr($match[3], 1, strlen($match[3]) - 2)));
+      }
+      elseif (preg_match('/'.self::REGEX_QUOTED_STRING.'/A', $input, $match, null, $cursor))
+      {
+        $tokens[] = stripcslashes(substr($match[0], 1, strlen($match[0]) - 2));
+      }
+      elseif (preg_match('/'.self::REGEX_STRING.'/A', $input, $match, null, $cursor))
+      {
+        $tokens[] = stripcslashes($match[1]);
+      }
+      else
+      {
+        // should never happen
+        // @codeCoverageIgnoreStart
+        throw new \InvalidArgumentException(sprintf('Unable to parse input near "... %s ..."', substr($input, $cursor, 10)));
+        // @codeCoverageIgnoreEnd
+      }
+
+      $cursor += strlen($match[0]);
+    }
+
+    return $tokens;
+  }
+}

lib/vendor/Symfony/Components/Console/Output/ConsoleOutput.php

+<?php
+
+namespace Symfony\Components\Console\Output;
+
+/*
+ * This file is part of the symfony framework.
+ *
+ * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+/**
+ * ConsoleOutput is the default class for all CLI output. It uses STDOUT.
+ *
+ * This class is a convenient wrapper around `StreamOutput`.
+ *
+ *     $output = new ConsoleOutput();
+ *
+ * This is equivalent to:
+ *
+ *     $output = new StreamOutput(fopen('php://stdout', 'w'));
+ *
+ * @package    symfony
+ * @subpackage console
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ */
+class ConsoleOutput extends StreamOutput
+{
+  /**
+   * Constructor.
+   *
+   * @param integer $verbosity The verbosity level (self::VERBOSITY_QUIET, self::VERBOSITY_NORMAL, self::VERBOSITY_VERBOSE)
+   * @param Boolean $decorated Whether to decorate messages or not (null for auto-guessing)
+   */
+  public function __construct($verbosity = self::VERBOSITY_NORMAL, $decorated = null)
+  {
+    parent::__construct(fopen('php://stdout', 'w'), $verbosity, $decorated);
+  }
+}

lib/vendor/Symfony/Components/Console/Output/NullOutput.php

+<?php
+
+namespace Symfony\Components\Console\Output;
+
+/*
+ * This file is part of the symfony framework.
+ *
+ * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+/**
+ * NullOutput suppresses all output.
+ *
+ *     $output = new NullOutput();
+ *
+ * @package    symfony
+ * @subpackage console
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ */
+class NullOutput extends Output
+{
+  /**
+   * Writes a message to the output.
+   *
+   * @param string $message A message to write to the output
+   * @param Boolean $newline Whether to add a newline or not
+   */
+  public function doWrite($message, $newline)
+  {
+  }
+}

lib/vendor/Symfony/Components/Console/Output/Output.php

+<?php
+
+namespace Symfony\Components\Console\Output;
+
+/*
+ * This file is part of the symfony framework.
+ *
+ * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+/**
+ * Base class for output classes.
+ *
+ * There is three level of verbosity:
+ *
+ *  * normal: no option passed (normal output - information)
+ *  * verbose: -v (more output - debug)
+ *  * quiet: -q (no output)
+ *
+ * @package    symfony
+ * @subpackage console
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ */
+abstract class Output implements OutputInterface
+{
+  const VERBOSITY_QUIET   = 0;
+  const VERBOSITY_NORMAL  = 1;
+  const VERBOSITY_VERBOSE = 2;
+
+  const OUTPUT_NORMAL = 0;
+  const OUTPUT_RAW = 1;
+  const OUTPUT_PLAIN = 2;
+
+  protected $verbosity;
+  protected $decorated;
+
+  static protected $styles = array(
+    'error'    => array('bg' => 'red', 'fg' => 'white'),
+    'info'     => array('fg' => 'green'),
+    'comment'  => array('fg' => 'yellow'),
+    'question' => array('bg' => 'cyan', 'fg' => 'black'),
+  );
+  static protected $options    = array('bold' => 1, 'underscore' => 4, 'blink' => 5, 'reverse' => 7, 'conceal' => 8);
+  static protected $foreground = array('black' => 30, 'red' => 31, 'green' => 32, 'yellow' => 33, 'blue' => 34, 'magenta' => 35, 'cyan' => 36, 'white' => 37);
+  static protected $background = array('black' => 40, 'red' => 41, 'green' => 42, 'yellow' => 43, 'blue' => 44, 'magenta' => 45, 'cyan' => 46, 'white' => 47);
+
+  /**
+   * Constructor.
+   *
+   * @param integer $verbosity The verbosity level (self::VERBOSITY_QUIET, self::VERBOSITY_NORMAL, self::VERBOSITY_VERBOSE)
+   * @param Boolean $decorated Whether to decorate messages or not (null for auto-guessing)
+   */
+  public function __construct($verbosity = self::VERBOSITY_NORMAL, $decorated = null)
+  {
+    $this->decorated = (Boolean) $decorated;
+    $this->verbosity = null === $verbosity ? self::VERBOSITY_NORMAL : $verbosity;
+  }
+
+  /**
+   * Sets a new style.
+   *
+   * @param string $name    The style name
+   * @param array  $options An array of options
+   */
+  static public function setStyle($name, $options = array())
+  {
+    static::$styles[strtolower($name)] = $options;
+  }
+
+  /**
+   * Sets the decorated flag.
+   *
+   * @param Boolean $decorated Whether to decorated the messages or not
+   */
+  public function setDecorated($decorated)
+  {
+    $this->decorated = (Boolean) $decorated;
+  }
+
+  /**
+   * Gets the decorated flag.
+   *
+   * @return Boolean true if the output will decorate messages, false otherwise
+   */
+  public function isDecorated()
+  {
+    return $this->decorated;
+  }
+
+  /**
+   * Sets the verbosity of the output.
+   *
+   * @param integer $level The level of verbosity
+   */
+  public function setVerbosity($level)
+  {
+    $this->verbosity = (int) $level;
+  }
+
+  /**
+   * Gets the current verbosity of the output.
+   *
+   * @return integer The current level of verbosity
+   */
+  public function getVerbosity()
+  {
+    return $this->verbosity;
+  }
+
+  /**
+   * Writes a message to the output and adds a newline at the end.
+   *
+   * @param string|array $messages The message as an array of lines of a single string
+   * @param integer      $type     The type of output
+   */
+  public function writeln($messages, $type = 0)
+  {
+    $this->write($messages, true, $type);
+  }
+
+  /**
+   * Writes a message to the output.
+   *
+   * @param string|array $messages The message as an array of lines of a single string
+   * @param Boolean      $newline  Whether to add a newline or not
+   * @param integer      $type     The type of output
+   */
+  public function write($messages, $newline = false, $type = 0)
+  {
+    if (self::VERBOSITY_QUIET === $this->verbosity)
+    {
+      return;
+    }
+
+    if (!is_array($messages))
+    {
+      $messages = array($messages);
+    }
+
+    foreach ($messages as $message)
+    {
+      switch ($type)
+      {
+        case Output::OUTPUT_NORMAL:
+          $message = $this->format($message);
+          break;
+        case Output::OUTPUT_RAW:
+          break;
+        case Output::OUTPUT_PLAIN:
+          $message = strip_tags($this->format($message));
+          break;
+        default:
+          throw new \InvalidArgumentException(sprintf('Unknown output type given (%s)', $type));
+      }
+
+      $this->doWrite($message, $newline);
+    }
+  }
+
+  /**
+   * Writes a message to the output.
+   *
+   * @param string  $message A message to write to the output
+   * @param Boolean $newline Whether to add a newline or not
+   */
+  abstract public function doWrite($message, $newline);
+
+  /**
+   * Formats a message according to the given styles.
+   *
+   * @param  string $message The message to style
+   *
+   * @return string The styled message
+   */
+  protected function format($message)
+  {
+    $message = preg_replace_callback('#<([a-z][a-z0-9\-_]+)>#i', array($this, 'replaceStartStyle'), $message);
+
+    return preg_replace_callback('#</([a-z][a-z0-9\-_]+)>#i', array($this, 'replaceEndStyle'), $message);
+  }
+
+  protected function replaceStartStyle($match)
+  {
+    if (!$this->decorated)
+    {
+      return '';
+    }
+
+    if (!isset(static::$styles[strtolower($match[1])]))
+    {
+      throw new \InvalidArgumentException(sprintf('Unknown style "%s".', $match[1]));
+    }
+
+    $parameters = static::$styles[strtolower($match[1])];
+    $codes = array();
+
+    if (isset($parameters['fg']))
+    {
+      $codes[] = static::$foreground[$parameters['fg']];
+    }
+
+    if (isset($parameters['bg']))
+    {
+      $codes[] = static::$background[$parameters['bg']];
+    }
+
+    foreach (static::$options as $option => $value)
+    {
+      if (isset($parameters[$option]) && $parameters[$option])
+      {
+        $codes[] = $value;
+      }
+    }
+
+    return "\033[".implode(';', $codes)."m";
+  }
+
+  protected function replaceEndStyle($match)
+  {
+    if (!$this->decorated)
+    {
+      return '';
+    }
+
+    return "\033[0m";
+  }
+}

lib/vendor/Symfony/Components/Console/Output/OutputInterface.php

+<?php
+
+namespace Symfony\Components\Console\Output;
+
+/*
+ * This file is part of the symfony framework.
+ *
+ * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+/**
+ * OutputInterface is the interface implemented by all Output classes.
+ *
+ * @package    symfony
+ * @subpackage console
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ */
+interface OutputInterface
+{
+  /**
+   * Writes a message to the output.
+   *
+   * @param string|array $messages The message as an array of lines of a single string
+   * @param integer      $type     The type of output
+   */
+  public function write($messages, $type = 0);
+
+  /**
+   * Sets the verbosity of the output.
+   *
+   * @param integer $level The level of verbosity
+   */
+  public function setVerbosity($level);
+
+  /**
+   * Sets the decorated flag.
+   *
+   * @param Boolean $decorated Whether to decorated the messages or not
+   */
+  public function setDecorated($decorated);
+}

lib/vendor/Symfony/Components/Console/Output/StreamOutput.php

+<?php
+
+namespace Symfony\Components\Console\Output;
+
+/*
+ * This file is part of the symfony framework.
+ *
+ * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+/**
+ * StreamOutput writes the output to a given stream.
+ *
+ * Usage:
+ *
+ * $output = new StreamOutput(fopen('php://stdout', 'w'));
+ *
+ * As `StreamOutput` can use any stream, you can also use a file:
+ *
+ * $output = new StreamOutput(fopen('/path/to/output.log', 'a', false));
+ *
+ * @package    symfony
+ * @subpackage console
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ */
+class StreamOutput extends Output
+{
+  protected $stream;
+
+  /**
+   * Constructor.
+   *
+   * @param mixed   $stream    A stream resource
+   * @param integer $verbosity The verbosity level (self::VERBOSITY_QUIET, self::VERBOSITY_NORMAL, self::VERBOSITY_VERBOSE)
+   * @param Boolean $decorated Whether to decorate messages or not (null for auto-guessing)
+   */
+  public function __construct($stream, $verbosity = self::VERBOSITY_NORMAL, $decorated = null)
+  {
+    if (!is_resource($stream) || 'stream' !== get_resource_type($stream))
+    {
+      throw new \InvalidArgumentException('The StreamOutput class needs a stream as its first argument.');
+    }
+
+    $this->stream = $stream;
+
+    if (null === $decorated)
+    {
+      $decorated = $this->hasColorSupport($decorated);
+    }
+
+    parent::__construct($verbosity, $decorated);
+  }
+
+  /**
+   * Gets the stream attached to this StreamOutput instance.
+   *
+   * @return resource A stream resource
+   */
+  public function getStream()
+  {
+    return $this->stream;
+  }
+
+  /**
+   * Writes a message to the output.
+   *
+   * @param string  $message A message to write to the output
+   * @param Boolean $newline Whether to add a newline or not
+   */
+  public function doWrite($message, $newline)
+  {
+    if (false === @fwrite($this->stream, $message.($newline ? PHP_EOL : '')))
+    {
+      // @codeCoverageIgnoreStart
+      // should never happen
+      throw new \RuntimeException('Unable to write output.');
+      // @codeCoverageIgnoreEnd
+    }
+
+    flush();
+  }
+
+  /**
+   * Returns true if the stream supports colorization.
+   *
+   * Colorization is disabled if not supported by the stream:
+   *
+   *  -  windows without ansicon
+   *  -  non tty consoles
+   *
+   * @return Boolean true if the stream supports colorization, false otherwise
+   */
+  protected function hasColorSupport()
+  {
+    // @codeCoverageIgnoreStart
+    if (DIRECTORY_SEPARATOR == '\\')
+    {
+      return false !== getenv('ANSICON');
+    }
+    else
+    {
+      return function_exists('posix_isatty') && @posix_isatty($this->stream);
+    }
+    // @codeCoverageIgnoreEnd
+  }
+}

lib/vendor/Symfony/Components/Console/Shell.php

+<?php
+
+namespace Symfony\Components\Console;
+
+use Symfony\Components\Console\Application;
+use Symfony\Components\Console\Input\StringInput;
+use Symfony\Components\Console\Output\ConsoleOutput;
+
+/*
+ * This file is part of the symfony framework.
+ *
+ * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * This source file is subject to the MIT license that is bundled
+ * with this source code in the file LICENSE.
+ */
+
+/**
+ * A Shell wraps an Application to add shell capabilities to it.
+ *
+ * This class only works with a PHP compiled with readline support
+ * (either --with-readline or --with-libedit)
+ *
+ * @package    symfony
+ * @subpackage cli
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ */
+class Shell
+{
+  protected $application;
+  protected $history;
+  protected $output;
+
+  /**
+   * Constructor.
+   *
+   * If there is no readline support for the current PHP executable
+   * a \RuntimeException exception is thrown.
+   *
+   * @param Application $application An application instance
+   */
+  public function __construct(Application $application)
+  {
+    if (!function_exists('readline'))
+    {
+      throw new \RuntimeException('Unable to start the shell as the Readline extension is not enabled.');
+    }
+
+    $this->application = $application;
+    $this->history = getenv('HOME').'/.history_'.$application->getName();
+    $this->output = new ConsoleOutput();
+  }
+
+  /**
+   * Runs the shell.
+   */
+  public function run()
+  {
+    $this->application->setAutoExit(false);
+    $this->application->setCatchExceptions(true);
+
+    readline_read_history($this->history);
+    readline_completion_function(array($this, 'autocompleter'));
+
+    $this->output->writeln($this->getHeader());
+    while (true)
+    {
+      $command = readline($this->application->getName().' > ');
+
+      if (false === $command)
+      {
+        $this->output->writeln("\n");
+
+        break;
+      }
+
+      readline_add_history($command);
+      readline_write_history($this->history);
+
+      if (0 !== $ret = $this->application->run(new StringInput($command), $this->output))
+      {
+        $this->output->writeln(sprintf('<error>The command terminated with an error status (%s)</error>', $ret));
+      }
+    }
+  }
+
+  /**
+   * Tries to return autocompletion for the current entered text.
+   *
+   * @param string  $text     The last segment of the entered text
+   * @param integer $position The current position
+   */
+  protected function autocompleter($text, $position)
+  {
+    $info = readline_info();
+    $text = substr($info['line_buffer'], 0, $info['end']);
+
+    if ($info['point'] !== $info['end'])
+    {
+      return true;
+    }
+
+    // task name?
+    if (false === strpos($text, ' ') || !$text)
+    {
+      return array_keys($this->application->getCommands());
+    }
+
+    // options and arguments?
+    try
+    {
+      $command = $this->application->findCommand(substr($text, 0, strpos($text, ' ')));
+    }
+    catch (\Exception $e)
+    {
+      return true;
+    }
+
+    $list = array('--help');
+    foreach ($command->getDefinition()->getOptions() as $option)
+    {
+      $list[] = '--'.$option->getName();
+    }
+
+    return $list;
+  }
+
+  /**
+   * Returns the shell header.
+   *
+   * @return string The header string
+   */
+  protected function getHeader()
+  {
+    return <<<EOF
+
+Welcome to the <info>{$this->application->getName()}</info> shell (<comment>{$this->application->getVersion()}</comment>).
+
+At the prompt, type <comment>help</comment> for some help,
+or <comment>list</comment> to get a list available commands.
+
+To exit the shell, type <comment>^D</comment>.
+
+EOF;
+  }
+}

lib/vendor/Symfony/Components/Console/Tester/ApplicationTester.php

+<?php
+
+namespace Symfony\Components\Console\Tester;
+
+use Symfony\Components\Console\Application;
+use Symfony\Components\Console\Input\ArrayInput;
+use Symfony\Components\Console\Output\StreamOutput;
+
+class ApplicationTester
+{
+  protected $application;
+  protected $display;
+  protected $input;
+  protected $output;
+
+  /**
+   * Constructor.
+   *
+   * @param Application $application A Application instance to test.
+   */
+  public function __construct(Application $application)
+  {
+    $this->application = $application;
+  }
+
+  /**
+   * Executes the application.
+   *
+   * Available options:
+   *
+   *  * interactive: Sets the input interactive flag
+   *  * decorated:   Sets the output decorated flag
+   *  * verbosity:   Sets the output verbosity flag
+   *
+   * @param array $input   An array of arguments and options
+   * @param array $options An array of options
+   */
+  public function run(array $input, $options = array())
+  {
+    $this->input = new ArrayInput($input);
+    if (isset($options['interactive']))
+    {
+      $this->input->setInteractive($options['interactive']);
+    }
+
+    $this->output = new StreamOutput(fopen('php://memory', 'w', false));
+    if (isset($options['decorated']))
+    {
+      $this->output->setDecorated($options['decorated']);
+    }
+    if (isset($options['verbosity']))
+    {
+      $this->output->setVerbosity($options['verbosity']);
+    }
+
+    $ret = $this->application->run($this->input, $this->output);
+
+    rewind($this->output->getStream());
+
+    return $this->display = stream_get_contents($this->output->getStream());
+  }
+
+  /**
+   * Gets the display returned by the last execution of the application.
+   *
+   * @return string The display
+   */
+  public function getDisplay()
+  {
+    return $this->display;
+  }
+
+  /**
+   * Gets the input instance used by the last execution of the application.
+   *
+   * @return InputInterface The current input instance
+   */
+  public function getInput()
+  {
+    return $this->input;
+  }
+
+  /**
+   * Gets the output instance used by the last execution of the application.
+   *
+   * @return OutputInterface The current output instance
+   */
+  public function getOutput()
+  {
+    return $this->output;
+  }
+}

lib/vendor/Symfony/Components/Console/Tester/CommandTester.php

+<?php
+
+namespace Symfony\Components\Console\Tester;
+
+use Symfony\Components\Console\Command\Command;
+use Symfony\Components\Console\Input\ArrayInput;
+use Symfony\Components\Console\Output\StreamOutput;
+
+class CommandTester
+{
+  protected $command;
+  protected $display;
+  protected $input;
+  protected $output;
+
+  /**
+   * Constructor.
+   *
+   * @param Command $command A Command instance to test.
+   */
+  public function __construct(Command $command)
+  {
+    $this->command = $command;
+  }
+
+  /**
+   * Executes the command.
+   *
+   * Available options:
+   *
+   *  * interactive: Sets the input interactive flag
+   *  * decorated:   Sets the output decorated flag
+   *  * verbosity:   Sets the output verbosity flag
+   *
+   * @param array $input   An array of arguments and options
+   * @param array $options An array of options
+   */
+  public function execute(array $input, array $options = array())
+  {
+    $this->input = new ArrayInput(array_merge($input, array('command' => $this->command->getFullName())));
+    if (isset($options['interactive']))
+    {
+      $this->input->setInteractive($options['interactive']);
+    }
+
+    $this->output = new StreamOutput(fopen('php://memory', 'w', false));
+    if (isset($options['decorated']))
+    {
+      $this->output->setDecorated($options['decorated']);
+    }
+    if (isset($options['verbosity']))
+    {
+      $this->output->setVerbosity($options['verbosity']);
+    }
+
+    $ret = $this->command->run($this->input, $this->output);
+
+    rewind($this->output->getStream());
+
+    return $this->display = stream_get_contents($this->output->getStream());
+  }
+
+  /**
+   * Gets the display returned by the last execution of the command.
+   *
+   * @return string The display
+   */
+  public function getDisplay()
+  {
+    return $this->display;
+  }
+
+  /**
+   * Gets the input instance used by the last execution of the command.
+   *
+   * @return InputInterface The current input instance
+   */
+  public function getInput()
+  {
+    return $this->input;
+  }
+
+  /**
+   * Gets the output instance used by the last execution of the command.
+   *
+   * @return OutputInterface The current output instance
+   */
+  public function getOutput()
+  {
+    return $this->output;
+  }
+}

lib/vendor/Symfony/Components/Yaml/Dumper.php

+<?php
+
+namespace Symfony\Components\Yaml;
+
+/*
+ * This file is part of the symfony package.
+ * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+/**
+ * Dumper dumps PHP variables to YAML strings.
+ *
+ * @package    symfony
+ * @subpackage yaml
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ */
+class Dumper
+{
+  /**
+   * Dumps a PHP value to YAML.
+   *
+   * @param  mixed   $input  The PHP value
+   * @param  integer $inline The level where you switch to inline YAML
+   * @param  integer $indent The level o indentation indentation (used internally)
+   *
+   * @return string  The YAML representation of the PHP value
+   */
+  public function dump($input, $inline = 0, $indent = 0)
+  {
+    $output = '';
+    $prefix = $indent ? str_repeat(' ', $indent) : '';
+
+    if ($inline <= 0 || !is_array($input) || empty($input))
+    {
+      $output .= $prefix.Inline::dump($input);
+    }
+    else
+    {
+      $isAHash = array_keys($input) !== range(0, count($input) - 1);
+
+      foreach ($input as $key => $value)
+      {
+        $willBeInlined = $inline - 1 <= 0 || !is_array($value) || empty($value);
+
+        $output .= sprintf('%s%s%s%s',
+          $prefix,
+          $isAHash ? Inline::dump($key).':' : '-',
+          $willBeInlined ? ' ' : "\n",
+          $this->dump($value, $inline - 1, $willBeInlined ? 0 : $indent + 2)
+        ).($willBeInlined ? "\n" : '');
+      }
+    }
+
+    return $output;
+  }
+}

lib/vendor/Symfony/Components/Yaml/Exception.php

+<?php
+
+namespace Symfony\Components\Yaml;
+
+/*
+ * This file is part of the symfony package.
+ *
+ * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+/**
+ * Exception class used by all exceptions thrown by the component.
+ *
+ * @package    symfony
+ * @subpackage yaml
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ */
+class Exception extends \Exception
+{
+}

lib/vendor/Symfony/Components/Yaml/ParserException.php

+<?php
+
+namespace Symfony\Components\Yaml;
+
+/*
+ * This file is part of the symfony package.
+ *
+ * (c) Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+/**
+ * Exception class used by all exceptions thrown by the component.
+ *
+ * @package    symfony
+ * @subpackage yaml
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ */
+class ParserException extends Exception
+{
+}

lib/vendor/Symfony/Components/Yaml/Yaml.php

+<?php
+
+namespace Symfony\Components\Yaml;
+
+/*
+ * This file is part of the symfony package.
+ * (c) 2004-2006 Fabien Potencier <fabien.potencier@symfony-project.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+/**
+ * Yaml offers convenience methods to load and dump YAML.
+ *
+ * @package    symfony
+ * @subpackage yaml
+ * @author     Fabien Potencier <fabien.potencier@symfony-project.com>
+ */
+class Yaml
+{
+  static protected $spec = '1.2';
+
+  /**
+   * Sets the YAML specification version to use.
+   *
+   * @param string $version The YAML specification version
+   */
+  static public function setSpecVersion($version)
+  {
+    if (!in_array($version, array('1.1', '1.2')))
+    {
+      throw new \InvalidArgumentException(sprintf('Version %s of the YAML specifications is not supported', $version));
+    }
+
+    self::$spec = $version;
+  }
+
+  /**
+   * Gets the YAML specification version to use.
+   *
+   * @return string The YAML specification version
+   */
+  static public function getSpecVersion()
+  {
+    return self::$spec;
+  }
+
+  /**
+   * Loads YAML into a PHP array.
+   *
+   * The load method, when supplied with a YAML stream (string or file),
+   * will do its best to convert YAML in a file into a PHP array.
+   *
+   *  Usage:
+   *  <code>
+   *   $array = Yaml::load('config.yml');
+   *   print_r($array);
+   *  </code>
+   *
+   * @param string $input Path of YAML file or string containing YAML
+   *
+   * @return array The YAML converted to a PHP array
+   *
+   * @throws \InvalidArgumentException If the YAML is not valid
+   */
+  public static function load($input)
+  {
+    $file = '';
+
+    // if input is a file, process it
+    if (strpos($input, "\n") === false && is_file($input))
+    {
+      $file = $input;
+
+      ob_start();
+      $retval = include($input);
+      $content = ob_get_clean();
+
+      // if an array is returned by the config file assume it's in plain php form else in YAML
+      $input = is_array($retval) ? $retval : $content;
+    }
+
+    // if an array is returned by the config file assume it's in plain php form else in YAML
+    if (is_array($input))
+    {
+      return $input;
+    }
+
+    $yaml = new Parser();
+
+    try
+    {
+      $ret = $yaml->parse($input);
+    }
+    catch (\Exception $e)
+    {
+      throw new \InvalidArgumentException(sprintf('Unable to parse %s: %s', $file ? sprintf('file "%s"', $file) : 'string', $e->getMessage()));
+    }
+
+    return $ret;
+  }
+
+  /**
+   * Dumps a PHP array to a YAML string.
+   *
+   * The dump method, when supplied with an array, will do its best
+   * to convert the array into friendly YAML.
+   *
+   * @param array   $array PHP array
+   * @param integer $inline The level where you switch to inline YAML
+   *
+   * @return string A YAML string representing the original PHP array
+   */
+  public static function dump($array, $inline = 2)
+  {
+    $yaml = new Dumper();
+
+    return $yaml->dump($array, $inline);
+  }
+}