/**
* Executes the action with the value entered by the user.
*
* @param mixed $value The option value
* @param array $params An array of optional parameters
*
* @return string
* @throws Console_CommandLine_Exception
*/
public function execute($value = false, $params = array())
{
if (!is_numeric($value)) {
throw Console_CommandLine_Exception::factory('OPTION_VALUE_TYPE_ERROR', array('name' => $this->option->name, 'type' => 'float', 'value' => $value), $this->parser);
}
$this->setResult((double) $value);
}
/**
* Execute the action with the value entered by the user.
*
* @param mixed $value the option value
* @param array $params an array of optional parameters
*
* @return string
* @access public
*/
public function execute($value = false, $params = array())
{
if (!is_numeric($value)) {
include_once 'Console/CommandLine/Exception';
throw Console_CommandLine_Exception::build('OPTION_VALUE_TYPE_ERROR', array('name' => $this->option->name, 'type' => 'float', 'value' => $value), $this->parser);
}
$this->setResult((int) $value);
}
/**
* Parses the command line token and modifies *by reference* the $options
* and $args arrays.
*
* @param string $token The command line token to parse
* @param object $result The Console_CommandLine_Result instance
* @param array &$args The argv array
* @param int $argc Number of lasting args
*
* @return void
* @access protected
* @throws Exception on user errors
*/
protected function parseToken($token, $result, &$args, $argc)
{
static $lastopt = false;
static $stopflag = false;
$last = $argc === 0;
if (!$stopflag && $lastopt) {
if (substr($token, 0, 1) == '-') {
if ($lastopt->argument_optional) {
$this->_dispatchAction($lastopt, '', $result);
if ($lastopt->action != 'StoreArray') {
$lastopt = false;
}
} else {
if (isset($result->options[$lastopt->name])) {
// case of an option that expect a list of args
$lastopt = false;
} else {
throw Console_CommandLine_Exception::factory('OPTION_VALUE_REQUIRED', array('name' => $lastopt->name), $this, $this->messages);
}
}
} else {
// when a StoreArray option is positioned last, the behavior
// is to consider that if there's already an element in the
// array, and the commandline expects one or more args, we
// leave last tokens to arguments
if ($lastopt->action == 'StoreArray' && !empty($result->options[$lastopt->name]) && count($this->args) > $argc + count($args)) {
if (!is_null($token)) {
$args[] = $token;
}
return;
}
if (!is_null($token) || $lastopt->action == 'Password') {
$this->_dispatchAction($lastopt, $token, $result);
}
if ($lastopt->action != 'StoreArray') {
$lastopt = false;
}
return;
}
}
if (!$stopflag && substr($token, 0, 2) == '--') {
// a long option
$optkv = explode('=', $token, 2);
if (trim($optkv[0]) == '--') {
// the special argument "--" forces in all cases the end of
// option scanning.
$stopflag = true;
return;
}
$opt = $this->findOption($optkv[0]);
if (!$opt) {
throw Console_CommandLine_Exception::factory('OPTION_UNKNOWN', array('name' => $optkv[0]), $this, $this->messages);
}
$value = isset($optkv[1]) ? $optkv[1] : false;
if (!$opt->expectsArgument() && $value !== false) {
throw Console_CommandLine_Exception::factory('OPTION_VALUE_UNEXPECTED', array('name' => $opt->name, 'value' => $value), $this, $this->messages);
}
if ($opt->expectsArgument() && $value === false) {
// maybe the long option argument is separated by a space, if
// this is the case it will be the next arg
if ($last && !$opt->argument_optional) {
throw Console_CommandLine_Exception::factory('OPTION_VALUE_REQUIRED', array('name' => $opt->name), $this, $this->messages);
}
// we will have a value next time
$lastopt = $opt;
return;
}
if ($opt->action == 'StoreArray') {
$lastopt = $opt;
}
$this->_dispatchAction($opt, $value, $result);
} else {
if (!$stopflag && substr($token, 0, 1) == '-') {
// a short option
$optname = substr($token, 0, 2);
if ($optname == '-') {
// special case of "-": try to read stdin
$args[] = file_get_contents('php://stdin');
return;
}
$opt = $this->findOption($optname);
if (!$opt) {
throw Console_CommandLine_Exception::factory('OPTION_UNKNOWN', array('name' => $optname), $this, $this->messages);
}
// parse other options or set the value
// in short: handle -f<value> and -f <value>
$next = substr($token, 2, 1);
// check if we must wait for a value
if ($next === false) {
if ($opt->expectsArgument()) {
if ($last && !$opt->argument_optional) {
throw Console_CommandLine_Exception::factory('OPTION_VALUE_REQUIRED', array('name' => $opt->name), $this, $this->messages);
}
// we will have a value next time
$lastopt = $opt;
return;
}
$value = false;
} else {
if (!$opt->expectsArgument()) {
if ($nextopt = $this->findOption('-' . $next)) {
$this->_dispatchAction($opt, false, $result);
$this->parseToken('-' . substr($token, 2), $result, $args, $last);
return;
} else {
throw Console_CommandLine_Exception::factory('OPTION_UNKNOWN', array('name' => $next), $this, $this->messages);
}
}
if ($opt->action == 'StoreArray') {
$lastopt = $opt;
}
$value = substr($token, 2);
}
$this->_dispatchAction($opt, $value, $result);
} else {
// We have an argument.
// if we are in POSIX compliant mode, we must set the stop flag to
// true in order to stop option parsing.
if (!$stopflag && $this->force_posix) {
$stopflag = true;
}
if (!is_null($token)) {
$args[] = $token;
}
}
}
}
/**
* Parses the command line arguments and returns a
* PEAR2\Console\CommandLine\Result instance.
*
* @param integer $userArgc Number of arguments (optional)
* @param array $userArgv Array containing arguments (optional)
*
* @return PEAR2\Console\CommandLine\Result The result instance
* @throws Exception on user errors
*/
public function parse($userArgc = null, $userArgv = null)
{
$this->addBuiltinOptions();
if ($userArgc !== null && $userArgv !== null) {
$argc = $userArgc;
$argv = $userArgv;
} else {
list($argc, $argv) = $this->getArgcArgv();
}
// build an empty result
$result = new CommandLine\Result();
if (!$this instanceof CommandLine\Command) {
// remove script name if we're not in a subcommand
array_shift($argv);
$argc--;
}
// will contain arguments
$args = array();
foreach ($this->options as $name => $option) {
$result->options[$name] = $option->default;
}
// parse command line tokens
while ($argc--) {
$token = array_shift($argv);
try {
if ($cmd = $this->_getSubCommand($token)) {
$result->command_name = $cmd->name;
$result->command = $cmd->parse($argc, $argv);
break;
} else {
$this->parseToken($token, $result, $args, $argc);
}
} catch (Exception $exc) {
throw $exc;
}
}
// Parse a null token to allow any undespatched actions to be despatched.
$this->parseToken(null, $result, $args, 0);
// Check if an invalid subcommand was specified. If there are
// subcommands and no arguments, but an argument was provided, it is
// an invalid subcommand.
if (count($this->commands) > 0 && count($this->args) === 0 && count($args) > 0) {
throw CommandLine\Exception::factory('INVALID_SUBCOMMAND', array('command' => $args[0]), $this, $this->messages);
}
// if subcommand_required is set to true we must check that we have a
// subcommand.
if (count($this->commands) && $this->subcommand_required && !$result->command_name) {
throw Console_CommandLine_Exception::factory('SUBCOMMAND_REQUIRED', array('commands' => implode(array_keys($this->commands), ', ')), $this, $this->messages);
}
// minimum argument number check
$argnum = 0;
foreach ($this->args as $name => $arg) {
if (!$arg->optional) {
$argnum++;
}
}
if (count($args) < $argnum) {
throw CommandLine\Exception::factory('ARGUMENT_REQUIRED', array('argnum' => $argnum, 'plural' => $argnum > 1 ? 's' : ''), $this, $this->messages);
}
// handle arguments
$c = count($this->args);
foreach ($this->args as $name => $arg) {
$c--;
if ($arg->multiple) {
$result->args[$name] = $c ? array_splice($args, 0, -$c) : $args;
} else {
$result->args[$name] = array_shift($args);
}
if (!$result->args[$name] && $arg->optional && $arg->default) {
$result->args[$name] = $arg->default;
}
}
// dispatch deferred options
foreach ($this->_dispatchLater as $optArray) {
$optArray[0]->dispatchAction($optArray[1], $optArray[2], $this);
}
return $result;
}
/**
* Formats the value $value according to the action of the option and
* updates the passed Console_CommandLine_Result object.
*
* @param mixed $value The value to format
* @param Console_CommandLine_Result $result The result instance
* @param Console_CommandLine $parser The parser instance
*
* @return void
* @throws Console_CommandLine_Exception
*/
public function dispatchAction($value, $result, $parser)
{
$actionInfo = Console_CommandLine::$actions[$this->action];
if (true === $actionInfo[1]) {
// we have a "builtin" action
$tokens = explode('_', $actionInfo[0]);
include_once implode('/', $tokens) . '.php';
}
$clsname = $actionInfo[0];
if ($this->_action_instance === null) {
$this->_action_instance = new $clsname($result, $this, $parser);
}
// check value is in option choices
if (!empty($this->choices) && !in_array($this->_action_instance->format($value), $this->choices)) {
throw Console_CommandLine_Exception::factory('OPTION_VALUE_NOT_VALID', array('name' => $this->name, 'choices' => implode('", "', $this->choices), 'value' => $value), $parser, $this->messages);
}
$this->_action_instance->execute($value, $this->action_params);
}
*/
// Include the Console_CommandLine package.
require_once 'Console/CommandLine.php';
// create the parser
$parser = new Console_CommandLine(array('description' => 'Extract contents of a phar archive to a given directory', 'version' => '@package_version@', 'name' => 'phar-extract'));
$parser->addOption('public', array('short_name' => '-P', 'long_name' => '--public', 'action' => 'StoreString', 'description' => "Public key file (PEM) to verify signature.\nIf not given, <pharfilename.phar>.pubkey will be used."));
$parser->addOption('list', array('short_name' => '-l', 'long_name' => '--list', 'action' => 'StoreTrue', 'description' => "Only list the files, don't extract them."));
$parser->addArgument('phar', array('action' => 'StoreString', 'description' => "Input Phar archive filename e.g. phar.phar"));
$parser->addArgument('destination', array('action' => 'StoreString', 'description' => "Destination directory", 'optional' => true));
// run the parser
try {
$result = $parser->parse();
$options = $result->options;
$args = $result->args;
if ($options['list'] !== true && !isset($args['destination'])) {
throw Console_CommandLine_Exception::factory('ARGUMENT_REQUIRED', array('argnum' => 2, 'plural' => 's'), $parser, $parser->messages);
}
} catch (Exception $exc) {
$parser->displayError($exc->getMessage());
}
echo $parser->name . ' ' . $parser->version . PHP_EOL . PHP_EOL;
// validate parameters
if (substr($args['phar'], -5) !== '.phar') {
$parser->displayError("Input Phar must have .phar extension, {$args['phar']} given.", 2);
}
if (!file_exists($args['phar']) || !is_readable($args['phar'])) {
$parser->displayError("Phar in '{$args['phar']}' does not exist or is not readable.", 4);
}
if ($options['public']) {
if (!file_exists($options['public']) || !is_readable($options['public'])) {
$parser->displayError("Public key in '{$options['public']}' does not exist or is not readable.", 4);
