/**
* Convert the object to an instance of ``IntString``.
*
* @param string|IntString $obj Object to convert to ``IntString``.
*
* @return IntString
* @throws InvalidArgumentException if object is not a string or format is invalid.
*/
public static function parse($obj)
{
if ($obj instanceof IntString) {
return $obj;
}
if (is_integer($obj)) {
return new VersionComponent($obj);
}
try {
$intValue = (int) String::ensureIsString($obj);
} catch (InvalidArgumentException $e) {
$args = ['position' => '1st', 'expected' => 'string" or "integer', 'actual' => typeof($obj)];
$msg = nml_msg('Invalid argument type.');
$msg .= nml_msg(' {position} parameter must to be an instance of "{expected}"; "{actual}" given.', $args);
throw new InvalidArgumentException($msg, 1, $e);
}
$stringValue = ltrim($obj, "{$intValue}");
// Validate that 0 (zero) is not interpreted as '' (empty string)
if ($stringValue === $obj) {
$msg = nml_msg('Invalid argument value.');
$msg .= nml_msg(' "{0}" (string) must to start with an integer.', $obj);
throw new InvalidArgumentException($msg);
}
return new IntString($intValue, $stringValue);
}
public function equals($other)
{
if (defined('CODE_ANALYSIS')) {
if ($this instanceof IEquatable) {
$type = typeof($this);
$args = ['access' => 'public', 'base_class' => __CLASS__, 'class' => $type->Name, 'function' => __FUNCTION__];
$msg = nml_msg('You implemented IEquatable, but using default "{base_class}::{function}" ({access}) method.', $args);
$msg .= nml_msg(' You can replace (override) its behavior by creating "{class}::{function}" ({access}) method.', $args);
trigger_error($msg, E_USER_NOTICE);
}
}
return $this == $other;
}
/**
*
*
* @param int|null $intValue
* @param string|null $stringValue
*/
public function __construct($intValue = null, $stringValue = null)
{
// Validates filters for only null or int/string value types.
parent::__construct($intValue, $stringValue);
if ($intValue === null) {
$this->intValue = $intValue;
// Ignore string value if intValue is null.
$this->stringValue = '';
} else {
// Validation of values
if ($this->IntValue < 0) {
$args = ['position' => '1st', 'actual' => $intValue];
$msg = nml_msg('Invalid argument value.');
$msg .= nml_msg(' {position} argument must to be a positive number; "{actual}" given.', $args);
throw new InvalidArgumentException($msg);
}
// Integer is valid
if ($stringValue !== null) {
if ($this->StringValue != '') {
$pattern = '~^([a-z])$~';
// 1 char
if (strlen($this->StringValue) > 1) {
$start = '~^([a-z]|-)';
$middle = '([a-z]|[0-9]|-)*';
$end = '([a-z]|[0-9])$~';
$pattern = $start . $middle . $end;
}
$correct = (bool) preg_match($pattern, $this->StringValue);
if ($correct) {
//Último chequeo: que no hayan 2 '-' consecutivos.
$correct = strpos($this->StringValue, '--') == false ? true : false;
}
if (!$correct) {
$args = ['position' => '2nd', 'actual' => $stringValue];
$msg = nml_msg('Invalid argument value.');
$msg .= nml_msg(' {position} parameter has invalid chars; "{actual}" given.', $args);
throw new InvalidArgumentException($msg);
}
}
}
// String is valid
}
}
/**
* Gets the property getter method name.
* You can customize the getter prefix by implementing ``ICustomPrefixedPropertiesContainer`` interface.
*
* @param string $name Property name.
*
* @return string
* @throws InvalidArgumentException If property is not valid or has not getter.
* @throws BadMethodCallException If custom prefix is not an ``string`` instance.
* @see ICustomPrefixedPropertiesContainer::getCustomGetterPrefix()
*/
protected static function getPropertyGetter($name)
{
$args = ['class' => get_called_class()];
$prefix = 'get';
$args['name'] = static::ensurePropertyExists($name, $args['class']);
try {
$getter = static::ensureMethodExists($prefix . $args['name']);
} catch (InvalidArgumentException $error) {
$msg = nml_msg('"{name}" property has not a getter method in "{class}".', $args);
if (is_subclass_of($args['class'], ICustomPrefixedPropertiesContainer::class)) {
// If not available standard getter, check if custom available
try {
$prefix = String::ensureIsString(static::getCustomGetterPrefix());
} catch (InvalidArgumentException $e) {
$msg = nml_msg('"{class}::getCustomGetterPrefix" method must to return an string.', $args['class']);
throw new BadMethodCallException($msg, 31, $e);
}
try {
$getter = static::ensureMethodExists($prefix . $args['name']);
} catch (InvalidArgumentException $e) {
throw new InvalidArgumentException($msg, 32, $e);
}
} else {
// Error for non custom prefixes
throw new InvalidArgumentException($msg, 30, $error);
}
}
return $getter;
}
/**
* Ensures that an string follows the PHP variables naming convention.
*
* @param string $string String to be ensured.
*
* @return string
* @throws InvalidArgumentException if object is not an `string` or do not
* follows the PHP variables naming convention.
*/
public static function ensureIsValidVarName($string)
{
$pattern = '/^[a-zA-Z_\\x7f-\\xff][a-zA-Z0-9_\\x7f-\\xff]*/';
if (!preg_match($pattern, static::ensureIsString($string))) {
$msg = nml_msg('Provided string do not follows PHP variables naming convention: "{0}".', $string);
throw new InvalidArgumentException($msg);
}
return $string;
}
/**
* Convierte una cadena a su representación del tipo Version.
*
* @param Version|string|int|float|array $value Objeto a convertir.
*
* @return Version Objeto convertido desde $value.
* */
public static function parse($value)
{
if ($value instanceof Version) {
return $value;
}
$version = [];
// Try to convert into an array
if (is_integer($value)) {
// Integer for major value
$version = [$value, 0];
} elseif (is_float($value)) {
// Integer part as major, and decimal part as minor
$version = sprintf("%F", $value);
$version = explode('.', $version);
} elseif (is_array($value)) {
// Implode first 4 places for major, minor, build and revision respectivally.
$version = array_slice($value, 0, 4);
} elseif (is_string($value)) {
$version = explode('.', $value);
} else {
$msg = nml_msg('Unable to parse. Argument passed has an invalid type: "{0}".', typeof($value));
throw new InvalidArgumentException($msg);
}
// $value ya debería ser un array.
$c = count($version);
if ($c > 4 || $c < 2) {
$msg = nml_msg('Unable to parse. Argument passed has an invalid format: "{0}".', $value);
//var_dump($version);
throw new InvalidArgumentException($msg);
}
$major = (int) $version[0];
$minor = (int) $version[1];
$build = null;
$revision = null;
if (count($version) >= 3) {
$build = VersionComponent::Parse($version[2]);
if (count($version) == 4) {
$revision = VersionComponent::Parse($version[3]);
}
}
return new Version($major, $minor, $build, $revision);
}
/**
* Obtiene la ruta del directorio de la versión especificada. Si no se
* especifica, se devuelve la versión más reciente.
*
* @param string|Version $version Versión a obtener. También puede
* tomar los valores 'newest' u 'oldest' para representar a la versión
* más nueva o más vieja, respectivamente.
*
* @return string Ruta del directorio de la versión especificada.
* */
public function getDirectoryPath($version = self::NEWEST)
{
$c = count($this->Versions);
if ($c == 0) {
throw new LogicException(nml_msg('This Asset has not versions.'));
}
$v = $version;
if ($version == self::OLDEST or $version == self::NEWEST) {
$v = $this->Versions[0];
if ($c > 1) {
usort($this->versions, array("NelsonMartell\\Version", "Compare"));
$v = $this->Versions[0];
if ($version == self::NEWEST) {
$v = $this->Versions[$c - 1];
}
}
} else {
try {
$v = Version::parse($version);
} catch (InvalidArgumentException $e) {
$args = ['name' => 'version', 'pos' => 0, 'expected' => typeof(new Version(1, 0))->Name, 'actual' => typeof($version)];
$msg = nml_msg('Invalid argument type.');
$msg .= nml_msg(' "{name}" (position {pos}) must to be an instance of "{expected}" (or compatible);' . ' "{actual}" given.', $args);
throw new InvalidArgumentException($msg);
}
if (array_search($v, $this->Versions) === false) {
$msg = nml_msg('Invalid argument value.');
$msg .= nml_msg(' Asset has not the version "{version}".', ['version' => $v]);
throw new InvalidArgumentException($msg);
}
}
return sprintf('%s%s/', $this->RootDirectory, $v);
}
