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
📄 argument.php <?php /** * File containing the ezcConsoleArgument 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 ezcConsoleArgument class represents an argument on the console. * This class is the container to store information about an argument submitted * to a shell application. It is used to define the appearance of an argument * before parsing the parameter string and contains the received value * afterwards. Argument objects are stored in an instance of the set class * {@link ezcConsoleArguments} which is stored in * {ezcConsoleInput::$argumentDefinition}. * * @property string $name The name for the argument. Must be unique. * @property int $type The value type. * @property string $shorthelp A short help text. * @property string $longhelp A long help text- * @property bool $mandatory Whether the argument is mandatory. * @property mixed $default A default value, if not mandatory. * @property bool $multiple Whether the argument accepts multiple values. * @property-read mixed $value The value parsed from the parameter string, using * {@link ezcConsoleInput::process()}. * @package ConsoleTools * @version 1.6.1 / class ezcConsoleArgument { /* * Properties * * @var array / protected $properties = array( "name" => null, "type" => ezcConsoleInput::TYPE_STRING, "shorthelp" => "No help available.", "longhelp" => "There is no help for this argument available.", "mandatory" => true, "multiple" => false, "default" => null, "value" => null, ); /* * Creates a new console argument object. * Creates a new console argument object, which represents a single * argument on the shell. Arguments are stored insiede * {@link ezcConsoleArguments} which is used with {@link ezcConsoleInput}. * * For the type property see {@link ezcConsoleInput::TYPE_STRING} and * {@link ezcConsoleInput::TYPE_INT}. If 1 argument is defined as optional * ($mandatory = false), all following arguments are autolamtically * considered optional, too. * * @param string $name The name for the argument. Must be unique. * @param int $type The value type. * @param string $shorthelp A short help text. * @param string $longhelp A long help text- * @param bool $mandatory Whether the argument is mandatory. * @param bool $multiple Whether the argument accepts multiple values. * @param mixed $default A default value, if not mandatory. * @return void / public function __construct( $name = null, $type = ezcConsoleInput::TYPE_STRING, $shorthelp = "No help available.", $longhelp = "There is no help for this argument available.", $mandatory = true, $multiple = false, $default = null ) { if ( !is_string( $name ) \|\| strlen( $name ) < 1 ) { throw new ezcBaseValueException( "name", $name, "string, length > 0" ); } $this->properties["name"] = $name; $this->type = $type; $this->shorthelp = $shorthelp; $this->longhelp = $longhelp; $this->mandatory = $mandatory; $this->multiple = $multiple; $this->default = $default; } /* * Property set access. * * @param string $propertyName Name of the property. * @param string $propertyValue Valze for the property. * @return void * @ignore / public function __set( $propertyName, $propertyValue ) { switch ( $propertyName ) { case "name": throw new ezcBasePropertyPermissionException( $propertyName, ezcBasePropertyPermissionException::READ ); break; case "type": if ( $propertyValue !== ezcConsoleInput::TYPE_INT && $propertyValue !== ezcConsoleInput::TYPE_STRING ) { throw new ezcBaseValueException( $propertyName, $propertyValue, "string, length > 0" ); } break; case "shorthelp": case "longhelp": if ( is_string( $propertyValue ) === false ) { throw new ezcBaseValueException( $propertyName, $propertyValue, "string" ); } break; case "mandatory": case "multiple": if ( is_bool( $propertyValue ) === false ) { throw new ezcBaseValueException( $propertyName, $propertyValue, "bool" ); } break; case "default": if ( is_scalar( $propertyValue ) === false && is_array( $propertyValue ) === false && $propertyValue !== null ) { throw new ezcBaseValueException( $propertyName, $propertyValue, "array, scalar or null" ); } break; case "value": if ( is_scalar( $propertyValue ) === false && is_array( $propertyValue ) === false && $propertyValue !== null ) { throw new ezcBaseValueException( $propertyName, $propertyValue, "string or null" ); } break; default: throw new ezcBasePropertyNotFoundException( $propertyName ); } $this->properties[$propertyName] = $propertyValue; } /* * 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 ) ) { return $this->properties[$propertyName]; } 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 ) { return array_key_exists( $propertyName, $this->properties ); } } ?>	6.48 KB	2024-07-17 10:16
📄 arguments.php <?php /** * File containing the ezcConsoleArguments collection 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 / /* * Collection class for ezcConsoleArgument objects. Used in {@link ezcConsoleInput}. * * @package ConsoleTools * @version 1.6.1 / class ezcConsoleArguments implements ArrayAccess, Iterator, Countable { /* * Ordered list of arguments. * * @var array(ezcConsoleArgument) / protected $ordered = array(); /* * Named list of arguments. * * @var array(string=>ezcConsoleArgument) / protected $named = array(); /* * 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. Valid offsets are integers or * strings. If an integer is used, it refers to the position in the command * line. A string refers to the arguments name property. * * @param mixed $offset The offset to check. * @return bool True when the offset exists, otherwise false. * * @throws ezcBaseValueException * If the provided offset is neither an integer, nor a string. / public function offsetExists( $offset ) { switch ( gettype( $offset ) ) { case "string": return array_key_exists( $offset, $this->named ); case "integer": return array_key_exists( $offset, $this->ordered ); default: throw new ezcBaseValueException( "offset", $offset, "string or int" ); } } /* * 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. Valid offsets are integers or * strings. If an integer is used, it refers to the position in the command * line. A string refers to the arguments name property. * * @param string\|integer $offset The offset to check. * @return ezcConsoleArgument * * @throws ezcBaseValueException * If the provided offset is neither an integer, nor a string. / public function offsetGet( $offset ) { switch ( gettype( $offset ) ) { case "string": if ( isset( $this[$offset] ) ) { return $this->named[$offset]; } break; case "integer": if ( isset( $this[$offset] ) ) { return $this->ordered[$offset]; } break; default: throw new ezcBaseValueException( "offset", $offset, "string or int" ); } throw new ezcBasePropertyNotFoundException( $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. In contrast to the other * ArrayAccess implementations of this class, this method allows only integer * keys. * * @param int $offset The offset to assign an item to. * @param ezcConsoleArgument $value The argument object to register. * @return void * * @throws ezcBaseValueException * If a non integer offset is provided. * @throws ezcBaseValueException * If the provided value is not of type {@ling ezcConsoleTableRow}. * @throws ezcConsoleArgumentAlreadyRegisteredException * If an argument with the given offset or name is already registered. / public function offsetSet( $offset, $value ) { // Determine key if not set (using $obj[] = ...) if ( $offset === null ) { $offset = count( $this->ordered ) === 0 ? 0 : max( array_keys( $this->ordered ) ) + 1; } // Set access only allowed with integer values if ( !is_int( $offset ) ) { throw new ezcBaseValueException( "offset", $offset, "int" ); } switch ( true ) { case ( $value instanceof ezcConsoleArgument ): if ( isset( $this->ordered[$offset] ) ) { throw new ezcConsoleArgumentAlreadyRegisteredException( $offset, ezcConsoleArgumentAlreadyRegisteredException::ORDERED ); } if ( isset( $this->named[$value->name] ) ) { throw new ezcConsoleArgumentAlreadyRegisteredException( $value->name, ezcConsoleArgumentAlreadyRegisteredException::NAMED ); } $this->named[$value->name] = $value; $this->ordered[$offset] = $value; break; case ( $value === null ): // Aliasing unset() with assignement to null unset( $this->named[$this->ordered[$offset]->name] ); unset( $this->ordered[$offset] ); break; default: throw new ezcBaseValueException( "value", $value, "ezcConsoleArgument or null" ); } } /* * 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. In contrast to the other * ArrayAccess implementations of this class, this method allows only integer * keys. * * @param int $offset The offset to unset the value for. * @return void * * @throws ezcBaseValueException * If a non numeric row offset is used. / public function offsetUnset( $offset ) { // Set access only allowed with integer values if ( is_int( $offset ) === false ) { throw new ezcBaseValueException( "offset", $offset, "int" ); } unset( $this->named[$this->ordered[$offset]->name] ); unset( $this->ordered[$offset] ); } /* * Returns the currently selected argument from the list. * Used by foreach-Loops. * * @return ezcConsoleArgument / public function current() { return current( $this->ordered ); } /* * Returns the key of the currently selected argument from the list. * Used by foreach-Loops. In contrast to the iteration direction, which is * defined by the ordered list of arguments, this is the name of the * argument. * * @return string / public function key() { return key( $this->ordered ); } /* * Advances the internal pointer to the next argument and returns it. * Used by foreach-Loops. * * @return ezcConsoleArgument / public function next() { return next( $this->ordered ); } /* * Rewinds the internal pointer to the first argument and returns it. * Used by foreach-Loops. * * @return ezcConsoleArgument / public function rewind() { // Called before foreach ksort( $this->ordered ); return reset( $this->ordered ); } /* * Checks if the current position is valid. * Used by foreach-Loops. * * @return bool / public function valid() { return ( current( $this->ordered ) !== false ); } /* * Returns the number of registered arguments. * * @return int */ public function count() { return count( $this->ordered ); } } ?>	7.59 KB	2024-07-17 10:16
📁 help_generators	-	2025-05-25 12:37
📄 option.php <?php /** * File containing the ezcConsoleOption 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 / /* * Objects of this class store data about a single option for ezcConsoleInput. * * This class represents a single command line option, which can be handled by * the ezcConsoleInput class. This classes only purpose is the storage of * the parameter data, the handling of options and arguments is done by the * class {@link ezcConsoleInput}. * * @property-read string $short * Short name of the parameter without '-' (eg. 'f'). * @property-read string $long * Long name of the parameter without '--' (eg. 'file'). * @property int $type * Value type of this parameter, default is ezcConsoleInput::TYPE_NONE. * See {@link ezcConsoleInput::TYPE_NONE}, * {@link ezcConsoleInput::TYPE_INT} and * {@link ezcConsoleInput::TYPE_STRING}. * @property mixed $default * Default value if the parameter is submitted without value. If a * parameter is eg. of type ezcConsoleInput::TYPE_STRING and * therefore expects a value when being submitted, it may be * submitted without a value and automatically get the default value * specified here. * @property bool $multiple * Is the submission of multiple instances of this parameters * allowed? * @property string $shorthelp * Short help text. Usually displayed when showing parameter help * overview. * @property string $longhelp * Long help text. Usually displayed when showing parameter detailed * help. * @property bool $arguments * Whether arguments to the program are allowed, when this parameter * is submitted. * @property bool $mandatory * Whether a parameter is mandatory to be set. If this flag is true, * the parameter must be submitted whenever the program is run. * @property bool $isHelpOption * Whether a parameter is a help option. If this flag is true, and * the parameter is set, all options marked as mandatory may be * skipped. * * @package ConsoleTools * @version 1.6.1 / class ezcConsoleOption { /* * Container to hold the properties * * @var array(string=>mixed) / protected $properties; /* * Dependency rules of this parameter. * * @see ezcConsoleOption::addDependency() * @see ezcConsoleOption::removeDependency() * @see ezcConsoleOption::hasDependency() * @see ezcConsoleOption::getDependencies() * @see ezcConsoleOption::resetDependencies() * * @var array(string=>ezcConsoleParamemterRule) / protected $dependencies = array(); /* * Exclusion rules of this parameter. * * @see ezcConsoleOption::addExclusion() * @see ezcConsoleOption::removeExclusion() * @see ezcConsoleOption::hasExclusion() * @see ezcConsoleOption::getExclusions() * @see ezcConsoleOption::resetExclusions() * * @var array(string=>ezcConsoleParamemterRule) / protected $exclusions = array(); /* * The value the parameter was assigned to when being submitted. * Boolean false indicates the parameter was not submitted, boolean * true means the parameter was submitted, but did not have a value. * In any other case, this caries the submitted value. * * @var mixed / public $value = false; /* * Create a new parameter struct. * Creates a new basic parameter struct with the base information "$short" * (the short name of the parameter) and "$long" (the long version). You * simply apply these parameters as strings (without '-' or '--'). So * * <code> * $param = new ezcConsoleOption( 'f', 'file' ); * </code> * * will result in a parameter that can be accessed using * * <code> * $ mytool -f * </code> * * or * * <code> * $ mytool --file * </code> * . * * The newly created parameter contains only it's 2 names and each other * attribute is set to it's default value. You can simply manipulate * those attributes by accessing them directly. * * @param string $short Short name of the parameter without '-' (eg. 'f'). * @param string $long Long name of the parameter without '--' (eg. 'file'). * @param int $type Value type of the parameter. One of ezcConsoleInput::TYPE_. @param mixed $default Default value the parameter holds if not submitted. * @param bool $multiple If the parameter may be submitted multiple times. * @param string $shorthelp Short help text. * @param string $longhelp Long help text. * @param array(ezcConsoleOptionRule) $dependencies Dependency rules. * @param array(ezcConsoleOptionRule) $exclusions Exclusion rules. * @param bool $arguments Whether supplying arguments is allowed when this parameter is set. * @param bool $mandatory Whether the parameter must be always submitted. * @param bool $isHelpOption Indicates that the given parameter is a help * option. If a help option is set, all rule * checking is skipped (dependency/exclusion/ * mandatory). * * @throws ezcConsoleInvalidOptionNameException If the option names start with a "-" * sign or contain whitespaces. / public function __construct( $short = '', $long, $type = ezcConsoleInput::TYPE_NONE, $default = null, $multiple = false, $shorthelp = 'No help available.', $longhelp = 'Sorry, there is no help text available for this parameter.', array $dependencies = array(), array $exclusions = array(), $arguments = true, $mandatory = false, $isHelpOption = false ) { $this->properties['short'] = ''; $this->properties['long'] = ''; $this->properties['arguments'] = $arguments; if ( !self::validateOptionName( $short ) ) { throw new ezcConsoleInvalidOptionNameException( $short ); } $this->properties['short'] = $short; if ( !self::validateOptionName( $long ) ) { throw new ezcConsoleInvalidOptionNameException( $long ); } $this->properties['long'] = $long; $this->__set( "type", $type !== null ? $type : ezcConsoleInput::TYPE_NONE ); $this->__set( "multiple", $multiple !== null ? $multiple : false ); $this->__set( "default", $default !== null ? $default : null ); $this->__set( "shorthelp", $shorthelp !== null ? $shorthelp : 'No help available.' ); $this->__set( "longhelp", $longhelp !== null ? $longhelp : 'Sorry, there is no help text available for this parameter.' ); $dependencies = $dependencies !== null && is_array( $dependencies ) ? $dependencies : array(); foreach ( $dependencies as $dep ) { $this->addDependency( $dep ); } $exclusions = $exclusions !== null && is_array( $exclusions ) ? $exclusions : array(); foreach ( $exclusions as $exc ) { $this->addExclusion( $exc ); } $this->__set( "mandatory", $mandatory !== null ? $mandatory : false ); $this->__set( "isHelpOption", $isHelpOption !== null ? $isHelpOption : false ); } /* * Add a new dependency for a parameter. * This registeres a new dependency rule with the parameter. If you try * to add an already registered rule it will simply be ignored. Else, * the submitted rule will be added to the parameter as a dependency. * * @param ezcConsoleOptionRule $rule The rule to add. * @return void / public function addDependency( ezcConsoleOptionRule $rule ) { foreach ( $this->dependencies as $existRule ) { if ( $rule == $existRule ) { return; } } $this->dependencies[] = $rule; } /* * Remove a dependency rule from a parameter. * This removes a given rule from a parameter, if it exists. If the rule is * not registered with the parameter, the method call will simply be ignored. * * @param ezcConsoleOptionRule $rule The rule to be removed. * @return void / public function removeDependency( ezcConsoleOptionRule $rule ) { foreach ( $this->dependencies as $id => $existRule ) { if ( $rule == $existRule ) { unset( $this->dependencies[$id] ); } } } /* * Remove all dependency rule referring to a parameter. * This removes all dependency rules from a parameter, that refer to as specific * parameter. If no rule is registered with this parameter as reference, the * method call will simply be ignored. * * @param ezcConsoleOption $param The param to be check for rules. * @return void / public function removeAllDependencies( ezcConsoleOption $param ) { foreach ( $this->dependencies as $id => $rule ) { if ( $rule->option == $param ) { unset( $this->dependencies[$id] ); } } } /* * Returns if a dependency to the given option exists. * Returns true if a dependency rule to the given option is registered, * otherwise false. * * @param ezcConsoleOption $param The param to check if a dependency exists to. * @return bool True if rule is registered, otherwise false. / public function hasDependency( ezcConsoleOption $param ) { foreach ( $this->dependencies as $id => $rule ) { if ( $rule->option == $param ) { return true; } } return false; } /* * Returns the dependency rules registered with this parameter. * Returns an array of registered dependencies. * * For example: * <code> * array( * 0 => ezcConsoleOptionRule, * 1 => ezcConsoleOptionRule, * 2 => ezcConsoleOptionRule, * ); * </code> * * @return array(ezcConsoleOptionRule) Dependency definition. / public function getDependencies() { return $this->dependencies; } /* * Reset existing dependency rules. * Deletes all registered dependency rules from the option definition. * * @return void / public function resetDependencies() { $this->dependencies = array(); } /* * Add a new exclusion for an option. * This registeres a new exclusion rule with the option. If you try * to add an already registered rule it will simply be ignored. Else, * the submitted rule will be added to the option as a exclusion. * * @param ezcConsoleOptionRule $rule The rule to add. * @return void / public function addExclusion( ezcConsoleOptionRule $rule ) { foreach ( $this->exclusions as $existRule ) { if ( $rule == $existRule ) { return; } } $this->exclusions[] = $rule; } /* * Remove a exclusion rule from a option. * This removes a given rule from a option, if it exists. If the rule is * not registered with the option, the method call will simply be ignored. * * @param ezcConsoleOptionRule $rule The rule to be removed. * @return void / public function removeExclusion( ezcConsoleOptionRule $rule ) { foreach ( $this->exclusions as $id => $existRule ) { if ( $rule == $existRule ) { unset( $this->exclusions[$id] ); } } } /* * Remove all exclusion rule referring to a option. * This removes all exclusion rules from a option, that refer to as specific * option. If no rule is registered with this option as reference, the * method call will simply be ignored. * * @param ezcConsoleOption $param The option to remove rule for. * @return void / public function removeAllExclusions( ezcConsoleOption $param ) { foreach ( $this->exclusions as $id => $rule ) { if ( $rule->option == $param ) { unset( $this->exclusions[$id] ); } } } /* * Returns if a given exclusion rule is registered with the option. * Returns true if a exclusion rule to the given option is registered, * otherwise false. * * @param ezcConsoleOption $param The param to check if exclusions exist for. * @return bool True if rule is registered, otherwise false. / public function hasExclusion( ezcConsoleOption $param ) { foreach ( $this->exclusions as $id => $rule ) { if ( $rule->option == $param ) { return true; } } return false; } /* * Returns the exclusion rules registered with this parameter. * Returns an array of registered exclusions. * * For example: * <code> * array( * 0 => ezcConsoleOptionRule, * 1 => ezcConsoleOptionRule, * 2 => ezcConsoleOptionRule, * ); * </code> * * @return array(ezcConsoleOptionRule) Exclusions definition. / public function getExclusions() { return $this->exclusions; } /* * Reset existing exclusion rules. * Deletes all registered exclusion rules from the option definition. * * @return void / public function resetExclusions() { $this->exclusions = array(); } /* * Property read access. * Provides read access to the properties of the object. * * @param string $key The name of the property. * @return mixed The value if property exists and isset, otherwise null. * @ignore / public function __get( $key ) { switch ( $key ) { case 'short': case 'long': case 'type': case 'default': case 'multiple': case 'shorthelp': case 'longhelp': case 'arguments': case 'isHelpOption': case 'mandatory': return $this->properties[$key]; case 'dependencies': default: throw new ezcBasePropertyNotFoundException( $key ); } } /* * Property write access. * * @param string $key Name of the property. * @param mixed $val The value for the property. * * @throws ezcBasePropertyPermissionException * If the property you try to access is read-only. * @throws ezcBasePropertyNotFoundException * If the the desired property is not found. * @ignore / public function __set( $key, $val ) { switch ( $key ) { case 'type': if ( $val !== ezcConsoleInput::TYPE_NONE && $val !== ezcConsoleInput::TYPE_INT && $val !== ezcConsoleInput::TYPE_STRING ) { throw new ezcBaseValueException( $key, $val, 'ezcConsoleInput::TYPE_STRING, ezcConsoleInput::TYPE_INT or ezcConsoleInput::TYPE_NONE' ); } break; case 'default': if ( ( is_scalar( $val ) === false && $val !== null ) ) { // Newly allow arrays, if multiple is true if ( $this->multiple === true && is_array( $val ) === true ) { break; } throw new ezcBaseValueException( $key, $val, 'a string or a number, if multiple == true also an array' ); } break; case 'multiple': if ( !is_bool( $val ) ) { throw new ezcBaseValueException( $key, $val, 'bool' ); } break; case 'shorthelp': if ( !is_string( $val ) ) { throw new ezcBaseValueException( $key, $val, 'string' ); } break; case 'longhelp': if ( !is_string( $val ) ) { throw new ezcBaseValueException( $key, $val, 'string' ); } break; case 'arguments': if ( !is_bool( $val ) ) { throw new ezcBaseValueException( $key, $val, 'bool' ); } break; case 'mandatory': if ( !is_bool( $val ) ) { throw new ezcBaseValueException( $key, $val, 'bool' ); } break; case 'isHelpOption': if ( !is_bool( $val ) ) { throw new ezcBaseValueException( $key, $val, 'bool' ); } break; case 'long': case 'short': throw new ezcBasePropertyPermissionException( $key, ezcBasePropertyPermissionException::READ ); break; default: throw new ezcBasePropertyNotFoundException( $key ); break; } $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 'short': case 'long': case 'type': case 'default': case 'multiple': case 'shorthelp': case 'longhelp': case 'arguments': case 'isHelpOption': case 'mandatory': return ( $this->properties[$key] !== null ); } return false; } /* * Returns if a given name if valid for use as a parameter name a parameter. * Checks if a given parameter name is generally valid for use. It checks a) * that the name does not start with '-' or '--' and b) if it contains * whitespaces. Note, that this method does not check any conflicts with already * used parameter names. * * @param string $name The name to check. * @return bool True if the name is valid, otherwise false. */ public static function validateOptionName( $name ) { if ( substr( $name, 0, 1 ) === '-' \|\| strpos( $name, ' ' ) !== false ) { return false; } return true; } } ?>	19.18 KB	2024-07-17 10:16
📁 validators	-	2025-05-25 12:37

Terminal