sda-php/nur-ture
11
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

renommer dest en value; tenir compte de la valeur par défaut

Browse Source
This commit is contained in:
Jephté Clain 2025-03-06 16:22:12 +04:00
parent fc523bfb6c
commit 089e4872aa
22 changed files with 448 additions and 411 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/php/access/KeyAccess.php
View File

@ -8,8 +8,8 @@ use nulib\cl;
* Class KeyAccess: accès à une valeur d'une clé dans un tableau * Class KeyAccess: accès à une valeur d'une clé dans un tableau
*/ */
class KeyAccess extends AbstractAccess { class KeyAccess extends AbstractAccess {
function __construct(&$dest, $key, ?array $params=null) { function __construct(&$array, $key, ?array $params=null) {
$this->dest =& $dest; $this->array =& $array;
$this->key = $key; $this->key = $key;
$this->allowNull = $params["allow_null"] ?? true; $this->allowNull = $params["allow_null"] ?? true;
$this->allowFalse = $params["allow_false"] ?? false; $this->allowFalse = $params["allow_false"] ?? false;
@ -17,10 +17,10 @@ class KeyAccess extends AbstractAccess {
} }
/** @var array|ArrayAccess */ /** @var array|ArrayAccess */
protected $dest; protected $array;
function reset(&$dest): self { function reset(&$array): self {
$this->dest =& $dest; $this->array =& $array;
return $this; return $this;
} }
@ -36,12 +36,12 @@ class KeyAccess extends AbstractAccess {
function exists(): bool { function exists(): bool {
$key = $this->key; $key = $this->key;
if ($key === null) return false; if ($key === null) return false;
return cl::has($this->dest, $key); return cl::has($this->array, $key);
} }
function available(): bool { function available(): bool {
if (!$this->exists()) return false; if (!$this->exists()) return false;
$value = cl::get($this->dest, $this->key); $value = cl::get($this->array, $this->key);
if ($value === null) return $this->allowNull; if ($value === null) return $this->allowNull;
if ($value === false) return $this->allowFalse; if ($value === false) return $this->allowFalse;
if ($value === "") return $this->allowEmpty; if ($value === "") return $this->allowEmpty;
@ -50,7 +50,7 @@ class KeyAccess extends AbstractAccess {
function get($default=null) { function get($default=null) {
if ($this->key === null) return $default; if ($this->key === null) return $default;
$value = cl::get($this->dest, $this->key, $default); $value = cl::get($this->array, $this->key, $default);
if ($value === null && !$this->allowNull) return $default; if ($value === null && !$this->allowNull) return $default;
if ($value === false && !$this->allowFalse) return $default; if ($value === false && !$this->allowFalse) return $default;
if ($value === "" && !$this->allowEmpty) return $default; if ($value === "" && !$this->allowEmpty) return $default;
@ -59,11 +59,11 @@ class KeyAccess extends AbstractAccess {
function set($value): void { function set($value): void {
if ($this->key === null) return; if ($this->key === null) return;
cl::set($this->dest, $this->key, $value); cl::set($this->array, $this->key, $value);
} }
function del(): void { function del(): void {
if ($this->key === null) return; if ($this->key === null) return;
cl::del($this->dest, $this->key); cl::del($this->array, $this->key);
} }
} }

20
src/php/access/ValueAccess.php
View File

@ -5,18 +5,18 @@ namespace nur\sery\wip\php\access;
* Class ValueAccess: accès à une valeur unitaire * Class ValueAccess: accès à une valeur unitaire
*/ */
class ValueAccess extends AbstractAccess { class ValueAccess extends AbstractAccess {
function __construct(&$dest, ?array $params=null) { function __construct(&$value, ?array $params=null) {
$this->dest =& $dest; $this->value =& $value;
$this->allowNull = $params["allow_null"] ?? false; $this->allowNull = $params["allow_null"] ?? false;
$this->allowFalse = $params["allow_false"] ?? true; $this->allowFalse = $params["allow_false"] ?? true;
$this->allowEmpty = $params["allow_empty"] ?? true; $this->allowEmpty = $params["allow_empty"] ?? true;
} }
/** @var mixed */ /** @var mixed */
protected $dest; protected $value;
function reset(&$dest): self { function reset(&$value): self {
$this->dest =& $dest; $this->value =& $value;
return $this; return $this;
} }
@ -27,19 +27,19 @@ class ValueAccess extends AbstractAccess {
protected bool $allowEmpty; protected bool $allowEmpty;
function exists(): bool { function exists(): bool {
return $this->allowNull || $this->dest !== null; return $this->allowNull || $this->value !== null;
} }
function available(): bool { function available(): bool {
if (!$this->exists()) return false; if (!$this->exists()) return false;
$value = $this->dest; $value = $this->value;
if ($value === false) return $this->allowFalse; if ($value === false) return $this->allowFalse;
if ($value === "") return $this->allowEmpty; if ($value === "") return $this->allowEmpty;
return true; return true;
} }
function get($default=null) { function get($default=null) {
$value = $this->dest; $value = $this->value;
if ($value === null && !$this->allowNull) return $default; if ($value === null && !$this->allowNull) return $default;
if ($value === false && !$this->allowFalse) return $default; if ($value === false && !$this->allowFalse) return $default;
if ($value === "" && !$this->allowEmpty) return $default; if ($value === "" && !$this->allowEmpty) return $default;
@ -47,10 +47,10 @@ class ValueAccess extends AbstractAccess {
} }
function set($value): void { function set($value): void {
$this->dest = $value; $this->value = $value;
} }
function del(): void { function del(): void {
$this->dest = null; $this->value = null;
} }
} }

14
src/schema/AnalyzerContext.php
View File

@ -5,15 +5,15 @@ use nur\sery\wip\schema\input\Input;
use nur\sery\wip\schema\types\IType; use nur\sery\wip\schema\types\IType;
class AnalyzerContext { class AnalyzerContext {
function __construct(Schema $schema, Wrapper $wrapper, Input $input, $destKey, Result $result) { function __construct(Schema $schema, Wrapper $wrapper, Input $input, $valueKey, Result $result) {
$this->schema = $schema; $this->schema = $schema;
$this->wrapper = $wrapper; $this->wrapper = $wrapper;
$this->input = $input; $this->input = $input;
$this->result = $result; $this->result = $result;
$this->type = null; $this->type = null;
$this->orig = null; $this->origValue = null;
$this->dest = null; $this->value = null;
$this->destKey = $destKey; $this->valueKey = $valueKey;
} }
public Schema $schema; public Schema $schema;
@ -22,9 +22,9 @@ class AnalyzerContext {
public Result $result; public Result $result;
public ?IType $type; public ?IType $type;
/** @var mixed */ /** @var mixed */
public $orig; public $origValue;
/** @var mixed */ /** @var mixed */
public $dest; public $value;
/** @var int|string|null */ /** @var int|string|null */
public $destKey; public $valueKey;
} }

10
src/schema/Schema.php
View File

@ -39,16 +39,16 @@ abstract class Schema implements ArrayAccess {
/** /**
* Créer une nouvelle instance de {@link Wrapper} qui référence la * Créer une nouvelle instance de {@link Wrapper} qui référence la
* variable $dest (si $destKey===null) ou $dest[$destKey] si $destKey n'est * variable $value (si $valueKey===null) ou $value[$valueKey] si $valueKey
* pas null * n'est pas null
*/ */
static function nw(&$dest=null, $destKey=null, &$schema=null, $definition=null, ?Wrapper &$destw=null): Wrapper { static function nw(&$value=null, $valueKey=null, &$schema=null, $definition=null, ?Wrapper &$wrapper=null): Wrapper {
if ($definition === null) { if ($definition === null) {
# bien que techniquement, $definition peut être null (il s'agit alors du # bien que techniquement, $definition peut être null (il s'agit alors du
# schéma d'un scalaire quelconque), on ne l'autorise pas ici # schéma d'un scalaire quelconque), on ne l'autorise pas ici
throw SchemaException::invalid_schema("definition is required"); throw SchemaException::invalid_schema("definition is required");
} }
return self::ns($schema, $definition)->newWrapper($dest, $destKey, $destw); return self::ns($schema, $definition)->getWrapper($value, $valueKey, $wrapper);
} }
/** /**
@ -70,7 +70,7 @@ abstract class Schema implements ArrayAccess {
/** retourner true si le schéma est de nature scalaire */ /** retourner true si le schéma est de nature scalaire */
function isScalar(?ScalarSchema &$scalar=null): bool { return false; } function isScalar(?ScalarSchema &$scalar=null): bool { return false; }
abstract function newWrapper(&$dest=null, $destKey=null, ?Wrapper &$destw=null): Wrapper; abstract function getWrapper(&$value=null, $valueKey=null, ?Wrapper &$wrapper=null): Wrapper;
############################################################################# #############################################################################
# key & properties # key & properties

15
src/schema/TODO.md
View File

@ -1,7 +1,6 @@
# nulib\schema # nulib\schema
* tenir compte de la valeur par défaut, qui *doit* être du bon type * tester type===null --> implémenter traw et tmixed
* newInput dans Schema
* ScalarSchema::from_property() * ScalarSchema::from_property()
* dans AssocSchema, support `[key_prefix]` qui permet de spécifier un préfixe * dans AssocSchema, support `[key_prefix]` qui permet de spécifier un préfixe
@ -11,11 +10,11 @@
"a" => "?string", "a" => "?string",
"b" => "?int", "b" => "?int",
])->newWrapper(); ])->newWrapper();
$dest = ["x_a" => 5, "x_b" => "10"], $value = ["x_a" => 5, "x_b" => "10"],
$wrapper->reset($dest, null, [ $wrapper->reset($value, null, [
"key_prefix" => "x_", "key_prefix" => "x_",
]); ]);
# $dest vaut ["x_a" => "5", "x_b" => 10]; # $value vaut ["x_a" => "5", "x_b" => 10];
~~~ ~~~
définir si le préfixe doit être spécifié sur le schéma ou sur la valeur... définir si le préfixe doit être spécifié sur le schéma ou sur la valeur...
actuellement, le code ne permet pas de définir de tels paramètres... actuellement, le code ne permet pas de définir de tels paramètres...
@ -29,9 +28,9 @@
], [ ], [
"key_prefix" => "x_", "key_prefix" => "x_",
])->newWrapper(); ])->newWrapper();
$dest = ["x_a" => 5, "x_b" => "10"], $value = ["x_a" => 5, "x_b" => "10"],
$wrapper->reset($dest); $wrapper->reset($value);
# $dest vaut ["x_a" => "5", "x_b" => 10]; # $value vaut ["x_a" => "5", "x_b" => 10];
~~~ ~~~
* implémenter l'instanciation de types avec des paramètres particuliers. *si* * implémenter l'instanciation de types avec des paramètres particuliers. *si*
des paramètres sont fournis, le type est instancié avec la signature des paramètres sont fournis, le type est instancié avec la signature

2
src/schema/Wrapper.php
View File

@ -14,7 +14,7 @@ abstract class Wrapper implements ArrayAccess, IteratorAggregate {
function isScalar(?ScalarWrapper &$scalar=null): bool { return false; } function isScalar(?ScalarWrapper &$scalar=null): bool { return false; }
/** spécifier la valeur destination gérée par cet objet */ /** spécifier la valeur destination gérée par cet objet */
abstract function reset(&$dest, $destKey=null, ?bool $verifix=null): self; abstract function reset(&$value, $valueKey=null, ?bool $verifix=null): self;
/** /**
* Obtenir la liste des clés valides pour les valeurs accessibles via cet * Obtenir la liste des clés valides pour les valeurs accessibles via cet

6
src/schema/_assoc/AssocSchema.php
View File

@ -48,8 +48,8 @@ class AssocSchema extends Schema {
return true; return true;
} }
function newWrapper(&$dest=null, $destKey=null, ?Wrapper &$destw=null): AssocWrapper { function getWrapper(&$value=null, $valueKey=null, ?Wrapper &$wrapper=null): AssocWrapper {
if ($destw instanceof AssocWrapper) return $destw->reset($dest, $destKey); if ($wrapper instanceof AssocWrapper) return $wrapper->reset($value, $valueKey);
else return ($destw = new AssocWrapper($this, $dest, $destKey)); else return ($wrapper = new AssocWrapper($this, $value, $valueKey));
} }
} }

6
src/schema/_list/ListSchema.php
View File

@ -46,8 +46,8 @@ class ListSchema extends Schema {
return true; return true;
} }
function newWrapper(&$dest=null, $destKey=null, ?Wrapper &$destw=null): ListWrapper { function getWrapper(&$value=null, $valueKey=null, ?Wrapper &$wrapper=null): ListWrapper {
if ($destw instanceof ListWrapper) return $destw->reset($dest, $destKey); if ($wrapper instanceof ListWrapper) return $wrapper->reset($value, $valueKey);
else return ($destw = new ListWrapper($this, $dest, $destKey)); else return ($wrapper = new ListWrapper($this, $value, $valueKey));
} }
} }

9
src/schema/_scalar/ScalarSchema.php
View File

@ -7,6 +7,7 @@ use nulib\ref\schema\ref_types;
use nur\sery\wip\schema\Schema; use nur\sery\wip\schema\Schema;
use nur\sery\wip\schema\SchemaException; use nur\sery\wip\schema\SchemaException;
use nur\sery\wip\schema\types; use nur\sery\wip\schema\types;
use nur\sery\wip\schema\types\IType;
use nur\sery\wip\schema\types\tarray; use nur\sery\wip\schema\types\tarray;
use nur\sery\wip\schema\types\tbool; use nur\sery\wip\schema\types\tbool;
use nur\sery\wip\schema\types\tcallable; use nur\sery\wip\schema\types\tcallable;
@ -18,7 +19,7 @@ use nur\sery\wip\schema\Wrapper;
/** /**
* Class ScalarSchema * Class ScalarSchema
* *
* @property-read array $type * @property-read array|IType $type
* @property-read mixed $default * @property-read mixed $default
* @property-read string|null $title * @property-read string|null $title
* @property-read bool $required * @property-read bool $required
@ -193,9 +194,9 @@ class ScalarSchema extends Schema {
return true; return true;
} }
function newWrapper(&$dest=null, $destKey=null, ?Wrapper &$destw=null): ScalarWrapper { function getWrapper(&$value=null, $valueKey=null, ?Wrapper &$wrapper=null): ScalarWrapper {
if ($destw instanceof ScalarWrapper) return $destw->reset($dest, $destKey); if ($wrapper instanceof ScalarWrapper) return $wrapper->reset($value, $valueKey);
else return ($destw = new ScalarWrapper($this, $dest, $destKey)); else return ($wrapper = new ScalarWrapper($this, $value, $valueKey));
} }
############################################################################# #############################################################################

96
src/schema/_scalar/ScalarWrapper.php
View File

@ -9,14 +9,13 @@ use nur\sery\wip\schema\input\Input;
use nur\sery\wip\schema\types; use nur\sery\wip\schema\types;
use nur\sery\wip\schema\types\IType; use nur\sery\wip\schema\types\IType;
use nur\sery\wip\schema\Wrapper; use nur\sery\wip\schema\Wrapper;
use PHPUnit\Event\Code\Throwable;
class ScalarWrapper extends Wrapper { class ScalarWrapper extends Wrapper {
function __construct(ScalarSchema $schema, &$dest=null, $destKey=null, ?array $params=null) { function __construct(ScalarSchema $schema, &$value=null, $valueKey=null, ?array $params=null) {
$verifix = $params["verifix"] ?? true; $verifix = $params["verifix"] ?? true;
$throw = $params["throw"] ?? null; $throw = $params["throw"] ?? null;
if ($dest !== null && $throw === null) { if ($value !== null && $throw === null) {
# Si $dest est null, ne pas lancer d'exception, parce qu'on considère que # Si $value est null, ne pas lancer d'exception, parce qu'on considère que
# c'est une initialisation sans conséquences # c'est une initialisation sans conséquences
$throw = true; $throw = true;
} }
@ -24,7 +23,7 @@ class ScalarWrapper extends Wrapper {
$this->verifix = $verifix; $this->verifix = $verifix;
$this->throw = $throw ?? false; $this->throw = $throw ?? false;
$this->result = new ScalarResult(); $this->result = new ScalarResult();
$this->reset($dest, $destKey); $this->reset($value, $valueKey);
$this->throw = $throw ?? true; $this->throw = $throw ?? true;
} }
@ -37,7 +36,7 @@ class ScalarWrapper extends Wrapper {
protected Input $input; protected Input $input;
/** @var string|int|null clé de la valeur dans le tableau destination */ /** @var string|int|null clé de la valeur dans le tableau destination */
protected $destKey; protected $valueKey;
protected bool $verifix; protected bool $verifix;
@ -49,11 +48,15 @@ class ScalarWrapper extends Wrapper {
/** résultat de l'analyse de la valeur */ /** résultat de l'analyse de la valeur */
protected ScalarResult $result; protected ScalarResult $result;
function reset(&$dest, $destKey=null, ?bool $verifix=null): Wrapper { protected function newInput(&$value): Input {
if ($dest instanceof Input) $input = $dest; return new Input($value);
else $input = new Input($dest); }
function reset(&$value, $valueKey=null, ?bool $verifix=null): Wrapper {
if ($value instanceof Input) $input = $value;
else $input = $this->newInput($value);
$this->input = $input; $this->input = $input;
$this->destKey = $destKey; $this->valueKey = $valueKey;
$this->type = null; $this->type = null;
$this->analyzeExtractParse(); $this->analyzeExtractParse();
if ($verifix ?? $this->verifix) $this->verifix(); if ($verifix ?? $this->verifix) $this->verifix();
@ -74,11 +77,19 @@ class ScalarWrapper extends Wrapper {
/** @var ScalarSchema $schema */ /** @var ScalarSchema $schema */
$schema = $context->schema; $schema = $context->schema;
$input = $context->input; $input = $context->input;
$destKey = $context->destKey; $valueKey = $context->valueKey;
/** @var ScalarResult $result */ /** @var ScalarResult $result */
$result = $context->result; $result = $context->result;
if (!$input->isPresent($destKey)) return $result->setMissing($schema); $default = $schema->default;
if (!$input->isPresent($valueKey)) {
if ($default !== null) {
$input->set($default, $valueKey);
return $result->setNormalized();
} else {
return $result->setMissing($schema);
}
}
$schemaTypes = $schema->type; $schemaTypes = $schema->type;
if ($schemaTypes instanceof IType) { if ($schemaTypes instanceof IType) {
@ -103,9 +114,9 @@ class ScalarWrapper extends Wrapper {
$type = types::get($schema->nullable, $name, $params, $this->schema->getDefinition()); $type = types::get($schema->nullable, $name, $params, $this->schema->getDefinition());
if ($firstType === null) $firstType = $type; if ($firstType === null) $firstType = $type;
$types[] = $type; $types[] = $type;
if ($type->isAvailable($input, $destKey)) { if ($type->isAvailable($input, $valueKey)) {
if (!$haveValue) { if (!$haveValue) {
$value = $input->get($destKey); $value = $input->get($valueKey);
$haveValue = true; $haveValue = true;
} }
if ($type->isValid($value, $normalized) && $normalized) { if ($type->isValid($value, $normalized) && $normalized) {
@ -117,7 +128,7 @@ class ScalarWrapper extends Wrapper {
# ensuite chercher un type pour lequel la valeur est valide # ensuite chercher un type pour lequel la valeur est valide
if (!$haveType) { if (!$haveType) {
foreach ($types as $type) { foreach ($types as $type) {
if ($type->isAvailable($input, $destKey) && $type->isValid($value)) { if ($type->isAvailable($input, $valueKey) && $type->isValid($value)) {
$haveType = true; $haveType = true;
break; break;
} }
@ -130,10 +141,17 @@ class ScalarWrapper extends Wrapper {
} }
$context->type = $this->type = $type; $context->type = $this->type = $type;
if (!$type->isAvailable($input, $destKey)) return $result->setUnavailable($schema); if (!$type->isAvailable($input, $valueKey)) {
if ($default !== null) {
$input->set($default, $valueKey);
return $result->setNormalized();
} else {
return $result->setUnavailable($schema);
}
}
$value = $input->get($destKey); $value = $input->get($valueKey);
$context->orig = $context->dest = $value; $context->origValue = $context->value = $value;
if ($type->isNull($value)) { if ($type->isNull($value)) {
return $result->setNull($schema); return $result->setNull($schema);
} elseif (is_string($value)) { } elseif (is_string($value)) {
@ -149,10 +167,10 @@ class ScalarWrapper extends Wrapper {
function analyzeExtractParse(): int { function analyzeExtractParse(): int {
$schema = $this->schema; $schema = $this->schema;
$input = $this->input; $input = $this->input;
$destKey = $this->destKey; $valueKey = $this->valueKey;
$result = $this->result; $result = $this->result;
$result->reset(); $result->reset();
$context = new AnalyzerContext($schema, $this, $input, $destKey, $result); $context = new AnalyzerContext($schema, $this, $input, $valueKey, $result);
/** @var func $analyzerFunc */ /** @var func $analyzerFunc */
$analyzerFunc = $schema->analyzerFunc; $analyzerFunc = $schema->analyzerFunc;
@ -160,15 +178,15 @@ class ScalarWrapper extends Wrapper {
else $what = $this->_analyze($context); else $what = $this->_analyze($context);
if ($what !== ref_analyze::STRING) return $what; if ($what !== ref_analyze::STRING) return $what;
$dest = $context->dest; $value = $context->value;
try { try {
/** @var func $extractorFunc */ /** @var func $extractorFunc */
$extractorFunc = $schema->extractorFunc; $extractorFunc = $schema->extractorFunc;
if ($extractorFunc !== null) $extracted = $extractorFunc->invoke([$dest, $context]); if ($extractorFunc !== null) $extracted = $extractorFunc->invoke([$value, $context]);
else $extracted = $context->type->extract($dest); else $extracted = $context->type->extract($value);
$context->dest = $extracted; $context->value = $extracted;
} catch (ValueException $e) { } catch (ValueException $e) {
return $result->setInvalid($context->orig, $schema, $e); return $result->setInvalid($context->origValue, $schema, $e);
} }
if ($context->type->isNull($extracted)) return $result->setNull($schema); if ($context->type->isNull($extracted)) return $result->setNull($schema);
@ -177,31 +195,31 @@ class ScalarWrapper extends Wrapper {
$parserFunc = $schema->parserFunc; $parserFunc = $schema->parserFunc;
if ($parserFunc !== null) $parsed = $parserFunc->invoke([$extracted, $context]); if ($parserFunc !== null) $parsed = $parserFunc->invoke([$extracted, $context]);
else $parsed = $context->type->parse($extracted); else $parsed = $context->type->parse($extracted);
$context->dest = $parsed; $context->value = $parsed;
} catch (ValueException $e) { } catch (ValueException $e) {
return $result->setInvalid($context->orig, $schema, $e); return $result->setInvalid($context->origValue, $schema, $e);
} }
$normalized = $parsed === $context->orig; $normalized = $parsed === $context->origValue;
if ($normalized) { if ($normalized) {
$input->set($parsed, $destKey); $input->set($parsed, $valueKey);
return $result->setNormalized(); return $result->setNormalized();
} else { } else {
$input->set($extracted, $destKey); $input->set($extracted, $valueKey);
return $result->setValid($parsed); return $result->setValid($parsed);
} }
} }
function verifix(?bool $throw=null): bool { function verifix(?bool $throw=null): bool {
$result = $this->result; $result = $this->result;
$destKey = $this->destKey; $valueKey = $this->valueKey;
$verifix = false; $verifix = false;
$modified = false; $modified = false;
if ($result->resultAvailable) { if ($result->resultAvailable) {
if ($result->null) { if ($result->null) {
# forcer la valeur null, parce que la valeur actuelle est peut-être une # forcer la valeur null, parce que la valeur actuelle est peut-être une
# valeur assimilée à null # valeur assimilée à null
$this->input->set(null, $destKey); $this->input->set(null, $valueKey);
} elseif ($result->valid && !$result->normalized) { } elseif ($result->valid && !$result->normalized) {
$normalizedValue = $result->normalizedValue; $normalizedValue = $result->normalizedValue;
if ($normalizedValue !== null) { if ($normalizedValue !== null) {
@ -219,19 +237,19 @@ class ScalarWrapper extends Wrapper {
} }
if ($verifix) { if ($verifix) {
$value = $this->input->get($destKey); $value = $this->input->get($valueKey);
$schema = $this->schema; $schema = $this->schema;
/** @var func $normalizerFunc */ /** @var func $normalizerFunc */
$normalizerFunc = $schema->normalizerFunc; $normalizerFunc = $schema->normalizerFunc;
if ($normalizerFunc !== null) { if ($normalizerFunc !== null) {
$context = new AnalyzerContext($schema, $this, $this->input, $destKey, $result); $context = new AnalyzerContext($schema, $this, $this->input, $valueKey, $result);
$orig = $value; $orig = $value;
$value = $normalizerFunc->invoke([$orig, $context]); $value = $normalizerFunc->invoke([$orig, $context]);
$modified = $value !== $orig; $modified = $value !== $orig;
} else { } else {
$modified = $this->type->verifix($value, $result, $this->schema); $modified = $this->type->verifix($value, $result, $this->schema);
} }
if ($result->valid) $this->input->set($value, $destKey); if ($result->valid) $this->input->set($value, $valueKey);
} }
if (!$result->valid) $result->throw($throw ?? $this->throw); if (!$result->valid) $result->throw($throw ?? $this->throw);
return $modified; return $modified;
@ -262,26 +280,26 @@ class ScalarWrapper extends Wrapper {
} }
function get($default=null) { function get($default=null) {
if ($this->result->available) return $this->input->get($this->destKey); if ($this->result->available) return $this->input->get($this->valueKey);
else return $default; else return $default;
} }
function set($value, ?bool $verifix=null): ScalarWrapper { function set($value, ?bool $verifix=null): ScalarWrapper {
$this->input->set($value, $this->destKey); $this->input->set($value, $this->valueKey);
$this->analyzeExtractParse(); $this->analyzeExtractParse();
if ($verifix ?? $this->verifix) $this->verifix(); if ($verifix ?? $this->verifix) $this->verifix();
return $this; return $this;
} }
function unset(?bool $verifix=null): ScalarWrapper { function unset(?bool $verifix=null): ScalarWrapper {
$this->input->unset($this->destKey); $this->input->unset($this->valueKey);
$this->analyzeExtractParse(); $this->analyzeExtractParse();
if ($verifix ?? $this->verifix) $this->verifix(); if ($verifix ?? $this->verifix) $this->verifix();
return $this; return $this;
} }
function format($format=null): string { function format($format=null): string {
$value = $this->input->get($this->destKey); $value = $this->input->get($this->valueKey);
/** @var func $formatterFunc */ /** @var func $formatterFunc */
$formatterFunc = $this->schema->formatterFunc; $formatterFunc = $this->schema->formatterFunc;
if ($formatterFunc !== null) { if ($formatterFunc !== null) {

2
src/schema/input/FormInput.php
View File

@ -25,7 +25,7 @@ class FormInput extends Input {
} }
protected function access($key): IAccess { protected function access($key): IAccess {
return $this->keyAccess[$key] ??= new ShadowAccess($this->formAccess($key), new KeyAccess($this->dest, $key, [ return $this->keyAccess[$key] ??= new ShadowAccess($this->formAccess($key), new KeyAccess($this->value, $key, [
"allow_empty" => $this->allowEmpty, "allow_empty" => $this->allowEmpty,
])); ]));
} }

10
src/schema/input/Input.php
View File

@ -13,13 +13,13 @@ use nur\sery\wip\php\access\ValueAccess;
class Input { class Input {
const ALLOW_EMPTY = true; const ALLOW_EMPTY = true;
function __construct(&$dest=null, ?array $params=null) { function __construct(&$value=null, ?array $params=null) {
$this->dest =& $dest; $this->value =& $value;
$this->allowEmpty = $params["allow_empty"] ?? static::ALLOW_EMPTY; $this->allowEmpty = $params["allow_empty"] ?? static::ALLOW_EMPTY;
} }
/** @var mixed */ /** @var mixed */
protected $dest; protected $value;
/** /**
* @var bool comment considérer une chaine vide: "" si allowEmpty, null sinon * @var bool comment considérer une chaine vide: "" si allowEmpty, null sinon
@ -31,12 +31,12 @@ class Input {
protected function access($key): IAccess { protected function access($key): IAccess {
if ($key === null) { if ($key === null) {
return $this->valueAccess ??= new ValueAccess($this->dest, [ return $this->valueAccess ??= new ValueAccess($this->value, [
"allow_null" => true, "allow_null" => true,
"allow_empty" => $this->allowEmpty, "allow_empty" => $this->allowEmpty,
]); ]);
} else { } else {
return $this->keyAccess[$key] ??= new KeyAccess($this->dest, $key, [ return $this->keyAccess[$key] ??= new KeyAccess($this->value, $key, [
"allow_empty" => $this->allowEmpty, "allow_empty" => $this->allowEmpty,
]); ]);
} }

1
src/schema/types.php
View File

@ -9,6 +9,7 @@ use nur\sery\wip\schema\types\tcallable;
use nur\sery\wip\schema\types\tfloat; use nur\sery\wip\schema\types\tfloat;
use nur\sery\wip\schema\types\tint; use nur\sery\wip\schema\types\tint;
use nur\sery\wip\schema\types\trawstring; use nur\sery\wip\schema\types\trawstring;
use nur\sery\wip\schema\types\tstring;
use nur\sery\wip\schema\types\ttext; use nur\sery\wip\schema\types\ttext;
/** /**

4
src/schema/types/IType.php
View File

@ -58,8 +58,8 @@ interface IType {
*/ */
function get3States(): array; function get3States(): array;
/** la donnée $input($destKey) est-elle disponible? */ /** la donnée $input($valueKey) est-elle disponible? */
function isAvailable(Input $input, $destKey): bool; function isAvailable(Input $input, $valueKey): bool;
/** la valeur $value est-elle nulle? */ /** la valeur $value est-elle nulle? */
function isNull($value): bool; function isNull($value): bool;

4
src/schema/types/_tsimple.php
View File

@ -39,8 +39,8 @@ abstract class _tsimple implements IType {
throw StateException::not_implemented(); throw StateException::not_implemented();
} }
function isAvailable(Input $input, $destKey): bool { function isAvailable(Input $input, $valueKey): bool {
return $input->isAvailable($destKey) && $input->get($destKey) !== false; return $input->isAvailable($valueKey) && $input->get($valueKey) !== false;
} }
function isNull($value): bool { function isNull($value): bool {

4
src/schema/types/tbool.php
View File

@ -72,8 +72,8 @@ class tbool extends _tformatable {
return [false, true, null]; return [false, true, null];
} }
function isAvailable(Input $input, $destKey): bool { function isAvailable(Input $input, $valueKey): bool {
return $input->isAvailable($destKey); return $input->isAvailable($valueKey);
} }
function isValid($value, ?bool &$normalized=null): bool { function isValid($value, ?bool &$normalized=null): bool {

33
tests/wip/schema/_scalar/ScalarValueTest.php
View File

@ -6,16 +6,16 @@ use nulib\ValueException;
use nur\sery\wip\schema\input\Input; use nur\sery\wip\schema\input\Input;
class ScalarValueTest extends TestCase { class ScalarValueTest extends TestCase {
function checkValue(ScalarWrapper $value, $dest, bool $present, bool $available, bool $valid, bool $normalized): void { function checkValue(ScalarWrapper $wrapper, $dest, bool $present, bool $available, bool $valid, bool $normalized): void {
self::assertSame($dest, $value->get(), "value"); self::assertSame($dest, $wrapper->get(), "value");
self::assertSame($present, $value->isPresent(), "present"); self::assertSame($present, $wrapper->isPresent(), "present");
self::assertSame($available, $value->isAvailable(), "available"); self::assertSame($available, $wrapper->isAvailable(), "available");
self::assertSame($valid, $value->isValid(), "valid"); self::assertSame($valid, $wrapper->isValid(), "valid");
self::assertSame($normalized, $value->isNormalized(), "normalized"); self::assertSame($normalized, $wrapper->isNormalized(), "normalized");
} }
function checkVerifix(ScalarSchema $schema, $src, bool $verifix, $dest, bool $present, bool $available, bool $valid, bool $normalized, ?array $inputParams=null): void { function checkVerifix(ScalarSchema $schema, $src, bool $verifix, $dest, bool $present, bool $available, bool $valid, bool $normalized, ?array $inputParams=null): void {
$value = $schema->newWrapper(); $value = $schema->getWrapper();
if ($inputParams !== null) $input = new Input($src, $inputParams); if ($inputParams !== null) $input = new Input($src, $inputParams);
else $input = $src; else $input = $src;
$value->reset($input, null, $verifix); $value->reset($input, null, $verifix);
@ -23,7 +23,7 @@ class ScalarValueTest extends TestCase {
} }
function checkException(ScalarSchema $schema, $src, bool $verifix, string $exceptionClass, ?array $inputParams=null) { function checkException(ScalarSchema $schema, $src, bool $verifix, string $exceptionClass, ?array $inputParams=null) {
$value = $schema->newWrapper(); $value = $schema->getWrapper();
if ($inputParams !== null) $src = new Input($src, $inputParams); if ($inputParams !== null) $src = new Input($src, $inputParams);
self::assertException($exceptionClass, function() use ($value, &$src, $verifix) { self::assertException($exceptionClass, function() use ($value, &$src, $verifix) {
$value->reset($src, null, $verifix); $value->reset($src, null, $verifix);
@ -60,6 +60,23 @@ class ScalarValueTest extends TestCase {
$this->checkVerifix($schema, [], false, [], true, true, false, false); $this->checkVerifix($schema, [], false, [], true, true, false, false);
$this->checkException($schema, [], true, ValueException::class); $this->checkException($schema, [], true, ValueException::class);
## Tester valeur par défaut
$schema = new ScalarSchema(["rawstring", null]);
$this->checkVerifix($schema, false, false, null, true, false, true, true);
$this->checkVerifix($schema, false, true, null, true, false, true, true);
$this->checkVerifix($schema, null, false, null, true, true, false, false);
$this->checkException($schema, null, true, ValueException::class);
$schema = new ScalarSchema(["rawstring", "default"]);
$this->checkVerifix($schema, false, false, "default", true, true, true, true);
$this->checkVerifix($schema, false, true, "default", true, true, true, true);
$this->checkVerifix($schema, null, false, null, true, true, false, false);
$this->checkException($schema, null, true, ValueException::class);
## Tester nullable ## Tester nullable
$schema = new ScalarSchema("?rawstring"); $schema = new ScalarSchema("?rawstring");

144
tests/wip/schema/types/boolTest.php
View File

@ -7,105 +7,105 @@ use nur\sery\wip\schema\_scalar\ScalarWrapper;
use nur\sery\wip\schema\Schema; use nur\sery\wip\schema\Schema;
class boolTest extends TestCase { class boolTest extends TestCase {
function commonTests($destv, &$dest, callable $destvSetter): void { function commonTests($wrapper, &$value, callable $wrapperSetter): void {
$destv->set(true); $wrapper->set(true);
self::assertSame(true, $destv->get()); self::assertSame(true, $wrapper->get());
self::assertSame(true, $dest); self::assertSame(true, $value);
self::assertSame("Oui", $destv->format()); self::assertSame("Oui", $wrapper->format());
self::assertSame("Oui", $destv->format("OuiNonNull")); self::assertSame("Oui", $wrapper->format("OuiNonNull"));
self::assertSame("O", $destv->format("ON")); self::assertSame("O", $wrapper->format("ON"));
self::assertSame("O", $destv->format("ONN")); self::assertSame("O", $wrapper->format("ONN"));
$destv->set(false); $wrapper->set(false);
self::assertSame(false, $destv->get()); self::assertSame(false, $wrapper->get());
self::assertSame(false, $dest); self::assertSame(false, $value);
self::assertSame("Non", $destv->format()); self::assertSame("Non", $wrapper->format());
self::assertSame("Non", $destv->format("OuiNonNull")); self::assertSame("Non", $wrapper->format("OuiNonNull"));
self::assertSame("N", $destv->format("ON")); self::assertSame("N", $wrapper->format("ON"));
self::assertSame("N", $destv->format("ONN")); self::assertSame("N", $wrapper->format("ONN"));
$destv->set("yes"); $wrapper->set("yes");
self::assertSame(true, $destv->get()); self::assertSame(true, $wrapper->get());
$destv->set(" yes "); $wrapper->set(" yes ");
self::assertSame(true, $destv->get()); self::assertSame(true, $wrapper->get());
$destv->set("12"); $wrapper->set("12");
self::assertSame(true, $destv->get()); self::assertSame(true, $wrapper->get());
$destv->set(12); $wrapper->set(12);
self::assertSame(true, $destv->get()); self::assertSame(true, $wrapper->get());
$destv->set("no"); $wrapper->set("no");
self::assertSame(false, $destv->get()); self::assertSame(false, $wrapper->get());
$destv->set(" no "); $wrapper->set(" no ");
self::assertSame(false, $destv->get()); self::assertSame(false, $wrapper->get());
$destv->set("0"); $wrapper->set("0");
self::assertSame(false, $destv->get()); self::assertSame(false, $wrapper->get());
$destv->set(0); $wrapper->set(0);
self::assertSame(false, $destv->get()); self::assertSame(false, $wrapper->get());
$destv->set(12.34); $wrapper->set(12.34);
self::assertSame(true, $destv->get()); self::assertSame(true, $wrapper->get());
self::assertException(Exception::class, $destvSetter("a")); self::assertException(Exception::class, $wrapperSetter("a"));
self::assertException(Exception::class, $destvSetter([])); self::assertException(Exception::class, $wrapperSetter([]));
self::assertException(Exception::class, $destvSetter(["a"])); self::assertException(Exception::class, $wrapperSetter(["a"]));
} }
function testBool() { function testBool() {
/** @var ScalarWrapper $destv */ /** @var ScalarWrapper $wrapper */
Schema::nw($dest, null, $schema, "bool", $destv); Schema::nw($value, null, $schema, "bool", $wrapper);
$destvSetter = function($value) use($destv) { $wrapperSetter = function($value) use($wrapper) {
return function() use($destv, $value) { return function() use($wrapper, $value) {
$destv->set($value); $wrapper->set($value);
}; };
}; };
self::assertException(Exception::class, $destvSetter(null)); self::assertException(Exception::class, $wrapperSetter(null));
self::assertException(Exception::class, $destvSetter("")); self::assertException(Exception::class, $wrapperSetter(""));
self::assertException(Exception::class, $destvSetter(" ")); self::assertException(Exception::class, $wrapperSetter(" "));
$this->commonTests($destv, $dest, $destvSetter); $this->commonTests($wrapper, $value, $wrapperSetter);
} }
function testNbool() { function testNbool() {
/** @var ScalarWrapper $destv */ /** @var ScalarWrapper $wrapper */
Schema::nw($dest, null, $schema, "?bool", $destv); Schema::nw($value, null, $schema, "?bool", $wrapper);
$destvSetter = function($value) use($destv) { $wrapperSetter = function($value) use($wrapper) {
return function() use($destv, $value) { return function() use($wrapper, $value) {
$destv->set($value); $wrapper->set($value);
}; };
}; };
$destv->set(null); $wrapper->set(null);
self::assertNull($destv->get()); self::assertNull($wrapper->get());
self::assertNull($dest); self::assertNull($value);
self::assertSame("Non", $destv->format()); self::assertSame("Non", $wrapper->format());
self::assertSame("", $destv->format("OuiNonNull")); self::assertSame("", $wrapper->format("OuiNonNull"));
self::assertSame("N", $destv->format("ON")); self::assertSame("N", $wrapper->format("ON"));
self::assertSame("", $destv->format("ONN")); self::assertSame("", $wrapper->format("ONN"));
$destv->set(""); $wrapper->set("");
self::assertNull($destv->get()); self::assertNull($wrapper->get());
self::assertNull($dest); self::assertNull($value);
self::assertSame("Non", $destv->format()); self::assertSame("Non", $wrapper->format());
self::assertSame("", $destv->format("OuiNonNull")); self::assertSame("", $wrapper->format("OuiNonNull"));
self::assertSame("N", $destv->format("ON")); self::assertSame("N", $wrapper->format("ON"));
self::assertSame("", $destv->format("ONN")); self::assertSame("", $wrapper->format("ONN"));
$destv->set(" "); $wrapper->set(" ");
self::assertNull($destv->get()); self::assertNull($wrapper->get());
self::assertNull($dest); self::assertNull($value);
self::assertSame("Non", $destv->format()); self::assertSame("Non", $wrapper->format());
self::assertSame("", $destv->format("OuiNonNull")); self::assertSame("", $wrapper->format("OuiNonNull"));
self::assertSame("N", $destv->format("ON")); self::assertSame("N", $wrapper->format("ON"));
self::assertSame("", $destv->format("ONN")); self::assertSame("", $wrapper->format("ONN"));
$this->commonTests($destv, $dest, $destvSetter); $this->commonTests($wrapper, $value, $wrapperSetter);
} }
} }

158
tests/wip/schema/types/floatTest.php
View File

@ -7,133 +7,133 @@ use nur\sery\wip\schema\_scalar\ScalarWrapper;
use nur\sery\wip\schema\Schema; use nur\sery\wip\schema\Schema;
class floatTest extends TestCase { class floatTest extends TestCase {
function commonTests($destv, &$dest, callable $destvSetter): void { function commonTests($wrapper, &$value, callable $wrapperSetter): void {
$destv->set(12); $wrapper->set(12);
self::assertSame(12.0, $destv->get()); self::assertSame(12.0, $wrapper->get());
self::assertSame(12.0, $dest); self::assertSame(12.0, $value);
self::assertSame("12", $destv->format()); self::assertSame("12", $wrapper->format());
self::assertSame("0012", $destv->format("%04u")); self::assertSame("0012", $wrapper->format("%04u"));
$destv->set("12"); $wrapper->set("12");
self::assertSame(12.0, $destv->get()); self::assertSame(12.0, $wrapper->get());
$destv->set(" 12 "); $wrapper->set(" 12 ");
self::assertSame(12.0, $destv->get()); self::assertSame(12.0, $wrapper->get());
$destv->set(12.34); $wrapper->set(12.34);
self::assertSame(12.34, $destv->get()); self::assertSame(12.34, $wrapper->get());
$destv->set(true); $wrapper->set(true);
self::assertSame(1.0, $destv->get()); self::assertSame(1.0, $wrapper->get());
self::assertException(Exception::class, $destvSetter("a")); self::assertException(Exception::class, $wrapperSetter("a"));
self::assertException(Exception::class, $destvSetter([])); self::assertException(Exception::class, $wrapperSetter([]));
self::assertException(Exception::class, $destvSetter(["a"])); self::assertException(Exception::class, $wrapperSetter(["a"]));
} }
function testFloat() { function testFloat() {
/** @var ScalarWrapper $destv */ /** @var ScalarWrapper $wrapper */
Schema::nw($dest, null, $schema, "float", $destv); Schema::nw($value, null, $schema, "float", $wrapper);
$destvSetter = function($value) use($destv) { $wrapperSetter = function($value) use($wrapper) {
return function() use($destv, $value) { return function() use($wrapper, $value) {
$destv->set($value); $wrapper->set($value);
}; };
}; };
self::assertException(Exception::class, $destvSetter(null)); self::assertException(Exception::class, $wrapperSetter(null));
self::assertException(Exception::class, $destvSetter("")); self::assertException(Exception::class, $wrapperSetter(""));
self::assertException(Exception::class, $destvSetter(" ")); self::assertException(Exception::class, $wrapperSetter(" "));
// valeur non requise donc retourne null // valeur non requise donc retourne null
$destv->set(false); $wrapper->set(false);
self::assertNull($destv->get()); self::assertNull($wrapper->get());
$this->commonTests($destv, $dest, $destvSetter); $this->commonTests($wrapper, $value, $wrapperSetter);
} }
function testRequiredFloat() { function testRequiredFloat() {
/** @var ScalarWrapper $destv */ /** @var ScalarWrapper $wrapper */
Schema::nw($dest, null, $schema, [ Schema::nw($value, null, $schema, [
"float", null, "float", null,
"required" => true, "required" => true,
], $destv); ], $wrapper);
$destvSetter = function($value) use($destv) { $wrapperSetter = function($value) use($wrapper) {
return function() use($destv, $value) { return function() use($wrapper, $value) {
$destv->set($value); $wrapper->set($value);
}; };
}; };
self::assertException(Exception::class, $destvSetter(null)); self::assertException(Exception::class, $wrapperSetter(null));
self::assertException(Exception::class, $destvSetter("")); self::assertException(Exception::class, $wrapperSetter(""));
self::assertException(Exception::class, $destvSetter(" ")); self::assertException(Exception::class, $wrapperSetter(" "));
// valeur requise donc lance une exception // valeur requise donc lance une exception
self::assertException(Exception::class, $destvSetter(false)); self::assertException(Exception::class, $wrapperSetter(false));
$this->commonTests($destv, $dest, $destvSetter); $this->commonTests($wrapper, $value, $wrapperSetter);
} }
function testNfloat() { function testNfloat() {
/** @var ScalarWrapper $destv */ /** @var ScalarWrapper $wrapper */
Schema::nw($dest, null, $schema, "?float", $destv); Schema::nw($value, null, $schema, "?float", $wrapper);
$destvSetter = function($value) use($destv) { $wrapperSetter = function($value) use($wrapper) {
return function() use($destv, $value) { return function() use($wrapper, $value) {
$destv->set($value); $wrapper->set($value);
}; };
}; };
$destv->set(null); $wrapper->set(null);
self::assertNull($destv->get()); self::assertNull($wrapper->get());
self::assertNull($dest); self::assertNull($value);
self::assertSame("", $destv->format()); self::assertSame("", $wrapper->format());
$destv->set(""); $wrapper->set("");
self::assertNull($destv->get()); self::assertNull($wrapper->get());
self::assertNull($dest); self::assertNull($value);
self::assertSame("", $destv->format()); self::assertSame("", $wrapper->format());
$destv->set(" "); $wrapper->set(" ");
self::assertNull($destv->get()); self::assertNull($wrapper->get());
self::assertNull($dest); self::assertNull($value);
self::assertSame("", $destv->format()); self::assertSame("", $wrapper->format());
// valeur non requise donc retourne null // valeur non requise donc retourne null
$destv->set(false); $wrapper->set(false);
self::assertNull($destv->get()); self::assertNull($wrapper->get());
$this->commonTests($destv, $dest, $destvSetter); $this->commonTests($wrapper, $value, $wrapperSetter);
} }
function testRequiredNfloat() { function testRequiredNfloat() {
/** @var ScalarWrapper $destv */ /** @var ScalarWrapper $wrapper */
Schema::nw($dest, null, $schema, [ Schema::nw($value, null, $schema, [
"?float", null, "?float", null,
"required" => true, "required" => true,
], $destv); ], $wrapper);
$destvSetter = function($value) use($destv) { $wrapperSetter = function($value) use($wrapper) {
return function() use($destv, $value) { return function() use($wrapper, $value) {
$destv->set($value); $wrapper->set($value);
}; };
}; };
$destv->set(null); $wrapper->set(null);
self::assertNull($destv->get()); self::assertNull($wrapper->get());
self::assertNull($dest); self::assertNull($value);
self::assertSame("", $destv->format()); self::assertSame("", $wrapper->format());
$destv->set(""); $wrapper->set("");
self::assertNull($destv->get()); self::assertNull($wrapper->get());
self::assertNull($dest); self::assertNull($value);
self::assertSame("", $destv->format()); self::assertSame("", $wrapper->format());
$destv->set(" "); $wrapper->set(" ");
self::assertNull($destv->get()); self::assertNull($wrapper->get());
self::assertNull($dest); self::assertNull($value);
self::assertSame("", $destv->format()); self::assertSame("", $wrapper->format());
// valeur requise donc lance une exception // valeur requise donc lance une exception
self::assertException(Exception::class, $destvSetter(false)); self::assertException(Exception::class, $wrapperSetter(false));
$this->commonTests($destv, $dest, $destvSetter); $this->commonTests($wrapper, $value, $wrapperSetter);
} }
} }

158
tests/wip/schema/types/intTest.php
View File

@ -7,133 +7,133 @@ use nur\sery\wip\schema\_scalar\ScalarWrapper;
use nur\sery\wip\schema\Schema; use nur\sery\wip\schema\Schema;
class intTest extends TestCase { class intTest extends TestCase {
function commonTests($destv, &$dest, callable $destvSetter): void { function commonTests($wrapper, &$value, callable $wrapperSetter): void {
$destv->set(12); $wrapper->set(12);
self::assertSame(12, $destv->get()); self::assertSame(12, $wrapper->get());
self::assertSame(12, $dest); self::assertSame(12, $value);
self::assertSame("12", $destv->format()); self::assertSame("12", $wrapper->format());
self::assertSame("0012", $destv->format("%04u")); self::assertSame("0012", $wrapper->format("%04u"));
$destv->set("12"); $wrapper->set("12");
self::assertSame(12, $destv->get()); self::assertSame(12, $wrapper->get());
$destv->set(" 12 "); $wrapper->set(" 12 ");
self::assertSame(12, $destv->get()); self::assertSame(12, $wrapper->get());
$destv->set(12.34); $wrapper->set(12.34);
self::assertSame(12, $destv->get()); self::assertSame(12, $wrapper->get());
$destv->set(true); $wrapper->set(true);
self::assertSame(1, $destv->get()); self::assertSame(1, $wrapper->get());
self::assertException(Exception::class, $destvSetter("a")); self::assertException(Exception::class, $wrapperSetter("a"));
self::assertException(Exception::class, $destvSetter([])); self::assertException(Exception::class, $wrapperSetter([]));
self::assertException(Exception::class, $destvSetter(["a"])); self::assertException(Exception::class, $wrapperSetter(["a"]));
} }
function testInt() { function testInt() {
/** @var ScalarWrapper $destv */ /** @var ScalarWrapper $wrapper */
Schema::nw($dest, null, $schema, "int", $destv); Schema::nw($value, null, $schema, "int", $wrapper);
$destvSetter = function($value) use($destv) { $wrapperSetter = function($value) use($wrapper) {
return function() use($destv, $value) { return function() use($wrapper, $value) {
$destv->set($value); $wrapper->set($value);
}; };
}; };
self::assertException(Exception::class, $destvSetter(null)); self::assertException(Exception::class, $wrapperSetter(null));
self::assertException(Exception::class, $destvSetter("")); self::assertException(Exception::class, $wrapperSetter(""));
self::assertException(Exception::class, $destvSetter(" ")); self::assertException(Exception::class, $wrapperSetter(" "));
// valeur non requise donc retourne null // valeur non requise donc retourne null
$destv->set(false); $wrapper->set(false);
self::assertNull($destv->get()); self::assertNull($wrapper->get());
$this->commonTests($destv, $dest, $destvSetter); $this->commonTests($wrapper, $value, $wrapperSetter);
} }
function testRequiredInt() { function testRequiredInt() {
/** @var ScalarWrapper $destv */ /** @var ScalarWrapper $wrapper */
Schema::nw($dest, null, $schema, [ Schema::nw($value, null, $schema, [
"int", null, "int", null,
"required" => true, "required" => true,
], $destv); ], $wrapper);
$destvSetter = function($value) use($destv) { $wrapperSetter = function($value) use($wrapper) {
return function() use($destv, $value) { return function() use($wrapper, $value) {
$destv->set($value); $wrapper->set($value);
}; };
}; };
self::assertException(Exception::class, $destvSetter(null)); self::assertException(Exception::class, $wrapperSetter(null));
self::assertException(Exception::class, $destvSetter("")); self::assertException(Exception::class, $wrapperSetter(""));
self::assertException(Exception::class, $destvSetter(" ")); self::assertException(Exception::class, $wrapperSetter(" "));
// valeur requise donc lance une exception // valeur requise donc lance une exception
self::assertException(Exception::class, $destvSetter(false)); self::assertException(Exception::class, $wrapperSetter(false));
$this->commonTests($destv, $dest, $destvSetter); $this->commonTests($wrapper, $value, $wrapperSetter);
} }
function testNint() { function testNint() {
/** @var ScalarWrapper $destv */ /** @var ScalarWrapper $wrapper */
Schema::nw($dest, null, $schema, "?int", $destv); Schema::nw($value, null, $schema, "?int", $wrapper);
$destvSetter = function($value) use($destv) { $wrapperSetter = function($value) use($wrapper) {
return function() use($destv, $value) { return function() use($wrapper, $value) {
$destv->set($value); $wrapper->set($value);
}; };
}; };
$destv->set(null); $wrapper->set(null);
self::assertNull($destv->get()); self::assertNull($wrapper->get());
self::assertNull($dest); self::assertNull($value);
self::assertSame("", $destv->format()); self::assertSame("", $wrapper->format());
$destv->set(""); $wrapper->set("");
self::assertNull($destv->get()); self::assertNull($wrapper->get());
self::assertNull($dest); self::assertNull($value);
self::assertSame("", $destv->format()); self::assertSame("", $wrapper->format());
$destv->set(" "); $wrapper->set(" ");
self::assertNull($destv->get()); self::assertNull($wrapper->get());
self::assertNull($dest); self::assertNull($value);
self::assertSame("", $destv->format()); self::assertSame("", $wrapper->format());
// valeur non requise donc retourne null // valeur non requise donc retourne null
$destv->set(false); $wrapper->set(false);
self::assertNull($destv->get()); self::assertNull($wrapper->get());
$this->commonTests($destv, $dest, $destvSetter); $this->commonTests($wrapper, $value, $wrapperSetter);
} }
function testRequiredNint() { function testRequiredNint() {
/** @var ScalarWrapper $destv */ /** @var ScalarWrapper $wrapper */
Schema::nw($dest, null, $schema, [ Schema::nw($value, null, $schema, [
"?int", null, "?int", null,
"required" => true, "required" => true,
], $destv); ], $wrapper);
$destvSetter = function($value) use($destv) { $wrapperSetter = function($value) use($wrapper) {
return function() use($destv, $value) { return function() use($wrapper, $value) {
$destv->set($value); $wrapper->set($value);
}; };
}; };
$destv->set(null); $wrapper->set(null);
self::assertNull($destv->get()); self::assertNull($wrapper->get());
self::assertNull($dest); self::assertNull($value);
self::assertSame("", $destv->format()); self::assertSame("", $wrapper->format());
$destv->set(""); $wrapper->set("");
self::assertNull($destv->get()); self::assertNull($wrapper->get());
self::assertNull($dest); self::assertNull($value);
self::assertSame("", $destv->format()); self::assertSame("", $wrapper->format());
$destv->set(" "); $wrapper->set(" ");
self::assertNull($destv->get()); self::assertNull($wrapper->get());
self::assertNull($dest); self::assertNull($value);
self::assertSame("", $destv->format()); self::assertSame("", $wrapper->format());
// valeur requise donc lance une exception // valeur requise donc lance une exception
self::assertException(Exception::class, $destvSetter(false)); self::assertException(Exception::class, $wrapperSetter(false));
$this->commonTests($destv, $dest, $destvSetter); $this->commonTests($wrapper, $value, $wrapperSetter);
} }
} }

128
tests/wip/schema/types/strTest.php
View File

@ -7,117 +7,117 @@ use nur\sery\wip\schema\_scalar\ScalarWrapper;
use nur\sery\wip\schema\Schema; use nur\sery\wip\schema\Schema;
class strTest extends TestCase { class strTest extends TestCase {
function commonTests($destv, &$dest, callable $destvSetter): void { function commonTests($wrapper, &$value, callable $wrapperSetter): void {
$destv->set(""); $wrapper->set("");
self::assertSame("", $destv->get()); self::assertSame("", $wrapper->get());
self::assertSame("", $dest); self::assertSame("", $value);
$destv->set(" "); $wrapper->set(" ");
self::assertSame("", $destv->get()); self::assertSame("", $wrapper->get());
self::assertSame("", $dest); self::assertSame("", $value);
$destv->set("a"); $wrapper->set("a");
self::assertSame("a", $destv->get()); self::assertSame("a", $wrapper->get());
self::assertSame("a", $dest); self::assertSame("a", $value);
$destv->set("12"); $wrapper->set("12");
self::assertSame("12", $destv->get()); self::assertSame("12", $wrapper->get());
$destv->set(" 12 "); $wrapper->set(" 12 ");
self::assertSame("12", $destv->get()); self::assertSame("12", $wrapper->get());
$destv->set(12); $wrapper->set(12);
self::assertSame("12", $destv->get()); self::assertSame("12", $wrapper->get());
$destv->set(12.34); $wrapper->set(12.34);
self::assertSame("12.34", $destv->get()); self::assertSame("12.34", $wrapper->get());
$destv->set(true); $wrapper->set(true);
self::assertSame("1", $destv->get()); self::assertSame("1", $wrapper->get());
self::assertException(Exception::class, $destvSetter([])); self::assertException(Exception::class, $wrapperSetter([]));
self::assertException(Exception::class, $destvSetter(["a"])); self::assertException(Exception::class, $wrapperSetter(["a"]));
} }
function testStr() { function testStr() {
/** @var ScalarWrapper $destv */ /** @var ScalarWrapper $wrapper */
Schema::nw($dest, null, $schema, "string", $destv); Schema::nw($value, null, $schema, "string", $wrapper);
$destvSetter = function($value) use($destv) { $wrapperSetter = function($value) use($wrapper) {
return function() use($destv, $value) { return function() use($wrapper, $value) {
$destv->set($value); $wrapper->set($value);
}; };
}; };
self::assertException(Exception::class, $destvSetter(null)); self::assertException(Exception::class, $wrapperSetter(null));
// valeur non requise donc retourne null // valeur non requise donc retourne null
$destv->set(false); $wrapper->set(false);
self::assertNull($destv->get()); self::assertNull($wrapper->get());
$this->commonTests($destv, $dest, $destvSetter); $this->commonTests($wrapper, $value, $wrapperSetter);
} }
function testRequiredStr() { function testRequiredStr() {
/** @var ScalarWrapper $destv */ /** @var ScalarWrapper $wrapper */
Schema::nw($dest, null, $schema, [ Schema::nw($value, null, $schema, [
"string", null, "string", null,
"required" => true, "required" => true,
], $destv); ], $wrapper);
$destvSetter = function($value) use($destv) { $wrapperSetter = function($value) use($wrapper) {
return function() use($destv, $value) { return function() use($wrapper, $value) {
$destv->set($value); $wrapper->set($value);
}; };
}; };
self::assertException(Exception::class, $destvSetter(null)); self::assertException(Exception::class, $wrapperSetter(null));
// valeur requise donc lance une exception // valeur requise donc lance une exception
self::assertException(Exception::class, $destvSetter(false)); self::assertException(Exception::class, $wrapperSetter(false));
$this->commonTests($destv, $dest, $destvSetter); $this->commonTests($wrapper, $value, $wrapperSetter);
} }
function testNstr() { function testNstr() {
/** @var ScalarWrapper $destv */ /** @var ScalarWrapper $wrapper */
Schema::nw($dest, null, $schema, "?string", $destv); Schema::nw($value, null, $schema, "?string", $wrapper);
$destvSetter = function($value) use($destv) { $wrapperSetter = function($value) use($wrapper) {
return function() use($destv, $value) { return function() use($wrapper, $value) {
$destv->set($value); $wrapper->set($value);
}; };
}; };
$destv->set(null); $wrapper->set(null);
self::assertNull($destv->get()); self::assertNull($wrapper->get());
self::assertNull($dest); self::assertNull($value);
self::assertSame("", $destv->format()); self::assertSame("", $wrapper->format());
// valeur non requise donc retourne null // valeur non requise donc retourne null
$destv->set(false); $wrapper->set(false);
self::assertNull($destv->get()); self::assertNull($wrapper->get());
$this->commonTests($destv, $dest, $destvSetter); $this->commonTests($wrapper, $value, $wrapperSetter);
} }
function testRequiredNstr() { function testRequiredNstr() {
/** @var ScalarWrapper $destv */ /** @var ScalarWrapper $wrapper */
Schema::nw($dest, null, $schema, [ Schema::nw($value, null, $schema, [
"?string", null, "?string", null,
"required" => true, "required" => true,
], $destv); ], $wrapper);
$destvSetter = function($value) use($destv) { $wrapperSetter = function($value) use($wrapper) {
return function() use($destv, $value) { return function() use($wrapper, $value) {
$destv->set($value); $wrapper->set($value);
}; };
}; };
$destv->set(null); $wrapper->set(null);
self::assertNull($destv->get()); self::assertNull($wrapper->get());
self::assertNull($dest); self::assertNull($value);
self::assertSame("", $destv->format()); self::assertSame("", $wrapper->format());
// valeur requise donc lance une exception // valeur requise donc lance une exception
self::assertException(Exception::class, $destvSetter(false)); self::assertException(Exception::class, $wrapperSetter(false));
$this->commonTests($destv, $dest, $destvSetter); $this->commonTests($wrapper, $value, $wrapperSetter);
} }
} }

15
tests/wip/schema/types/unionTest.php
View File

@ -10,20 +10,21 @@ class unionTest extends TestCase {
## l'ordre des types doit être respecté ## l'ordre des types doit être respecté
# string puis int # string puis int
/** @var ScalarWrapper $siv */ /** @var ScalarWrapper $siw */
Schema::nw($si, null, $sis, "string|int", $siv); Schema::nw($si, null, $sis, "string|int", $siw);
$siv->set("12"); $siw->set("12");
self::assertSame("12", $si); self::assertSame("12", $si);
$siv->set(12); $siw->set(12);
self::assertSame(12, $si); self::assertSame(12, $si);
# int puis string # int puis string
Schema::nw($is, null, $iss, "int|string", $isv); /** @var ScalarWrapper $isw */
Schema::nw($is, null, $iss, "int|string", $isw);
$isv->set("12"); $isw->set("12");
self::assertSame("12", $is); self::assertSame("12", $is);
$isv->set(12); $isw->set(12);
self::assertSame(12, $is); self::assertSame(12, $is);
} }
} }