Subversion Repositories SmartDukaan

<?php

/**

 * HelpFormatter

 *

 * CakePHP(tm) : Rapid Development Framework (http://cakephp.org)

 * Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)

 *

 * Licensed under The MIT License

 * For full copyright and license information, please see the LICENSE.txt

 * Redistributions of files must retain the above copyright notice.

 *

 * @copyright     Copyright (c) Cake Software Foundation, Inc. (http://cakefoundation.org)

 * @link          http://cakephp.org CakePHP(tm) Project

 * @license       http://www.opensource.org/licenses/mit-license.php MIT License

 */

App::uses('CakeText', 'Utility');

/**

 * HelpFormatter formats help for console shells. Can format to either

 * text or XML formats. Uses ConsoleOptionParser methods to generate help.

 *

 * Generally not directly used. Using $parser->help($command, 'xml'); is usually

 * how you would access help. Or via the `--help=xml` option on the command line.

 *

 * Xml output is useful for integration with other tools like IDE's or other build tools.

 *

 * @package       Cake.Console

 * @since  CakePHP(tm) v 2.0

 */

class HelpFormatter {

/**

 * The maximum number of arguments shown when generating usage.

 *

 * @var int

 */

	protected $_maxArgs = 6;

/**

 * The maximum number of options shown when generating usage.

 *

 * @var int

 */

	protected $_maxOptions = 6;

/**

 * Build the help formatter for an OptionParser

 *

 * @param ConsoleOptionParser $parser The option parser help is being generated for.

 */

	public function __construct(ConsoleOptionParser $parser) {

		$this->_parser = $parser;

	}

/**

 * Get the help as formatted text suitable for output on the command line.

 *

 * @param int $width The width of the help output.

 * @return string

 */

	public function text($width = 72) {

		$parser = $this->_parser;

		$out = array();

		$description = $parser->description();

		if (!empty($description)) {

			$out[] = CakeText::wrap($description, $width);

			$out[] = '';

		}

		$out[] = __d('cake_console', '<info>Usage:</info>');

		$out[] = $this->_generateUsage();

		$out[] = '';

		$subcommands = $parser->subcommands();

		if (!empty($subcommands)) {

			$out[] = __d('cake_console', '<info>Subcommands:</info>');

			$out[] = '';

			$max = $this->_getMaxLength($subcommands) + 2;

			foreach ($subcommands as $command) {

				$out[] = CakeText::wrap($command->help($max), array(

					'width' => $width,

					'indent' => str_repeat(' ', $max),

					'indentAt' => 1

				));

			}

			$out[] = '';

			$out[] = __d('cake_console', 'To see help on a subcommand use <info>`cake %s [subcommand] --help`</info>', $parser->command());

			$out[] = '';

		}

		$options = $parser->options();

		if (!empty($options)) {

			$max = $this->_getMaxLength($options) + 8;

			$out[] = __d('cake_console', '<info>Options:</info>');

			$out[] = '';

			foreach ($options as $option) {

				$out[] = CakeText::wrap($option->help($max), array(

					'width' => $width,

					'indent' => str_repeat(' ', $max),

					'indentAt' => 1

				));

			}

			$out[] = '';

		}

		$arguments = $parser->arguments();

		if (!empty($arguments)) {

			$max = $this->_getMaxLength($arguments) + 2;

			$out[] = __d('cake_console', '<info>Arguments:</info>');

			$out[] = '';

			foreach ($arguments as $argument) {

				$out[] = CakeText::wrap($argument->help($max), array(

					'width' => $width,

					'indent' => str_repeat(' ', $max),

					'indentAt' => 1

				));

			}

			$out[] = '';

		}

		$epilog = $parser->epilog();

		if (!empty($epilog)) {

			$out[] = CakeText::wrap($epilog, $width);

			$out[] = '';

		}

		return implode("\n", $out);

	}

/**

 * 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 = array('cake ' . $this->_parser->command());

		$subcommands = $this->_parser->subcommands();

		if (!empty($subcommands)) {

			$usage[] = '[subcommand]';

		}

		$options = array();

		foreach ($this->_parser->options() as $option) {

			$options[] = $option->usage();

		}

		if (count($options) > $this->_maxOptions) {

			$options = array('[options]');

		}

		$usage = array_merge($usage, $options);

		$args = array();

		foreach ($this->_parser->arguments() as $argument) {

			$args[] = $argument->usage();

		}

		if (count($args) > $this->_maxArgs) {

			$args = array('[arguments]');

		}

		$usage = array_merge($usage, $args);

		return implode(' ', $usage);

	}

/**

 * Iterate over a collection and find the longest named thing.

 *

 * @param array $collection The collection to find a max length of.

 * @return int

 */

	protected function _getMaxLength($collection) {

		$max = 0;

		foreach ($collection as $item) {

			$max = (strlen($item->name()) > $max) ? strlen($item->name()) : $max;

		}

		return $max;

	}

/**

 * Get the help as an xml string.

 *

 * @param bool $string Return the SimpleXml object or a string. Defaults to true.

 * @return string|SimpleXmlElement See $string

 */

	public function xml($string = true) {

		$parser = $this->_parser;

		$xml = new SimpleXmlElement('<shell></shell>');

		$xml->addChild('command', $parser->command());

		$xml->addChild('description', $parser->description());

		$xml->addChild('epilog', $parser->epilog());

		$subcommands = $xml->addChild('subcommands');

		foreach ($parser->subcommands() as $command) {

			$command->xml($subcommands);

		}

		$options = $xml->addChild('options');

		foreach ($parser->options() as $option) {

			$option->xml($options);

		}

		$arguments = $xml->addChild('arguments');

		foreach ($parser->arguments() as $argument) {

			$argument->xml($arguments);

		}

		return $string ? $xml->asXml() : $xml;

	}

}