1. sfCommandManager.class.php
  2. /**
 * Class to manage command line arguments and options.
 *
 * @package    symfony
 * @subpackage command
 * @author     Fabien Potencier 
 * @version    SVN: $Id: sfCommandManager.class.php 21908 2009-09-11 12:06:21Z fabien $
 */
  3. class sfCommandManager
  4. {
  5.   protected
  6.     $arguments            = '',
  7.     $errors               = array(),
  8.     $optionSet            = null,
  9.     $argumentSet          = array(),
  10.     $optionValues         = array(),
  11.     $argumentValues       = array(),
  12.     $parsedArgumentValues = array();
  14.   /**
  15.    * Constructor.
  16.    *
  17.    * @param sfCommandArgumentSet $argumentSet A sfCommandArgumentSet object
  18.    * @param sfCommandOptionSet   $optionSet   A setOptionSet object
  19.    */
  20.   public function __construct(sfCommandArgumentSet $argumentSet = null, sfCommandOptionSet $optionSet = null)
  21.   {
  22.     if (null === $argumentSet)
  23.     {
  24.       $argumentSet = new sfCommandArgumentSet();
  25.     }
  26.     $this->setArgumentSet($argumentSet);
  28.     if (null === $optionSet)
  29.     {
  30.       $optionSet = new sfCommandOptionSet();
  31.     }
  32.     $this->setOptionSet($optionSet);
  33.   }
  35.   /**
  36.    * Sets the argument set.
  37.    *
  38.    * @param sfCommandArgumentSet $argumentSet A sfCommandArgumentSet object
  39.    */
  40.   public function setArgumentSet(sfCommandArgumentSet $argumentSet)
  41.   {
  42.     $this->argumentSet = $argumentSet;
  43.   }
  45.   /**
  46.    * Gets the argument set.
  47.    *
  48.    * @return sfCommandArgumentSet A sfCommandArgumentSet object
  49.    */
  50.   public function getArgumentSet()
  51.   {
  52.     return $this->argumentSet;
  53.   }
  55.   /**
  56.    * Sets the option set.
  57.    *
  58.    * @param sfCommandOptionSet $optionSet A sfCommandOptionSet object
  59.    */
  60.   public function setOptionSet(sfCommandOptionSet $optionSet)
  61.   {
  62.     $this->optionSet = $optionSet;
  63.   }
  65.   /**
  66.    * Gets the option set.
  67.    *
  68.    * @return sfCommandOptionSet A sfCommandOptionSet object
  69.    */
  70.   public function getOptionSet()
  71.   {
  72.     return $this->optionSet;
  73.   }
  75.   /**
  76.    * Processes command line arguments.
  77.    *
  78.    * @param mixed $arguments A string or an array of command line parameters
  79.    */
  80.   public function process($arguments = null)
  81.   {
  82.     if (null === $arguments)
  83.     {
  84.       $arguments = $_SERVER['argv'];
  86.       // we strip command line program
  87.       if (isset($arguments[0]) && '-' != $arguments[0][0])
  88.       {
  89.         array_shift($arguments);
  90.       }
  91.     }
  92.     else if (!is_array($arguments))
  93.     {
  94.       // hack to split arguments with spaces : --test="with some spaces"
  95.       $arguments = preg_replace('/(\'|")(.+?)\\1/e', "str_replace(' ', '=PLACEHOLDER=', '\\2')", $arguments);
  96.       $arguments = preg_split('/\s+/', $arguments);
  97.       $arguments = str_replace('=PLACEHOLDER=', ' ', $arguments);
  98.     }
  100.     $this->arguments            = $arguments;
  101.     $this->optionValues         = $this->optionSet->getDefaults();
  102.     $this->argumentValues       = $this->argumentSet->getDefaults();
  103.     $this->parsedArgumentValues = array();
  104.     $this->errors               = array();
  106.     while (!in_array($argument = array_shift($this->arguments), array('', null)))
  107.     {
  108.       if ('--' == $argument)
  109.       {
  110.         // stop options parsing
  111.         $this->parsedArgumentValues = array_merge($this->parsedArgumentValues, $this->arguments);
  112.         break;
  113.       }
  115.       if ('--' == substr($argument, 0, 2))
  116.       {
  117.         $this->parseLongOption(substr($argument, 2));
  118.       }
  119.       else if ('-' == $argument[0])
  120.       {
  121.         $this->parseShortOption(substr($argument, 1));
  122.       }
  123.       else
  124.       {
  125.         $this->parsedArgumentValues[] = $argument;
  126.       }
  127.     }
  129.     $position = 0;
  130.     foreach ($this->argumentSet->getArguments() as $argument)
  131.     {
  132.       if (array_key_exists($position, $this->parsedArgumentValues))
  133.       {
  134.         if ($argument->isArray())
  135.         {
  136.           $this->argumentValues[$argument->getName()] = array_slice($this->parsedArgumentValues, $position);
  137.           break;
  138.         }
  139.         else
  140.         {
  141.           $this->argumentValues[$argument->getName()] = $this->parsedArgumentValues[$position];
  142.         }
  143.       }
  144.       ++$position;
  145.     }
  147.     $this->arguments = $arguments;
  149.     if (count($this->parsedArgumentValues) < $this->argumentSet->getArgumentRequiredCount())
  150.     {
  151.       $this->errors[] = 'Not enough arguments.';
  152.     }
  153.     else if (count($this->parsedArgumentValues) > $this->argumentSet->getArgumentCount())
  154.     {
  155.       $this->errors[] = sprintf('Too many arguments ("%s" given).', implode(' ', $this->parsedArgumentValues));
  156.     }
  157.   }
  159.   /**
  160.    * Returns true if the current command line options validate the argument and option sets.
  161.    *
  162.    * @return true if there are some validation errors, false otherwise
  163.    */
  164.   public function isValid()
  165.   {
  166.     return count($this->errors) ? false : true;
  167.   }
  169.   /**
  170.    * Gets the current errors.
  171.    *
  172.    * @return array An array of errors
  173.    */
  174.   public function getErrors()
  175.   {
  176.     return $this->errors;
  177.   }
  179.   /**
  180.    * Returns the argument values.
  181.    *
  182.    * @return array An array of argument values
  183.    */
  184.   public function getArgumentValues()
  185.   {
  186.     return $this->argumentValues;
  187.   }
  189.   /**
  190.    * Returns the argument value for a given argument name.
  191.    *
  192.    * @param string $name The argument name
  193.    *
  194.    * @return mixed The argument value
  195.    */
  196.   public function getArgumentValue($name)
  197.   {
  198.     if (!$this->argumentSet->hasArgument($name))
  199.     {
  200.       throw new sfCommandException(sprintf('The "%s" argument does not exist.', $name));
  201.     }
  203.     return $this->argumentValues[$name];
  204.   }
  206.   /**
  207.    * Returns the options values.
  208.    *
  209.    * @return array An array of option values
  210.    */
  211.   public function getOptionValues()
  212.   {
  213.     return $this->optionValues;
  214.   }
  216.   /**
  217.    * Returns the option value for a given option name.
  218.    *
  219.    * @param string $name The option name
  220.    *
  221.    * @return mixed The option value
  222.    */
  223.   public function getOptionValue($name)
  224.   {
  225.     if (!$this->optionSet->hasOption($name))
  226.     {
  227.       throw new sfCommandException(sprintf('The "%s" option does not exist.', $name));
  228.     }
  230.     return $this->optionValues[$name];
  231.   }
  233.   /**
  234.    * Parses a short option.
  235.    *
  236.    * @param string $argument The option argument
  237.    */
  238.   protected function parseShortOption($argument)
  239.   {
  240.     // short option can be aggregated like in -vd (== -v -d)
  241.     for ($i = 0, $count = strlen($argument); $i < $count; $i++)
  242.     {
  243.       $shortcut = $argument[$i];
  244.       $value    = true;
  246.       if (!$this->optionSet->hasShortcut($shortcut))
  247.       {
  248.         $this->errors[] = sprintf('The option "-%s" does not exist.', $shortcut);
  249.         continue;
  250.       }
  252.       $option = $this->optionSet->getOptionForShortcut($shortcut);
  254.       // required argument?
  255.       if ($option->isParameterRequired())
  256.       {
  257.         if ($i + 1 < strlen($argument))
  258.         {
  259.           $value = substr($argument, $i + 1);
  260.           $this->setOption($option, $value);
  261.           break;
  262.         }
  263.         else
  264.         {
  265.           // take next element as argument (if it doesn't start with a -)
  266.           if (count($this->arguments) && $this->arguments[0][0] != '-')
  267.           {
  268.             $value = array_shift($this->arguments);
  269.             $this->setOption($option, $value);
  270.             break;
  271.           }
  272.           else
  273.           {
  274.             $this->errors[] = sprintf('Option "-%s" requires an argument', $shortcut);
  275.             $value = null;
  276.           }
  277.         }
  278.       }
  279.       else if ($option->isParameterOptional())
  280.       {
  281.         if (substr($argument, $i + 1) != '')
  282.         {
  283.           $value = substr($argument, $i + 1);
  284.         }
  285.         else
  286.         {
  287.           // take next element as argument (if it doesn't start with a -)
  288.           if (count($this->arguments) && $this->arguments[0][0] != '-')
  289.           {
  290.             $value = array_shift($this->arguments);
  291.           }
  292.           else
  293.           {
  294.             $value = $option->getDefault();
  295.           }
  296.         }
  298.         $this->setOption($option, $value);
  299.         break;
  300.       }
  302.       $this->setOption($option, $value);
  303.     }
  304.   }
  306.   /**
  307.    * Parses a long option.
  308.    *
  309.    * @param string $argument The option argument
  310.    */
  311.   protected function parseLongOption($argument)
  312.   {
  313.     if (false !== strpos($argument, '='))
  314.     {
  315.       list($name, $value) = explode('=', $argument, 2);
  317.       if (!$this->optionSet->hasOption($name))
  318.       {
  319.         $this->errors[] = sprintf('The "--%s" option does not exist.', $name);
  320.         return;
  321.       }
  323.       $option = $this->optionSet->getOption($name);
  325.       if (!$option->acceptParameter())
  326.       {
  327.         $this->errors[] = sprintf('Option "--%s" does not take an argument.', $name);
  328.         $value = true;
  329.       }
  330.     }
  331.     else
  332.     {
  333.       $name = $argument;
  335.       if (!$this->optionSet->hasOption($name))
  336.       {
  337.         $this->errors[] = sprintf('The "--%s" option does not exist.', $name);
  338.         return;
  339.       }
  341.       $option = $this->optionSet->getOption($name);
  343.       if ($option->isParameterRequired())
  344.       {
  345.         $this->errors[] = sprintf('Option "--%s" requires an argument.', $name);
  346.       }
  348.       $value = $option->acceptParameter() ? $option->getDefault() : true;
  349.     }
  351.     $this->setOption($option, $value);
  352.   }
  354.   public function setOption(sfCommandOption $option, $value)
  355.   {
  356.     if ($option->isArray())
  357.     {
  358.       $this->optionValues[$option->getName()][] = $value;
  359.     }
  360.     else
  361.     {
  362.       $this->optionValues[$option->getName()] = $value;
  363.     }
  364.   }
  365. }
Debug toolbar