castTo() is realized via transform()

readme.md

@@ -376,6 +376,8 @@ $processor->process($schema, ['a', 'b', 'c']);
 // Failed assertion "Even items in array" for item with value array.
 ```
 
+The method can be called repeatedly to add multiple constraints. It can be intermixed with calls to `transform()` and `castTo()`.
+
 
 Transformation: transform()
 ---------------------------
@@ -387,6 +389,15 @@ Successfully validated data can be modified using a custom function:
 Expect::string()->transform(fn(string $s) => strtoupper($s));
 ```
 
+The method can be called repeatedly to add multiple transformations. It can be intermixed with calls to `assert()` and `castTo()`. The operations will be executed in the order in which they are declared:
+
+```php
+Expect::type('string|int')
+	->castTo('string')
+	->assert('ctype_lower', 'All characters must be lowercased')
+	->transform(fn(string $s) => strtoupper($s)); // conversion to uppercase
+```
+
 The `transform()` method can both transform and validate the value simultaneously. This is often simpler and less redundant than chaining `transform()` and `assert()`. For this purpose, the function receives a [Nette\Schema\Context](https://api.nette.org/schema/master/Nette/Schema/Context.html) object with an `addError()` method, which can be used to add information about validation issues:
 
 ```php

src/Schema/Elements/Base.php

@@ -31,9 +31,6 @@ trait Base
 	/** @var callable[] */
 	private $transforms = [];
 
-	/** @var string|null */
-	private $castTo;
-
 	/** @var string|null */
 	private $deprecated;
 
@@ -61,8 +58,7 @@ public function before(callable $handler): self
 
 	public function castTo(string $type): self
 	{
-		$this->castTo = $type;
-		return $this;
+		return $this->transform(Helpers::getCastStrategy($type));
 	}
 
 
@@ -134,18 +130,6 @@ private function doDeprecation(Context $context): void
 
 	private function doTransform($value, Context $context)
 	{
-		if ($this->castTo) {
-			if (Nette\Utils\Reflection::isBuiltinType($this->castTo)) {
-				settype($value, $this->castTo);
-			} else {
-				$object = new $this->castTo;
-				foreach ($value as $k => $v) {
-					$object->$k = $v;
-				}
-				$value = $object;
-			}
-		}
-
 		$isOk = $context->createChecker();
 		foreach ($this->transforms as $handler) {
 			$value = $handler($value, $context);

src/Schema/Elements/Structure.php

@@ -40,7 +40,7 @@ public function __construct(array $items)
 	{
 		(function (Schema ...$items) {})(...array_values($items));
 		$this->items = $items;
-		$this->castTo = 'object';
+		$this->castTo('object');
 		$this->required = true;
 	}
 

src/Schema/Helpers.php

@@ -167,4 +167,23 @@ public static function validatePattern(string $value, string $pattern, Context $
 			);
 		}
 	}
+
+
+	public static function getCastStrategy(string $type): \Closure
+	{
+		if (Nette\Utils\Reflection::isBuiltinType($type)) {
+			return static function ($value) use ($type) {
+				settype($value, $type);
+				return $value;
+			};
+		} else {
+			return static function ($value) use ($type) {
+				$object = new $type;
+				foreach ($value as $k => $v) {
+					$object->$k = $v;
+				}
+				return $object;
+			};
+		}
+	}
 }

tests/Schema/Expect.from.php74.phpt

@@ -8,14 +8,15 @@ declare(strict_types=1);
 
 use Nette\Schema\Elements\Structure;
 use Nette\Schema\Expect;
+use Nette\Schema\Processor;
 use Tester\Assert;
 
 
 require __DIR__ . '/../bootstrap.php';
 
 
 Assert::with(Structure::class, function () {
-	$schema = Expect::from(new class {
+	$schema = Expect::from($obj = new class {
 		public string $dsn = 'mysql';
 		public ?string $user;
 		public ?string $password = null;
@@ -35,5 +36,5 @@ Assert::with(Structure::class, function () {
 		'mixed' => Expect::mixed(),
 		'arr' => Expect::type('array')->default([1]),
 	], $schema->items);
-	Assert::type('string', $schema->castTo);
+	Assert::type($obj, (new Processor)->process($schema, ['user' => '']));
 });

tests/Schema/Expect.from.php80.phpt

@@ -8,14 +8,15 @@ declare(strict_types=1);
 
 use Nette\Schema\Elements\Structure;
 use Nette\Schema\Expect;
+use Nette\Schema\Processor;
 use Tester\Assert;
 
 
 require __DIR__ . '/../bootstrap.php';
 
 
 Assert::with(Structure::class, function () {
-	$schema = Expect::from(new class {
+	$schema = Expect::from($obj = new class {
 		public string $dsn = 'mysql';
 		public ?string $user;
 		public ?string $password = null;
@@ -35,5 +36,5 @@ Assert::with(Structure::class, function () {
 		'mixed' => Expect::mixed()->required(),
 		'arr' => Expect::type('array')->default([1]),
 	], $schema->items);
-	Assert::type('string', $schema->castTo);
+	Assert::type($obj, (new Processor)->process($schema, ['user' => '', 'mixed' => '']));
 });

tests/Schema/Expect.from.phpt

@@ -4,6 +4,7 @@ declare(strict_types=1);
 
 use Nette\Schema\Elements\Structure;
 use Nette\Schema\Expect;
+use Nette\Schema\Processor;
 use Tester\Assert;
 
 
@@ -19,12 +20,12 @@ Assert::with(Structure::class, function () {
 
 	Assert::type(Structure::class, $schema);
 	Assert::same([], $schema->items);
-	Assert::same(stdClass::class, $schema->castTo);
+	Assert::type(stdClass::class, (new Processor)->process($schema, []));
 });
 
 
 Assert::with(Structure::class, function () {
-	$schema = Expect::from(new class {
+	$schema = Expect::from($obj = new class {
 		/** @var string */
 		public $dsn = 'mysql';
 
@@ -59,7 +60,7 @@ Assert::with(Structure::class, function () {
 		'arr' => Expect::type('array|null')->default(null),
 		'required' => Expect::type('string')->required(),
 	], $schema->items);
-	Assert::type('string', $schema->castTo);
+	Assert::type($obj, (new Processor)->process($schema, ['required' => '']));
 });