1. sfCommandApplication.class.php
  2. /**
 * sfCommandApplication manages the lifecycle of a CLI application.
 *
 * @package    symfony
 * @subpackage command
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfCommandApplication.class.php 23218 2009-10-20 20:59:02Z FabianLange $
 */
  3. abstract class sfCommandApplication
  4. {
  5.   protected
  6.     $commandManager = null,
  7.     $trace          = false,
  8.     $verbose        = true,
  9.     $nowrite        = false,
  10.     $name           = 'UNKNOWN',
  11.     $version        = 'UNKNOWN',
  12.     $tasks          = array(),
  13.     $currentTask    = null,
  14.     $dispatcher     = null,
  15.     $options        = array(),
  16.     $formatter      = null;
  18.   /**
  19.    * Constructor.
  20.    *
  21.    * @param sfEventDispatcher $dispatcher   A sfEventDispatcher instance
  22.    * @param sfFormatter       $formatter    A sfFormatter instance
  23.    * @param array             $options      An array of options
  24.    */
  25.   public function __construct(sfEventDispatcher $dispatcher, sfFormatter $formatter = null, $options = array())
  26.   {
  27.     $this->dispatcher = $dispatcher;
  28.     $this->formatter = null === $formatter ? $this->guessBestFormatter(STDOUT) : $formatter;
  29.     $this->options = $options;
  31.     $this->fixCgi();
  33.     $argumentSet = new sfCommandArgumentSet(array(
  34.       new sfCommandArgument('task', sfCommandArgument::REQUIRED, 'The task to execute'),
  35.     ));
  36.     $optionSet = new sfCommandOptionSet(array(
  37.       new sfCommandOption('--help',    '-H', sfCommandOption::PARAMETER_NONE, 'Display this help message.'),
  38.       new sfCommandOption('--quiet',   '-q', sfCommandOption::PARAMETER_NONE, 'Do not log messages to standard output.'),
  39.       new sfCommandOption('--trace',   '-t', sfCommandOption::PARAMETER_NONE, 'Turn on invoke/execute tracing, enable full backtrace.'),
  40.       new sfCommandOption('--version', '-V', sfCommandOption::PARAMETER_NONE, 'Display the program version.'),
  41.       new sfCommandOption('--color',   '',   sfCommandOption::PARAMETER_NONE, 'Forces ANSI color output.'),
  42.     ));
  43.     $this->commandManager = new sfCommandManager($argumentSet, $optionSet);
  45.     $this->configure();
  47.     $this->registerTasks();
  48.   }
  50.   /**
  51.    * Configures the current command application.
  52.    */
  53.   abstract public function configure();
  55.   /**
  56.    * Returns the value of a given option.
  57.    *
  58.    * @param  string  $name  The option name
  59.    *
  60.    * @return mixed  The option value
  61.    */
  62.   public function getOption($name)
  63.   {
  64.     return isset($this->options[$name]) ? $this->options[$name] : null;
  65.   }
  67.   /**
  68.    * Returns the formatter instance.
  69.    *
  70.    * @return sfFormatter The formatter instance
  71.    */
  72.   public function getFormatter()
  73.   {
  74.     return $this->formatter;
  75.   }
  77.   /**
  78.    * Sets the formatter instance.
  79.    *
  80.    * @param sfFormatter The formatter instance
  81.    */
  82.   public function setFormatter(sfFormatter $formatter)
  83.   {
  84.     $this->formatter = $formatter;
  86.     foreach ($this->getTasks() as $task)
  87.     {
  88.       $task->setFormatter($formatter);
  89.     }
  90.   }
  92.   public function clearTasks()
  93.   {
  94.     $this->tasks = array();
  95.   }
  97.   /**
  98.    * Registers an array of task objects.
  99.    *
  100.    * If you pass null, this method will register all available tasks.
  101.    *
  102.    * @param array  $tasks  An array of tasks
  103.    */
  104.   public function registerTasks($tasks = null)
  105.   {
  106.     if (null === $tasks)
  107.     {
  108.       $tasks = $this->autodiscoverTasks();
  109.     }
  111.     foreach ($tasks as $task)
  112.     {
  113.       $this->registerTask($task);
  114.     }
  115.   }
  117.   /**
  118.    * Registers a task object.
  119.    *
  120.    * @param sfTask $task An sfTask object
  121.    */
  122.   public function registerTask(sfTask $task)
  123.   {
  124.     if (isset($this->tasks[$task->getFullName()]))
  125.     {
  126.       throw new sfCommandException(sprintf('The task named "%s" in "%s" task is already registered by the "%s" task.', $task->getFullName(), get_class($task), get_class($this->tasks[$task->getFullName()])));
  127.     }
  129.     $this->tasks[$task->getFullName()] = $task;
  131.     foreach ($task->getAliases() as $alias)
  132.     {
  133.       if (isset($this->tasks[$alias]))
  134.       {
  135.         throw new sfCommandException(sprintf('A task named "%s" is already registered.', $alias));
  136.       }
  138.       $this->tasks[$alias] = $task;
  139.     }
  140.   }
  142.   /**
  143.    * Autodiscovers task classes.
  144.    *
  145.    * @return array An array of tasks instances
  146.    */
  147.   public function autodiscoverTasks()
  148.   {
  149.     $tasks = array();
  150.     foreach (get_declared_classes() as $class)
  151.     {
  152.       $r = new ReflectionClass($class);
  154.       if ($r->isSubclassOf('sfTask') && !$r->isAbstract())
  155.       {
  156.         $tasks[] = new $class($this->dispatcher, $this->formatter);
  157.       }
  158.     }
  160.     return $tasks;
  161.   }
  163.   /**
  164.    * Returns all registered tasks.
  165.    *
  166.    * @return array An array of sfTask objects
  167.    */
  168.   public function getTasks()
  169.   {
  170.     return $this->tasks;
  171.   }
  173.   /**
  174.    * Returns a registered task by name or alias.
  175.    *
  176.    * @param string $name The task name or alias
  177.    *
  178.    * @return sfTask An sfTask object
  179.    */
  180.   public function getTask($name)
  181.   {
  182.     if (!isset($this->tasks[$name]))
  183.     {
  184.       throw new sfCommandException(sprintf('The task "%s" does not exist.', $name));
  185.     }
  187.     return $this->tasks[$name];
  188.   }
  190.   /**
  191.    * Runs the current application.
  192.    *
  193.    * @param mixed $options The command line options
  194.    *
  195.    * @return integer 0 if everything went fine, or an error code
  196.    */
  197.   public function run($options = null)
  198.   {
  199.     $this->handleOptions($options);
  200.     $arguments = $this->commandManager->getArgumentValues();
  202.     $this->currentTask = $this->getTaskToExecute($arguments['task']);
  204.     $ret = $this->currentTask->runFromCLI($this->commandManager, $this->commandOptions);
  206.     $this->currentTask = null;
  208.     return $ret;
  209.   }
  211.   /**
  212.    * Gets the name of the application.
  213.    *
  214.    * @return string The application name
  215.    */
  216.   public function getName()
  217.   {
  218.     return $this->name;
  219.   }
  221.   /**
  222.    * Sets the application name.
  223.    *
  224.    * @param string $name The application name
  225.    */
  226.   public function setName($name)
  227.   {
  228.     $this->name = $name;
  229.   }
  231.   /**
  232.    * Gets the application version.
  233.    *
  234.    * @return string The application version
  235.    */
  236.   public function getVersion()
  237.   {
  238.     return $this->version;
  239.   }
  241.   /**
  242.    * Sets the application version.
  243.    *
  244.    * @param string $version The application version
  245.    */
  246.   public function setVersion($version)
  247.   {
  248.     $this->version = $version;
  249.   }
  251.   /**
  252.    * Returns the long version of the application.
  253.    *
  254.    * @return string The long application version
  255.    */
  256.   public function getLongVersion()
  257.   {
  258.     return sprintf('%s version %s', $this->getName(), $this->formatter->format($this->getVersion(), 'INFO'))."\n";
  259.   }
  261.   /**
  262.    * Returns whether the application must be verbose.
  263.    *
  264.    * @return Boolean true if the application must be verbose, false otherwise
  265.    */
  266.   public function isVerbose()
  267.   {
  268.     return $this->verbose;
  269.   }
  271.   /**
  272.    * Returns whether the application must activate the trace.
  273.    *
  274.    * @return Boolean true if the application must activate the trace, false otherwise
  275.    */
  276.   public function withTrace()
  277.   {
  278.     return $this->trace;
  279.   }
  281.   /**
  282.    * Outputs a help message for the current application.
  283.    */
  284.   public function help()
  285.   {
  286.     $messages = array(
  287.       $this->formatter->format('Usage:', 'COMMENT'),
  288.       sprintf("  %s [options] task_name [arguments]\n", $this->getName()),
  289.       $this->formatter->format('Options:', 'COMMENT'),
  290.     );
  292.     foreach ($this->commandManager->getOptionSet()->getOptions() as $option)
  293.     {
  294.       $messages[] = sprintf('  %-24s %s  %s',
  295.         $this->formatter->format('--'.$option->getName(), 'INFO'),
  296.         $option->getShortcut() ? $this->formatter->format('-'.$option->getShortcut(), 'INFO') : '  ',
  297.         $option->getHelp()
  298.       );
  299.     }
  301.     $this->dispatcher->notify(new sfEvent($this, 'command.log', $messages));
  302.   }
  304.   /**
  305.    * Parses and handles command line options.
  306.    *
  307.    * @param mixed $options The command line options
  308.    */
  309.   protected function handleOptions($options = null)
  310.   {
  311.     $this->commandManager->process($options);
  312.     $this->commandOptions = $options;
  314.     // the order of option processing matters
  316.     if ($this->commandManager->getOptionSet()->hasOption('color') && false !== $this->commandManager->getOptionValue('color'))
  317.     {
  318.       $this->setFormatter(new sfAnsiColorFormatter());
  319.     }
  321.     if ($this->commandManager->getOptionSet()->hasOption('quiet') && false !== $this->commandManager->getOptionValue('quiet'))
  322.     {
  323.       $this->verbose = false;
  324.     }
  326.     if ($this->commandManager->getOptionSet()->hasOption('trace') && false !== $this->commandManager->getOptionValue('trace'))
  327.     {
  328.       $this->verbose = true;
  329.       $this->trace   = true;
  330.     }
  332.     if ($this->commandManager->getOptionSet()->hasOption('help') && false !== $this->commandManager->getOptionValue('help'))
  333.     {
  334.       $this->help();
  335.       exit(0);
  336.     }
  338.     if ($this->commandManager->getOptionSet()->hasOption('version') && false !== $this->commandManager->getOptionValue('version'))
  339.     {
  340.       echo $this->getLongVersion();
  341.       exit(0);
  342.     }
  343.   }
  345.   /**
  346.    * Renders an exception.
  347.    *
  348.    * @param Exception $e An exception object
  349.    */
  350.   public function renderException($e)
  351.   {
  352.     $title = sprintf('  [%s]  ', get_class($e));
  353.     $len = $this->strlen($title);
  354.     $lines = array();
  355.     foreach (explode("\n", $e->getMessage()) as $line)
  356.     {
  357.       $lines[] = sprintf('  %s  ', $line);
  358.       $len = max($this->strlen($line) + 4, $len);
  359.     }
  361.     $messages = array(str_repeat(' ', $len));
  363.     if ($this->trace)
  364.     {
  365.       $messages[] = $title.str_repeat(' ', $len - $this->strlen($title));
  366.     }
  368.     foreach ($lines as $line)
  369.     {
  370.       $messages[] = $line.str_repeat(' ', $len - $this->strlen($line));
  371.     }
  373.     $messages[] = str_repeat(' ', $len);
  375.     fwrite(STDERR, "\n");
  376.     foreach ($messages as $message)
  377.     {
  378.       fwrite(STDERR, $this->formatter->format($message, 'ERROR', STDERR)."\n");
  379.     }
  380.     fwrite(STDERR, "\n");
  382.     if (null !== $this->currentTask && $e instanceof sfCommandArgumentsException)
  383.     {
  384.       fwrite(STDERR, $this->formatter->format(sprintf($this->currentTask->getSynopsis(), $this->getName()), 'INFO', STDERR)."\n");
  385.       fwrite(STDERR, "\n");
  386.     }
  388.     if ($this->trace)
  389.     {
  390.       fwrite(STDERR, $this->formatter->format("Exception trace:\n", 'COMMENT'));
  392.       // exception related properties
  393.       $trace = $e->getTrace();
  394.       array_unshift($trace, array(
  395.         'function' => '',
  396.         'file'     => $e->getFile() != null ? $e->getFile() : 'n/a',
  397.         'line'     => $e->getLine() != null ? $e->getLine() : 'n/a',
  398.         'args'     => array(),
  399.       ));
  401.       for ($i = 0, $count = count($trace); $i < $count; $i++)
  402.       {
  403.         $class = isset($trace[$i]['class']) ? $trace[$i]['class'] : '';
  404.         $type = isset($trace[$i]['type']) ? $trace[$i]['type'] : '';
  405.         $function = $trace[$i]['function'];
  406.         $file = isset($trace[$i]['file']) ? $trace[$i]['file'] : 'n/a';
  407.         $line = isset($trace[$i]['line']) ? $trace[$i]['line'] : 'n/a';
  409.         fwrite(STDERR, sprintf(" %s%s%s at %s:%s\n", $class, $type, $function, $this->formatter->format($file, 'INFO', STDERR), $this->formatter->format($line, 'INFO', STDERR)));
  410.       }
  412.       fwrite(STDERR, "\n");
  413.     }
  414.   }
  416.   /**
  417.    * Gets a task from a task name or a shortcut.
  418.    *
  419.    * @param  string  $name  The task name or a task shortcut
  420.    *
  421.    * @return sfTask A sfTask object
  422.    */
  423.   public function getTaskToExecute($name)
  424.   {
  425.     // namespace
  426.     if (false !== $pos = strpos($name, ':'))
  427.     {
  428.       $namespace = substr($name, 0, $pos);
  429.       $name = substr($name, $pos + 1);
  431.       $namespaces = array();
  432.       foreach ($this->tasks as $task)
  433.       {
  434.         if ($task->getNamespace() && !in_array($task->getNamespace(), $namespaces))
  435.         {
  436.           $namespaces[] = $task->getNamespace();
  437.         }
  438.       }
  439.       $abbrev = $this->getAbbreviations($namespaces);
  441.       if (!isset($abbrev[$namespace]))
  442.       {
  443.         throw new sfCommandException(sprintf('There are no tasks defined in the "%s" namespace.', $namespace));
  444.       }
  445.       else if (count($abbrev[$namespace]) > 1)
  446.       {
  447.         throw new sfCommandException(sprintf('The namespace "%s" is ambiguous (%s).', $namespace, implode(', ', $abbrev[$namespace])));
  448.       }
  449.       else
  450.       {
  451.         $namespace = $abbrev[$namespace][0];
  452.       }
  453.     }
  454.     else
  455.     {
  456.       $namespace = '';
  457.     }
  459.     // name
  460.     $tasks = array();
  461.     foreach ($this->tasks as $taskName => $task)
  462.     {
  463.       if ($taskName == $task->getFullName() && $task->getNamespace() == $namespace)
  464.       {
  465.         $tasks[] = $task->getName();
  466.       }
  467.     }
  469.     $abbrev = $this->getAbbreviations($tasks);
  470.     if (isset($abbrev[$name]) && count($abbrev[$name]) == 1)
  471.     {
  472.       return $this->getTask($namespace ? $namespace.':'.$abbrev[$name][0] : $abbrev[$name][0]);
  473.     }
  475.     // aliases
  476.     $aliases = array();
  477.     foreach ($this->tasks as $taskName => $task)
  478.     {
  479.       if ($taskName == $task->getFullName())
  480.       {
  481.         foreach ($task->getAliases() as $alias)
  482.         {
  483.           $aliases[] = $alias;
  484.         }
  485.       }
  486.     }
  488.     $abbrev = $this->getAbbreviations($aliases);
  489.     $fullName = $namespace ? $namespace.':'.$name : $name;
  490.     if (!isset($abbrev[$fullName]))
  491.     {
  492.       throw new sfCommandException(sprintf('Task "%s" is not defined.', $fullName));
  493.     }
  494.     else if (count($abbrev[$fullName]) > 1)
  495.     {
  496.       throw new sfCommandException(sprintf('Task "%s" is ambiguous (%s).', $fullName, implode(', ', $abbrev[$fullName])));
  497.     }
  498.     else
  499.     {
  500.       return $this->getTask($abbrev[$fullName][0]);
  501.     }
  502.   }
  504.   protected function strlen($string)
  505.   {
  506.     return function_exists('mb_strlen') ? mb_strlen($string) : strlen($string);
  507.   }
  509.   /**
  510.    * Fixes php behavior if using cgi php.
  511.    *
  512.    * @see http://www.sitepoint.com/article/php-command-line-1/3
  513.    */
  514.   protected function fixCgi()
  515.   {
  516.     // handle output buffering
  517.     @ob_end_flush();
  518.     ob_implicit_flush(true);
  520.     // PHP ini settings
  521.     set_time_limit(0);
  522.     ini_set('track_errors', true);
  523.     ini_set('html_errors', false);
  524.     ini_set('magic_quotes_runtime', false);
  526.     if (false === strpos(PHP_SAPI, 'cgi'))
  527.     {
  528.       return;
  529.     }
  531.     // define stream constants
  532.     define('STDIN',  fopen('php://stdin',  'r'));
  533.     define('STDOUT', fopen('php://stdout', 'w'));
  534.     define('STDERR', fopen('php://stderr', 'w'));
  536.     // change directory
  537.     if (isset($_SERVER['PWD']))
  538.     {
  539.       chdir($_SERVER['PWD']);
  540.     }
  542.     // close the streams on script termination
  543.     register_shutdown_function(create_function('', 'fclose(STDIN); fclose(STDOUT); fclose(STDERR); return true;'));
  544.   }
  546.   /**
  547.    * Returns an array of possible abbreviations given a set of names.
  548.    *
  549.    * @see Text::Abbrev perl module for the algorithm
  550.    */
  551.   protected function getAbbreviations($names)
  552.   {
  553.     $abbrevs = array();
  554.     $table   = array();
  556.     foreach ($names as $name)
  557.     {
  558.       for ($len = strlen($name) - 1; $len > 0; --$len)
  559.       {
  560.         $abbrev = substr($name, 0, $len);
  561.         if (!array_key_exists($abbrev, $table))
  562.         {
  563.           $table[$abbrev] = 1;
  564.         }
  565.         else
  566.         {
  567.           ++$table[$abbrev];
  568.         }
  570.         $seen = $table[$abbrev];
  571.         if ($seen == 1)
  572.         {
  573.           // We're the first word so far to have this abbreviation.
  574.           $abbrevs[$abbrev] = array($name);
  575.         }
  576.         else if ($seen == 2)
  577.         {
  578.           // We're the second word to have this abbreviation, so we can't use it.
  579.           // unset($abbrevs[$abbrev]);
  580.           $abbrevs[$abbrev][] = $name;
  581.         }
  582.         else
  583.         {
  584.           // We're the third word to have this abbreviation, so skip to the next word.
  585.           continue;
  586.         }
  587.       }
  588.     }
  590.     // Non-abbreviations always get entered, even if they aren't unique
  591.     foreach ($names as $name)
  592.     {
  593.       $abbrevs[$name] = array($name);
  594.     }
  596.     return $abbrevs;
  597.   }
  599.   /**
  600.    * Returns true if the stream supports colorization.
  601.    *
  602.    * Colorization is disabled if not supported by the stream:
  603.    *
  604.    *  -  windows without ansicon
  605.    *  -  non tty consoles
  606.    *
  607.    * @param  mixed  $stream  A stream
  608.    *
  609.    * @return Boolean true if the stream supports colorization, false otherwise
  610.    */
  611.   protected function isStreamSupportsColors($stream)
  612.   {
  613.     if (DIRECTORY_SEPARATOR == '\\')
  614.     {
  615.       return false !== getenv('ANSICON');
  616.     }
  617.     else
  618.     {
  619.       return function_exists('posix_isatty') && @posix_isatty($stream);
  620.     }
  621.   }
  623.   /**
  624.    * Guesses the best formatter for the stream.
  625.    *
  626.    * @param  mixed       $stream  A stream
  627.    *
  628.    * @return sfFormatter A formatter instance
  629.    */
  630.   protected function guessBestFormatter($stream)
  631.   {
  632.     return $this->isStreamSupportsColors($stream) ? new sfAnsiColorFormatter() : new sfFormatter();
  633.   }
  634. }
Debug toolbar