Expect::from() works with class names

Author: dg

src/Schema/Expect.php

@@ -71,32 +71,49 @@ public static function structure(array $shape): Structure
 
 
 	/**
-	 * Generates a structure schema from a class instance by reflecting its properties or constructor parameters.
-	 * @param  array<string, Schema>  $items  Optional overrides for specific properties.
+	 * Generates a structure schema from a class by reflecting its properties or constructor parameters.
+	 * @param  class-string|object  $object
+	 * @param  array<string, Schema>  $items
 	 */
-	public static function from(object $object, array $items = []): Structure
+	public static function from(object|string $object, array $items = []): Structure
 	{
-		$ro = new \ReflectionObject($object);
+		$ro = new \ReflectionClass($object);
 		$props = $ro->hasMethod('__construct')
 			? $ro->getMethod('__construct')->getParameters()
 			: $ro->getProperties();
 
 		foreach ($props as $prop) {
 			$name = $prop->getName();
-			if (!isset($items[$name])) {
-				$item = new Type((string) (Nette\Utils\Type::fromReflection($prop) ?? 'mixed'));
-				if ($prop instanceof \ReflectionProperty ? $prop->isInitialized($object) : $prop->isOptional()) {
-					$def = ($prop instanceof \ReflectionProperty ? $prop->getValue($object) : $prop->getDefaultValue());
-					if (is_object($def)) {
-						$item = static::from($def);
-					} else {
-						$item->default($def);
-					}
+			if (isset($items[$name])) {
+				continue;
+			}
+
+			$item = new Type($propType = (string) (Nette\Utils\Type::fromReflection($prop) ?? 'mixed'));
+			if (class_exists($propType)) {
+				$item = static::from($propType);
+			}
+
+			$hasDefault = match (true) {
+				$prop instanceof \ReflectionParameter => $prop->isOptional(),
+				is_object($object) => $prop->isInitialized($object),
+				default => $prop->hasDefaultValue(),
+			};
+			if ($hasDefault) {
+				$default = match (true) {
+					$prop instanceof \ReflectionParameter => $prop->getDefaultValue(),
+					is_object($object) => $prop->getValue($object),
+					default => $prop->getDefaultValue(),
+				};
+				if (is_object($default)) {
+					$item = static::from($default);
 				} else {
-					$item->required();
+					$item->default($default);
 				}
-				$items[$name] = $item;
+			} else {
+				$item->required();
 			}
+
+			$items[$name] = $item;
 		}
 
 		return (new Structure($items))->castTo($ro->getName());

tests/Schema/Expect.from.phpt tests/Schema/Expect.from.dynamic.phpttests/Schema/Expect.from.phpt renamed to tests/Schema/Expect.from.dynamic.phpt

@@ -0,0 +1,107 @@
+<?php 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(stdClass::class);
+
+	Assert::type(Structure::class, $schema);
+	Assert::same([], $schema->items);
+	Assert::type(stdClass::class, (new Processor)->process($schema, []));
+});
+
+
+Assert::with(Structure::class, function () {
+	class Data1
+	{
+		public string $dsn = 'mysql';
+		public ?string $user;
+		public ?string $password = null;
+		public array|int $options = [];
+		public bool $debugger = true;
+		public mixed $mixed;
+		public array $arr = [1];
+	}
+
+	$schema = Expect::from(Data1::class);
+
+	Assert::type(Structure::class, $schema);
+	Assert::equal([
+		'dsn' => Expect::string('mysql'),
+		'user' => Expect::type('?string')->required(),
+		'password' => Expect::type('?string'),
+		'options' => Expect::type('array|int')->default([]),
+		'debugger' => Expect::bool(true),
+		'mixed' => Expect::mixed()->required(),
+		'arr' => Expect::type('array')->default([1]),
+	], $schema->items);
+	Assert::type(Data1::class, (new Processor)->process($schema, ['user' => '', 'mixed' => '']));
+});
+
+
+Assert::with(Structure::class, function () { // constructor injection
+	class Data2
+	{
+		public function __construct(
+			public ?string $user,
+			public ?string $password = null,
+		) {
+		}
+	}
+
+	$schema = Expect::from(Data2::class);
+
+	Assert::type(Structure::class, $schema);
+	Assert::equal([
+		'user' => Expect::type('?string')->required(),
+		'password' => Expect::type('?string'),
+	], $schema->items);
+	Assert::equal(
+		new Data2('foo', 'bar'),
+		(new Processor)->process($schema, ['user' => 'foo', 'password' => 'bar']),
+	);
+});
+
+
+Assert::with(Structure::class, function () { // overwritten item
+	class Data3
+	{
+		public string $dsn = 'mysql';
+		public ?string $user;
+	}
+
+	$schema = Expect::from(Data3::class, ['dsn' => Expect::int(123)]);
+
+	Assert::equal([
+		'dsn' => Expect::int(123),
+		'user' => Expect::type('?string')->required(),
+	], $schema->items);
+});
+
+
+Assert::with(Structure::class, function () { // nested object
+	class Data4
+	{
+		public Data5 $inner;
+	}
+
+	class Data5
+	{
+		public string $name;
+	}
+
+	$schema = Expect::from(Data4::class);
+
+	Assert::equal([
+		'inner' => Expect::structure([
+			'name' => Expect::string()->required(),
+		])->castTo(Data5::class),
+	], $schema->items);
+});