Fixing InvalidArgumentException in parsers

master
Julien Rosset 6 years ago
parent 3d869f684f
commit 33d04e872c

@ -1,121 +1,125 @@
<?php <?php
/** /**
* Déclaration de la classe CommandLine\Argument\AbstractArgument. * Déclaration de la classe CommandLine\Argument\AbstractArgument.
*/ */
namespace CommandLine\Argument; namespace CommandLine\Argument;
use Fidit\v3\AutoProperty; /**
use Fidit\v3\Exception\InvalidArgument; * Classe abstraite pour n'importe quel type de paramètre
*
/** * @package CommandLine\Argument
* Classe abstraite pour n'importe quel type de paramètre */
* abstract class ArgumentAbstract implements IArgument {
* @property string $varName {@see $_varName $_varName } /**
* @property string $name {@see $_name $_name } * @var string Le nom de la variable de retour de l'argument.
* @property string|null $description {@see $_description $_description} */
* @property mixed|null $default {@see $_default $_default } protected $_varName;
* /**
* @package CommandLine\Argument * @var string Le nom de l'argument.
*/ */
abstract class ArgumentAbstract extends AutoProperty implements IArgument { protected $_name;
/** /**
* @var string Le nom de la variable de retour de l'argument. * @var string|null La description de l'argument.
*/ */
protected $_varName; protected $_description;
/**
* @var string Le nom de l'argument. /**
*/ * @var mixed|null La valeur par défaut. Null si aucune.
protected $_name; */
/** protected $_default = null;
* @var string|null La description de l'argument.
*/ /**
protected $_description; * Crée un nouvel argument.
*
/** * @param string $name Le nom de l'argument
* @var mixed|null La valeur par défaut. Null si aucune. * @param string|null $description La description de l'argument
*/ */
protected $_default = null; protected function __construct ($name, $description) {
$this->setName($name, true);
/** $this->setDescription($description);
* Crée un nouvel argument. }
*
* @param string $name Le nom de l'argument /**
* @param string|null $description La description de l'argument * @inheritDoc
*/ */
protected function __construct ($name, $description) { public function getVarName() {
$this->setName($name, true); return $this->_varName;
$this->setDescription($description); }
} /**
* Définit le nom de la variable de retour de l'argument.
public function getVarName() { *
return $this->_varName; * @param string $varName Le nom
} *
/** * @return $this
* Définit le nom de la variable de retour de l'argument. *
* * @see $_name
* @param string $varName Le nom */
* public function setVarName($varName) {
* @return $this $this->_varName = $varName;
* return $this;
* @see $_name }
*/
public function setVarName($varName) { /**
$this->_varName = $varName; * @inheritDoc
return $this; */
} public function getName() {
return $this->_name;
public function getName() { }
return $this->_name; /**
} * Définit le nom de l'argument.
/** *
* Définit le nom de l'argument. * @param string $name Le nom
* * @param boolean $replaceVarName Remplacer également le nom de la variable de retour ?
* @param string $name Le nom *
* @param boolean $replaceVarName Remplacer également le nom de la variable de retour ? * @return $this
* *
* @return $this * @see $_name
* */
* @see $_name public function setName($name, $replaceVarName = true) {
*/ $this->_name = $name;
public function setName($name, $replaceVarName = true) { if($replaceVarName)
$this->_name = $name; $this->setVarName($name);
if($replaceVarName) return $this;
$this->setVarName($name); }
return $this;
} /**
* @inheritDoc
public function getDescription() { */
return $this->_description; public function getDescription() {
} return $this->_description;
/** }
* Définit la description de l'argument. /**
* * Définit la description de l'argument.
* @param string|null $description La description *
* * @param string|null $description La description
* @return $this *
* * @return $this
* @see $_description *
*/ * @see $_description
public function setDescription($description) { */
$this->_description = $description; public function setDescription($description) {
return $this; $this->_description = $description;
} return $this;
}
public function getDefault() {
return $this->_default; /**
} * @inheritDoc
/** */
* Définit le valeur par défaut public function getDefault() {
* return $this->_default;
* @param mixed|null $default La valeur par défaut. }
* /**
* @return $this * Définit le valeur par défaut
* *
* @see $_default * @param mixed|null $default La valeur par défaut.
*/ *
public function setDefault($default = null) { * @return $this
$this->_default = $default; *
return $this; * @see $_default
} */
public function setDefault($default = null) {
$this->_default = $default;
return $this;
}
} }

@ -1,85 +1,80 @@
<?php <?php
/** /**
* Déclaration de la classe CommandLine\Argument\ParseResult. * Déclaration de la classe CommandLine\Argument\ParseResult.
*/ */
namespace CommandLine\Argument; namespace CommandLine\Argument;
use Fidit\v3\AutoProperty; /**
* Résultat du parsage d'un argument
/** *
* Résultat du parsage d'un argument * @package CommandLine\Argument
* */
* @property int $consume {@see $_consume $_consume} class ParseResult {
* @property mixed $value {@see $_value $_value } /**
* * @var int Le nombre d'argument consumé.
* @package CommandLine\Argument */
*/ protected $_consume;
class ParseResult extends AutoProperty { /**
/** * @var mixed La valeur.
* @var int Le nombre d'argument consumé. */
*/ protected $_value;
protected $_consume;
/** /**
* @var mixed La valeur. * ArgumentParseResult constructor.
*/ *
protected $_value; * @param mixed $value La valeur.
* @param int $consume Le nombre d'argument consumé.
/** */
* ArgumentParseResult constructor. public function __construct ($value, $consume = 1) {
* $this->setValue($value);
* @param mixed $value La valeur. $this->setConsume($consume);
* @param int $consume Le nombre d'argument consumé. }
*/
public function __construct ($value, $consume = 1) { /**
$this->setValue($value); * Le nombre d'argument consumé.
$this->setConsume($consume); *
} * @return int Le nombre d'argument consumé.
*
/** * @see $_consume
* Le nombre d'argument consumé. */
* public function getConsume() {
* @return int Le nombre d'argument consumé. return $this->_consume;
* }
* @see $_consume /**
*/ * Définit le nombre d'argument consumé.
public function getConsume() { *
return $this->_consume; * @param $consume int Le nombre d'argument consumé.
} *
/** * @return $this
* Définit le nombre d'argument consumé. *
* * @see $_consume
* @param $consume int Le nombre d'argument consumé. */
* public function setConsume($consume) {
* @return $this $this->_consume = $consume;
* return $this;
* @see $_consume }
*/
public function setConsume($consume) { /**
$this->_consume = $consume; * La valeur.
return $this; *
} * @return mixed La valeur.
*
/** * @see $_value
* La valeur. */
* public function getValue() {
* @return mixed La valeur. return $this->_value;
* }
* @see $_value /**
*/ * Définit les valeurs définies.
public function getValue() { *
return $this->_value; * @param mixed $value La valeur.
} *
/** * @return $this
* Définit les valeurs définies. *
* * @see $_value
* @param mixed $value La valeur. */
* public function setValue($value) {
* @return $this $this->_value = $value;
* return $this;
* @see $_value }
*/
public function setValue($value) {
$this->_value = $value;
return $this;
}
} }

@ -1,32 +1,38 @@
<?php <?php
/** /**
* Déclaration de la classe CommandLine\Argument\Parser\BooleanParser * Déclaration de la classe CommandLine\Argument\Parser\BooleanParser
*/ */
namespace CommandLine\Argument\Parser; namespace CommandLine\Argument\Parser;
use Fidit\v3\Exception\InvalidArgument; use http\Exception\InvalidArgumentException;
/** /**
* Parseur vers un booléen * Parseur vers un booléen
* *
* Les valeurs suivantes sont acceptées : * Les valeurs suivantes sont acceptées :
* - true , 1, oui, vrai * - true , 1, oui, vrai
* - false, 0, non, faux * - false, 0, non, faux
* *
* @package CommandLine\Argument\Parser * @package CommandLine\Argument\Parser
*/ */
class BooleanParser implements IValueParser { class BooleanParser implements IValueParser {
public function parseValue ($arg) { /**
if(!in_array($arg, array( * @inheritDoc
'true' , '1', 'oui', 'vrai', */
'false', '0', 'non', 'faux', public function parseValue ($arg) {
))) if(!in_array($arg, array(
throw new InvalidArgument($arg, 'La valeur n\'est pas un booléen valide'); 'true' , '1', 'oui', 'vrai',
'false', '0', 'non', 'faux',
return in_array($arg, array('true' , '1', 'oui', 'vrai')); )))
} throw new InvalidArgumentException('La valeur n\'est pas un booléen valide : '.$arg);
public function getValueDescription () { return in_array($arg, array('true' , '1', 'oui', 'vrai'));
return 'boolean'; }
}
/**
* @inheritDoc
*/
public function getValueDescription () {
return 'boolean';
}
} }

@ -1,138 +1,138 @@
<?php <?php
/** /**
* Déclaration de la classe CommandLine\Argument\Parser\DecimalParser * Déclaration de la classe CommandLine\Argument\Parser\DecimalParser
*/ */
namespace CommandLine\Argument\Parser; namespace CommandLine\Argument\Parser;
use Fidit\v3\Exception\InvalidArgument; use InvalidArgumentException;
/** /**
* Parseur vers un réel * Parseur vers un réel
* *
* @property double|null $valueMin {@see $_valueMin $_valueMin} * @package CommandLine\Argument\Parser
* @property double|null $valueMax {@see $_valueMax $_valueMax} */
* class DecimalParser implements IValueParser {
* @package CommandLine\Argument\Parser /**
*/ * @var double|null La valeur minimum autorisée. Null si pas de limite.
class DecimalParser implements IValueParser { */
/** protected $_valueMin = null;
* @var double|null La valeur minimum autorisée. Null si pas de limite. /**
*/ * @var double|null La valeur maximum autorisée. Null si pas de limite
protected $_valueMin = null; */
/** protected $_valueMax = null;
* @var double|null La valeur maximum autorisée. Null si pas de limite
*/ /**
protected $_valueMax = null; * Crée un nouveau parseur
*
/** * @param double|null $valueMin La valeur minimum autorisée
* Crée un nouveau parseur * @param double|null $valueMax La valeur maximum autorisée
* */
* @param double|null $valueMin La valeur minimum autorisée public function __construct ($valueMin = null, $valueMax = null) {
* @param double|null $valueMax La valeur maximum autorisée $this->setValueMin($valueMin);
* $this->setValueMax($valueMax);
* @throws InvalidArgument Si l'un des paramètre est invalide. }
*/
public function __construct ($valueMin = null, $valueMax = null) { /**
$this->setValueMin($valueMin); * @inheritDoc
$this->setValueMax($valueMax); */
} public function parseValue ($arg) {
if (!$this->_isDecimal($arg))
public function parseValue ($arg) { throw new InvalidArgumentException('La valeur n\'est pas un réel valide : ' . $arg);
if (!$this->_isDecimal($arg))
throw new InvalidArgument($arg, 'La valeur n\'est pas un réel valide'); $int = (int)$arg;
$int = (int)$arg; if ($this->hasValueMin()) {
if ($int < $this->getValueMin())
if ($this->hasValueMin()) { throw new InvalidArgumentException('La valeur est inférieure au minimum (' . $this->getValueMin().') : ' . $arg);
if ($int < $this->getValueMin()) }
throw new InvalidArgument($int, 'La valeur est inférieure au minimum : ' . $this->getValueMin()); if ($this->hasValueMax()) {
} if ($int > $this->getValueMax())
if ($this->hasValueMax()) { throw new InvalidArgumentException($int, 'La valeur est supérieur au maximum (' . $this->getValueMax() . ') : ' . $arg);
if ($int > $this->getValueMax()) }
throw new InvalidArgument($int, 'La valeur est supérieur au maximum : ' . $this->getValueMax());
} return $int;
}
return $int;
} /**
* @inheritDoc
protected function _isDecimal($val) { */
if(!is_numeric($val)) protected function _isDecimal($val) {
return false; if(!is_numeric($val))
return false;
return true;
} return true;
}
public function getValueDescription () {
return ($this->hasValueMin() ? $this->getValueMin().' <= ' : '').'decimal'.($this->hasValueMax() ? ' <= '.$this->getValueMax() : ''); /**
} * @inheritDoc
*/
/** public function getValueDescription () {
* La valeur minimumm autorisée return ($this->hasValueMin() ? $this->getValueMin().' <= ' : '').'decimal'.($this->hasValueMax() ? ' <= '.$this->getValueMax() : '');
* }
* @return double|null La valeur minimum.
* /**
* @see $_valueMin * La valeur minimumm autorisée
*/ *
public function getValueMin() { * @return double|null La valeur minimum.
return $this->_valueMin; *
} * @see $_valueMin
/** */
* Définit la valeur minimum autorisée. public function getValueMin() {
* return $this->_valueMin;
* @param double|null $valueMin La valeur minimum. }
* /**
* @return $this * Définit la valeur minimum autorisée.
* *
* @throws InvalidArgument Si la valeur minimum n'est ni null, ni un entier * @param double|null $valueMin La valeur minimum.
*/ *
public function setValueMin($valueMin = null) { * @return $this
if(!is_null($valueMin) && !$this->_isDecimal($valueMin)) */
throw new InvalidArgument($valueMin, 'La valeur n\'est pas un entier ou null'); public function setValueMin($valueMin = null) {
if(!is_null($valueMin) && !$this->_isDecimal($valueMin))
$this->_valueMin = (int)$valueMin; throw new InvalidArgumentException('La valeur n\'est pas un entier ou null' . $valueMin);
return $this;
} $this->_valueMin = (int)$valueMin;
/** return $this;
* Est-ce qu'il existe une limite minimum ? }
* /**
* @return boolean True s'il existe une limite, sinon False * Est-ce qu'il existe une limite minimum ?
*/ *
public function hasValueMin() { * @return boolean True s'il existe une limite, sinon False
return !is_null($this->getValueMin()); */
} public function hasValueMin() {
return !is_null($this->getValueMin());
/** }
* La valeur maximum autorisée
* /**
* @return double|null La valeur maximum. * La valeur maximum autorisée
* *
* @see $_valueMax * @return double|null La valeur maximum.
*/ *
public function getValueMax() { * @see $_valueMax
return $this->_valueMax; */
} public function getValueMax() {
/** return $this->_valueMax;
* Définit la valeur maximum autorisée. }
* /**
* @param double|null $valueMax La valeur maximum. * Définit la valeur maximum autorisée.
* *
* @return $this * @param double|null $valueMax La valeur maximum.
* *
* @throws InvalidArgument Si la valeur maximum n'est ni null, ni un entier * @return $this
*/ */
public function setValueMax($valueMax = null) { public function setValueMax($valueMax = null) {
if(!is_null($valueMax) && !$this->_isDecimal($valueMax)) if(!is_null($valueMax) && !$this->_isDecimal($valueMax))
throw new InvalidArgument($valueMax, 'La valeur n\'est pas un entier ou null'); throw new InvalidArgumentException('La valeur n\'est pas un entier ou null : ' . $valueMax);
$this->_valueMax = (int)$valueMax; $this->_valueMax = (int)$valueMax;
return $this; return $this;
} }
/** /**
* Est-ce qu'il existe une limite maximum ? * Est-ce qu'il existe une limite maximum ?
* *
* @return boolean True s'il existe une limite, sinon False * @return boolean True s'il existe une limite, sinon False
*/ */
public function hasValueMax() { public function hasValueMax() {
return !is_null($this->getValueMax()); return !is_null($this->getValueMax());
} }
} }

@ -1,75 +1,74 @@
<?php <?php
/** /**
* Déclaration de la classe CommandLine\Argument\Parser\EnumParser * Déclaration de la classe CommandLine\Argument\Parser\EnumParser
*/ */
namespace CommandLine\Argument\Parser; namespace CommandLine\Argument\Parser;
use Fidit\v3\Exception\InvalidArgument; use InvalidArgumentException;
/** /**
* Parseur vers une liste de valeurs possible (chaine de caractère). * Parseur vers une liste de valeurs possible (chaine de caractère).
* *
* @property string[] $values {@see $_values $_values} * @package CommandLine\Argument\Parser
* */
* @package CommandLine\Argument\Parser class EnumParser implements IValueParser {
*/ /**
class EnumParser implements IValueParser { * @var string[] Liste des valeurs autorisées
/** */
* @var string[] Liste des valeurs autorisées protected $_values;
*/
protected $_values; /**
* Crée un nouveau parseur
/** *
* Crée un nouveau parseur. * @param string[] $values La liste des valeurs autorisées
* */
* @param string[] $values La liste des valeurs autorisées. public function __construct ($values) {
* $this->setValues($values);
* @throws InvalidArgument Si l'un des paramètres n'est pas correct }
*/
public function __construct ($values) { /**
$this->setValues($values); * @inheritDoc
} */
public function parseValue ($arg) {
public function parseValue ($arg) { if(!in_array($arg, $this->_values))
if(!in_array($arg, $this->_values)) throw new InvalidArgumentException('La valeur ne fait partie de liste des valeurs autorisées (' . implode(', ', $this->getValues()) . ') : ' . $arg);
throw new InvalidArgument($arg, 'La valeur ne fait partie de liste des valeurs autorisées : '.implode(', ', $this->getValues()));
return $arg;
return $arg; }
}
/**
public function getValueDescription () { * @inheritDoc
return 'enum('.implode(',', $this->getValues()).')'; */
} public function getValueDescription () {
return 'enum('.implode(',', $this->getValues()).')';
/** }
* La liste des valeurs autoriséees.
* /**
* @return string[] La liste des valeurs * La liste des valeurs autoriséees.
* *
* @see $_values * @return string[] La liste des valeurs
*/ *
public function getValues() { * @see $_values
return $this->_values; */
} public function getValues() {
/** return $this->_values;
* Définit la liste des valeurs autorisées. }
* /**
* @param string[] $values La liste des valeurs * Définit la liste des valeurs autorisées.
* *
* @return $this * @param string[] $values La liste des valeurs
* *
* @throws InvalidArgument Si la liste n'est pas un tableau ou si celui-ci est vide * @return $this
* * @see $_values
* @see $_values */
*/ public function setValues($values) {
public function setValues($values) { if(!is_array($values))
if(!is_array($values)) throw new InvalidArgumentException('La liste de valeurs n\'est pas un tableau');
throw new InvalidArgument($values, 'La liste de valeurs n\'est pas un tableau');
if(count($values) == 0)
if(count($values) == 0) throw new InvalidArgumentException('La liste de valeurs doit avoir au moins un élément');
throw new InvalidArgument($values, 'La liste de valeurs doit avoir au moins un élément');
$this->_values = $values;
$this->_values = $values; return $this;
return $this; }
}
} }

@ -1,32 +1,28 @@
<?php <?php
/** /**
* Déclare l'interface CommandLine\Argument\Parser\IValueParser * Déclare l'interface CommandLine\Argument\Parser\IValueParser
*/ */
namespace CommandLine\Argument\Parser; namespace CommandLine\Argument\Parser;
use Fidit\v3\Exception\InvalidArgument; /**
* Interface pour les parseurs
/** *
* Interface pour les parseurs * @package CommandLine\Argument\Parser
* */
* @package CommandLine\Argument\Parser interface IValueParser {
*/ /**
interface IValueParser { * Vérifie et transforme une valeur.
/** *
* Vérifie et transforme une valeur. * @param string $val La valeur à transformer.
* *
* @param string $val La valeur à transformer. * @return mixed La valeur transformée.
* */
* @return mixed La valeur transformée. public function parseValue($val);
*
* @throws InvalidArgument Si la valeur n'est pas valide. /**
*/ * La description des contraintes de la valeur.
public function parseValue($val); *
* @return string La description.
/** */
* La description des contraintes de la valeur. public function getValueDescription();
*
* @return string La description.
*/
public function getValueDescription();
} }

@ -1,141 +1,141 @@
<?php <?php
/** /**
* Déclaration de la classe CommandLine\Argument\Parser\IntegerParser * Déclaration de la classe CommandLine\Argument\Parser\IntegerParser
*/ */
namespace CommandLine\Argument\Parser; namespace CommandLine\Argument\Parser;
use Fidit\v3\Exception\InvalidArgument; use InvalidArgumentException;
/** /**
* Parseur vers un entier. * Parseur vers un entier
* *
* @property int|null $valueMin {@see $_valueMin $_valueMin} * @package CommandLine\Argument\Parser
* @property int|null $valueMax {@see $_valueMax $_valueMax} */
* class IntegerParser implements IValueParser {
* @package CommandLine\Argument\Parser /**
*/ * @var int|null La valeur minimum autorisée. Null si pas de limite.
class IntegerParser implements IValueParser { */
/** protected $_valueMin = null;
* @var int|null La valeur minimum autorisée. Null si pas de limite. /**
*/ * @var int|null La valeur maximum autorisée. Null si pas de limite
protected $_valueMin = null; */
/** protected $_valueMax = null;
* @var int|null La valeur maximum autorisée. Null si pas de limite
*/ /**
protected $_valueMax = null; * Crée un nouveau parseur
*
/** * @param int|null $valueMin La valeur minimum autorisée
* Crée un nouveau parseur * @param int|null $valueMax La valeur maximum autorisée
* */
* @param int|null $valueMin La valeur minimum autorisée public function __construct ($valueMin = null, $valueMax = null) {
* @param int|null $valueMax La valeur maximum autorisée $this->setValueMin($valueMin);
* $this->setValueMax($valueMax);
* @throws InvalidArgument Si l'un des paramètre est invalide. }
*/
public function __construct ($valueMin = null, $valueMax = null) { /**
$this->setValueMin($valueMin); * @inheritDoc
$this->setValueMax($valueMax); */
} public function parseValue ($arg) {
if(!$this->_isInt($arg))
public function parseValue ($arg) { throw new InvalidArgumentException('La valeur n\'est pas un entier valide : ' . $arg);
if(!$this->_isInt($arg))
throw new InvalidArgument($arg, 'La valeur n\'est pas un entier valide'); $int = (int)$arg;
$int = (int)$arg; if($this->hasValueMin()) {
if($int < $this->getValueMin())
if($this->hasValueMin()) { throw new InvalidArgumentException('La valeur est inférieure au minimum (' . $this->getValueMin() . ') :' . $int);
if($int < $this->getValueMin()) }
throw new InvalidArgument($int, 'La valeur est inférieure au minimum : '.$this->getValueMin()); if($this->hasValueMax()) {
} if($int > $this->getValueMax())
if($this->hasValueMax()) { throw new InvalidArgumentException('La valeur est supérieur au maximum (' . $this->getValueMax() . ') : ' . $int);
if($int > $this->getValueMax()) }
throw new InvalidArgument($int, 'La valeur est supérieur au maximum : '.$this->getValueMax());
} return $int;
}
return $int;
} /**
* @inheritDoc
protected function _isInt($val) { */
if(!is_numeric($val)) protected function _isInt($val) {
return false; if(!is_numeric($val))
return false;
if(floor($val) != $val)
return false; if(floor($val) != $val)
return false;
return true;
} return true;
}
public function getValueDescription () {
return ($this->hasValueMin() ? $this->getValueMin().' <= ' : '').'integer'.($this->hasValueMax() ? ' <= '.$this->getValueMax() : ''); /**
} * @inheritDoc
*/
/** public function getValueDescription () {
* La valeur minimumm autorisée return ($this->hasValueMin() ? $this->getValueMin().' <= ' : '').'integer'.($this->hasValueMax() ? ' <= '.$this->getValueMax() : '');
* }
* @return int|null La valeur minimum.
* /**
* @see $_valueMin * La valeur minimumm autorisée
*/ *
public function getValueMin() { * @return int|null La valeur minimum.
return $this->_valueMin; *
} * @see $_valueMin
/** */
* Définit la valeur minimum autorisée. public function getValueMin() {
* return $this->_valueMin;
* @param int|null $valueMin La valeur minimum. }
* /**
* @return $this * Définit la valeur minimum autorisée.
* *
* @throws InvalidArgument Si la valeur minimum n'est ni null, ni un entier * @param int|null $valueMin La valeur minimum.
*/ *
public function setValueMin($valueMin = null) { * @return $this
if(!is_null($valueMin) && !$this->_isInt($valueMin)) */
throw new InvalidArgument($valueMin, 'La valeur n\'est pas un entier ou null'); public function setValueMin($valueMin = null) {
if(!is_null($valueMin) && !$this->_isInt($valueMin))
$this->_valueMin = (int)$valueMin; throw new InvalidArgumentException('La valeur n\'est pas un entier ou null : '.$valueMin);
return $this;
} $this->_valueMin = (int)$valueMin;
/** return $this;
* Est-ce qu'il existe une limite minimum ? }
* /**
* @return boolean True s'il existe une limite, sinon False * Est-ce qu'il existe une limite minimum ?
*/ *
public function hasValueMin() { * @return boolean True s'il existe une limite, sinon False
return !is_null($this->getValueMin()); */
} public function hasValueMin() {
return !is_null($this->getValueMin());
/** }
* La valeur maximum autorisée
* /**
* @return int|null La valeur maximum. * La valeur maximum autorisée
* *
* @see $_valueMax * @return int|null La valeur maximum.
*/ *
public function getValueMax() { * @see $_valueMax
return $this->_valueMax; */
} public function getValueMax() {
/** return $this->_valueMax;
* Définit la valeur maximum autorisée. }
* /**
* @param int|null $valueMax La valeur maximum. * Définit la valeur maximum autorisée.
* *
* @return $this * @param int|null $valueMax La valeur maximum.
* *
* @throws InvalidArgument Si la valeur maximum n'est ni null, ni un entier * @return $this
*/ */
public function setValueMax($valueMax = null) { public function setValueMax($valueMax = null) {
if(!is_null($valueMax) && !$this->_isInt($valueMax)) if(!is_null($valueMax) && !$this->_isInt($valueMax))
throw new InvalidArgument($valueMax, 'La valeur n\'est pas un entier ou null'); throw new InvalidArgumentException('La valeur n\'est pas un entier ou null : '.$valueMax);
$this->_valueMax = (int)$valueMax; $this->_valueMax = (int)$valueMax;
return $this; return $this;
} }
/** /**
* Est-ce qu'il existe une limite maximum ? * Est-ce qu'il existe une limite maximum ?
* *
* @return boolean True s'il existe une limite, sinon False * @return boolean True s'il existe une limite, sinon False
*/ */
public function hasValueMax() { public function hasValueMax() {
return !is_null($this->getValueMax()); return !is_null($this->getValueMax());
} }
} }

@ -1,65 +1,69 @@
<?php <?php
/** /**
* Déclaration de la classe CommandLine\Argument\Parser\RegexParser * Déclaration de la classe CommandLine\Argument\Parser\RegexParser
*/ */
namespace CommandLine\Argument\Parser; namespace CommandLine\Argument\Parser;
use Fidit\v3\Exception\InvalidArgument; use InvalidArgumentException;
/** /**
* Parseur vers une chaine de caractère correspondant à un motif * Parseur vers une chaine de caractère correspondant à un motif
* *
* Renvoie la liste des groupes capturants * Renvoie la liste des groupes capturants
* *
* @property string $regex {@see $_regex $_regex} * @package CommandLine\Argument\Parser
* */
* @package CommandLine\Argument\Parser class RegexParser implements IValueParser {
*/ /**
class RegexParser implements IValueParser { * @var string La regex à respecter
/** */
* @var string La regex à respecter protected $_regex = '';
*/
protected $_regex = ''; /**
* Crée un nouveau parseur
/** *
* Crée un nouveau parseur * @param string $regex Le motif à respecter
* */
* @param string $regex Le motif à respecter public function __construct ($regex) {
*/ $this->setRegex($regex);
public function __construct ($regex) { }
$this->setRegex($regex);
} /**
* @inheritDoc
public function parseValue ($arg) { */
if(!preg_match($this->regex, $arg, $matches)) public function parseValue ($arg) {
throw new InvalidArgument($arg, 'La valeur ne correspond pas au motif attendu'); if(!preg_match($this->_regex, $arg, $matches))
throw new InvalidArgumentException('La valeur ne correspond pas au motif attendu : ' . $arg);
return $matches;
} return $matches;
}
public function getValueDescription () {
return $this->getRegex(); /**
} * @inheritDoc
*/
/** public function getValueDescription () {
* Le motif à respecter return $this->getRegex();
* }
* @return string Le motif
* /**
* @see $_regex * Le motif à respecter
*/ *
public function getRegex() { * @return string Le motif
return $this->_regex; *
} * @see $_regex
/** */
* Modifie le motif à respecter public function getRegex() {
* return $this->_regex;
* @param string $regex Le nouveau motif }
* /**
* @return $this * Modifie le motif à respecter
*/ *
public function setRegex($regex = null) { * @param string $regex Le nouveau motif
$this->_regex = $regex; *
return $this; * @return $this
} */
public function setRegex($regex = null) {
$this->_regex = $regex;
return $this;
}
} }

@ -1,20 +1,26 @@
<?php <?php
/** /**
* Déclaration de la classe CommandLine\Argument\Parser\StringParser * Déclaration de la classe CommandLine\Argument\Parser\StringParser
*/ */
namespace CommandLine\Argument\Parser; namespace CommandLine\Argument\Parser;
/** /**
* Parseur vers une chaine de caractères * Parseur vers une chaine de caractères
* *
* @package CommandLine\Argument\Parser * @package CommandLine\Argument\Parser
*/ */
class StringParser implements IValueParser { class StringParser implements IValueParser {
public function parseValue ($arg) { /**
return $arg; * @inheritDoc
} */
public function parseValue ($arg) {
public function getValueDescription () { return $arg;
return 'string'; }
}
/**
* @inheritDoc
*/
public function getValueDescription () {
return 'string';
}
} }
Loading…
Cancel
Save