Compare commits

...

7 Commits

  1. 4
      composer.json
  2. 13
      src/Attribute/DataPath.php
  3. 11
      src/Attribute/HandleTags.php
  4. 4
      src/Attribute/PropertyPath.php
  5. 18
      src/Attribute/Schema.php
  6. 422
      src/Dto2DataConverter.php
  7. 16
      src/Resolver/SimpleResolver.php
  8. 11
      src/Resolver/TransformerResolverInterface.php
  9. 32
      src/Resolver/TransformerResolverStorage.php
  10. 14
      src/Transformer/DateTimeFormat.php
  11. 18
      src/Transformer/DateTimeFormatTransformer.php
  12. 15
      src/Transformer/Meta.php
  13. 8
      src/Transformer/TransformerInterface.php
  14. 14
      src/Transformer/Trim.php
  15. 18
      src/Transformer/TrimTransformer.php
  16. 112
      tests/unit/Converter/FillTest.php
  17. 39
      tests/unit/Converter/TagsTest.php
  18. 151
      tests/unit/Converter/fixtures/FillTest/HelloRequest.php
  19. 32
      tests/unit/Converter/fixtures/FillTest/HelloSchema.php
  20. 18
      tests/unit/Converter/fixtures/FillTest/HelloTagsRequest.php
  21. 2
      tests/unit/Converter/fixtures/FillTest/Transformer/ClassData.php
  22. 9
      tests/unit/Converter/fixtures/FillTest/Transformer/ClassDataTransformer.php
  23. 2
      tests/unit/Converter/fixtures/FillTest/Transformer/ClassObject.php
  24. 9
      tests/unit/Converter/fixtures/FillTest/Transformer/ClassObjectTransformer.php
  25. 5
      tests/unit/Converter/fixtures/FillTest/UUID.php

@ -8,7 +8,9 @@
"ext-iconv": "*", "ext-iconv": "*",
"ext-json": "*", "ext-json": "*",
"symfony/string": "^5.3", "symfony/string": "^5.3",
"rinsvent/attribute-extractor": "^0.0" "rinsvent/attribute-extractor": "^0.0",
"rinsvent/transformer": "^0.0",
"symfony/property-access": "^6.0"
}, },
"require-dev": { "require-dev": {
"codeception/codeception": "^4.1", "codeception/codeception": "^4.1",

@ -1,13 +0,0 @@
<?php
namespace Rinsvent\DTO2Data\Attribute;
#[\Attribute(\Attribute::TARGET_ALL|\Attribute::IS_REPEATABLE)]
class DataPath
{
public function __construct(
public string $path,
/** @var string[] $tags */
public array $tags = ['default']
) {}
}

@ -1,11 +0,0 @@
<?php
namespace Rinsvent\DTO2Data\Attribute;
#[\Attribute(\Attribute::TARGET_ALL|\Attribute::IS_REPEATABLE)]
class HandleTags
{
public function __construct(
public string $method,
) {}
}

@ -1,4 +1,5 @@
<?php <?php
declare(strict_types=1);
namespace Rinsvent\DTO2Data\Attribute; namespace Rinsvent\DTO2Data\Attribute;
@ -9,5 +10,6 @@ class PropertyPath
public string $path, public string $path,
/** @var string[] $tags */ /** @var string[] $tags */
public array $tags = ['default'] public array $tags = ['default']
) {} ) {
}
} }

@ -1,17 +1,25 @@
<?php <?php
declare(strict_types=1);
namespace Rinsvent\DTO2Data\Attribute; namespace Rinsvent\DTO2Data\Attribute;
#[\Attribute(\Attribute::TARGET_ALL|\Attribute::IS_REPEATABLE)] #[\Attribute(\Attribute::TARGET_ALL|\Attribute::IS_REPEATABLE)]
class Schema class Schema
{ {
public ?array $baseMap = null; protected array $baseMap = [];
public function __construct( public function __construct(
public ?array $map = null, public array $map = [],
/** @var string[] $tags */
public array $tags = ['default']
) { ) {
$this->map = $map ?? $this->baseMap; }
public function getMap(): array
{
return $this->baseMap ?: $this->map;
}
public function getTags(mixed $data = null): array
{
return ['default'];
} }
} }

@ -1,370 +1,168 @@
<?php <?php
declare(strict_types=1);
namespace Rinsvent\DTO2Data; namespace Rinsvent\DTO2Data;
use ReflectionMethod;
use ReflectionProperty; use ReflectionProperty;
use Rinsvent\AttributeExtractor\ClassExtractor;
use Rinsvent\AttributeExtractor\MethodExtractor; use Rinsvent\AttributeExtractor\MethodExtractor;
use Rinsvent\AttributeExtractor\PropertyExtractor; use Rinsvent\AttributeExtractor\PropertyExtractor;
use Rinsvent\DTO2Data\Attribute\DataPath;
use Rinsvent\DTO2Data\Attribute\HandleTags;
use Rinsvent\DTO2Data\Attribute\PropertyPath;
use Rinsvent\DTO2Data\Attribute\Schema; use Rinsvent\DTO2Data\Attribute\Schema;
use Rinsvent\DTO2Data\Resolver\TransformerResolverStorage; use Rinsvent\Transformer\Transformer;
use Rinsvent\DTO2Data\Transformer\Meta; use Rinsvent\Transformer\Transformer\Meta;
use Rinsvent\DTO2Data\Transformer\TransformerInterface; use Symfony\Component\PropertyAccess\PropertyAccess;
use Symfony\Component\PropertyAccess\PropertyAccessorInterface;
class Dto2DataConverter class Dto2DataConverter
{ {
public function getTags(object $object, array $tags = []): array private PropertyAccessorInterface $propertyAccessor;
private Transformer $transformer;
public function __construct()
{ {
return $this->processTags($object, $tags); $this->propertyAccessor = PropertyAccess::createPropertyAccessorBuilder()
->disableExceptionOnInvalidPropertyPath()
->enableMagicMethods()
->getPropertyAccessor();
$this->transformer = new Transformer();
} }
public function convert($data, array $tags = []): array public function convert($data, string $schemaClass): array
{ {
if (!is_object($data) && !is_iterable($data)) { $schema = new $schemaClass();
throw new \InvalidArgumentException(); if (!$schema instanceof Schema) {
throw new \InvalidArgumentException(
'Schema should be instance of Rinsvent\DTO2Data\Attribute\Schema'
);
} }
return is_iterable($data) return $this->convertByMap($data, $schema->getMap(), $schema->getTags($data));
? $this->convertArray($data, $tags)
: $this->convertObject($data, $tags);
} }
public function convertArray(iterable $items, array $tags = []): array private function convertByMap($data, array $map, array $tags): array
{ {
$result = []; $result = [];
foreach ($items as $item) { if (is_iterable($data)) {
if (!is_object($item)) { foreach ($data as $item) {
throw new \InvalidArgumentException(); $result[] = $this->processItem($item, $map, $tags);
} }
$result[] = $this->convertObject($item, $tags); } else {
$result = $this->processItem($data, $map, $tags);
} }
return $result; return $result;
} }
public function convertObject(object $object, array $tags = []): array private function processItem($data, array $map, array $tags): array
{
$tags = empty($tags) ? ['default'] : $tags;
$schema = $this->grabSchema($object, $tags);
return $this->convertObjectByMap($object, $schema->map, $tags);
}
public function convertObjectByMap(object $object, array $map, array $tags = []): array
{ {
$data = []; $result = [];
foreach ($map as $key => $item) {
$reflectionObject = new \ReflectionObject($object); try {
foreach ($map as $key => $propertyInfo) { switch (true) {
$sourceName = is_array($propertyInfo) ? $key : $propertyInfo; // key -> propertyPath (===).
case is_int($key) && is_string($item):
if (!method_exists($object, $sourceName) && !property_exists($object, $sourceName)) { $result[$item] = $this->grabValue($data, $item);
continue; $result[$item] = $this->transform($data, $item, $result[$item], $tags);
} break;
// key -> propertyPath (!==)
$value = $this->grabValue($object, $sourceName, $tags); case is_string($key) && is_string($item):
$result[$key] = $this->grabValue($data, $item);
$canSkip = false; $result[$key] = $this->transform($data, $item, $result[$key], $tags);
// Если нет карты, то не сериализуем. break;
if (is_iterable($value)) { // key -> recursive data processing
$childMap = is_array($propertyInfo) ? $propertyInfo : null; case is_string($key) && is_array($item):
$value = $this->convertArrayByMap($value, $childMap, $tags); $result[$key] = $this->convertByMap($this->grabValue($data, $key), $item, $tags);
} elseif (is_object($value) && is_array($propertyInfo)) { break;
$value = $this->convertObjectByMap($value, $propertyInfo, $tags); // key -> virtual field
} elseif (!is_scalar($value) && null !== $value) { case is_string($key) && is_callable($item):
$canSkip = true; $result[$key] = call_user_func_array($item, [$data]);
} break;
// key -> data processing with transformer
$this->processIterationTransformers($object, $sourceName, $value, $tags); case $item instanceof Meta:
case (new $item) instanceof Meta:
if ($canSkip && !is_scalar($value) && null !== $value) { $meta = is_string($item) ? new $item : $item;
continue; $result[$key] = $this->transformer->transform($data, $meta);
break;
// key -> recursive data processing with other schema
case $item instanceof Schema:
case (new $item) instanceof Schema:
$schemaClass = is_object($item) ? $item::class : $item;
$result[$key] = $this->convert($data[$key] ?? null, $schemaClass);
break;
default:
$result[$key] = null;
}
} catch (\Throwable) {
$result[$key] = null;
} }
$dataPath = $this->grabIterationDataPath($object, $sourceName, $tags);
$data[$dataPath] = $value;
} }
return $result;
$this->processClassTransformers($reflectionObject, $data, $tags);
return $data;
} }
public function convertArrayByMap($data, ?array $map, array $tags = []): ?array private function transform(object|array|null $data, string $path, mixed $value, array $tags): mixed
{ {
// $isAssociative = count($data) && !array_key_exists(0, $data); $metas = $this->grabTransformMetas($data, $path);
foreach ($metas as $meta) {
$tempValue = []; $value = $this->transformer->transform($value, $meta, $tags);
foreach ($data as $key => $item) {
if (is_scalar($item)) {
$tempValue[$key] = $item;
continue;
}
if (is_iterable($item) && $map) {
$tempValue[$key] = $this->convertArrayByMap($item, $map, $tags);
continue;
}
if (is_object($item) && $map) {
$tempValue[$key] = $this->convertObjectByMap($item, $map, $tags);
continue;
} }
} return $value;
return $tempValue;
} }
protected function grabValue(object $object, $sourceName, array $tags) private function grabValue(object|array|null $value, string $path): mixed
{ {
if (method_exists($object, $sourceName)) { if (null === $value) {
$reflectionSource = new ReflectionMethod($object, $sourceName);
return $this->getMethodValue($object, $reflectionSource);
} elseif (property_exists($object, $sourceName)) {
$reflectionSource = new ReflectionProperty($object, $sourceName);
$propertyExtractor = new PropertyExtractor($object::class, $sourceName);
/** @var PropertyPath $propertyPath */
while ($propertyPath = $propertyExtractor->fetch(PropertyPath::class)) {
$filteredTags = array_diff($tags, $propertyPath->tags);
if (count($filteredTags) === count($tags)) {
continue;
}
return $this->getValueByPath($object, $propertyPath->path);
}
return $this->getValue($object, $reflectionSource);
}
return null; return null;
} }
$path = is_array($value) && 0 === mb_substr_count($path, '.') &&
public function processIterationTransformers(object $object, string $sourceName, &$value, array $tags): void false === mb_strpos($path, '[')
{ ? "[{$path}]"
if (method_exists($object, $sourceName)) { : $path;
$reflectionSource = new ReflectionMethod($object, $sourceName); return $this->propertyAccessor->getValue($value, $path);
$this->processMethodTransformers($reflectionSource, $value, $tags);
} elseif (property_exists($object, $sourceName)) {
$reflectionSource = new ReflectionProperty($object, $sourceName);
$this->processTransformers($reflectionSource, $value, $tags);
}
}
public function grabIterationDataPath(object $object, string $sourceName, array $tags): string
{
if (method_exists($object, $sourceName)) {
$reflectionSource = new ReflectionMethod($object, $sourceName);
$dataPath = $this->grabMethodDataPath($reflectionSource, $tags);
} elseif (property_exists($object, $sourceName)) {
$reflectionSource = new ReflectionProperty($object, $sourceName);
$dataPath = $this->grabDataPath($reflectionSource, $tags);
}
return $dataPath ?? $sourceName;
}
/**
* Получаем теги для обработки
*/
protected function processTags(object $object, array $tags): array
{
$classExtractor = new ClassExtractor($object::class);
/** @var HandleTags $tagsMeta */
if ($tagsMeta = $classExtractor->fetch(HandleTags::class)) {
if (method_exists($object, $tagsMeta->method)) {
$reflectionMethod = new ReflectionMethod($object, $tagsMeta->method);
if (!$reflectionMethod->isPublic()) {
$reflectionMethod->setAccessible(true);
}
$methodTags = $reflectionMethod->invoke($object, ...[$tags]);
if (!$reflectionMethod->isPublic()) {
$reflectionMethod->setAccessible(false);
}
return $methodTags;
}
}
return $tags;
} }
/** /**
* Трнансформируем на уровне класса * @return Meta[]
*/ */
protected function processClassTransformers(\ReflectionObject $object, &$data, array $tags): void private function grabTransformMetas(mixed $data, string $propertyPath): array
{
$className = $object->getName();
$classExtractor = new ClassExtractor($className);
/** @var Meta $transformMeta */
while ($transformMeta = $classExtractor->fetch(Meta::class)) {
$transformMeta->returnType = $className;
$filteredTags = array_diff($tags, $transformMeta->tags);
if (count($filteredTags) === count($tags)) {
continue;
}
$transformer = $this->grabTransformer($transformMeta);
$transformer->transform($data, $transformMeta);
}
}
/**
* Трнансформируем на уровне свойст объекта
*/
protected function processTransformers(\ReflectionProperty $property, &$data, array $tags): void
{
$propertyName = $property->getName();
$propertyExtractor = new PropertyExtractor($property->class, $propertyName);
/** @var Meta $transformMeta */
while ($transformMeta = $propertyExtractor->fetch(Meta::class)) {
$filteredTags = array_diff($tags, $transformMeta->tags);
if (count($filteredTags) === count($tags)) {
continue;
}
/** @var \ReflectionNamedType $reflectionPropertyType */
$reflectionPropertyType = $property->getType();
$propertyType = $reflectionPropertyType->getName();
$transformMeta->returnType = $propertyType;
$transformMeta->allowsNull = $reflectionPropertyType->allowsNull();
$transformer = $this->grabTransformer($transformMeta);
$transformer->transform($data, $transformMeta);
}
}
protected function processMethodTransformers(ReflectionMethod $method, &$data, array $tags): void
{
$methodName = $method->getName();
$methodExtractor = new MethodExtractor($method->class, $methodName);
/** @var Meta $transformMeta */
while ($transformMeta = $methodExtractor->fetch(Meta::class)) {
$filteredTags = array_diff($tags, $transformMeta->tags);
if (count($filteredTags) === count($tags)) {
continue;
}
/** @var \ReflectionNamedType $reflectionMethodType */
$reflectionMethodType = $method->getReturnType();
$methodType = $reflectionMethodType->getName();
$transformMeta->returnType = $methodType;
$transformMeta->allowsNull = $reflectionMethodType->allowsNull();
$transformer = $this->grabTransformer($transformMeta);
$transformer->transform($data, $transformMeta);
}
}
protected function grabTransformer(Meta $meta): TransformerInterface
{
$storage = TransformerResolverStorage::getInstance();
$resolver = $storage->get($meta::TYPE);
return $resolver->resolve($meta);
}
private function getValueByPath($data, string $path)
{
$parts = explode('.', $path);
$length = count($parts);
$i = 1;
foreach ($parts as $part) {
// Если получили скалярное значение но прошли не весь путь, то вернем null
if (is_scalar($data) && $i < $length) {
return null;
}
// Если объекс реализует ArrayAccess, то получаем значение и идем дальше
if (is_object($data) && $data instanceof \ArrayAccess) {
$data = $data[$part] ?? null;
continue;
}
// Если объект, то достаем значение
if (is_object($data)) {
if (!property_exists($data, $part)) {
return null;
}
$property = new ReflectionProperty($data, $part);
$data = $this->getValue($data, $property);
continue;
}
// Если массив, то достаем занчение и идем дальше
if (is_array($data)) {
$data = $data[$part] ?? null;
continue;
}
$i++;
}
return $data;
}
private function getValue(object $object, \ReflectionProperty $property)
{
if (!$property->isPublic()) {
$property->setAccessible(true);
}
if (!$property->isInitialized($object)) {
return null;
}
$value = $property->getValue($object);
if (!$property->isPublic()) {
$property->setAccessible(false);
}
return $value;
}
private function getMethodValue(object $object, ReflectionMethod $method)
{ {
if (!$method->isPublic()) { $result = [];
$method->setAccessible(true); $propertyName = $propertyPath;
$propertyPathParts = explode('.', $propertyPath);
if (count($propertyPathParts) > 1) {
$propertyName = array_shift($propertyPathParts);
$pathToObject = implode('.', $propertyPathParts);
$object = $this->grabValue($data, $pathToObject);
if (!is_object($object)) {
return [];
} }
$value = $method->invoke($object);
if (!$method->isPublic()) {
$method->setAccessible(false);
} }
return $value; if (!is_object($data)) {
return [];
} }
private function grabSchema(object $object, array $tags): ?Schema if (property_exists($data, $propertyName)) {
{ $reflectionProperty = new ReflectionProperty($data, $propertyName);
$classExtractor = new ClassExtractor($object::class); $methodExtractor = new PropertyExtractor($reflectionProperty->class, $propertyName);
/** @var Schema $schema */ while ($meta = $methodExtractor->fetch(Meta::class)) {
while ($schema = $classExtractor->fetch(Schema::class)) { $result[] = $meta;
$filteredTags = array_diff($tags, $schema->tags);
if (count($filteredTags) === count($tags)) {
continue;
} }
return $schema; if ($result) {
return $result;
} }
return null;
} }
private function grabDataPath(\ReflectionProperty $property, array $tags): ?string foreach (['get', 'has', 'is'] as $prefix) {
{ $methodName = $prefix . ucfirst($propertyName);
$propertyName = $property->getName(); if (method_exists($data, $methodName)) {
$propertyExtractor = new PropertyExtractor($property->class, $propertyName); $reflectionMethod = new \ReflectionMethod($data, $methodName);
/** @var DataPath $schema */ $methodExtractor = new MethodExtractor($reflectionMethod->class, $methodName);
while ($dataPath = $propertyExtractor->fetch(DataPath::class)) { while ($meta = $methodExtractor->fetch(Meta::class)) {
$filteredTags = array_diff($tags, $dataPath->tags); $result[] = $meta;
if (count($filteredTags) === count($tags)) {
continue;
} }
return $dataPath->path;
} }
if ($result) {
return null; return $result;
}
private function grabMethodDataPath(ReflectionMethod $method, array $tags): ?string
{
$methodName = $method->getName();
$methodExtractor = new MethodExtractor($method->class, $methodName);
/** @var DataPath $schema */
while ($dataPath = $methodExtractor->fetch(DataPath::class)) {
$filteredTags = array_diff($tags, $dataPath->tags);
if (count($filteredTags) === count($tags)) {
continue;
} }
return $dataPath->path;
} }
return null; return [];
} }
} }

@ -1,16 +0,0 @@
<?php
namespace Rinsvent\DTO2Data\Resolver;
use Rinsvent\DTO2Data\Transformer\Meta;
use Rinsvent\DTO2Data\Transformer\TransformerInterface;
class SimpleResolver implements TransformerResolverInterface
{
public function resolve(Meta $meta): TransformerInterface
{
$metaClass = $meta::class;
$transformerClass = $metaClass . 'Transformer';
return new $transformerClass;
}
}

@ -1,11 +0,0 @@
<?php
namespace Rinsvent\DTO2Data\Resolver;
use Rinsvent\DTO2Data\Transformer\Meta;
use Rinsvent\DTO2Data\Transformer\TransformerInterface;
interface TransformerResolverInterface
{
public function resolve(Meta $meta): TransformerInterface;
}

@ -1,32 +0,0 @@
<?php
namespace Rinsvent\DTO2Data\Resolver;
class TransformerResolverStorage
{
private array $items = [];
public static function getInstance(): self
{
static $instance = null;
if ($instance) {
return $instance;
}
$instance = new self();
$instance->add('simple', new SimpleResolver());
return $instance;
}
public function add(string $code, TransformerResolverInterface $transformerResolver): void
{
$this->items[$code] = $transformerResolver;
}
public function get(string $code): TransformerResolverInterface
{
return $this->items[$code];
}
}

@ -1,14 +0,0 @@
<?php
namespace Rinsvent\DTO2Data\Transformer;
#[\Attribute(\Attribute::TARGET_ALL|\Attribute::IS_REPEATABLE)]
class DateTimeFormat extends Meta
{
public function __construct(
public array $tags = ['default'],
public string $format = \DateTimeInterface::ATOM
) {
parent::__construct(...func_get_args());
}
}

@ -1,18 +0,0 @@
<?php
namespace Rinsvent\DTO2Data\Transformer;
class DateTimeFormatTransformer implements TransformerInterface
{
/**
* @param \DateTimeImmutable|\DateTime|null $data
* @param DateTimeFormat $meta
*/
public function transform(&$data, Meta $meta): void
{
if ($data === null) {
return;
}
$data = $data->format($meta->format);
}
}

@ -1,15 +0,0 @@
<?php
namespace Rinsvent\DTO2Data\Transformer;
#[\Attribute(\Attribute::TARGET_ALL|\Attribute::IS_REPEATABLE)]
abstract class Meta
{
public const TYPE = 'simple';
public ?string $returnType = null;
public ?bool $allowsNull = null;
public function __construct(
public array $tags = ['default']
) {}
}

@ -1,8 +0,0 @@
<?php
namespace Rinsvent\DTO2Data\Transformer;
interface TransformerInterface
{
public function transform(&$data, Meta $meta): void;
}

@ -1,14 +0,0 @@
<?php
namespace Rinsvent\DTO2Data\Transformer;
#[\Attribute(\Attribute::TARGET_ALL|\Attribute::IS_REPEATABLE)]
class Trim extends Meta
{
public function __construct(
public array $tags = ['default'],
public string $characters = " \t\n\r\0\x0B"
) {
parent::__construct(...func_get_args());
}
}

@ -1,18 +0,0 @@
<?php
namespace Rinsvent\DTO2Data\Transformer;
class TrimTransformer implements TransformerInterface
{
/**
* @param string|null $data
* @param Trim $meta
*/
public function transform(&$data, Meta $meta): void
{
if ($data === null) {
return;
}
$data = trim($data, $meta->characters);
}
}

@ -9,6 +9,7 @@ use Rinsvent\DTO2Data\Tests\unit\Converter\fixtures\FillTest\BuyRequest;
use Rinsvent\DTO2Data\Tests\unit\Converter\fixtures\FillTest\Collection; use Rinsvent\DTO2Data\Tests\unit\Converter\fixtures\FillTest\Collection;
use Rinsvent\DTO2Data\Tests\unit\Converter\fixtures\FillTest\CollectionItem; use Rinsvent\DTO2Data\Tests\unit\Converter\fixtures\FillTest\CollectionItem;
use Rinsvent\DTO2Data\Tests\unit\Converter\fixtures\FillTest\HelloRequest; use Rinsvent\DTO2Data\Tests\unit\Converter\fixtures\FillTest\HelloRequest;
use Rinsvent\DTO2Data\Tests\unit\Converter\fixtures\FillTest\HelloSchema;
use Rinsvent\DTO2Data\Tests\unit\Converter\fixtures\FillTest\UUID; use Rinsvent\DTO2Data\Tests\unit\Converter\fixtures\FillTest\UUID;
class FillTest extends \Codeception\Test\Unit class FillTest extends \Codeception\Test\Unit
@ -18,14 +19,6 @@ class FillTest extends \Codeception\Test\Unit
*/ */
protected $tester; protected $tester;
protected function _before()
{
}
protected function _after()
{
}
// tests // tests
public function testSuccessFillRequestData() public function testSuccessFillRequestData()
{ {
@ -80,7 +73,42 @@ class FillTest extends \Codeception\Test\Unit
$helloRequest->collection = $collection; $helloRequest->collection = $collection;
$helloRequest->createdAt = new \DateTimeImmutable('2020-05-21 13:36:22'); $helloRequest->createdAt = new \DateTimeImmutable('2020-05-21 13:36:22');
$dto = $dto2DataConverter->convert($helloRequest); // private
$helloRequest->setPsurname(' asdf');
$helloRequest->setPage(3);
$helloRequest->setPemails([
'sfdgsa',
'af234f',
'asdf33333'
]);
$helloRequest->setPauthors([
$author1,
$author2
]);
$helloRequest->setPauthors2([
[
"name" => "Tolkien"
],
[
"name" => "Sapkovsky"
]
]);
$helloRequest->setPauthors3([
[
"name" => "Tolkien"
],
[
"name" => "Sapkovsky"
]
]);
$helloRequest->setPbuy($buy);
$helloRequest->setPbar($bar);
$helloRequest->setPuuid(new UUID('qwerqw-qwerqwe-werqw-qwerqw'));
$helloRequest->setPcollection($collection);
$helloRequest->setPcreatedAt(new \DateTimeImmutable('2020-05-21 13:36:22'));
$dto = $dto2DataConverter->convert($helloRequest, HelloSchema::class);
// codecept_debug(json_encode($dto)); // codecept_debug(json_encode($dto));
$this->assertEquals([ $this->assertEquals([
@ -107,7 +135,14 @@ class FillTest extends \Codeception\Test\Unit
"name" => "Sapkovsky" "name" => "Sapkovsky"
] ]
], ],
"authors3" => [], "authors3" => [
[
"name" => "Tolkien"
],
[
"name" => "Sapkovsky"
]
],
"buy" => [ "buy" => [
"phrase" => "Buy buy!!!", "phrase" => "Buy buy!!!",
"length" => 10, "length" => 10,
@ -128,7 +163,62 @@ class FillTest extends \Codeception\Test\Unit
'value' => '2', 'value' => '2',
], ],
], ],
'createdAt' => '2020-05-21T13:36:22+00:00' 'createdAt' => '2020-05-21T13:36:22+00:00',
"psurname" => "asdf",
"pfake_age" => 3,
"pemails" => [
"sfdgsa",
"af234f",
"asdf33333"
],
"pauthors" => [
[
"name" => "Tolkien"
],
[
"name" => "Sapkovsky"
]
],
"pauthors2" => [
[
"name" => "Tolkien"
],
[
"name" => "Sapkovsky"
]
],
"pauthors3" => [
[
"name" => "Tolkien"
],
[
"name" => "Sapkovsky"
]
],
"pbuy" => [
"phrase" => "Buy buy!!!",
"length" => 10,
"isFirst" => true
],
"pbar" => [
"barField" => 32
],
'puuid' => 'qwerqw-qwerqwe-werqw-qwerqw',
'pcollection' => [
[
'value' => '3',
],
[
'value' => '1',
],
[
'value' => '2',
],
],
'pcreatedAt' => '2020-05-21T13:36:22+00:00',
'fake_Pdevdo' => 'getPdevdo',
], $dto); ], $dto);
} }
} }

@ -1,39 +0,0 @@
<?php
namespace Rinsvent\DTO2Data\Tests\Converter;
use Rinsvent\DTO2Data\Dto2DataConverter;
use Rinsvent\DTO2Data\Tests\unit\Converter\fixtures\FillTest\HelloTagsRequest;
class TagsTest extends \Codeception\Test\Unit
{
/**
* @var \UnitTester
*/
protected $tester;
protected function _before()
{
}
protected function _after()
{
}
// tests
public function testSuccessFillRequestData()
{
$dto2DataConverter = new Dto2DataConverter();
$helloTagsRequest = new HelloTagsRequest();
$helloTagsRequest->surname = ' Surname1234';
$helloTagsRequest->age = 3;
$helloTagsRequest->emails = [
'sfdgsa',
'af234f',
'asdf33333'
];
$tags = $dto2DataConverter->getTags($helloTagsRequest);
$this->assertEquals(['surname-group'], $tags);
}
}

@ -2,17 +2,16 @@
namespace Rinsvent\DTO2Data\Tests\unit\Converter\fixtures\FillTest; namespace Rinsvent\DTO2Data\Tests\unit\Converter\fixtures\FillTest;
use Rinsvent\DTO2Data\Attribute\DataPath;
use Rinsvent\DTO2Data\Attribute\PropertyPath; use Rinsvent\DTO2Data\Attribute\PropertyPath;
use Rinsvent\DTO2Data\Transformer\DateTimeFormat; use Rinsvent\Transformer\Transformer\DateTimeFormat;
use Rinsvent\DTO2Data\Transformer\Trim; use Rinsvent\Transformer\Transformer\ToString;
use Rinsvent\Transformer\Transformer\Trim;
#[HelloSchema] #[HelloSchema]
class HelloRequest class HelloRequest
{ {
#[Trim] #[Trim]
public string $surname; public string $surname;
#[DataPath('fake_age')]
public int $age; public int $age;
public array $emails; public array $emails;
public array $authors; public array $authors;
@ -20,9 +19,151 @@ class HelloRequest
public array $authors3; public array $authors3;
public BuyRequest $buy; public BuyRequest $buy;
public BarInterface $bar; public BarInterface $bar;
#[PropertyPath(path: 'uuid.id')] #[ToString()]
public UUID $uuid; public UUID $uuid;
public Collection $collection; public Collection $collection;
#[DateTimeFormat] #[DateTimeFormat]
public \DateTimeImmutable $createdAt; public \DateTimeImmutable $createdAt;
#[Trim]
private string $psurname;
private int $page;
private array $pemails;
private array $pauthors;
private array $pauthors2;
private array $pauthors3;
private BuyRequest $pbuy;
private BarInterface $pbar;
#[ToString()]
private UUID $puuid;
private Collection $pcollection;
#[DateTimeFormat]
private \DateTimeImmutable $pcreatedAt;
public function getPsurname(): string
{
return $this->psurname;
}
public function setPsurname(string $psurname): self
{
$this->psurname = $psurname;
return $this;
}
public function getPage(): int
{
return $this->page;
}
public function setPage(int $page): self
{
$this->page = $page;
return $this;
}
public function getPemails(): array
{
return $this->pemails;
}
public function setPemails(array $pemails): self
{
$this->pemails = $pemails;
return $this;
}
public function getPauthors(): array
{
return $this->pauthors;
}
public function setPauthors(array $pauthors): self
{
$this->pauthors = $pauthors;
return $this;
}
public function getPauthors2(): array
{
return $this->pauthors2;
}
public function setPauthors2(array $pauthors2): self
{
$this->pauthors2 = $pauthors2;
return $this;
}
public function getPauthors3(): array
{
return $this->pauthors3;
}
public function setPauthors3(array $pauthors3): self
{
$this->pauthors3 = $pauthors3;
return $this;
}
public function getPbuy(): BuyRequest
{
return $this->pbuy;
}
public function setPbuy(BuyRequest $pbuy): self
{
$this->pbuy = $pbuy;
return $this;
}
public function getPuuid(): UUID
{
return $this->puuid;
}
public function setPuuid(UUID $puuid): self
{
$this->puuid = $puuid;
return $this;
}
public function getPbar(): BarInterface
{
return $this->pbar;
}
public function setPbar(BarInterface $pbar): self
{
$this->pbar = $pbar;
return $this;
}
public function getPcollection(): Collection
{
return $this->pcollection;
}
public function setPcollection(Collection $pcollection): self
{
$this->pcollection = $pcollection;
return $this;
}
public function getPcreatedAt(): \DateTimeImmutable
{
return $this->pcreatedAt;
}
public function setPcreatedAt(\DateTimeImmutable $pcreatedAt): self
{
$this->pcreatedAt = $pcreatedAt;
return $this;
}
#[Trim]
public function getPdevdo(): string
{
return ' getPdevdo';
}
} }

@ -7,9 +7,9 @@ use Rinsvent\DTO2Data\Attribute\Schema;
#[\Attribute(\Attribute::TARGET_ALL|\Attribute::IS_REPEATABLE)] #[\Attribute(\Attribute::TARGET_ALL|\Attribute::IS_REPEATABLE)]
class HelloSchema extends Schema class HelloSchema extends Schema
{ {
public ?array $baseMap = [ protected array $baseMap = [
'surname', 'surname',
'age', 'fake_age' => 'age',
'emails', 'emails',
'authors' => [ 'authors' => [
'name', 'name',
@ -30,6 +30,32 @@ class HelloSchema extends Schema
'collection' => [ 'collection' => [
'value' 'value'
], ],
'createdAt' 'createdAt',
'psurname',
'pfake_age' => 'page',
'pemails',
'pauthors' => [
'name',
],
'pauthors2' => [
'name',
],
'pauthors3',
'pbuy' => [
'phrase',
'length',
'isFirst',
],
'pbar' => [
'barField'
],
'puuid',
'pcollection' => [
'value'
],
'pcreatedAt',
'fake_Pdevdo' => 'pdevdo'
]; ];
} }

@ -1,18 +0,0 @@
<?php
namespace Rinsvent\DTO2Data\Tests\unit\Converter\fixtures\FillTest;
use Rinsvent\DTO2Data\Attribute\DataPath;
use Rinsvent\DTO2Data\Attribute\HandleTags;
#[HandleTags(method: 'getTags')]
class HelloTagsRequest extends HelloRequest
{
#[DataPath('fake_age2', tags: ['surname-group'])]
public int $age;
public function getTags(array $tags)
{
return 'Surname1234' === trim(($this->surname ?? '')) ? ['surname-group'] : $tags;
}
}

@ -2,7 +2,7 @@
namespace Rinsvent\DTO2Data\Tests\unit\Converter\fixtures\FillTest\Transformer; namespace Rinsvent\DTO2Data\Tests\unit\Converter\fixtures\FillTest\Transformer;
use Rinsvent\DTO2Data\Transformer\Meta; use Rinsvent\Transformer\Transformer\Meta;
#[\Attribute] #[\Attribute]
class ClassData extends Meta class ClassData extends Meta

@ -2,8 +2,8 @@
namespace Rinsvent\DTO2Data\Tests\unit\Converter\fixtures\FillTest\Transformer; namespace Rinsvent\DTO2Data\Tests\unit\Converter\fixtures\FillTest\Transformer;
use Rinsvent\DTO2Data\Transformer\Meta; use Rinsvent\Transformer\Transformer\Meta;
use Rinsvent\DTO2Data\Transformer\TransformerInterface; use Rinsvent\Transformer\Transformer\TransformerInterface;
class ClassDataTransformer implements TransformerInterface class ClassDataTransformer implements TransformerInterface
{ {
@ -11,14 +11,15 @@ class ClassDataTransformer implements TransformerInterface
* @param array|null $data * @param array|null $data
* @param ClassData $meta * @param ClassData $meta
*/ */
public function transform(&$data, Meta $meta): void public function transform(mixed $data, Meta $meta): mixed
{ {
if ($data === null) { if ($data === null) {
return; return $data;
} }
if (isset($data['surname'])) { if (isset($data['surname'])) {
$data['surname'] = '123454321'; $data['surname'] = '123454321';
} }
return $data;
} }
} }

@ -2,7 +2,7 @@
namespace Rinsvent\DTO2Data\Tests\unit\Converter\fixtures\FillTest\Transformer; namespace Rinsvent\DTO2Data\Tests\unit\Converter\fixtures\FillTest\Transformer;
use Rinsvent\DTO2Data\Transformer\Meta; use Rinsvent\Transformer\Transformer\Meta;
#[\Attribute] #[\Attribute]
class ClassObject extends Meta class ClassObject extends Meta

@ -3,8 +3,8 @@
namespace Rinsvent\DTO2Data\Tests\unit\Converter\fixtures\FillTest\Transformer; namespace Rinsvent\DTO2Data\Tests\unit\Converter\fixtures\FillTest\Transformer;
use Rinsvent\DTO2Data\Tests\unit\Converter\fixtures\FillTest\HelloClassTransformersRequest2; use Rinsvent\DTO2Data\Tests\unit\Converter\fixtures\FillTest\HelloClassTransformersRequest2;
use Rinsvent\DTO2Data\Transformer\Meta; use Rinsvent\Transformer\Transformer\Meta;
use Rinsvent\DTO2Data\Transformer\TransformerInterface; use Rinsvent\Transformer\Transformer\TransformerInterface;
class ClassObjectTransformer implements TransformerInterface class ClassObjectTransformer implements TransformerInterface
{ {
@ -12,13 +12,14 @@ class ClassObjectTransformer implements TransformerInterface
* @param array|null $data * @param array|null $data
* @param ClassData $meta * @param ClassData $meta
*/ */
public function transform(&$data, Meta $meta): void public function transform(mixed $data, Meta $meta): mixed
{ {
if ($data === null) { if ($data === null) {
return; return $data;
} }
$object = new HelloClassTransformersRequest2(); $object = new HelloClassTransformersRequest2();
$object->surname = '98789'; $object->surname = '98789';
$data = $object; $data = $object;
return $data;
} }
} }

@ -11,4 +11,9 @@ class UUID
{ {
$this->id = $id; $this->id = $id;
} }
public function __toString(): string
{
return $this->id;
}
} }

Loading…
Cancel
Save