/**
  * Display help for this console.
  *
  * @return ConsoleOptionParser
  */
 public function getOptionParser()
 {
     $parser = new ConsoleOptionParser('console');
     $parser->description('This shell provides a REPL that you can use to interact ' . 'with your application in an interactive fashion. You can use ' . 'it to run adhoc queries with your models, or experiment ' . 'and explore the features of CakePHP and your application.' . "\n\n" . 'You will need to have psysh installed for this Shell to work.');
     $parser->epilog('Thank you for baking with CakePHP!');
     return $parser;
 }

 /**
  * Display help for this console.
  *
  * @return ConsoleOptionParser
  */
 public function getOptionParser()
 {
     $file = Runner::ROBOFILE;
     if (Configure::check('Path.robofile')) {
         $file = Configure::read('Path.robofile');
     }
     $parser = new ConsoleOptionParser('robot', false);
     $parser->description('This shell provides a Robo runner.' . "\n\n" . 'You will need to have robo installed for this Shell to work. ')->addOption('config', ['help' => __d('cake_console', 'Path to your RoboFile class'), 'default' => $file]);
     return $parser;
 }

 /**
  * Display help for this console.
  *
  * @return ConsoleOptionParser
  */
 public function getOptionParser()
 {
     $parser = new ConsoleOptionParser('console');
     $parser->description("This shell clean the cache of your application.")->command("cache.clear")->addOption('all', ['short' => 'a', 'help' => 'Clear all caches', 'boolean' => true])->addSubcommand('all', ['help' => 'Clear all caches']);
     foreach ($this->tasks as $task => $option) {
         $classname = $this->taskClassname($task);
         $parser->addSubcommand($this->taskName($task), ['help' => $this->{$classname}->help(), 'parser' => $this->{$classname}->getOptionParser()]);
     }
     return $parser;
 }

 /**
  * Make a new Subcommand
  *
  * @param string|array $name The long name of the subcommand, or an array with all the properties.
  * @param string $help The help text for this option.
  * @param \Cake\Console\ConsoleOptionParser|array|null $parser A parser for this subcommand. Either a ConsoleOptionParser, or an
  *   array that can be used with ConsoleOptionParser::buildFromArray().
  */
 public function __construct($name, $help = '', $parser = null)
 {
     if (is_array($name) && isset($name['name'])) {
         foreach ($name as $key => $value) {
             $this->{'_' . $key} = $value;
         }
     } else {
         $this->_name = $name;
         $this->_help = $help;
         $this->_parser = $parser;
     }
     if (is_array($this->_parser)) {
         $this->_parser['command'] = $this->_name;
         $this->_parser = ConsoleOptionParser::buildFromArray($this->_parser);
     }
 }

 /**
  * Display help for this console.
  *
  * @return ConsoleOptionParser
  */
 public function getOptionParser()
 {
     $parser = new ConsoleOptionParser('console', false);
     $parser->description('This shell provides a REPL that you can use to interact' . 'with your application in an interactive fashion. You can use' . 'it to run adhoc queries with your models, or experiment' . 'and explore the features of CakePHP and your application.' . "\n\n" . 'You will need to have boris installed for this Shell to work. ' . 'Boris is known to not work well on windows due to dependencies on ' . 'readline and posix.');
     return $parser;
 }

 /**
  * Display help for this console.
  *
  * @return ConsoleOptionParser
  */
 public function getOptionParser()
 {
     $parser = new ConsoleOptionParser('console');
     $parser->description('Clear directories in "tmp/cache/"')->command("dir")->addOption('all', ['short' => 'a', 'help' => 'Clear all directories', 'boolean' => true]);
     return $parser;
 }

 /**
  * Test xml help as object
  *
  * @return void
  */
 public function testXmlHelpAsObject()
 {
     $parser = new ConsoleOptionParser('mycommand', false);
     $parser->addOption('test', ['help' => 'A test option.'])->addArgument('model', ['help' => 'The model to make.', 'required' => true])->addArgument('other_longer', ['help' => 'Another argument.']);
     $formatter = new HelpFormatter($parser);
     $result = $formatter->xml(false);
     $this->assertInstanceOf('SimpleXmlElement', $result);
 }

 /**
  * test that runCommand will call runCommand on the task.
  *
  * @return void
  */
 public function testRunCommandHittingTaskInSubcommand()
 {
     $parser = new ConsoleOptionParser('knife');
     $parser->addSubcommand('slice');
     $io = $this->getMock('Cake\\Console\\ConsoleIo');
     $shell = $this->getMock('Cake\\Console\\Shell', ['hasTask', 'startup', 'getOptionParser'], [], '', false);
     $shell->io($io);
     $task = $this->getMock('Cake\\Console\\Shell', ['main', 'runCommand'], [], '', false);
     $task->io($io);
     $task->expects($this->once())->method('runCommand')->with(['one'], false);
     $shell->expects($this->once())->method('getOptionParser')->will($this->returnValue($parser));
     $shell->expects($this->once())->method('startup');
     $shell->expects($this->any())->method('hasTask')->will($this->returnValue(true));
     $shell->Slice = $task;
     $shell->runCommand(['slice', 'one']);
 }

 /**
  * Display help for this console.
  *
  * @return ConsoleOptionParser
  */
 public function getOptionParser()
 {
     $parser = new ConsoleOptionParser('deployer', false);
     $parser->description('This shell is used when deploying the application.')->addSubcommand('clear_cache', ['help' => 'Clear the cache files.', 'parser' => $this->ClearCache->getOptionParser()]);
     return $parser;
 }

 /**
  * Set shell description and command line options
  *
  * @return ConsoleOptionParser
  */
 public function getOptionParser()
 {
     $parser = new ConsoleOptionParser('console');
     $parser->description('Validate CSV and configuration files of all CSV modules');
     return $parser;
 }

 public function getOptionParser()
 {
     $parser = new ConsoleOptionParser('console');
     $parser->description("Clear ORM Cache.")->command("model");
     return $parser;
 }

 /**
  * Tests merge()
  *
  * @return void
  */
 public function testMerge()
 {
     $parser = new ConsoleOptionParser('test');
     $parser->addOption('test', ['short' => 't', 'boolean' => true])->addArgument('one', ['required' => true, 'choices' => ['a', 'b']])->addArgument('two', ['required' => true]);
     $parserTwo = new ConsoleOptionParser('test');
     $parserTwo->addOption('file', ['short' => 'f', 'boolean' => true])->addOption('output', ['short' => 'o', 'boolean' => true])->addArgument('one', ['required' => true, 'choices' => ['a', 'b']]);
     $parser->merge($parserTwo);
     $result = $parser->toArray();
     $options = $result['options'];
     $this->assertTrue(isset($options['quiet']));
     $this->assertTrue(isset($options['test']));
     $this->assertTrue(isset($options['file']));
     $this->assertTrue(isset($options['output']));
     $this->assertEquals(2, count($result['arguments']));
     $this->assertEquals(6, count($result['options']));
 }

 /**
  * Gets the option parser instance and configures it.
  *
  * @return \Cake\Console\ConsoleOptionParser
  */
 public function getOptionParser()
 {
     $name = ($this->plugin ? $this->plugin . '.' : '') . $this->name;
     $parser = new ConsoleOptionParser($name);
     $bakeThemes = [];
     foreach (Plugin::loaded() as $plugin) {
         $path = Plugin::classPath($plugin);
         if (is_dir($path . 'Template' . DS . 'Bake')) {
             $bakeThemes[] = $plugin;
         }
     }
     $parser->description('Bake seed class.')->addOption('plugin', ['short' => 'p', 'help' => 'Plugin to bake into.'])->addOption('force', ['short' => 'f', 'boolean' => true, 'help' => 'Force overwriting existing files without prompting.'])->addOption('connection', ['short' => 'c', 'default' => 'default', 'help' => 'The datasource connection to get data from.'])->addOption('table', ['help' => 'The database table to use.'])->addOption('theme', ['short' => 't', 'help' => 'The theme to use when baking code.', 'choices' => $bakeThemes])->addArgument('name', ['help' => 'Name of the seed to bake. Can use Plugin.name to bake plugin models.'])->addOption('data', ['boolean' => true, 'help' => 'Include data from the table to the seed'])->addOption('fields', ['default' => '*', 'help' => 'If including data, comma separated list of fields to select (all fields by default)'])->addOption('limit', ['short' => 'l', 'help' => 'If including data, max number of rows to select']);
     return $parser;
 }

 /**
  * Gets the option parser instance and configures it.
  * By overriding this method you can configure the ConsoleOptionParser before returning it.
  *
  * @return ConsoleOptionParser
  * @link http://book.cakephp.org/2.0/en/console-and-shells.html#Shell::getOptionParser
  */
 public function processOptionParser(ConsoleOptionParser $parser)
 {
     return $parser->addOption('process_id', ['help' => 'A process identifier to make locking work with Supervisor']);
 }

 /**
  * test that parse() takes a subcommand argument, and that the subcommand parser
  * is used.
  *
  * @return void
  */
 public function testParsingWithSubParser()
 {
     $parser = new ConsoleOptionParser('test', false);
     $parser->addOption('primary')->addArgument('one', array('required' => true, 'choices' => array('a', 'b')))->addArgument('two', array('required' => true))->addSubcommand('sub', array('parser' => array('options' => array('secondary' => array('boolean' => true), 'fourth' => array('help' => 'fourth option')), 'arguments' => array('sub_arg' => array('choices' => array('c', 'd'))))));
     $result = $parser->parse(array('sub', '--secondary', '--fourth', '4', 'c'));
     $expected = array(array('secondary' => true, 'fourth' => '4', 'help' => false, 'verbose' => false, 'quiet' => false), array('c'));
     $this->assertEquals($expected, $result, 'Sub parser did not parse request.');
 }

 /**
  * Display help for this console.
  *
  * @return ConsoleOptionParser
  */
 public function getOptionParser()
 {
     $parser = new ConsoleOptionParser('clear_cache', false);
     $parser->description('This tasks is used to clear the cached files in the application.');
     return $parser;
 }

 /**
  * Build a parser from an array. Uses an array like
  *
  * ```
  * $spec = [
  *      'description' => 'text',
  *      'epilog' => 'text',
  *      'arguments' => [
  *          // list of arguments compatible with addArguments.
  *      ],
  *      'options' => [
  *          // list of options compatible with addOptions
  *      ],
  *      'subcommands' => [
  *          // list of subcommands to add.
  *      ]
  * ];
  * ```
  *
  * @param array $spec The spec to build the OptionParser with.
  * @param bool $defaultOptions Whether you want the verbose and quiet options set.
  * @return $this
  */
 public static function buildFromArray($spec, $defaultOptions = true)
 {
     $parser = new ConsoleOptionParser($spec['command'], $defaultOptions);
     if (!empty($spec['arguments'])) {
         $parser->addArguments($spec['arguments']);
     }
     if (!empty($spec['options'])) {
         $parser->addOptions($spec['options']);
     }
     if (!empty($spec['subcommands'])) {
         $parser->addSubcommands($spec['subcommands']);
     }
     if (!empty($spec['description'])) {
         $parser->description($spec['description']);
     }
     if (!empty($spec['epilog'])) {
         $parser->epilog($spec['epilog']);
     }
     return $parser;
 }

 /**
  * Gets the option parser instance and configures it.
  *
  * @return \Cake\Console\ConsoleOptionParser
  */
 public function getOptionParser()
 {
     $name = ($this->plugin ? $this->plugin . '.' : '') . $this->name;
     $parser = new ConsoleOptionParser($name);
     $bakeThemes = [];
     foreach (Plugin::loaded() as $plugin) {
         $path = Plugin::classPath($plugin);
         if (is_dir($path . 'Template' . DS . 'Bake')) {
             $bakeThemes[] = $plugin;
         }
     }
     $parser->description('Bake migration class.')->addOption('plugin', ['short' => 'p', 'help' => 'Plugin to bake into.'])->addOption('force', ['short' => 'f', 'boolean' => true, 'help' => 'Force overwriting existing files without prompting.'])->addOption('connection', ['short' => 'c', 'default' => 'default', 'help' => 'The datasource connection to get data from.'])->addOption('theme', ['short' => 't', 'help' => 'The theme to use when baking code.', 'choices' => $bakeThemes]);
     return $parser;
 }

 /**
  * Generate the usage for a shell based on its arguments and options.
  * Usage strings favor short options over the long ones. and optional args will
  * be indicated with []
  *
  * @return string
  */
 protected function _generateUsage()
 {
     $usage = ['cake ' . $this->_parser->command()];
     $subcommands = $this->_parser->subcommands();
     if (!empty($subcommands)) {
         $usage[] = '[subcommand]';
     }
     $options = [];
     foreach ($this->_parser->options() as $option) {
         $options[] = $option->usage();
     }
     if (count($options) > $this->_maxOptions) {
         $options = ['[options]'];
     }
     $usage = array_merge($usage, $options);
     $args = [];
     foreach ($this->_parser->arguments() as $argument) {
         $args[] = $argument->usage();
     }
     if (count($args) > $this->_maxArgs) {
         $args = ['[arguments]'];
     }
     $usage = array_merge($usage, $args);
     return implode(' ', $usage);
 }

 /**
  * Display the help in the correct format
  *
  * @param string $command The command to get help for.
  * @return int|bool
  */
 protected function _displayHelp($command)
 {
     $format = 'text';
     if (!empty($this->args[0]) && $this->args[0] === 'xml') {
         $format = 'xml';
         $this->_io->outputAs(ConsoleOutput::RAW);
     } else {
         $this->_welcome();
     }
     return $this->out($this->OptionParser->help($command, $format));
 }