Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:37
📄 console_autoload.php <?php /** * Autoloader definition for the ConsoleTools component. * * @copyright Copyright (C) 2005-2010 eZ Systems AS. All rights reserved. * @license http://ez.no/licenses/new_bsd New BSD License * @version 1.6.1 * @filesource * @package ConsoleTools */ return array( 'ezcConsoleException' => 'ConsoleTools/exceptions/exception.php', 'ezcConsoleArgumentException' => 'ConsoleTools/exceptions/argument.php', 'ezcConsoleOptionException' => 'ConsoleTools/exceptions/option.php', 'ezcConsoleArgumentAlreadyRegisteredException' => 'ConsoleTools/exceptions/argument_already_registered.php', 'ezcConsoleArgumentMandatoryViolationException' => 'ConsoleTools/exceptions/argument_mandatory_violation.php', 'ezcConsoleArgumentTypeViolationException' => 'ConsoleTools/exceptions/argument_type_violation.php', 'ezcConsoleDialogAbortException' => 'ConsoleTools/exceptions/dialog_abort.php', 'ezcConsoleInvalidOptionNameException' => 'ConsoleTools/exceptions/invalid_option_name.php', 'ezcConsoleInvalidOutputTargetException' => 'ConsoleTools/exceptions/invalid_output_target.php', 'ezcConsoleNoPositionStoredException' => 'ConsoleTools/exceptions/no_position_stored.php', 'ezcConsoleNoValidDialogResultException' => 'ConsoleTools/exceptions/no_valid_dialog_result.php', 'ezcConsoleOptionAlreadyRegisteredException' => 'ConsoleTools/exceptions/option_already_registered.php', 'ezcConsoleOptionArgumentsViolationException' => 'ConsoleTools/exceptions/option_arguments_violation.php', 'ezcConsoleOptionDependencyViolationException' => 'ConsoleTools/exceptions/option_dependency_violation.php', 'ezcConsoleOptionExclusionViolationException' => 'ConsoleTools/exceptions/option_exclusion_violation.php', 'ezcConsoleOptionMandatoryViolationException' => 'ConsoleTools/exceptions/option_mandatory_violation.php', 'ezcConsoleOptionMissingValueException' => 'ConsoleTools/exceptions/option_missing_value.php', 'ezcConsoleOptionNoAliasException' => 'ConsoleTools/exceptions/option_no_alias.php', 'ezcConsoleOptionNotExistsException' => 'ConsoleTools/exceptions/option_not_exists.php', 'ezcConsoleOptionStringNotWellformedException' => 'ConsoleTools/exceptions/option_string_not_wellformed.php', 'ezcConsoleOptionTooManyValuesException' => 'ConsoleTools/exceptions/option_too_many_values.php', 'ezcConsoleOptionTypeViolationException' => 'ConsoleTools/exceptions/option_type_violation.php', 'ezcConsoleTooManyArgumentsException' => 'ConsoleTools/exceptions/argument_too_many.php', 'ezcConsoleDialogValidator' => 'ConsoleTools/interfaces/dialog_validator.php', 'ezcConsoleQuestionDialogValidator' => 'ConsoleTools/interfaces/question_dialog_validator.php', 'ezcConsoleDialog' => 'ConsoleTools/interfaces/dialog.php', 'ezcConsoleDialogOptions' => 'ConsoleTools/options/dialog.php', 'ezcConsoleInputHelpGenerator' => 'ConsoleTools/interfaces/input_help_generator.php', 'ezcConsoleInputValidator' => 'ConsoleTools/interfaces/input_validator.php', 'ezcConsoleMenuDialogValidator' => 'ConsoleTools/interfaces/menu_dialog_validator.php', 'ezcConsoleQuestionDialogCollectionValidator' => 'ConsoleTools/dialog/validators/question_dialog_collection.php', 'ezcConsoleArgument' => 'ConsoleTools/input/argument.php', 'ezcConsoleArguments' => 'ConsoleTools/input/arguments.php', 'ezcConsoleDialogViewer' => 'ConsoleTools/dialog_viewer.php', 'ezcConsoleInput' => 'ConsoleTools/input.php', 'ezcConsoleInputStandardHelpGenerator' => 'ConsoleTools/input/help_generators/standard.php', 'ezcConsoleMenuDialog' => 'ConsoleTools/dialog/menu_dialog.php', 'ezcConsoleMenuDialogDefaultValidator' => 'ConsoleTools/dialog/validators/menu_dialog_default.php', 'ezcConsoleMenuDialogOptions' => 'ConsoleTools/options/menu_dialog.php', 'ezcConsoleOption' => 'ConsoleTools/input/option.php', 'ezcConsoleOptionRule' => 'ConsoleTools/structs/option_rule.php', 'ezcConsoleOutput' => 'ConsoleTools/output.php', 'ezcConsoleOutputFormat' => 'ConsoleTools/structs/output_format.php', 'ezcConsoleOutputFormats' => 'ConsoleTools/structs/output_formats.php', 'ezcConsoleOutputOptions' => 'ConsoleTools/options/output.php', 'ezcConsoleProgressMonitor' => 'ConsoleTools/progressmonitor.php', 'ezcConsoleProgressMonitorOptions' => 'ConsoleTools/options/progressmonitor.php', 'ezcConsoleProgressbar' => 'ConsoleTools/progressbar.php', 'ezcConsoleProgressbarOptions' => 'ConsoleTools/options/progressbar.php', 'ezcConsoleQuestionDialog' => 'ConsoleTools/dialog/question_dialog.php', 'ezcConsoleQuestionDialogMappingValidator' => 'ConsoleTools/dialog/validators/question_dialog_mapping.php', 'ezcConsoleQuestionDialogOptions' => 'ConsoleTools/options/question_dialog.php', 'ezcConsoleQuestionDialogRegexValidator' => 'ConsoleTools/dialog/validators/question_dialog_regex.php', 'ezcConsoleQuestionDialogTypeValidator' => 'ConsoleTools/dialog/validators/question_dialog_type.php', 'ezcConsoleStandardInputValidator' => 'ConsoleTools/input/validators/standard.php', 'ezcConsoleStatusbar' => 'ConsoleTools/statusbar.php', 'ezcConsoleStatusbarOptions' => 'ConsoleTools/options/statusbar.php', 'ezcConsoleStringTool' => 'ConsoleTools/tools/string.php', 'ezcConsoleTable' => 'ConsoleTools/table.php', 'ezcConsoleTableCell' => 'ConsoleTools/table/cell.php', 'ezcConsoleTableOptions' => 'ConsoleTools/options/table.php', 'ezcConsoleTableRow' => 'ConsoleTools/table/row.php', ); ?>	6.36 KB	2024-07-17 10:16
📁 dialog	-	2025-05-25 12:37
📄 dialog_viewer.php <?php /** * File containing the ezcConsoleDialogViewer class. * * @package ConsoleTools * @version 1.6.1 * @copyright Copyright (C) 2005-2010 eZ Systems AS. All rights reserved. * @license http://ez.no/licenses/new_bsd New BSD License * @filesource / /* * Utility class for ezcConsoleDialog implementations. * This class contains utility methods for working with {@link * ezcConsoleDialog} implementations. * * To display a dialog in a loop until a valid result is received do: * <code> * // Instatiate dialog in $dialog ... * ezcConsoleDialogViewer::displayDialog( $dialog ); * </code> * * For implementing a custom dialog, the method {@link readLine()} method can be * used to read a line of input from the user. * * @package ConsoleTools * @version 1.6.1 / class ezcConsoleDialogViewer { /* * Displays a dialog and returns a valid result from it. * This methods displays a dialog in a loop, until it received a valid * result from it and returns this result. * * @param ezcConsoleDialog $dialog The dialog to display. * @return mixed The result from this dialog. / public static function displayDialog( ezcConsoleDialog $dialog ) { do { $dialog->display(); } while ( $dialog->hasValidResult() === false ); return $dialog->getResult(); } /* * Returns a line from STDIN. * The returned line is fully trimmed. * * @return string * @throws ezcConsoleDialogAbortException * if the user closes STDIN using <CTRL>-D. */ public static function readLine() { $res = trim( fgets( STDIN ) ); if ( feof( STDIN ) ) { throw new ezcConsoleDialogAbortException(); } return $res; } } ?>	1.78 KB	2024-07-17 10:16
📁 exceptions	-	2025-05-25 12:37
📁 input	-	2025-05-25 12:37
📄 input.php <?php /** * File containing the ezcConsoleInput class. * * @package ConsoleTools * @version 1.6.1 * @copyright Copyright (C) 2005-2010 eZ Systems AS. All rights reserved. * @license http://ez.no/licenses/new_bsd New BSD License * @filesource / /* * The ezcConsoleInput class handles the given options and arguments on the console. * * This class allows the complete handling of options and arguments submitted * to a console based application. * * The next example demonstrate how to capture the console options: * * <code> * $optionHandler = new ezcConsoleInput(); * * // Register simple parameter -h/--help * $optionHandler->registerOption( new ezcConsoleOption( 'h', 'help' ) ); * * // Register complex parameter -f/--file * $file = new ezcConsoleOption( * 'f', * 'file', * ezcConsoleInput::TYPE_STRING, * null, * false, * 'Process a file.', * 'Processes a single file.' * ); * $optionHandler->registerOption( $file ); * * // Manipulate parameter -f/--file after registration * $file->multiple = true; * * // Register another complex parameter that depends on -f and excludes -h * $dir = new ezcConsoleOption( * 'd', * 'dir', * ezcConsoleInput::TYPE_STRING, * null, * true, * 'Process a directory.', * 'Processes a complete directory.', * array( new ezcConsoleOptionRule( $optionHandler->getOption( 'f' ) ) ), * array( new ezcConsoleOptionRule( $optionHandler->getOption( 'h' ) ) ) * ); * $optionHandler->registerOption( $dir ); * * // Register an alias for this parameter * $optionHandler->registerAlias( 'e', 'extended-dir', $dir ); * * // Process registered parameters and handle errors * try * { * $optionHandler->process( array( 'example_input.php', '-h' ) ); * } * catch ( ezcConsoleOptionException $e ) * { * echo $e->getMessage(); * exit( 1 ); * } * * // Process a single parameter * $file = $optionHandler->getOption( 'f' ); * if ( $file->value === false ) * { * echo "Parameter -{$file->short}/--{$file->long} was not submitted.\n"; * } * elseif ( $file->value === true ) * { * echo "Parameter -{$file->short}/--{$file->long} was submitted without value.\n"; * } * else * { * echo "Parameter -{$file->short}/--{$file->long} was submitted with value '".var_export($file->value, true)."'.\n"; * } * * // Process all parameters at once: * foreach ( $optionHandler->getOptionValues() as $paramShort => $val ) * { * switch ( true ) * { * case $val === false: * echo "Parameter $paramShort was not submitted.\n"; * break; * case $val === true: * echo "Parameter $paramShort was submitted without a value.\n"; * break; * case is_array( $val ): * echo "Parameter $paramShort was submitted multiple times with value: '".implode(', ', $val)."'.\n"; * break; * default: * echo "Parameter $paramShort was submitted with value: '$val'.\n"; * break; * } * } * </code> * * @package ConsoleTools * @version 1.6.1 * @mainclass * * @property ezcConsoleArguments $argumentDefinition Optional argument definition. / class ezcConsoleInput { /* * Option does not carry a value. / const TYPE_NONE = 1; /* * Option takes an integer value. / const TYPE_INT = 2; /* * Option takes a string value. / const TYPE_STRING = 3; /* * Array of option definitions, indexed by number. * * This array stores the ezcConsoleOption objects representing * the options. * * For lookup of an option after its short or long values the attributes * {@link ezcConsoleInput::$optionShort} * {@link ezcConsoleInput::$optionLong} * are used. * * @var array(array) / private $options = array(); /* * Short option names. * * Each references a key in {@link ezcConsoleInput::$options}. * * @var array(string=>int) / private $optionShort = array(); /* * Long option names. * * Each references a key in {@link ezcConsoleInput::$options}. * * @var array(string=>int) / private $optionLong = array(); /* * Arguments, if submitted, are stored here. * * @var array(string) / private $arguments = array(); /* * Wether the process() method has already been called. * * @var bool / private $processed = false; /* * Indicates if an option was submitted, that has the isHelpOption flag set. * * @var bool / private $helpOptionSet = false; /* * Tool object for multi-byte encoding safe string operations. * * @var ezcConsoleStringTool / private $stringTool; /* * Input validator. * * @var ezcConsoleInputValidator / private $validator; /* * Help generator. * * @var ezcConsoleInputHelpGenerator / private $helpGenerator; /* * Collection of properties. * * @var array(string=>mixed) / protected $properties = array(); /* * Creates an input handler. / public function __construct() { $this->argumentDefinition = null; $this->stringTool = new ezcConsoleStringTool(); // @TODO Verify interface and make plugable $this->validator = new ezcConsoleStandardInputValidator(); $this->helpGenerator = new ezcConsoleInputStandardHelpGenerator( $this ); } /* * Registers the new option $option. * * This method adds the new option $option to your option collection. If * already an option with the assigned short or long value exists, an * exception will be thrown. * * @see ezcConsoleInput::unregisterOption() * * @param ezcConsoleOption $option * * @return ezcConsoleOption The recently registered option. / public function registerOption( ezcConsoleOption $option ) { foreach ( $this->optionShort as $short => $ref ) { if ( $short === $option->short ) { throw new ezcConsoleOptionAlreadyRegisteredException( $short ); } } foreach ( $this->optionLong as $long => $ref ) { if ( $long === $option->long ) { throw new ezcConsoleOptionAlreadyRegisteredException( $long ); } } $this->options[] = $option; $this->optionLong[$option->long] = $option; if ( $option->short !== "" ) { $this->optionShort[$option->short] = $option; } return $option; } /* * Registers an alias for an option. * * Registers a new alias for an existing option. Aliases can * be used as if they were a normal option. * * The alias is registered with the short option name $short and the * long option name $long. The alias references to the existing * option $option. * * @see ezcConsoleInput::unregisterAlias() * * @param string $short * @param string $long * @param ezcConsoleOption $option * * * @throws ezcConsoleOptionNotExistsException * If the referenced option is not registered. * @throws ezcConsoleOptionAlreadyRegisteredException * If another option/alias has taken the provided short or long name. * @return void / public function registerAlias( $short, $long, ezcConsoleOption $option ) { if ( !isset( $this->optionShort[$option->short] ) \|\| !isset( $this->optionLong[$option->long] ) ) { throw new ezcConsoleOptionNotExistsException( $option->long ); } if ( isset( $this->optionShort[$short] ) \|\| isset( $this->optionLong[$long] ) ) { throw new ezcConsoleOptionAlreadyRegisteredException( isset( $this->optionShort[$short] ) ? "-$short" : "--$long" ); } $this->optionShort[$short] = $option; $this->optionLong[$long] = $option; } /* * Registers options according to a string specification. * * Accepts a string to define parameters and registers all parameters as * options accordingly. String definition, specified in $optionDef, looks * like this: * * <code> * [s:\|size:][u:\|user:][a:\|all:] * </code> * * This string registers 3 parameters: * -s / --size * -u / --user * -a / --all * * @param string $optionDef * @return void * * @throws ezcConsoleOptionStringNotWellformedException * If provided string does not have the correct format. / public function registerOptionString( $optionDef ) { $regex = '\[([a-z0-9-]+)([:?+])?([^\|])\\|([a-z0-9-]+)([:?+])?\]'; // Check string for wellformedness if ( preg_match( "/^($regex)+$/", $optionDef ) == 0 ) { throw new ezcConsoleOptionStringNotWellformedException( "Option definition not wellformed: \"$optionDef\"" ); } if ( preg_match_all( "/$regex/", $optionDef, $matches ) ) { foreach ( $matches[1] as $id => $short ) { $option = null; $option = new ezcConsoleOption( $short, $matches[4][$id] ); if ( !empty( $matches[2][$id] ) \|\| !empty( $matches[5][$id] ) ) { switch ( !empty( $matches[2][$id] ) ? $matches[2][$id] : $matches[5][$id] ) { case '': // Allows 0 or more occurances $option->multiple = true; break; case '+': // Allows 1 or more occurances $option->multiple = true; $option->type = self::TYPE_STRING; break; case '?': $option->type = self::TYPE_STRING; $option->default = ''; break; default: break; } } if ( !empty( $matches[3][$id] ) ) { $option->default = $matches[3][$id]; } $this->registerOption( $option ); } } } /* * Removes an option. * * This function removes an option. All dependencies to that * specific option are removed completely from every other registered * option. * * @see ezcConsoleInput::registerOption() * * @param ezcConsoleOption $option The option object to unregister. * * @throws ezcConsoleOptionNotExistsException * If requesting a not registered option. * @return void / public function unregisterOption( ezcConsoleOption $option ) { $found = false; foreach ( $this->options as $id => $existParam ) { if ( $existParam === $option ) { $found = true; unset( $this->options[$id] ); continue; } $existParam->removeAllExclusions( $option ); $existParam->removeAllDependencies( $option ); } if ( $found === false ) { throw new ezcConsoleOptionNotExistsException( $option->long ); } foreach ( $this->optionLong as $name => $existParam ) { if ( $existParam === $option ) { unset( $this->optionLong[$name] ); } } foreach ( $this->optionShort as $name => $existParam ) { if ( $existParam === $option ) { unset( $this->optionShort[$name] ); } } } /* * Removes an alias to an option. * * This function removes an alias with the short name $short and long * name $long. * * @see ezcConsoleInput::registerAlias() * * @throws ezcConsoleOptionNoAliasException * If the requested short/long name belongs to a real parameter instead. * * @param string $short * @param string $long * @return void * * @todo Check if $short and $long refer to the same option! / public function unregisterAlias( $short, $long ) { foreach ( $this->options as $id => $option ) { if ( $option->short === $short ) { throw new ezcConsoleOptionNoAliasException( $short ); } if ( $option->long === $long ) { throw new ezcConsoleOptionNoAliasException( $long ); } } if ( isset( $this->optionShort[$short] ) ) { unset( $this->optionShort[$short] ); } if ( isset( $this->optionLong[$long] ) ) { unset( $this->optionLong[$long] ); } } /* * Returns the definition object for the option with the name $name. * * This method receives the long or short name of an option and * returns the ezcConsoleOption object. * * @param string $name Short or long name of the option (without - or --). * @return ezcConsoleOption * * @throws ezcConsoleOptionNotExistsException * If requesting a not registered parameter. / public function getOption( $name ) { $name = $name; if ( isset( $this->optionShort[$name] ) ) { return $this->optionShort[$name]; } if ( isset( $this->optionLong[$name] ) ) { return $this->optionLong[$name]; } throw new ezcConsoleOptionNotExistsException( $name ); } /* * Process the input parameters. * * Actually process the input options and arguments according to the actual * settings. * * Per default this method uses $argc and $argv for processing. You can * override this setting with your own input, if necessary, using the * parameters of this method. (Attention, first argument is always the pro * gram name itself!) * * All exceptions thrown by this method contain an additional attribute "option" * which specifies the parameter on which the error occurred. * * @param array(string) $args The arguments * @return void * * @throws ezcConsoleOptionNotExistsException * If an option that was submitted does not exist. * @throws ezcConsoleOptionDependencyViolationException * If a dependency rule was violated. * @throws ezcConsoleOptionExclusionViolationException * If an exclusion rule was violated. * @throws ezcConsoleOptionTypeViolationException * If the type of a submitted value violates the options type rule. * @throws ezcConsoleOptionArgumentsViolationException * If arguments are passed although a parameter disallowed them. * * @see ezcConsoleOptionException / public function process( array $args = null ) { if ( $this->processed ) { $this->reset(); } $this->processed = true; if ( !isset( $args ) ) { $args = isset( $argv ) ? $argv : isset( $_SERVER['argv'] ) ? $_SERVER['argv'] : array(); } $nextIndex = $this->processOptions( $args ); if ( $this->helpOptionSet() ) { // No need to parse arguments return; } $this->processArguments( $args, $nextIndex ); $this->checkRules(); $this->setOptionDefaults(); } /* * Sets defaults for options that have not been submitted. * * Checks all options if they have been submited. If not and a default * values is present, this is set as the options value. / private function setOptionDefaults() { foreach ( $this->options as $option ) { if ( $option->value === false \|\| $option->value === array() ) { // Default value to set? if ( $option->default !== null ) { $option->value = $option->default; } } } } /* * Reads the submitted options from $args array. * * Returns the next index to check for arguments. * * @param array(string) $args * @returns int * * @throws ezcConsoleOptionNotExistsException * if a submitted option does not exist. * @throws ezcConsoleOptionTooManyValuesException * if an option that expects only a single value was submitted * with multiple values. * @throws ezcConsoleOptionTypeViolationException * if an option was submitted with a value of the wrong type. * @throws ezcConsoleOptionMissingValueException * if an option thats expects a value was submitted without. / private function processOptions( array $args ) { $numArgs = count( $args ); $i = 1; while ( $i < $numArgs ) { if ( $args[$i] === '--' ) { break; } // Equalize parameter handling (long params with =) if ( iconv_substr( $args[$i], 0, 2, 'UTF-8' ) == '--' ) { $this->preprocessLongOption( $args, $i ); // Update number of args, changed by preprocessLongOption() $numArgs = count( $args ); } // Check for parameter if ( iconv_substr( $args[$i], 0, 1, 'UTF-8' ) === '-' ) { if ( !$this->hasOption( preg_replace( '/^-/', '', $args[$i] ) ) ) { throw new ezcConsoleOptionNotExistsException( $args[$i] ); } $this->processOption( $args, $i ); } // Must be the arguments else { break; } } // Move pointer over argument sign isset( $args[$i] ) && $args[$i] == '--' ? ++$i : $i; return $i; } /** * Resets all option and argument values. * * This method is called automatically by {@link process()}, if this method * is called twice or more, and may also be used to manually reset the * values of all registered {@ezcConsoleOption} and {@link * ezcConsoleArgument} objects. / public function reset() { foreach ( $this->options as $option ) { $option->value = false; } if ( $this->argumentDefinition !== null ) { foreach ( $this->argumentDefinition as $argument ) { $argument->value = null; } } $this->arguments = array(); } /* * Returns true if an option with the given name exists, otherwise false. * * Checks if an option with the given name is registered. * * @param string $name Short or long name of the option. * @return bool True if option exists, otherwise false. / public function hasOption( $name ) { try { $param = $this->getOption( $name ); } catch ( ezcConsoleOptionNotExistsException $e ) { return false; } return true; } /* * Returns an array of all registered options. * * Returns an array of all registered options in the following format: * <code> * array( * 0 => ezcConsoleOption, * 1 => ezcConsoleOption, * 2 => ezcConsoleOption, * ... * ); * </code> * * @return array(string=>ezcConsoleOption) Registered options. / public function getOptions() { return $this->options; } /* * Returns the values of all submitted options. * * Returns an array of all values submitted to the options. The array is * indexed by the parameters short name (excluding the '-' prefix). The array * does not contain any parameter, which value is 'false' (meaning: the * parameter was not submitted). * * @param bool $longnames Wheather to use longnames for indexing. * @return array(string=>mixed) / public function getOptionValues( $longnames = false ) { $res = array(); foreach ( $this->options as $param ) { if ( $param->value !== false ) { $res[( $longnames === true ) ? $param->long : $param->short] = $param->value; } } return $res; } /* * Returns arguments provided to the program. * * This method returns all arguments provided to a program in an * int indexed array. Arguments are sorted in the way * they are submitted to the program. You can disable arguments * through the 'arguments' flag of a parameter, if you want * to disallow arguments. * * Arguments are either the last part of the program call (if the * last parameter is not a 'multiple' one) or divided via the '--' * method which is commonly used on Unix (if the last parameter * accepts multiple values this is required). * * @return array(string) Arguments. / public function getArguments() { return $this->arguments; } /* * Get help information for your options. * * This method returns an array of help information for your options, * indexed by int. Each help info has 2 fields: * * 0 => The options names ("<short> / <long>") * 1 => The help text (depending on the $long parameter) * * The $long options determines if you want to get the short or long help * texts. The array returned can be used by {@link ezcConsoleTable}. * * If using the second options, you can filter the options shown in the * help output (e.g. to show short help for related options). Provide * as simple number indexed array of short and/or long values to set a filter. * * The $paramGrouping option can be used to group options in the help * output. The structure of this array parameter is as follows: * * <code> * array( * 'First section' => array( * 'input', * 'output' * 'overwrite', * ), * 'Second section' => array( * 'v', * 'h', * ), * ) * </code> * * As can be seen, short option names are possible as well as long ones. * The key of the first array level is the name of the section, which is * assigned to an array of options to group under this section. The $params * parameter still influences if an option is displayed at all. * * @param bool $long * @param array(string) $params * @param array(string=>array(string)) $paramGrouping * @return array(array(string)) Table structure as explained. * * @apichange In future versions, the default values of $params will change * to null instead of an empty array. Giving an empty array for * these will then be taken literally. / public function getHelp( $long = false, array $params = array(), array $paramGrouping = null ) { // New handling $params = ( $params === array() \|\| $params === null ? null : $params ); $help = array(); if ( $paramGrouping === null ) { // Original handling $help = $this->getOptionHelpWithoutGrouping( $long, $params ); } else { $help = $this->getOptionHelpWithGrouping( $long, $params, $paramGrouping ); } if ( $this->argumentDefinition !== null ) { $help[] = array( "Arguments:", '' ); $argumentsHelp = $this->helpGenerator->generateArgumentHelp( $long ); if ( $argumentsHelp === array() ) { $help[] = array( '', "No arguments available." ); } else { $help = array_merge( $help, $argumentsHelp ); } } return $help; } /* * Creates the option help array in the original, ungrouped way. * * Creates the original help array generated by {@link getHelp()}. The * $long and $params options are the same as they are for this method. * * @param bool $long * @param array $params * @return array / private function getOptionHelpWithoutGrouping( $long, $params ) { return $this->helpGenerator->generateUngroupedOptionHelp( $long, $params ); } /* * Generates options helo array with ordering and grouping. * * @param mixed $long * @param mixed $params * @param mixed $paramGrouping * @return array() / private function getOptionHelpWithGrouping( $long, $params, $paramGrouping ) { $rawHelp = $this->helpGenerator->generateGroupedOptionHelp( $paramGrouping, $long, $params ); $help = array(); $first = true; foreach ( $rawHelp as $category => $optionsHelp ) { if ( !$first ) { $help[] = array( '', '' ); } else { $first = false; } $help[] = array( $category, '' ); $help = array_merge( $help, $optionsHelp ); } return $help; } /* * Get help information for your options as a table. * * This method provides the information returned by * {@link ezcConsoleInput::getHelp()} in a table. * * The $paramGrouping option can be used to group options in the help * output. The structure of this array parameter is as follows: * * <code> * array( * 'First section' => array( * 'input', * 'output' * 'overwrite', * ), * 'Second section' => array( * 'v', * 'h', * ), * ) * </code> * * As can be seen, short option names are possible as well as long ones. * The key of the first array level is the name of the section, which is * assigned to an array of options to group under this section. The $params * parameter still influences if an option as displayed at all. * * @param ezcConsoleTable $table The table object to fill. * @param bool $long Set this to true for getting the * long help version. * @param array(string) $params Set of option names to generate help * for, default is all. * @param array(string=>array(string)) $paramGrouping * @return ezcConsoleTable The filled table. / public function getHelpTable( ezcConsoleTable $table, $long = false, array $params = array(), $paramGrouping = null ) { $help = $this->getHelp( $long, $params, $paramGrouping ); $i = 0; foreach ( $help as $row ) { $table[$i][0]->content = $row[0]; $table[$i++][1]->content = $row[1]; } return $table; } /* * Returns a standard help output for your program. * * This method generates a help text as it's commonly known from Unix * command line programs. The output will contain the synopsis, your * provided program description and the selected parameter help * as also provided by {@link ezcConsoleInput::getHelp()}. The returned * string can directly be printed to the console. * * The $paramGrouping option can be used to group options in the help * output. The structure of this array parameter is as follows: * * <code> * array( * 'First section' => array( * 'input', * 'output' * 'overwrite', * ), * 'Second section' => array( * 'v', * 'h', * ), * ) * </code> * * As can be seen, short option names are possible as well as long ones. * The key of the first array level is the name of the section, which is * assigned to an array of options to group under this section. The $params * parameter still influences if an option as displayed at all. * * @param string $programDesc The description of your program. * @param int $width The width to adjust the output text to. * @param bool $long Set this to true for getting the long * help version. * @param array(string) $params Set of option names to generate help * for, default is all. * @param array(string=>array(string)) $paramGrouping * @return string The generated help text. / public function getHelpText( $programDesc, $width = 80, $long = false, array $params = null, $paramGrouping = null ) { $help = $this->getHelp( $long, ( $params == null ? array() : $params ), $paramGrouping ); // Determine max length of first column text. $maxLength = 0; foreach ( $help as $row ) { $maxLength = max( $maxLength, iconv_strlen( $row[0], 'UTF-8' ) ); } // Width of left column $leftColWidth = $maxLength + 2; // Width of righ column $rightColWidth = $width - $leftColWidth; $res = 'Usage: ' . $this->getSynopsis( $params ) . PHP_EOL; $res .= $this->stringTool->wordwrap( $programDesc, $width, PHP_EOL ); $res .= PHP_EOL . PHP_EOL; foreach ( $help as $row ) { $rowParts = explode( "\n", $this->stringTool->wordwrap( $row[1], $rightColWidth ) ); $res .= $this->stringTool->strPad( $row[0], $leftColWidth, ' ' ); $res .= $rowParts[0] . PHP_EOL; // @TODO: Fix function call in loop header for ( $i = 1; $i < sizeof( $rowParts ); $i++ ) { $res .= str_repeat( ' ', $leftColWidth ) . $rowParts[$i] . PHP_EOL; } } return $res; } /* * Returns the synopsis string for the program. * * This gives you a synopsis definition for the options and arguments * defined with this instance of ezcConsoleInput. You can filter the * options named in the synopsis by submitting their short names in an * array as the parameter of this method. If the parameter $optionNames * is set, only those options are listed in the synopsis. * * @param array(string) $optionNames * @return string / public function getSynopsis( array $optionNames = null ) { return $this->helpGenerator->generateSynopsis( $optionNames ); } /* * Returns if a help option was set. * This method returns if an option was submitted, which was defined to be * a help option, using the isHelpOption flag. * * @return bool If a help option was set. / public function helpOptionSet() { return $this->helpOptionSet; } /* * Property read access. * * @throws ezcBasePropertyNotFoundException * If the the desired property is not found. * * @param string $propertyName Name of the property. * @return mixed Value of the property or null. * @ignore / public function __get( $propertyName ) { if ( !isset( $this->$propertyName ) ) { throw new ezcBasePropertyNotFoundException( $propertyName ); } return $this->properties[$propertyName]; } /* * Property set access. * * @param string $propertyName * @param string $propertyValue * @ignore * @return void / public function __set( $propertyName, $propertyValue ) { switch ( $propertyName ) { case "argumentDefinition": if ( ( $propertyValue instanceof ezcConsoleArguments ) === false && $propertyValue !== null ) { throw new ezcBaseValueException( $propertyName, $propertyValue, "ezcConsoleArguments" ); } break; default: throw new ezcBasePropertyNotFoundException( $propertyName ); } $this->properties[$propertyName] = $propertyValue; } /* * Property isset access. * * @param string $propertyName Name of the property. * @return bool True if the property is set, otherwise false. * @ignore / public function __isset( $propertyName ) { return array_key_exists( $propertyName, $this->properties ); } /* * Returns the synopsis string for a single option and its dependencies. * * This method returns a part of the program synopsis, specifically for a * certain parameter. The method recursively adds depending parameters up * to the 2nd depth level to the synopsis. The second parameter is used * to store the short names of all options that have already been used in * the synopsis (to avoid adding an option twice). The 3rd parameter * determines the actual deps in the option dependency recursion to * terminate that after 2 recursions. * * @param ezcConsoleOption $option The option to include. * @param array(string) $usedOptions Array of used option short names. * @param int $depth Current recursion depth. * @return string The synopsis for this parameter. * * @apichange This method is deprecates. Implement your own {@link * ezcConsoleInputHelpGenerator} instead, as soon as the * interface is made public. / protected function createOptionSynopsis( ezcConsoleOption $option, &$usedOptions, $depth = 0 ) { $synopsis = ''; // Break after a nesting level of 2 if ( $depth++ > 2 \|\| ( in_array( $option->short, $usedOptions['short'] ) && in_array( $option->long, $usedOptions['long'] ) ) ) return $synopsis; $usedOptions['short'][] = $option->short; $usedOptions['long'][] = $option->long; $synopsis .= $option->short !== "" ? "-{$option->short}" : "--{$option->long}"; if ( isset( $option->default ) ) { $synopsis .= " " . ( $option->type === ezcConsoleInput::TYPE_STRING ? '"' : '' ) . $option->default . ( $option->type === ezcConsoleInput::TYPE_STRING ? '"' : '' ); } else if ( $option->type !== ezcConsoleInput::TYPE_NONE ) { $synopsis .= " "; switch ( $option->type ) { case ezcConsoleInput::TYPE_STRING: $synopsis .= "<string>"; break; case ezcConsoleInput::TYPE_INT: $synopsis .= "<int>"; break; } } foreach ( $option->getDependencies() as $rule ) { $deeperSynopsis = $this->createOptionSynopsis( $rule->option, $usedOptions, $depth ); $synopsis .= ( iconv_strlen( trim( $deeperSynopsis ), 'UTF-8' ) > 0 ? ' ' . $deeperSynopsis : '' ); } if ( $option->arguments === false ) { $allowsArgs = false; } // Make the whole thing optional? if ( $option->mandatory === false ) { $synopsis = "[$synopsis]"; } return $synopsis . ' '; } /* * Process an option. * * This method does the processing of a single option. * * @param array(string) $args The arguments array. * @param int $i The current position in the arguments array. * @return void * * @throws ezcConsoleOptionTooManyValuesException * If an option that expects only a single value was submitted * with multiple values. * @throws ezcConsoleOptionTypeViolationException * If an option was submitted with a value of the wrong type. * @throws ezcConsoleOptionMissingValueException * If an option thats expects a value was submitted without. / private function processOption( array $args, &$i ) { $option = $this->getOption( preg_replace( '/^-+/', '', $args[$i++] ) ); // Is the actual option a help option? if ( $option->isHelpOption === true ) { $this->helpOptionSet = true; } // No value expected if ( $option->type === ezcConsoleInput::TYPE_NONE ) { // No value expected if ( isset( $args[$i] ) && iconv_substr( $args[$i], 0, 1, 'UTF-8' ) !== '-' && sizeof( $args ) > ( $i + 1 ) ) { // But one found throw new ezcConsoleOptionTypeViolationException( $option, $args[$i] ); } // Multiple occurance possible if ( $option->multiple === true ) { $option->value[] = true; } else { $option->value = true; } // Everything fine, nothing to do return $i; } // Value expected, check for it if ( isset( $args[$i] ) && iconv_substr( $args[$i], 0, 1, 'UTF-8' ) !== '-' ) { // Type check if ( $this->isCorrectType( $option->type, $args[$i] ) === false ) { throw new ezcConsoleOptionTypeViolationException( $option, $args[$i] ); } // Multiple values possible if ( $option->multiple === true ) { $option->value[] = $args[$i]; } // Only single value expected, check for multiple elseif ( isset( $option->value ) && $option->value !== false ) { throw new ezcConsoleOptionTooManyValuesException( $option ); } else { $option->value = $args[$i]; } $i++; } // Value found? If not, use default, if available if ( !isset( $option->value ) \|\| $option->value === false \|\| ( is_array( $option->value ) && count( $option->value ) === 0) ) { throw new ezcConsoleOptionMissingValueException( $option ); } } /* * Process arguments given to the program. * * @param array(string) $args The arguments array. * @param int $i Current index in arguments array. * @return void / private function processArguments( array $args, &$i ) { $numArgs = count( $args ); if ( $this->argumentDefinition === null \|\| $this->argumentsAllowed() === false ) { // Old argument handling, also used of a set option sets disallowing arguments while ( $i < $numArgs ) { $this->arguments[] = $args[$i++]; } } else { $mandatory = true; foreach ( $this->argumentDefinition as $arg ) { // Check if all followinga arguments are optional if ( $arg->mandatory === false ) { $mandatory = false; } // Check if the current argument is present and mandatory if ( $mandatory === true ) { if ( !isset( $args[$i] ) ) { throw new ezcConsoleArgumentMandatoryViolationException( $arg ); } } else { // Arguments are optional, if no more left: return. if ( !isset( $args[$i] ) ) { // Optional and no more arguments left, assign default $arg->value = $arg->default; continue; } } if ( $arg->multiple === true ) { $arg->value = array(); for ( $i = $i; $i < $numArgs; ++$i ) { if ( $this->isCorrectType( $arg->type, $args[$i] ) === false ) { throw new ezcConsoleArgumentTypeViolationException( $arg, $args[$i] ); } $arg->value = array_merge( $arg->value, array( $args[$i] ) ); // Keep old handling, too $this->arguments[] = $args[$i]; } return; } else { if ( $this->isCorrectType( $arg->type, $args[$i] ) === false ) { throw new ezcConsoleArgumentTypeViolationException( $arg, $args[$i] ); } $arg->value = $args[$i]; // Keep old handling, too $this->arguments[] = $args[$i]; } ++$i; } if ( $i < $numArgs ) { throw new ezcConsoleTooManyArgumentsException( $args, $i ); } } } /* * Returns if arguments are allowed with the current option submition. * * @return bool If arguments allowed. / protected function argumentsAllowed() { foreach ( $this->options as $id => $option ) { if ( $option->value !== false && $option->arguments === false ) { return false; } } return true; } /* * Check the rules that may be associated with an option. * * Options are allowed to have rules associated for dependencies to other * options and exclusion of other options or arguments. This method * processes the checks. * * @throws ezcConsoleException * in case validation fails. / private function checkRules() { // If a help option is set, skip rule checking if ( $this->helpOptionSet === true ) { return; } $this->validator->validateOptions( $this->options, ( $this->arguments !== array() ) ); } /* * Checks if a value is of a given type. Converts the value to the * correct PHP type on success. * * @param int $type The type to check for. One of self::TYPE_. @param string $val The value to check. Will possibly altered! * @return bool True on succesful check, otherwise false. / private function isCorrectType( $type, &$val ) { $res = false; switch ( $type ) { case ezcConsoleInput::TYPE_STRING: $res = true; $val = preg_replace( '/^(["\'])(.)\1$/', '\2', $val ); break; case ezcConsoleInput::TYPE_INT: $res = preg_match( '/^[0-9]+$/', $val ) ? true : false; if ( $res ) { $val = ( int ) $val; } break; } return $res; } /** * Split parameter and value for long option names. * * This method checks for long options, if the value is passed using =. If * this is the case parameter and value get split and replaced in the * arguments array. * * @param array(string) $args The arguments array * @param int $i Current arguments array position * @return void */ private function preprocessLongOption( array &$args, $i ) { // Value given? if ( preg_match( '/^--\w+\=[^ ]/i', $args[$i] ) ) { // Split param and value and replace current param $parts = explode( '=', $args[$i], 2 ); array_splice( $args, $i, 1, $parts ); } } } ?>	44.07 KB	2024-07-17 10:16
📁 interfaces	-	2025-05-25 12:37
📁 options	-	2025-05-25 12:37
📄 output.php <?php /** * File containing the ezcConsoleOutput class. * * @package ConsoleTools * @version 1.6.1 * @copyright Copyright (C) 2005-2010 eZ Systems AS. All rights reserved. * @license http://ez.no/licenses/new_bsd New BSD License * @filesource / /* * Class for handling console output. * * The ezcConsoleOutput class provides an interface to output text to the console. It deals with formating * text in different ways and offers some comfortable options to deal * with console text output. * * <code> * // Create the output handler * $out = new ezcConsoleOutput(); * * // Set the verbosity to level 10 * $out->options->verbosityLevel = 10; * // Enable auto wrapping of lines after 40 characters * $out->options->autobreak = 40; * * // Set the color of the default output format to green * $out->formats->default->color = 'green'; * * // Set the color of the output format named 'success' to white * $out->formats->success->color = 'white'; * // Set the style of the output format named 'success' to bold * $out->formats->success->style = array( 'bold' ); * * // Set the color of the output format named 'failure' to red * $out->formats->failure->color = 'red'; * // Set the style of the output format named 'failure' to bold * $out->formats->failure->style = array( 'bold' ); * // Set the background color of the output format named 'failure' to blue * $out->formats->failure->bgcolor = 'blue'; * * // Output text with default format * $out->outputText( 'This is default text ' ); * // Output text with format 'success' * $out->outputText( 'including success message', 'success' ); * // Some more output with default output. * $out->outputText( "and a manual linebreak.\n" ); * * // Manipulate the later output * $out->formats->success->color = 'green'; * $out->formats->default->color = 'blue'; * * // This is visible, since we set verbosityLevel to 10, and printed in default format (now blue) * $out->outputText( "Some verbose output.\n", null, 10 ); * // This is not visible, since we set verbosityLevel to 10 * $out->outputText( "Some more verbose output.\n", null, 20 ); * // This is visible, since we set verbosityLevel to 10, and printed in format 'failure' * $out->outputText( "And some not so verbose, failure output.\n", 'failure', 5 ); * </code> * * For a list of valid colors, style attributes and background colors, please * refer to {@link ezcConsoleOutputFormat}. * * ATTENTION: Windows operating systems do not support styling of text on the * console. Therefore no styling sequences are generated on any version of * this operating system. * * @property ezcConsoleOutputOptions $options * Contains the options for this class. * @property ezcConsoleOutputFormats $formats * Contains the output formats. * * @package ConsoleTools * @version 1.6.1 * @mainclass / class ezcConsoleOutput { /* * Target to print to standard out, with output buffering possibility. / const TARGET_OUTPUT = "php://output"; /* * Target to print to standard out. / const TARGET_STDOUT = "php://stdout"; /* * Target to print to standard error. / const TARGET_STDERR = "php://stderr"; /* * Container to hold the properties * * @var array(string=>mixed) / protected $properties; /* * Whether a position has been stored before, using the storePos() method. * * @see ezcConsoleOutput::storePos() * @var bool / protected $positionStored = false; /* * Stores the mapping of color names to their escape * sequence values. * * @var array(string=>int) / protected static $color = array( 'gray' => 30, 'black' => 30, // Alias black to gray (Bug #8478) 'red' => 31, 'green' => 32, 'yellow' => 33, 'blue' => 34, 'magenta' => 35, 'cyan' => 36, 'white' => 37, 'default' => 39 ); /* * Stores the mapping of bgcolor names to their escape * sequence values. * * @var array(string=>int) / protected static $bgcolor = array( 'gray' => 40, // Alias gray to black (Bug #8478) 'black' => 40, 'red' => 41, 'green' => 42, 'yellow' => 43, 'blue' => 44, 'magenta' => 45, 'cyan' => 46, 'white' => 47, 'default' => 49, ); /* * Stores the mapping of styles names to their escape * sequence values. * * @var array(string=>int) / protected static $style = array( 'default' => '0', 'bold' => 1, 'faint' => 2, 'normal' => 22, 'italic' => 3, 'notitalic' => 23, 'underlined' => 4, 'doubleunderlined' => 21, 'notunderlined' => 24, 'blink' => 5, 'blinkfast' => 6, 'noblink' => 25, 'negative' => 7, 'positive' => 27, ); /* * Basic escape sequence string. Use sprintf() to insert escape codes. * * @var string / private $escapeSequence = "\033[%sm"; /* * Collection of targets to print to. * * @var array / private $targets = array(); /* * Create a new console output handler. * * @see ezcConsoleOutput::$options * @see ezcConsoleOutputOptions * @see ezcConsoleOutput::$formats * @see ezcConsoleOutputFormats * * @param ezcConsoleOutputFormats $formats Formats to be used for output. * @param array(string=>string) $options Options to set. / public function __construct( ezcConsoleOutputFormats $formats = null, array $options = array() ) { $options = isset( $options ) ? $options : new ezcConsoleOutputOptions(); $formats = isset( $formats ) ? $formats : new ezcConsoleOutputFormats(); $this->properties['options'] = new ezcConsoleOutputOptions( $options ); $this->properties['formats'] = $formats; } /* * Set new options. * This method allows you to change the options of an output handler. * * @param ezcConsoleOutputOptions $options The options to set. * * @throws ezcBaseSettingNotFoundException * If you tried to set a non-existent option value. * @throws ezcBaseSettingValueException * If the value is not valid for the desired option. * @throws ezcBaseValueException * If you submit neither an array nor an instance of * ezcConsoleOutputOptions. / public function setOptions( $options ) { if ( is_array( $options ) ) { $this->properties['options']->merge( $options ); } else if ( $options instanceof ezcConsoleOutputOptions ) { $this->properties['options'] = $options; } else { throw new ezcBaseValueException( "options", $options, "instance of ezcConsoleOutputOptions" ); } } /* * Returns the current options. * Returns the options currently set for this output handler. * * @return ezcConsoleOutputOptions The current options. / public function getOptions() { return $this->properties['options']; } /* * Property read access. * * @throws ezcBasePropertyNotFoundException * If the the desired property is not found. * * @param string $propertyName Name of the property. * @return mixed Value of the property or null. * @ignore / public function __get( $propertyName ) { switch ( $propertyName ) { case 'options': case 'formats': return $this->properties[$propertyName]; default: break; } throw new ezcBasePropertyNotFoundException( $propertyName ); } /* * Property write access. * * @param string $propertyName Name of the property. * @param mixed $val The value for the property. * * @throws ezcBaseValueException * If a the value for the property options is not an instance of * ezcConsoleOutputOptions. * @throws ezcBaseValueException * If a the value for the property formats is not an instance of * ezcConsoleOutputFormats. * @ignore / public function __set( $propertyName, $val ) { switch ( $propertyName ) { case 'options': if ( !( $val instanceof ezcConsoleOutputOptions ) ) { throw new ezcBaseValueException( $propertyName, $val, 'ezcConsoleOutputOptions' ); } $this->properties['options'] = $val; return; case 'formats': if ( !( $val instanceof ezcConsoleOutputFormats ) ) { throw new ezcBaseValueException( $propertyName, $val, 'ezcConsoleOutputFormats' ); } $this->properties['formats'] = $val; return; default: break; } throw new ezcBasePropertyNotFoundException( $propertyName ); } /* * Property isset access. * * @param string $propertyName Name of the property. * @return bool True is the property is set, otherwise false. * @ignore / public function __isset( $propertyName ) { switch ( $propertyName ) { case 'options': case 'formats': return true; } return false; } /* * Print text to the console. * * Output a string to the console. If $format parameter is omitted, the * default style is chosen. Style can either be a special style {@link * ezcConsoleOutput::$options}, a style name {@link * ezcConsoleOutput::$formats} or 'default' to print with the default * styling. * * The $format parameter defines the name of a format. Formats are defined * through the $formats proprty, which contains format definitions in form * of {@link ezcConsoleOutputFormat} objects. The format influences the * outer appearance of a message (e.g. color) as well as the target the * message is printed to (e.g. STDERR). * * @throws ezcConsoleInvalidOutputTargetException * If the given target ({@link ezcConsoleOutputFormat}) could not * be opened for writing or writing failed. * * @param string $text The text to print. * @param string $format Format chosen for printing. * @param int $verbosityLevel On which verbose level to output this message. * @return void / public function outputText( $text, $format = 'default', $verbosityLevel = 1 ) { if ( $this->properties['options']->verbosityLevel >= $verbosityLevel ) { if ( is_int( $this->properties['options']->autobreak ) && $this->properties['options']->autobreak > 0 ) { $textLines = preg_split( "(\r\n\|\n\|\r)", $text ); foreach ( $textLines as $id => $textLine ) { $textLines[$id] = wordwrap( $textLine, $this->properties['options']->autobreak, PHP_EOL, true ); } $text = implode( PHP_EOL, $textLines ); } // Initialize target, if not happened before if ( !isset( $this->targets[$this->formats->$format->target] ) ) { // @ to suppress the warning. We handle error cases with an // exception here. if ( ( $this->targets[$this->formats->$format->target] = @fopen( $this->formats->$format->target, "w" ) ) === false ) { throw new ezcConsoleInvalidOutputTargetException( $this->formats->$format->target ); } } // Print using formats or without. Note: Since the target is a part // of the format, it will also be ignored, if you switch formats off! if ( $this->properties['options']->useFormats === true ) { if ( fwrite( $this->targets[$this->formats->$format->target], $this->formatText( $text, $format ) ) === false ) { throw new ezcConsoleInvalidOutputTargetException( $this->formats->$format->target ); } } else { echo $text; } } } /* * Print text to the console and automatically append a line break. * * This method acts similar to {@link ezcConsoleOutput::outputText()}, in * fact it even uses it. The difference is, that outputLine() * automatically appends a manual line break to the printed text. Besides * that, you can leave out the $text parameter of outputLine() to only * print a line break. * * The $format parameter defines the name of a format. Formats are defined * through the $formats proprty, which contains format definitions in form * of {@link ezcConsoleOutputFormat} objects. The format influences the * outer appearance of a message (e.g. color) as well as the target the * message is printed to (e.g. STDERR). * * @param string $text The text to print. * @param string $format Format chosen for printing. * @param int $verbosityLevel On which verbose level to output this message. * @return void / public function outputLine( $text = '', $format = 'default', $verbosityLevel = 1 ) { $this->outputText( $text . PHP_EOL, $format, $verbosityLevel ); } /* * Returns a formated version of the text. * * If $format parameter is omitted, the default style is chosen. The format * must be a valid registered format definition. For information on the * formats, see {@link ezcConsoleOutput::$formats}. * * @param string $text Text to apply style to. * @param string $format Format chosen to be applied. * @return string / public function formatText( $text, $format = 'default' ) { switch ( ezcBaseFeatures::os() ) { case "Windows": return $text; default: return $this->buildSequence( $format ) . $text . $this->buildSequence( 'default' ); } } /* * Stores the current cursor position. * * Saves the current cursor position to return to it using * {@link ezcConsoleOutput::restorePos()}. Multiple calls * to this method will override each other. Only the last * position is saved. * * @return void / public function storePos() { if ( ezcBaseFeatures::os() !== "Windows" ) { echo "\0337"; $this->positionStored = true; } } /* * Restores a cursor position. * * Restores the cursor position last saved using {@link * ezcConsoleOutput::storePos()}. * * @throws ezcConsoleNoPositionStoredException * If no position is saved. * @return void / public function restorePos() { if ( ezcBaseFeatures::os() !== "Windows" ) { if ( $this->positionStored === false ) { throw new ezcConsoleNoPositionStoredException(); } echo "\0338"; } } /* * Move the cursor to a specific column of the current line. * * Moves the cursor to a specific column index of the current line (default * is 1). * * @param int $column Column to jump to. * @return void / public function toPos( $column = 1 ) { if ( ezcBaseFeatures::os() !== "Windows" ) { echo "\033[{$column}G"; } } /* * Returns if a format code is valid for the specific formating option. * * This method determines if a given code is valid for a specific * formatting option ('color', 'bgcolor' or 'style'). * * @see ezcConsoleOutput::getFormatCode(); * * @param string $type Formating type. * @param string $key Format option name. * @return bool True if the code is valid. / public static function isValidFormatCode( $type, $key ) { return isset( self::${$type}[$key] ); } /* * Returns the escape sequence for a specific format. * * Returns the default format escape sequence, if the requested format does * not exist. * * @param string $format Name of the format. * @return string The escape sequence. / protected function buildSequence( $format = 'default' ) { if ( $format === 'default' ) { return sprintf( $this->escapeSequence, 0 ); } $modifiers = array(); $formats = array( 'color', 'style', 'bgcolor' ); foreach ( $formats as $formatType ) { // Get modifiers if ( is_array( $this->formats->$format->$formatType ) ) { if ( !in_array( 'default', $this->formats->$format->$formatType ) ) { foreach ( $this->formats->$format->$formatType as $singleVal ) { $modifiers[] = $this->getFormatCode( $formatType, $singleVal ); } } } else { if ( $this->formats->$format->$formatType !== 'default' ) { $modifiers[] = $this->getFormatCode( $formatType, $this->formats->$format->$formatType ); } } } // Merge modifiers return sprintf( $this->escapeSequence, implode( ';', $modifiers ) ); } /* * Returns the code for a given formating option of a given type. * * $type is the type of formating ('color', 'bgcolor' or 'style'), $key the * name of the format to lookup. Returns the numeric code for the requested * format or 0 if format or type do not exist. * * @see ezcConsoleOutput::isValidFormatCode() * * @param string $type Formatting type. * @param string $key Format option name. * @return int The code representation. */ protected function getFormatCode( $type, $key ) { if ( !ezcConsoleOutput::isValidFormatCode( $type, $key ) ) { return 0; } return ezcConsoleOutput::${$type}[$key]; } } ?>	18.68 KB	2024-07-17 10:16
📄 progressbar.php <?php /** * File containing the ezcConsoleProgressbar class. * * @package ConsoleTools * @version 1.6.1 * @copyright Copyright (C) 2005-2010 eZ Systems AS. All rights reserved. * @license http://ez.no/licenses/new_bsd New BSD License * @filesource / /* * Creating and maintaining progress-bars to be printed to the console. * * <code> * $out = new ezcConsoleOutput(); * * // Create progress bar itself * $progress = new ezcConsoleProgressbar( $out, 100, array( 'step' => 5 ) ); * * $progress->options->emptyChar = '-'; * $progress->options->progressChar = '#'; * $progress->options->formatString = "Uploading file </tmp/foobar.tar.bz2>: %act%/%max% kb [%bar%]"; * * // Perform actions * $i = 0; * while ( $i++ < 20 ) * { * // Do whatever you want to indicate progress for * usleep( mt_rand( 20000, 2000000 ) ); * // Advance the progressbar by one step ( uploading 5k per run ) * $progress->advance(); * } * * // Finish progress bar and jump to next line. * $progress->finish(); * * $out->outputText( "Successfully uploaded </tmp/foobar.tar.bz2>.\n", 'success' ); * </code> * * @property ezcConsoleProgressbarOptions $options * Contains the options for this class. * @property int $max * The maximum progress value to reach. * * @package ConsoleTools * @version 1.6.1 * @mainclass / class ezcConsoleProgressbar { /* * Container to hold the properties * * @var array(string=>mixed) / protected $properties; /* * Storage for actual values to be replaced in the format string. * Actual values are stored here and will be inserted into the bar * before printing it. * * @var array(string=>string) / protected $valueMap = array( 'bar' => '', 'fraction' => '', 'act' => '', 'max' => '', ); /* * Stores the bar utilization. * * This array saves how much space a specific part of the bar utilizes to not * recalculate those on every step. * * @var array(string=>int) / protected $measures = array( 'barSpace' => 0, 'fractionSpace' => 0, 'actSpace' => 0, 'maxSpace' => 0, 'fixedCharSpace' => 0, ); /* * The current step the progress bar should show. * * @var int / protected $currentStep = 0; /* * The maximum number of steps to go. * Calculated once from the settings. * * @var int / protected $numSteps = 0; /* * The ezcConsoleOutput object to use. * * @var ezcConsoleOutput / protected $output; /* * Indicates if the starting point for the bar has been stored. * Per default this is false to indicate that no start position has been * stored, yet. * * @var bool / protected $started = false; /* * Tool object to perform multi-byte encoding safe string operations. * * @var ezcConsoleStringTool / private $stringTool; /* * Creates a new progress bar. * * @param ezcConsoleOutput $outHandler Handler to utilize for output * @param int $max Maximum value, where progressbar * reaches 100%. * @param array(string=>string) $options Options * * @see ezcConsoleProgressbar::$options / public function __construct( ezcConsoleOutput $outHandler, $max, array $options = array() ) { $this->output = $outHandler; $this->stringTool = new ezcConsoleStringTool(); $this->__set( 'max', $max ); $this->properties['options'] = new ezcConsoleProgressbarOptions( $options ); } /* * Set new options. * This method allows you to change the options of progressbar. * * @param ezcConsoleProgresbarOptions $options The options to set. * * @throws ezcBaseSettingNotFoundException * If you tried to set a non-existent option value. * @throws ezcBaseSettingValueException * If the value is not valid for the desired option. * @throws ezcBaseValueException * If you submit neither an array nor an instance of * ezcConsoleProgresbarOptions. / public function setOptions( $options ) { if ( is_array( $options ) ) { $this->properties['options']->merge( $options ); } else if ( $options instanceof ezcConsoleProgressbarOptions ) { $this->properties['options'] = $options; } else { throw new ezcBaseValueException( "options", $options, "instance of ezcConsoleProgressbarOptions" ); } } /* * Returns the current options. * Returns the options currently set for this progressbar. * * @return ezcConsoleProgressbarOptions The current options. / public function getOptions() { return $this->properties['options']; } /* * Property read access. * * @param string $key Name of the property. * @return mixed Value of the property or null. * * @throws ezcBasePropertyNotFoundException * If the the desired property is not found. * @ignore / public function __get( $key ) { switch ( $key ) { case 'options': return $this->properties['options']; case 'step': // Step is now an option return $this->properties['options']->step; case 'max': return $this->properties[$key]; default: break; } throw new ezcBasePropertyNotFoundException( $key ); } /* * Property write access. * * @param string $key Name of the property. * @param mixed $val The value for the property. * * @throws ezcBasePropertyNotFoundException * If a desired property could not be found. * @throws ezcBaseValueException * If a desired property value is out of range. * @ignore / public function __set( $key, $val ) { switch ( $key ) { case 'options': if ( !( $val instanceof ezcConsoleProgressbarOptions ) ) { throw new ezcBaseValueException( 'options', $val, 'instance of ezcConsoleProgressbarOptions' ); }; break; case 'max': if ( ( !is_int( $val ) && !is_float( $val ) ) \|\| $val < 0 ) { throw new ezcBaseValueException( $key, $val, 'number >= 0' ); } break; case 'step': if ( ( !is_int( $val ) && !is_float( $val ) ) \|\| $val < 0 ) { throw new ezcBaseValueException( $key, $val, 'number >= 0' ); } // Step is now an option. $this->properties['options']->step = $val; return; default: throw new ezcBasePropertyNotFoundException( $key ); break; } // Changes settings or options, need for recalculating measures $this->started = false; $this->properties[$key] = $val; } /* * Property isset access. * * @param string $key Name of the property. * @return bool True is the property is set, otherwise false. * @ignore / public function __isset( $key ) { switch ( $key ) { case 'options': case 'max': case 'step': return true; } return false; } /* * Start the progress bar * Starts the progress bar and sticks it to the current line. * No output will be done yet. Call {@link ezcConsoleProgressbar::output()} * to print the bar. * * @return void / public function start() { $this->calculateMeasures(); $this->output->storePos(); $this->started = true; } /* * Draw the progress bar. * Prints the progress-bar to the screen. If start() has not been called * yet, the current line is used for {@link ezcConsolProgressbar::start()}. * * @return void / public function output() { if ( $this->options->minVerbosity > $this->output->options->verbosityLevel \|\| ( $this->options->maxVerbosity !== false && $this->options->maxVerbosity < $this->output->options->verbosityLevel ) ) { // Do not print progress bar if verbosity level is lower than it's // output objects value. return; } if ( $this->started === false ) { $this->start(); } $this->output->restorePos(); if ( ezcBaseFeatures::os() === "Windows" ) { echo str_repeat( "\x8", $this->options->width ); } $this->generateValues(); echo $this->insertValues(); } /* * Advance the progress bar. * Advances the progress bar by $step steps. Redraws the bar by default, * using the {@link ezcConsoleProgressbar::output()} method. * * @param bool $redraw Whether to redraw the bar immediately. * @param int $step How many steps to advance. * @return void / public function advance( $redraw = true, $step = 1 ) { $this->currentStep += $step; if ( $redraw === true && $this->currentStep % $this->properties['options']->redrawFrequency === 0 ) { $this->output(); } } /* * Finish the progress bar. * Finishes the bar (jump to 100% if not happened yet,...) and jumps * to the next line to allow new output. Also resets the values of the * output handler used, if changed. * * @return void / public function finish() { $this->currentStep = $this->numSteps; $this->output(); } /* * Generate all values to be replaced in the format string. * * @return void / protected function generateValues() { // Bar $barFilledSpace = ceil( $this->measures['barSpace'] / $this->numSteps $this->currentStep ); // Sanitize value if it gets to large by rounding $barFilledSpace = $barFilledSpace > $this->measures['barSpace'] ? $this->measures['barSpace'] : $barFilledSpace; $bar = $this->stringTool->strPad( $this->stringTool->strPad( $this->properties['options']->progressChar, $barFilledSpace, $this->properties['options']->barChar, STR_PAD_LEFT ), $this->measures['barSpace'], $this->properties['options']->emptyChar, STR_PAD_RIGHT ); $this->valueMap['bar'] = $bar; // Fraction $fractionVal = sprintf( $this->properties['options']->fractionFormat, ( $fractionVal = ( $this->properties['options']->step * $this->currentStep ) / $this->max * 100 ) > 100 ? 100 : $fractionVal ); $this->valueMap['fraction'] = $this->stringTool->strPad( $fractionVal, iconv_strlen( sprintf( $this->properties['options']->fractionFormat, 100 ), 'UTF-8' ), ' ', STR_PAD_LEFT ); // Act / max $actVal = sprintf( $this->properties['options']->actFormat, ( $actVal = $this->currentStep * $this->properties['options']->step ) > $this->max ? $this->max : $actVal ); $this->valueMap['act'] = $this->stringTool->strPad( $actVal, iconv_strlen( sprintf( $this->properties['options']->actFormat, $this->max ), 'UTF-8' ), ' ', STR_PAD_LEFT ); $this->valueMap['max'] = sprintf( $this->properties['options']->maxFormat, $this->max ); } /** * Insert values into bar format string. * * @return void / protected function insertValues() { $bar = $this->properties['options']->formatString; foreach ( $this->valueMap as $name => $val ) { $bar = str_replace( "%{$name}%", $val, $bar ); } return $bar; } /* * Calculate several measures necessary to generate a bar. * * @return void / protected function calculateMeasures() { // Calc number of steps bar goes through $this->numSteps = ( int ) round( $this->max / $this->properties['options']->step ); // Calculate measures $this->measures['fixedCharSpace'] = iconv_strlen( $this->stripEscapeSequences( $this->insertValues() ), 'UTF-8' ); if ( iconv_strpos( $this->properties['options']->formatString, '%max%', 0, 'UTF-8' ) !== false ) { $this->measures['maxSpace'] = iconv_strlen( sprintf( $this->properties['options']->maxFormat, $this->max ), 'UTF-8' ); } if ( iconv_strpos( $this->properties['options']->formatString, '%act%', 0, 'UTF-8' ) !== false ) { $this->measures['actSpace'] = iconv_strlen( sprintf( $this->properties['options']->actFormat, $this->max ), 'UTF-8' ); } if ( iconv_strpos( $this->properties['options']->formatString, '%fraction%', 0, 'UTF-8' ) !== false ) { $this->measures['fractionSpace'] = iconv_strlen( sprintf( $this->properties['options']->fractionFormat, 100 ), 'UTF-8' ); } $this->measures['barSpace'] = $this->properties['options']->width - array_sum( $this->measures ); } /* * Strip all escape sequences from a string to measure it's size correctly. * * @param mixed $str * @return void / protected function stripEscapeSequences( $str ) { return preg_replace( '/\033\[[0-9a-f;]m/i', '', $str ); } } ?>	13.92 KB	2024-07-17 10:16
📄 progressmonitor.php <?php /** * File containing the ezcConsoleProgressMonitor class. * * @package ConsoleTools * @version 1.6.1 * @copyright Copyright (C) 2005-2010 eZ Systems AS. All rights reserved. * @license http://ez.no/licenses/new_bsd New BSD License * @filesource / /* * Printing structured status information on the console. * * <code> * // Construction * $status = new ezcConsoleProgressMonitor( new ezcConsoleOutput(), 42 ); * * // Run statusbar * foreach ( $files as $file ) * { * $res = $file->upload(); * // Add a status-entry to be printed. * $status->addEntry( 'UPLOAD', $file->path ); * // Result like " 2.5% UPLOAD /var/upload/test.png" * } * </code> * * @property ezcConsoleProgressMonitorOptions $options * Contains the options for this class. * * @package ConsoleTools * @version 1.6.1 * @mainclass / class ezcConsoleProgressMonitor { /* * Options * * @var ezcConsoleProgressMonitorOptions / protected $options; /* * The ezcConsoleOutput object to use. * * @var ezcConsoleOutput / protected $outputHandler; /* * Counter for the items already printed. * * @var int / protected $counter = 0; /* * The number of entries to expect. * * @var int / protected $max; /* * Creates a new progress monitor. * The $outputHandler parameter will be used to display the progress * monitor. $max is the number of monitor items to expect. $options can be * used to define the behaviour of the monitor * {@link ezcConsoleProgressMonitorOptions}. * * @param ezcConsoleOutput $outHandler Handler to utilize for output * @param int $max Number of items to expect * @param array(string=>string) $options Options. * * @see ezcConsoleProgressMonitor::$options / public function __construct( ezcConsoleOutput $outHandler, $max, array $options = array() ) { $this->outputHandler = $outHandler; $this->max = $max; $this->options = new ezcConsoleProgressMonitorOptions( $options ); } /* * Property read access. * * @param string $key Name of the property. * @return mixed Value of the property or null. * * @throws ezcBasePropertyNotFoundException * If the the desired property is not found. / public function __get( $key ) { switch ( $key ) { case 'options': return $this->options; break; } throw new ezcBasePropertyNotFoundException( $key ); } /* * Property write access. * * @param string $propertyName Name of the property. * @param mixed $val The value for the property. * * @throws ezcBaseValueException * If a the value for the property options is not an instance of * ezcConsoleProgressMonitorOptions. * @return void / public function __set( $propertyName, $val ) { switch ( $propertyName ) { case 'options': if ( !( $val instanceof ezcConsoleProgressMonitorOptions ) ) { throw new ezcBaseValueException( $propertyName, $val, 'instance of ezcConsoleProgressMonitorOptions' ); } $this->options = $val; return; } throw new ezcBasePropertyNotFoundException( $propertyName ); } /* * Property isset access. * * @param string $propertyName Name of the property. * @return bool True is the property is set, otherwise false. / public function __isset( $propertyName ) { switch ( $propertyName ) { case 'options': return true; } return false; } /* * Set new options. * This method allows you to change the options of an progress monitor. * * @param ezcConsoleProgressMonitorOptions $options The options to set. * * @throws ezcBaseSettingNotFoundException * If you tried to set a non-existent option value. * @throws ezcBaseSettingValueException * If the value is not valid for the desired option. * @throws ezcBaseValueException * If you submit neither an array nor an instance of * ezcConsoleProgressMonitorOptions. / public function setOptions( $options ) { if ( is_array( $options ) ) { $this->options->merge( $options ); } else if ( $options instanceof ezcConsoleProgressMonitorOptions ) { $this->options = $options; } else { throw new ezcBaseValueException( "options", $options, "instance of ezcConsoleProgressMonitorOptions" ); } } /* * Returns the currently set options. * Returns the currently set option array. * * @return ezcConsoleProgressMonitorOptions The options. / public function getOptions() { return $this->options; } /* * Print a status entry. * Prints a new status entry to the console and updates the internal counter. * * @param string $tag The tag to print (second argument in the * formatString). * @param string $data The data to be printed in the status entry (third * argument in the format string). * @return void / public function addEntry( $tag, $data ) { $this->counter++; $percentage = $this->counter / $this->max 100; $this->outputHandler->outputLine( sprintf( $this->options['formatString'], $percentage, $tag, $data ) ); } } ?>	5.83 KB	2024-07-17 10:16
📄 statusbar.php <?php /** * File containing the ezcConsoleStatusbar class. * * @package ConsoleTools * @version 1.6.1 * @copyright Copyright (C) 2005-2010 eZ Systems AS. All rights reserved. * @license http://ez.no/licenses/new_bsd New BSD License * @filesource / /* * Creating and maintaining status-bars to be printed to the console. * * <code> * // Construction * $status = new ezcConsoleStatusbar( new ezcConsoleOutput() ); * * // Set option * $status->options['successChar'] = ''; * // Run statusbar * foreach ( $files as $file ) * { * $res = $file->upload(); * // Add status if form of bool true/false to statusbar. * $status->add( $res ); // $res is true or false * } * * // Retreive and display final statusbar results * $msg = $status->getSuccess() . ' succeeded, ' . $status->getFailure() . ' failed.'; * $out->outputText( "Finished uploading files: $msg\n" ); * </code> * * @property ezcConsoleStatusbarOptions $options * Contains the options for this class. * * @package ConsoleTools * @version 1.6.1 * @mainclass / class ezcConsoleStatusbar { /* * Container to hold the properties * * @var array(string=>mixed) / protected $properties; /* * The ezcConsoleOutput object to use. * * @var ezcConsoleOutput / protected $outputHandler; /* * Counter for success and failure outputs. * * @var array(bool=>int) / protected $counter = array( true => 0, false => 0, ); /* * Creates a new status bar. * * @param ezcConsoleOutput $outHandler Handler to utilize for output * @param array(string=>string) $options Options * * @see ezcConsoleStatusbar::$options / public function __construct( ezcConsoleOutput $outHandler, array $options = array() ) { $this->outputHandler = $outHandler; $this->properties['options'] = new ezcConsoleStatusbarOptions( $options ); } /* * Property read access. * * @param string $key Name of the property. * @return mixed Value of the property or null. * * @throws ezcBasePropertyNotFoundException * If the the desired property is not found. * @ignore / public function __get( $key ) { switch ( $key ) { case 'options': return $this->properties['options']; break; } if ( isset( $this->properties['options']->$key ) ) { return $this->properties['options']->$key; } throw new ezcBasePropertyNotFoundException( $key ); } /* * Set new options. * This method allows you to change the options of a statusbar. * * @param array(string=>string)\|ezcConsoleOutputOptions $options The options to set. * * @throws ezcBaseSettingNotFoundException * If you tried to set a non-existent option value. * @throws ezcBaseSettingValueException * If the value is not valid for the desired option. * @throws ezcBaseValueException * If you submit neither an array nor an instance of * ezcConsoleOutputOptions. / public function setOptions( $options ) { if ( is_array( $options ) ) { $this->properties['options']->merge( $options ); } else if ( $options instanceof ezcConsoleStatusbarOptions ) { $this->properties['options'] = $options; } else { throw new ezcBaseValueException( "options", $options, "instance of ezcConsoleStatusbarOptions" ); } } /* * Property write access. * * @param string $key Name of the property. * @param mixed $val The value for the property. * * @throws ezcBasePropertyNotFoundException * If a desired property could not be found. * @throws ezcBaseValueException * If a desired property value is out of range. * @ignore / public function __set( $key, $val ) { switch ( $key ) { // Those two are here for BC reasons only, it is proper to // use $statusbar->options->successChar instead of just // $statusbar->successChar. case 'successChar': case 'failureChar': // No checks necessary here, already performed in // ezcConsoleStatusbarOptions break; case "options": if ( ( $val instanceof ezcConsoleStatusbarOptions ) === false ) { throw new ezcBaseValueException( $key, $val, 'ezcConsoleStatusbarOptions' ); } $this->properties[$key] = $val; return; default: throw new ezcBasePropertyNotFoundException( $key ); } $this->properties['options'][$key] = $val; } /* * Property isset access. * * @param string $key Name of the property. * @return bool True is the property is set, otherwise false. * @ignore / public function __isset( $key ) { return isset( $this->properties['options'][$key] ) \|\| isset( $this->properties[$key] ); } /* * Returns the current options. * Returns the options currently set for this progressbar. * * @return ezcConsoleStatusbarOptions The current options. / public function getOptions() { return $this->properties['options']; } /* * Add a status to the status bar. * Adds a new status to the bar which is printed immediately. If the * cursor is currently not at the beginning of a line, it will move to * the next line. * * @param bool $status Print successChar on true, failureChar on false. * @return void / public function add( $status ) { if ( is_bool( $status ) === false ) { trigger_error( 'Unknown status '.var_export( $status, true ).'.', E_USER_WARNING ); $status = (bool) $status; } switch ( $status ) { case true: $this->outputHandler->outputText( $this->properties['options']['successChar'], 'success' ); break; case false: $this->outputHandler->outputText( $this->properties['options']['failureChar'], 'failure' ); break; } $this->counter[$status]++; } /* * Reset the state of the status-bar object to its initial one. * * @return void / public function reset() { foreach ( $this->counter as $status => $count ) { $this->counter[$status] = 0; } } /* * Returns number of successes during the run. * Returns the number of success characters printed from this status bar. * * @return int Number of successes. / public function getSuccessCount() { return $this->counter[true]; } /* * Returns number of failures during the run. * Returns the number of failure characters printed from this status bar. * * @return int Number of failures. */ public function getFailureCount() { return $this->counter[false]; } } ?>	7.26 KB	2024-07-17 10:16
📁 structs	-	2025-05-25 12:37
📁 table	-	2025-05-25 12:37
📄 table.php <?php /** * File containing the ezcConsoleTable class. * * @package ConsoleTools * @version 1.6.1 * @copyright Copyright (C) 2005-2010 eZ Systems AS. All rights reserved. * @license http://ez.no/licenses/new_bsd New BSD License * @filesource / /* * Creating tables to be printed to the console. * * Every ezcConsoleTable object can be accessed as if it was a multidimensional, * numerically indexed array. The first dimension represents the rows of the * table, so $table[0] gives you access to the first row of the table, which is * represented by a {@link ezcConsoleTableRow} object. You can access its * properties directly, using e.g. $table[0]->format. The second dimension gives * you direct access to the cells of your table, like $table[0][0] accesses the * first cell in the first row of your table. You can access its properties * diretly here, too. This works like e.g. $table[0][0]->format. Table row and * cell objects are created on the fly, when you access them for the first time. * You can also create them as if you simply create new array elements. E.g. * $table[] creates a new row in the table. * * <code> * // Initialize the console output handler * $out = new ezcConsoleOutput(); * // Define a new format "headline" * $out->formats->headline->color = 'red'; * $out->formats->headline->style = array( 'bold' ); * // Define a new format "sum" * $out->formats->sum->color = 'blue'; * $out->formats->sum->style = array( 'negative' ); * * // Create a new table * $table = new ezcConsoleTable( $out, 60 ); * * // Create first row and in it the first cell * $table[0][0]->content = 'Headline 1'; * * // Create 3 more cells in row 0 * for ( $i = 2; $i < 5; $i++ ) * { * $table[0][]->content = "Headline $i"; * } * * $data = array( 1, 2, 3, 4 ); * * // Create some more data in the table... * foreach ( $data as $value ) * { * // Create a new row each time and set it's contents to the actual value * $table[][0]->content = $value; * } * * // Set another border format for our headline row * $table[0]->borderFormat = 'headline'; * * // Set the content format for all cells of the 3rd row to "sum" * $table[2]->format = 'sum'; * * $table->outputTable(); * </code> * * @property ezcConsoleTableOptions $options * Contains the options for this class. * @property int $width * Width of the table. * * @see ezcConsoleOutput * @package ConsoleTools * @version 1.6.1 * @mainclass / class ezcConsoleTable implements Countable, Iterator, ArrayAccess { /* * Automatically wrap text to fit into a column. * @see ezcConsoleTable::$options / const WRAP_AUTO = 1; /* * Do not wrap text. Columns will be extended to fit the largest text. * ATTENTION: This is risky! * @see ezcConsoleTable::$options / const WRAP_NONE = 2; /* * Text will be cut to fit into a column. * @see ezcConsoleTable::$options / const WRAP_CUT = 3; /* * Align text in the default direction. / const ALIGN_DEFAULT = -1; /* * Align text in cells to the right. / const ALIGN_LEFT = STR_PAD_RIGHT; /* * Align text in cells to the left. / const ALIGN_RIGHT = STR_PAD_LEFT; /* * Align text in cells to the center. / const ALIGN_CENTER = STR_PAD_BOTH; /* * The width given by settings must be used even if the data allows it smaller. / const WIDTH_FIXED = 1; /* * The width given by settings is a maximum value, if data allows it, the table gets smaller. / const WIDTH_MAX = 2; /* * Container to hold the properties * * @var array(string=>mixed) / protected $properties; /* * The ezcConsoleOutput object to use. * * @var ezcConsoleOutput / protected $outputHandler; /* * Collection of the rows that are contained in the table. * * @var array(ezcConsoleTableRow) / protected $rows; /* * Tool object for multi-byte encoding safe string operations. * * @var ezcConsoleStringTool / private $stringTool; /* * Creates a new table. * * @param ezcConsoleOutput $outHandler Output handler to utilize * @param int $width Overall width of the table (chars). * @param array $options Options * * @see ezcConsoleTable::$options * * @throws ezcBaseValueException On an invalid setting. / public function __construct( ezcConsoleOutput $outHandler, $width, $options = array() ) { $this->rows = array(); $this->outputHandler = $outHandler; $this->stringTool = new ezcConsoleStringTool(); $this->__set( 'width', $width ); if ( $options instanceof ezcConsoleTableOptions ) { $this->properties['options'] = $options; } else if ( is_array( $options ) ) { $this->properties['options'] = new ezcConsoleTableOptions( $options ); } else { throw new ezcBaseValueException( "options", $options, "array" ); } } /* * Set new options. * This method allows you to change the options of the table. * * @param ezcConsoleTableOptions $options The options to set. * * @throws ezcBaseSettingNotFoundException * If you tried to set a non-existent option value. * @throws ezcBaseSettingValueException * If the value is not valid for the desired option. * @throws ezcBaseValueException * If you submit neither an array nor an instance of * ezcConsoleTableOptions. / public function setOptions( $options = array() ) { if ( is_array( $options ) ) { $this->properties['options']->merge( $options ); } else if ( $options instanceof ezcConsoleTableOptions ) { $this->properties['options'] = $options; } else { throw new ezcBaseValueException( "options", $options, "instance of ezcConsoleTableOptions" ); } } /* * Returns the current options. * Returns the options currently set for this table. * * @return ezcConsoleTableOptions The current options. / public function getOptions() { return $this->properties['options']; } /* * Returns the table in an array. * * Returns the entire table as an array of printable lines. Each element of * the array represents a physical line of the drawn table, including all * borders and stuff, so you can simply print the table using * <code> * echo implode( "\n" , $table->getTable() ): * </code> * which is basically what {@link ezcConsoleTable::outputTable()} does. * * @return array An array representation of the table. / public function getTable() { return $this->generateTable(); } /* * Output the table. * Prints the complete table to the console. * * @return void / public function outputTable() { echo implode( PHP_EOL, $this->generateTable() ); } /* * Returns the table in a string. * * @return string / public function __toString() { return implode( PHP_EOL, $this->generateTable() ); } /* * Returns if the given offset exists. * This method is part of the ArrayAccess interface to allow access to the * data of this object as if it was an array. * * @param int $offset The offset to check. * @return bool True when the offset exists, otherwise false. * * @throws ezcBaseValueException * If a non numeric row ID is requested. / public function offsetExists( $offset ) { if ( !is_int( $offset ) \|\| $offset < 0 ) { throw new ezcBaseValueException( 'offset', $offset, 'int >= 0' ); } return isset( $this->rows[$offset] ); } // From here only interface method implementations follow, which are not intended for direct usage /* * Returns the element with the given offset. * This method is part of the ArrayAccess interface to allow access to the * data of this object as if it was an array. In case of the * ezcConsoleTable class this method always returns a valid row object * since it creates them on the fly, if a given item does not exist. * * @param int $offset The offset to check. * @return ezcConsoleTableCell * * @throws ezcBaseValueException * If a non numeric row ID is requested. / public function offsetGet( $offset ) { $offset = ( $offset === null ) ? count( $this->rows ) : $offset; if ( !is_int( $offset ) \|\| $offset < 0 ) { throw new ezcBaseValueException( 'offset', $offset, 'int >= 0 or null' ); } if ( !isset( $this->rows[$offset] ) ) { $this->rows[$offset] = new ezcConsoleTableRow(); } return $this->rows[$offset]; } /* * Set the element with the given offset. * This method is part of the ArrayAccess interface to allow access to the * data of this object as if it was an array. * * @param int $offset The offset to assign an item to. * @param ezcConsoleTableRow $value The row to assign. * @return void * * @throws ezcBaseValueException * If a non numeric row ID is requested. * @throws ezcBaseValueException * If the provided value is not of type {@link ezcConsoleTableRow}. / public function offsetSet( $offset, $value ) { if ( !( $value instanceof ezcConsoleTableRow ) ) { throw new ezcBaseValueException( 'value', $value, 'ezcConsoleTableRow' ); } if ( !isset( $offset ) ) { $offset = count( $this ); } if ( !is_int( $offset ) \|\| $offset < 0 ) { throw new ezcBaseValueException( 'offset', $offset, 'int >= 0' ); } $this->rows[$offset] = $value; } /* * Unset the element with the given offset. * This method is part of the ArrayAccess interface to allow access to the * data of this object as if it was an array. * * @param int $offset The offset to unset the value for. * @return void * * @throws ezcBaseValueException * If a non numeric row ID is requested. / public function offsetUnset( $offset ) { if ( !is_int( $offset ) \|\| $offset < 0 ) { throw new ezcBaseValueException( 'offset', $offset, 'int >= 0' ); } if ( isset( $this->rows[$offset] ) ) { unset( $this->rows[$offset] ); } } /* * Returns the number of cells in the row. * This method is part of the Countable interface to allow the usage of * PHP's count() function to check how many cells this row has. * * @return int Number of cells in this row. / public function count() { $keys = array_keys( $this->rows ); return count( $keys ) > 0 ? ( end( $keys ) + 1 ) : 0; } /* * Returns the currently selected cell. * This method is part of the Iterator interface to allow access to the * cells of this row by iterating over it like an array (e.g. using * foreach). * * @return ezcConsoleTableCell The currently selected cell. / public function current() { return current( $this->rows ); } /* * Returns the key of the currently selected cell. * This method is part of the Iterator interface to allow access to the * cells of this row by iterating over it like an array (e.g. using * foreach). * * @return int The key of the currently selected cell. / public function key() { return key( $this->rows ); } /* * Returns the next cell and selects it or false on the last cell. * This method is part of the Iterator interface to allow access to the * cells of this row by iterating over it like an array (e.g. using * foreach). * * @return mixed ezcConsoleTableCell if the next cell exists, or false. / public function next() { return next( $this->rows ); } /* * Selects the very first cell and returns it. * This method is part of the Iterator interface to allow access to the * cells of this row by iterating over it like an array (e.g. using * foreach). * * @return ezcConsoleTableCell The very first cell of this row. / public function rewind() { return reset( $this->rows ); } /* * Returns if the current cell is valid. * This method is part of the Iterator interface to allow access to the * cells of this row by iterating over it like an array (e.g. using * foreach). * * @return ezcConsoleTableCell The very first cell of this row. / public function valid() { return current( $this->rows ) !== false; } /* * Property read access. * * @param string $key Name of the property. * @return mixed Value of the property or null. * * @throws ezcBasePropertyNotFoundException * If the the desired property is not found. * @ignore / public function __get( $key ) { switch ( $key ) { case 'options': case 'width': return $this->properties[$key]; default: break; } throw new ezcBasePropertyNotFoundException( $key ); } /* * Property write access. * * @param string $key Name of the property. * @param mixed $val The value for the property. * * @throws ezcBasePropertyNotFoundException * If a the value for the property options is not an instance of * @throws ezcBaseValueException * If a the value for a property is out of range. * @ignore / public function __set( $key, $val ) { switch ( $key ) { case 'options': if ( !( $val instanceof ezcConsoleTableOptions ) ) { throw new ezcBaseValueException( $key, $val, 'ezcConsoleTableOptions' ); } $this->properties['options'] = $val; return; case 'width': if ( $val < 1 ) { throw new ezcBaseValueException( $key, $val, 'int > 0' ); } $this->properties[$key] = $val; return; default: break; } throw new ezcBasePropertyNotFoundException( $key ); } /* * Property isset access. * * @param string $key Name of the property. * @return bool True is the property is set, otherwise false. * @ignore / public function __isset( $key ) { switch ( $key ) { case 'options': case 'width': case 'cols': return true; } return false; } /* * Generate the complete table as an array. * * @return array(string) The table. / private function generateTable() { $colWidth = $this->getColWidths(); $table = array(); if ( $this->options->lineVertical !== null ) { $table[] = $this->generateBorder( $colWidth, ( isset( $this[0] ) ? $this[0]->borderFormat : 'default' ) ); } // Rows submitted by the user for ( $i = 0; $i < count( $this->rows ); $i++ ) { // Auto broken rows foreach ( $this->breakRows( $this->rows[$i], $colWidth ) as $brkRow => $brkCells ) { $table[] = $this->generateRow( $brkCells, $colWidth, $this->rows[$i] ); } $afterBorderFormat = isset( $this->rows[$i + 1] ) && $this->rows[$i + 1]->borderFormat != 'default' ? $this->rows[$i + 1]->borderFormat : $this->rows[$i]->borderFormat; if ( $this->options->lineVertical !== null ) { $table[] = $this->generateBorder( $colWidth, $afterBorderFormat ); } } // Empty tables need closing border if ( $this->options->lineVertical !== null && count( $this->rows ) == null ) { $table[] = $this->generateBorder( $colWidth, 'default' ); } return $table; } /* * Generate top/bottom borders of rows. * * @param array(int) $colWidth Array of column width. * @param string $format Format name. * @return string The Border string. / private function generateBorder( $colWidth, $format ) { $border = ''; foreach ( $colWidth as $col => $width ) { $border .= ( $this->options->lineHorizontal !== null ? $this->properties['options']->corner : '' ) . str_repeat( $this->properties['options']->lineVertical, $width + ( 2 iconv_strlen( $this->properties['options']->colPadding, 'UTF-8' ) ) ); } $border .= ( $this->options->lineHorizontal !== null ? $this->properties['options']->corner : '' ); return $this->formatText( $border, $format ); } /** * Generate a single physical row. * This method generates the string for a single physical table row. * * @param array(string) $cells Cells of the row. * @param array(int) $colWidth Calculated columns widths. * @param ezcConsoleTableRow $row The row to generate. * @return string The row. / private function generateRow( $cells, $colWidth, $row ) { $rowData = ''; for ( $cell = 0; $cell < count( $colWidth ); $cell++ ) { $align = $this->determineAlign( $row, $cell ); $format = $this->determineFormat( $row, $cell ); $borderFormat = $this->determineBorderFormat( $row ); $data = isset( $cells[$cell] ) ? $cells[$cell] : ''; $rowData .= $this->formatText( $this->properties['options']->lineHorizontal, $borderFormat ); $rowData .= $this->properties['options']->colPadding; $rowData .= $this->formatText( $this->stringTool->strPad( $data, $colWidth[$cell], ' ', $align ), $format ); $rowData .= $this->properties['options']->colPadding; } $rowData .= $this->formatText( $this->properties['options']->lineHorizontal, $row->borderFormat ); return $rowData; } /* * Determine the alignment of a cell. * Walks the inheritance path upwards to determine the alignment of a * cell. Checks first, if the cell has it's own alignment (apart from * ezcConsoleTable::ALIGN_DEFAULT). If not, checks the row for an * alignment setting and uses the default alignment if not found. * * @param ezcConsoleTableRow $row The row this cell belongs to. * @param int $cellId Index of the desired cell. * @return int An alignement constant (ezcConsoleTable::ALIGN_). / private function determineAlign( $row, $cellId = 0 ) { return ( $row[$cellId]->align !== ezcConsoleTable::ALIGN_DEFAULT ? $row[$cellId]->align : ( $row->align !== ezcConsoleTable::ALIGN_DEFAULT ? $row->align : ( $this->properties['options']->defaultAlign !== ezcConsoleTable::ALIGN_DEFAULT ? $this->properties['options']->defaultAlign : ezcConsoleTable::ALIGN_LEFT ) ) ); } /** * Determine the format of a cells content. * Walks the inheritance path upwards to determine the format of a * cells content. Checks first, if the cell has it's own format (apart * from 'default'). If not, checks the row for a format setting and * uses the default format if not found. * * @param ezcConsoleTableRow $row The row this cell belongs to. * @param int $cellId Index of the desired cell. * @return string A format name. / private function determineFormat( $row, $cellId ) { return ( $row[$cellId]->format != 'default' ? $row[$cellId]->format : ( $row->format !== 'default' ? $row->format : $this->properties['options']->defaultFormat ) ); } /* * Determine the format of a rows border. * Walks the inheritance path upwards to determine the format of a * rows border. Checks first, if the row has it's own format (apart * from 'default'). If not, uses the default format. * * @param ezcConsoleTableRow $row The row this cell belongs to. * @return string A format name. / private function determineBorderFormat( $row ) { return $row->borderFormat !== 'default' ? $row->borderFormat : $this->properties['options']->defaultBorderFormat; } /* * Returns auto broken rows from an array of cells. * The data provided by a user may not fit into a cell calculated by the * class. In this case, the data can be automatically wrapped. The table * row then spans over multiple physical console lines. * * @param array(string) $cells Array of cells in one row. * @param array(int) $colWidth Columns widths array. * @return array(string) Physical rows generated out of this row. / private function breakRows( $cells, $colWidth ) { $rows = array(); // Iterate through cells of the row foreach ( $colWidth as $cell => $width ) { $data = $cells[$cell]->content; // Physical row id, start with 0 for each row $row = 0; // Split into multiple physical rows if manual breaks exist $dataLines = explode( "\n", $data ); foreach ( $dataLines as $dataLine ) { // Does the physical row fit? if ( iconv_strlen( $dataLine, 'UTF-8' ) > ( $colWidth[$cell] ) ) { switch ( $this->properties['options']->colWrap ) { case ezcConsoleTable::WRAP_AUTO: $subLines = explode( "\n", $this->stringTool->wordwrap( $dataLine, $colWidth[$cell], "\n", true ) ); foreach ( $subLines as $lineNo => $line ) { $rows[$row++][$cell] = $line; } break; case ezcConsoleTable::WRAP_CUT: $rows[$row++][$cell] = iconv_substr( $dataLine, 0, $colWidth[$cell], 'UTF-8' ); break; case ezcConsoleTable::WRAP_NONE: default: $rows[$row++][$cell] = $dataLine; break; } } else { $rows[$row++][$cell] = $dataLine; } } } return $rows; } /* * Determine width of each single column. * * @return void / private function getColWidths() { if ( is_array( $this->properties['options']->colWidth ) ) { return $this->properties['options']->colWidth; } // Determine number of columns: $colCount = 0; foreach ( $this->rows as $row ) { $colCount = max( sizeof( $row ), $colCount ); } if ( $colCount === 0 ) { return array( $this->width ); } $borderWidth = iconv_strlen( $this->properties['options']->lineHorizontal, 'UTF-8' ); // Subtract border and padding chars from global width $globalWidth = $this->width - ( // Per column: 2 border padding + 1 border $colCount * ( 2 * iconv_strlen( $this->properties['options']->colPadding, 'UTF-8' ) + $borderWidth ) // 1 Additional border ) - $borderWidth; // Width of a column if each is made equal $colNormWidth = round( $globalWidth / $colCount ); $colMaxWidth = array(); // Determine the longest data for each column foreach ( $this->rows as $row => $cells ) { foreach ( $cells as $col => $cell ) { $contentLength = 0; foreach ( explode( PHP_EOL, $cell->content ) as $contentRow ) { $contentLength = max( $contentLength, iconv_strlen( $contentRow, 'UTF-8' ) ); } $colMaxWidth[$col] = isset( $colMaxWidth[$col] ) ? max( $colMaxWidth[$col], $contentLength ) : $contentLength; } } $colWidth = array(); $colWidthOverflow = array(); $spareWidth = 0; // Make columns best fit foreach ( $colMaxWidth as $col => $maxWidth ) { // Does the largest data of the column fit into the average size // + what we have in spare from earlier columns? if ( $maxWidth <= ( $colNormWidth + $spareWidth ) ) { // We fit in, make the column as large as necessary $colWidth[$col] = $maxWidth; $spareWidth += ( $colNormWidth - $maxWidth ); } else { // Does not fit, use maximal possible width $colWidth[$col] = $colNormWidth + $spareWidth; $spareWidth = 0; // Store overflow for second processing step $colWidthOverflow[$col] = $maxWidth - $colWidth[$col]; } } // Do we have spare to give to the columns again? if ( $spareWidth > 0 ) { // Second processing step if ( count( $colWidthOverflow ) > 0 ) { $overflowSum = array_sum( $colWidthOverflow ); foreach ( $colWidthOverflow as $col => $overflow ); { $colWidth[$col] += floor( $overflow / $overflowSum * $spareWidth ); } } elseif ( $this->properties['options']->widthType === ezcConsoleTable::WIDTH_FIXED ) { $widthSum = array_sum( $colWidth ); foreach ( $colWidth as $col => $width ) { $colWidth[$col] += floor( $width / $widthSum * $spareWidth ); } } } // Finally sanitize values from rounding issues, if necessary if ( ( $colSum = array_sum( $colWidth ) ) != $globalWidth && $this->properties['options']->widthType === ezcConsoleTable::WIDTH_FIXED ) { $colWidth[count( $colWidth ) - 1] -= $colSum - $globalWidth; } return $colWidth; } /** * Returns the given $text formatted with $format. * * In case $useFormats is set to false in the output handler, the text is * returned as given, without any formatting. * * @param string $text * @param string $format * @return string */ private function formatText( $text, $format ) { if ( $this->outputHandler->options->useFormats ) { return $this->outputHandler->formatText( $text, $format ); } else { return $text; } } } ?>	28.04 KB	2024-07-17 10:16
📁 tools	-	2025-05-25 12:37

Terminal