danog/Valinor
1
0
Fork 0
mirror of https://github.com/danog/Valinor.git synced 2025-01-10 14:48:20 +01:00
Code Issues Packages Projects Releases Wiki Activity
bf2264b8e3
Valinor/tests/Integration/Mapping/Object/ListValuesMappingTest.php

164 lines
5.6 KiB
PHP
Raw Normal View History

feat: initial release 🎉
2021-11-28 17:43:02 +01:00
<?php
declare(strict_types=1);
feat!: allow mapping to any type Previously, the method `TreeMapper::map` would allow mapping only to an object. It is now possible to map to any type handled by the library. It is for instance possible to map to an array of objects: ```php $objects = (new \CuyZ\Valinor\MapperBuilder())->mapper()->map( 'array<' . SomeClass::class . '>', [/* … */] ); ``` For simple use-cases, an array shape can be used: ```php $array = (new \CuyZ\Valinor\MapperBuilder())->mapper()->map( 'array{foo: string, bar: int}', [/* … */] ); echo strtolower($array['foo']); echo $array['bar'] * 2; ``` This new feature changes the possible behaviour of the mapper, meaning static analysis tools need help to understand the types correctly. An extension for PHPStan and a plugin for Psalm are now provided and can be included in a project to automatically increase the type coverage.
2021-12-29 00:09:34 +01:00
namespace CuyZ\Valinor\Tests\Integration\Mapping\Object;
feat: initial release 🎉
2021-11-28 17:43:02 +01:00
use CuyZ\Valinor\Mapper\MappingError;
feat: allow injecting a cache implementation that is used by the mapper The cache implementation that was previously injected in the mapper builder must now be manually injected. This gives better control on when the cache should be enabled, especially depending on which environment the application is running. The library provides a cache implementation out of the box, which saves cache entries into the file system. It is also possible to use any PSR-16 compliant implementation, as long as it is capable of caching the entries handled by the library. ```php $cache = new \CuyZ\Valinor\Cache\FileSystemCache('path/to/cache-dir'); (new \CuyZ\Valinor\MapperBuilder()) ->withCache($cache) ->mapper() ->map(SomeClass::class, [/* … */]); ```
2022-05-22 20:43:01 +02:00
use CuyZ\Valinor\MapperBuilder;
feat: initial release 🎉
2021-11-28 17:43:02 +01:00
use CuyZ\Valinor\Tests\Integration\IntegrationTest;
use CuyZ\Valinor\Tests\Integration\Mapping\Fixture\SimpleObject;
use CuyZ\Valinor\Tests\Integration\Mapping\Fixture\SimpleObject as SimpleObjectAlias;
feat!: add access to root node when error occurs during mapping When an error occurs during mapping, the root instance of `Node` can now be accessed from the exception. This recursive object allows retrieving all needed information through the whole mapping tree: path, values, types and messages, including the issues that caused the exception. It can be used like the following: ```php try { (new \CuyZ\Valinor\MapperBuilder()) ->mapper() ->map(SomeClass::class, [/* ... */]); } catch (\CuyZ\Valinor\Mapper\MappingError $error) { // Do something with `$error->node()` // See README for more information } ``` This change removes the method `MappingError::describe()` which provided a flattened view of messages of all the errors that were encountered during the mapping. The same behaviour can still be retrieved, see the example below: ```php use CuyZ\Valinor\Mapper\Tree\Message\Message; use CuyZ\Valinor\Mapper\Tree\Node; /** * @implements \IteratorAggregate<string, array<\Throwable&Message>> */ final class MappingErrorList implements \IteratorAggregate { private Node $node; public function __construct(Node $node) { $this->node = $node; } /** * @return \Traversable<string, array<\Throwable&Message>> */ public function getIterator(): \Traversable { yield from $this->errors($this->node); } /** * @return \Traversable<string, array<\Throwable&Message>> */ private function errors(Node $node): \Traversable { $errors = array_filter( $node->messages(), static fn (Message $m) => $m instanceof \Throwable ); if (! empty($errors)) { yield $node->path() => array_values($errors); } foreach ($node->children() as $child) { yield from $this->errors($child); } } } try { (new \CuyZ\Valinor\MapperBuilder()) ->mapper() ->map(SomeClass::class, [/* ... */]); } catch (\CuyZ\Valinor\Mapper\MappingError $error) { $errors = iterator_to_array(new MappingErrorList($error->node())); } ``` The class `CannotMapObject` is deleted, as it does not provide any value; this means that `MappingError` which was previously an interface becomes a class.
2021-12-16 00:00:45 +01:00
feat: initial release 🎉
2021-11-28 17:43:02 +01:00
use function array_values;
final class ListValuesMappingTest extends IntegrationTest
{
public function test_values_are_mapped_properly(): void
{
$source = [
'booleans' => [true, false, true],
'floats' => [42.404, 404.42],
'integers' => [42, 404, 1337],
'strings' => ['foo', 'bar', 'baz'],
'objects' => [
['value' => 'foo'],
['value' => 'bar'],
['value' => 'baz'],
],
'objectsWithAlias' => [
['value' => 'foo'],
['value' => 'bar'],
['value' => 'baz'],
],
'nonEmptyListOfStrings' => ['foo', 'bar', 'baz'],
'listOfStringsWithKeys' => [
'foo' => 'foo',
'bar' => 'bar',
'baz' => 'baz',
],
'nonEmptyListOfStringsWithKeys' => [
'foo' => 'foo',
'bar' => 'bar',
'baz' => 'baz',
],
];
foreach ([ListValues::class, ListValuesWithConstructor::class] as $class) {
try {
feat: allow injecting a cache implementation that is used by the mapper The cache implementation that was previously injected in the mapper builder must now be manually injected. This gives better control on when the cache should be enabled, especially depending on which environment the application is running. The library provides a cache implementation out of the box, which saves cache entries into the file system. It is also possible to use any PSR-16 compliant implementation, as long as it is capable of caching the entries handled by the library. ```php $cache = new \CuyZ\Valinor\Cache\FileSystemCache('path/to/cache-dir'); (new \CuyZ\Valinor\MapperBuilder()) ->withCache($cache) ->mapper() ->map(SomeClass::class, [/* … */]); ```
2022-05-22 20:43:01 +02:00
$result = (new MapperBuilder())->mapper()->map($class, $source);
feat: initial release 🎉
2021-11-28 17:43:02 +01:00
} catch (MappingError $error) {
$this->mappingFail($error);
}
self::assertSame($source['booleans'], $result->booleans);
self::assertSame($source['floats'], $result->floats);
self::assertSame($source['integers'], $result->integers);
self::assertSame($source['strings'], $result->strings);
self::assertSame('foo', $result->objects[0]->value);
self::assertSame('bar', $result->objects[1]->value);
self::assertSame('baz', $result->objects[2]->value);
self::assertSame('foo', $result->objectsWithAlias[0]->value);
self::assertSame('bar', $result->objectsWithAlias[1]->value);
self::assertSame('baz', $result->objectsWithAlias[2]->value);
self::assertSame($source['nonEmptyListOfStrings'], $result->nonEmptyListOfStrings);
self::assertSame(array_values($source['listOfStringsWithKeys']), $result->listOfStringsWithKeys);
self::assertSame(array_values($source['nonEmptyListOfStringsWithKeys']), $result->nonEmptyListOfStringsWithKeys);
}
}
public function test_empty_list_in_non_empty_list_throws_exception(): void
{
try {
feat: allow injecting a cache implementation that is used by the mapper The cache implementation that was previously injected in the mapper builder must now be manually injected. This gives better control on when the cache should be enabled, especially depending on which environment the application is running. The library provides a cache implementation out of the box, which saves cache entries into the file system. It is also possible to use any PSR-16 compliant implementation, as long as it is capable of caching the entries handled by the library. ```php $cache = new \CuyZ\Valinor\Cache\FileSystemCache('path/to/cache-dir'); (new \CuyZ\Valinor\MapperBuilder()) ->withCache($cache) ->mapper() ->map(SomeClass::class, [/* … */]); ```
2022-05-22 20:43:01 +02:00
(new MapperBuilder())->mapper()->map(ListValues::class, [
feat: initial release 🎉
2021-11-28 17:43:02 +01:00
'nonEmptyListOfStrings' => [],
]);
} catch (MappingError $exception) {
feat!: add access to root node when error occurs during mapping When an error occurs during mapping, the root instance of `Node` can now be accessed from the exception. This recursive object allows retrieving all needed information through the whole mapping tree: path, values, types and messages, including the issues that caused the exception. It can be used like the following: ```php try { (new \CuyZ\Valinor\MapperBuilder()) ->mapper() ->map(SomeClass::class, [/* ... */]); } catch (\CuyZ\Valinor\Mapper\MappingError $error) { // Do something with `$error->node()` // See README for more information } ``` This change removes the method `MappingError::describe()` which provided a flattened view of messages of all the errors that were encountered during the mapping. The same behaviour can still be retrieved, see the example below: ```php use CuyZ\Valinor\Mapper\Tree\Message\Message; use CuyZ\Valinor\Mapper\Tree\Node; /** * @implements \IteratorAggregate<string, array<\Throwable&Message>> */ final class MappingErrorList implements \IteratorAggregate { private Node $node; public function __construct(Node $node) { $this->node = $node; } /** * @return \Traversable<string, array<\Throwable&Message>> */ public function getIterator(): \Traversable { yield from $this->errors($this->node); } /** * @return \Traversable<string, array<\Throwable&Message>> */ private function errors(Node $node): \Traversable { $errors = array_filter( $node->messages(), static fn (Message $m) => $m instanceof \Throwable ); if (! empty($errors)) { yield $node->path() => array_values($errors); } foreach ($node->children() as $child) { yield from $this->errors($child); } } } try { (new \CuyZ\Valinor\MapperBuilder()) ->mapper() ->map(SomeClass::class, [/* ... */]); } catch (\CuyZ\Valinor\Mapper\MappingError $error) { $errors = iterator_to_array(new MappingErrorList($error->node())); } ``` The class `CannotMapObject` is deleted, as it does not provide any value; this means that `MappingError` which was previously an interface becomes a class.
2021-12-16 00:00:45 +01:00
$error = $exception->node()->children()['nonEmptyListOfStrings']->messages()[0];
feat!: wrap node messages in proper class A new class `NodeMessage` is used to wrap messages added to a node during the mapping. This class will allow further features by giving access to useful data related to the bound node. BREAKING CHANGE: as of now every message is wrapped into a `NodeMessage` it is therefore not possible to check whether the message is an instance of `Throwable` — a new method `$message->isError()` is now to be used for such cases.
2021-12-31 13:10:20 +01:00
self::assertSame('1630678334', $error->code());
feat!: improve message customization with formatters The way messages can be customized has been totally revisited, requiring several breaking changes. All existing error messages have been rewritten to better fit the actual meaning of the error. The content of a message can be changed to fit custom use cases; it can contain placeholders that will be replaced with useful information. The placeholders below are always available; even more may be used depending on the original message. - `{message_code}` — the code of the message - `{node_name}` — name of the node to which the message is bound - `{node_path}` — path of the node to which the message is bound - `{node_type}` — type of the node to which the message is bound - `{original_value}` — the source value that was given to the node - `{original_message}` — the original message before being customized ```php try { (new \CuyZ\Valinor\MapperBuilder()) ->mapper() ->map(SomeClass::class, [/* … */]); } catch (\CuyZ\Valinor\Mapper\MappingError $error) { $messages = new MessagesFlattener($error->node()); foreach ($messages as $message) { if ($message->code() === 'some_code') { $message = $message->withBody('new / {original_message}'); } echo $message; } } ``` The messages are formatted using the ICU library, enabling the placeholders to use advanced syntax to perform proper translations, for instance currency support. ```php try { (new MapperBuilder())->mapper()->map('int<0, 100>', 1337); } catch (\CuyZ\Valinor\Mapper\MappingError $error) { $message = $error->node()->messages()[0]; if (is_numeric($message->value())) { $message = $message->withBody( 'Invalid amount {original_value, number, currency}' ); } // Invalid amount: $1,337.00 echo $message->withLocale('en_US'); // Invalid amount: £1,337.00 echo $message->withLocale('en_GB'); // Invalid amount: 1 337,00 € echo $message->withLocale('fr_FR'); } ``` If the `intl` extension is not installed, a shim will be available to replace the placeholders, but it won't handle advanced syntax as described above. --- The new formatter `TranslationMessageFormatter` can be used to translate the content of messages. The library provides a list of all messages that can be returned; this list can be filled or modified with custom translations. ```php TranslationMessageFormatter::default() // Create/override a single entry… ->withTranslation( 'fr', 'some custom message', 'un message personnalisé' ) // …or several entries. ->withTranslations([ 'some custom message' => [ 'en' => 'Some custom message', 'fr' => 'Un message personnalisé', 'es' => 'Un mensaje personalizado', ], 'some other message' => [ // … ], ]) ->format($message); ``` It is possible to join several formatters into one formatter by using the `AggregateMessageFormatter`. This instance can then easily be injected in a service that will handle messages. The formatters will be called in the same order they are given to the aggregate. ```php (new AggregateMessageFormatter( new LocaleMessageFormatter('fr'), new MessageMapFormatter([ // … ], TranslationMessageFormatter::default(), ))->format($message) ``` BREAKING CHANGE: The method `NodeMessage::format` has been removed, message formatters should be used instead. If needed, the old behaviour can be retrieved with the formatter `PlaceHolderMessageFormatter`, although it is strongly advised to use the new placeholders feature. BREAKING CHANGE: The signature of the method `MessageFormatter::format` has changed.
2022-05-18 23:15:08 +02:00
self::assertSame('Value array (empty) does not match type `non-empty-list<string>`.', (string)$error);
feat: initial release 🎉
2021-11-28 17:43:02 +01:00
}
}
public function test_value_that_cannot_be_casted_throws_exception(): void
{
try {
feat: allow injecting a cache implementation that is used by the mapper The cache implementation that was previously injected in the mapper builder must now be manually injected. This gives better control on when the cache should be enabled, especially depending on which environment the application is running. The library provides a cache implementation out of the box, which saves cache entries into the file system. It is also possible to use any PSR-16 compliant implementation, as long as it is capable of caching the entries handled by the library. ```php $cache = new \CuyZ\Valinor\Cache\FileSystemCache('path/to/cache-dir'); (new \CuyZ\Valinor\MapperBuilder()) ->withCache($cache) ->mapper() ->map(SomeClass::class, [/* … */]); ```
2022-05-22 20:43:01 +02:00
(new MapperBuilder())->mapper()->map(ListValues::class, [
feat: initial release 🎉
2021-11-28 17:43:02 +01:00
'integers' => ['foo'],
]);
} catch (MappingError $exception) {
feat!: add access to root node when error occurs during mapping When an error occurs during mapping, the root instance of `Node` can now be accessed from the exception. This recursive object allows retrieving all needed information through the whole mapping tree: path, values, types and messages, including the issues that caused the exception. It can be used like the following: ```php try { (new \CuyZ\Valinor\MapperBuilder()) ->mapper() ->map(SomeClass::class, [/* ... */]); } catch (\CuyZ\Valinor\Mapper\MappingError $error) { // Do something with `$error->node()` // See README for more information } ``` This change removes the method `MappingError::describe()` which provided a flattened view of messages of all the errors that were encountered during the mapping. The same behaviour can still be retrieved, see the example below: ```php use CuyZ\Valinor\Mapper\Tree\Message\Message; use CuyZ\Valinor\Mapper\Tree\Node; /** * @implements \IteratorAggregate<string, array<\Throwable&Message>> */ final class MappingErrorList implements \IteratorAggregate { private Node $node; public function __construct(Node $node) { $this->node = $node; } /** * @return \Traversable<string, array<\Throwable&Message>> */ public function getIterator(): \Traversable { yield from $this->errors($this->node); } /** * @return \Traversable<string, array<\Throwable&Message>> */ private function errors(Node $node): \Traversable { $errors = array_filter( $node->messages(), static fn (Message $m) => $m instanceof \Throwable ); if (! empty($errors)) { yield $node->path() => array_values($errors); } foreach ($node->children() as $child) { yield from $this->errors($child); } } } try { (new \CuyZ\Valinor\MapperBuilder()) ->mapper() ->map(SomeClass::class, [/* ... */]); } catch (\CuyZ\Valinor\Mapper\MappingError $error) { $errors = iterator_to_array(new MappingErrorList($error->node())); } ``` The class `CannotMapObject` is deleted, as it does not provide any value; this means that `MappingError` which was previously an interface becomes a class.
2021-12-16 00:00:45 +01:00
$error = $exception->node()->children()['integers']->children()['0']->messages()[0];
feat!: wrap node messages in proper class A new class `NodeMessage` is used to wrap messages added to a node during the mapping. This class will allow further features by giving access to useful data related to the bound node. BREAKING CHANGE: as of now every message is wrapped into a `NodeMessage` it is therefore not possible to check whether the message is an instance of `Throwable` — a new method `$message->isError()` is now to be used for such cases.
2021-12-31 13:10:20 +01:00
self::assertSame('1618736242', $error->code());
feat: improve mapping error messages Enhances most of the messages for the end users. Two major changes can be noticed: 1. In most cases no class name will be written in the message; it prevents users that potentially have no access to the codebase to get a useless/unclear information. 2. The input values are now properly formatted; for instance a string value will now be written directly instead of the type `string`; arrays are also handled with the array shape format, for instance: `array{foo: 'some string'}`.
2022-04-04 23:36:28 +02:00
self::assertSame("Cannot cast 'foo' to `int`.", (string)$error);
feat: initial release 🎉
2021-11-28 17:43:02 +01:00
}
}
}
class ListValues
{
/** @var list<bool> */
public array $booleans;
/** @var list<float> */
public array $floats;
/** @var list<int> */
public array $integers;
/** @var list<string> */
public array $strings;
/** @var list<SimpleObject> */
public array $objects;
/** @var list<SimpleObjectAlias> */
public array $objectsWithAlias;
/** @var non-empty-list<string> */
public array $nonEmptyListOfStrings = ['foo'];
/** @var list<string> */
public array $listOfStringsWithKeys;
/** @var non-empty-list<string> */
public array $nonEmptyListOfStringsWithKeys;
}
class ListValuesWithConstructor extends ListValues
{
/**
* @param list<bool> $booleans
* @param list<float> $floats
* @param list<int> $integers
* @param list<string> $strings
* @param list<SimpleObject> $objects
* @param list<SimpleObjectAlias> $objectsWithAlias
* @param non-empty-list<string> $nonEmptyListOfStrings
* @param list<string> $listOfStringsWithKeys
* @param non-empty-list<string> $nonEmptyListOfStringsWithKeys
*/
public function __construct(
array $booleans,
array $floats,
array $integers,
array $strings,
array $objects,
array $objectsWithAlias,
array $nonEmptyListOfStrings,
array $listOfStringsWithKeys,
array $nonEmptyListOfStringsWithKeys
) {
$this->booleans = $booleans;
$this->floats = $floats;
$this->integers = $integers;
$this->strings = $strings;
$this->objects = $objects;
$this->objectsWithAlias = $objectsWithAlias;
$this->nonEmptyListOfStrings = $nonEmptyListOfStrings;
$this->listOfStringsWithKeys = $listOfStringsWithKeys;
$this->nonEmptyListOfStringsWithKeys = $nonEmptyListOfStringsWithKeys;
}
}
Reference in New Issue Copy Permalink