feature: поправил зависимости

расширил тест

Readme.md

@@ -49,32 +49,32 @@ class HelloRequest
 use Rinsvent\Data2DTO\Data2DtoConverter;
 
 $data2DtoConverter = new Data2DtoConverter();
-        $dto = $data2DtoConverter->convert([
-            'surname' => '   asdf',
-            'fake_age' => 3,
-            'emails' => [
-                'sfdgsa',
-                'af234f',
-                'asdf33333'
-            ],
-            'authors' => [
-                [
-                    'name' => 'Tolkien',
-                ],
-                [
-                    'name' => 'Sapkovsky'
-                ]
-            ],
-            'buy' => [
-                'phrase' => 'Buy buy!!!',
-                'length' => 10,
-                'isFirst' => true,
-                'extraData2' => '1234'
-            ],
-            'bar' => [
-                'barField' => 32
-            ],
-            'extraData1' => 'qwer'
-        ], HelloRequest::class);
+$dto = $data2DtoConverter->convert([
+    'surname' => '   asdf',
+    'fake_age' => 3,
+    'emails' => [
+        'sfdgsa',
+        'af234f',
+        'asdf33333'
+    ],
+    'authors' => [
+        [
+            'name' => 'Tolkien',
+        ],
+        [
+            'name' => 'Sapkovsky'
+        ]
+    ],
+    'buy' => [
+        'phrase' => 'Buy buy!!!',
+        'length' => 10,
+        'isFirst' => true,
+        'extraData2' => '1234'
+    ],
+    'bar' => [
+        'barField' => 32
+    ],
+    'extraData1' => 'qwer'
+], new HelloRequest);
 ```
 

composer.json

@@ -1,15 +1,15 @@
 {
     "name": "rinsvent/data2dto",
     "description": "Convert data to dto object",
-    "type": "project",
-    "license": "proprietary",
+    "license": "MIT",
     "require": {
         "php": "^8.0",
         "ext-ctype": "*",
         "ext-iconv": "*",
         "ext-json": "*",
         "symfony/string": "^5.3",
-        "rinsvent/attribute-extractor": "^0.0"
+        "rinsvent/attribute-extractor": "^0.0",
+        "rinsvent/transformer": "^0."
     },
     "require-dev": {
         "codeception/codeception": "^4.1",

src/Attribute/DTOMeta.php

@@ -2,10 +2,12 @@
 
 namespace Rinsvent\Data2DTO\Attribute;
 
-#[\Attribute]
+#[\Attribute(\Attribute::IS_REPEATABLE|\Attribute::TARGET_ALL)]
 class DTOMeta
 {
     public function __construct(
-        public string $class
+        public string $class,
+        /** @var string[] $tags */
+        public array $tags = ['default']
     ) {}
-}
+}

src/Attribute/HandleTags.php

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

src/Attribute/PropertyPath.php

@@ -2,10 +2,12 @@
 
 namespace Rinsvent\Data2DTO\Attribute;
 
-#[\Attribute]
+#[\Attribute(\Attribute::IS_REPEATABLE|\Attribute::TARGET_ALL)]
 class PropertyPath
 {
     public function __construct(
-        public string $path
+        public string $path,
+        /** @var string[] $tags */
+        public array $tags = ['default']
     ) {}
-}
+}

src/Attribute/VirtualProperty.php

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

src/Data2DtoConverter.php

@@ -2,85 +2,188 @@
 
 namespace Rinsvent\Data2DTO;
 
+use ReflectionProperty;
+use Rinsvent\AttributeExtractor\ClassExtractor;
 use Rinsvent\AttributeExtractor\PropertyExtractor;
 use Rinsvent\Data2DTO\Attribute\DTOMeta;
 use Rinsvent\Data2DTO\Attribute\PropertyPath;
-use Rinsvent\Data2DTO\Resolver\TransformerResolverStorage;
-use Rinsvent\Data2DTO\Transformer\Meta;
-use Rinsvent\Data2DTO\Transformer\TransformerInterface;
+use Rinsvent\Data2DTO\Attribute\HandleTags;
+use Rinsvent\Data2DTO\Attribute\VirtualProperty;
+use Rinsvent\Transformer\Transformer;
+use Rinsvent\Transformer\Transformer\Meta;
 use function Symfony\Component\String\u;
 
 class Data2DtoConverter
 {
-    public function convert(array $data, string $class): object
-    {
-        $object = new $class;
+    private Transformer $transformer;
 
+    public function __construct()
+    {
+        $this->transformer = new Transformer();
+    }
+
+    public function getTags(array $data, object $object, array $tags = []): array
+    {
+        return $this->processTags($object, $data, $tags);
+    }
+
+    public function convert(array $data, object $object, array $tags = []): object
+    {
+        $tags = empty($tags) ? ['default'] : $tags;
         $reflectionObject = new \ReflectionObject($object);
+
+        $this->processClassTransformers($reflectionObject, $data, $tags);
+        if (is_object($data)) {
+            return $data;
+        }
+
         $properties = $reflectionObject->getProperties();
         /** @var \ReflectionProperty $property */
         foreach ($properties as $property) {
+            // todo добавить атрибут на пропуск обработки и еще атрибут на допустимые поля
+
             /** @var \ReflectionNamedType $reflectionPropertyType */
             $reflectionPropertyType = $property->getType();
             $propertyType = $reflectionPropertyType->getName();
 
-            if ($dataPath = $this->grabDataPath($property, $data)) {
-                $value = $data[$dataPath];
-                // Трансформируем данные
-                $this->processTransformers($property, $value);
-
-                if ($this->checkNullRule($value, $reflectionPropertyType)) {
-                    continue;
-                }
-                // В данных лежит объект, то дальше его не заполняем. Только присваиваем. Например, entity, document
-                if (is_object($value)) {
-                    $property->setValue($object, $value);
-                    continue;
-                }
-
-                if (!$this->transformArray($value, $property)) {
-                    continue;
-                }
-
-                $preparedPropertyType = $propertyType;
-
-                if (interface_exists($preparedPropertyType)) {
-                    $attributedPropertyClass = $this->grabPropertyDTOClass($property);
-                    // Если не указали мета информацию для интерфейса - пропустим
-                    if (!$attributedPropertyClass) {
-                        continue;
-                    }
-                    // Если класс не реализует интерфейс свойства - пропустим
-                    $interfaces = class_implements($attributedPropertyClass);
-                    if (!isset($interfaces[$preparedPropertyType])) {
-                        continue;
-                    }
-                    $preparedPropertyType = $attributedPropertyClass;
-                }
-
-                // Если это class, то рекурсивно заполняем дальше
-                if (class_exists($preparedPropertyType)) {
-                    $value = $this->convert($value, $preparedPropertyType);
-                }
-
-                // присваиваем получившееся значение
-                $property->setValue($object, $value);
+            if ($this->processVirtualProperty($object, $property, $data, $tags)) {
+                continue;
             }
+
+            $value = $this->grabValue($property, $data, $tags);
+
+            $this->processTransformers($property, $value, $tags);
+
+            if ($this->processDataObject($object, $property, $value)) {
+                continue;
+            }
+
+            if ($this->processArray($property, $value, $tags)) {
+                continue;
+            }
+
+            $preparedPropertyType = $propertyType;
+            if ($this->processInterface($property, $preparedPropertyType)) {
+                continue;
+            }
+
+            if ($this->processClass($object, $property, $preparedPropertyType, $value, $tags)) {
+                continue;
+            }
+
+            if ($this->processNull($reflectionPropertyType, $value)) {
+                continue;
+            }
+
+            $this->setValue($object, $property, $value);
         }
 
         return $object;
     }
 
-    protected function grabDataPath(\ReflectionProperty $property, array $data): ?string
+    /**
+     * Для виртуальных полей добавляем пустой масиив, чтобы заполнить поля дто
+     */
+    protected function processVirtualProperty(
+        object $object,
+        \ReflectionProperty $property,
+        array $data,
+        array $tags
+    ): bool {
+        $propertyExtractor = new PropertyExtractor($property->class, $property->getName());
+        if ($propertyExtractor->fetch(VirtualProperty::class)) {
+            $propertyValue = $this->getValue($object, $property);
+            if ($property->isInitialized($object) && $propertyValue) {
+                $value = $this->convert($data, $propertyValue, $tags);
+            } else {
+                $propertyType = $property->getType()->getName();
+                $value = $this->convert($data, new $propertyType, $tags);
+            }
+            // присваиваем получившееся значение
+            $this->setValue($object, $property, $value);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * В данных лежит объект, то дальше его не заполняем. Только присваиваем. Например, entity, document
+     */
+    protected function processDataObject(object $object, \ReflectionProperty $property, $value): bool
+    {
+        if (is_object($value)) {
+            $this->setValue($object, $property, $value);
+            return true;
+        }
+        return false;
+    }
+
+    protected function processInterface(ReflectionProperty $property, &$preparedPropertyType): bool
+    {
+        if (interface_exists($preparedPropertyType)) {
+            $attributedPropertyClass = $this->grabPropertyDTOClass($property);
+            // Если не указали мета информацию для интерфейса - пропустим
+            if (!$attributedPropertyClass) {
+                return true;
+            }
+            // Если класс не реализует интерфейс свойства - пропустим
+            $interfaces = class_implements($attributedPropertyClass);
+            if (!isset($interfaces[$preparedPropertyType])) {
+                return true;
+            }
+            $preparedPropertyType = $attributedPropertyClass;
+        }
+        return false;
+    }
+
+    /**
+     * Если это class, то рекурсивно заполняем дальше
+     */
+    protected function processClass(
+        object $object,
+        ReflectionProperty $property,
+        string $preparedPropertyType,
+        &$value,
+        array $tags
+    ): bool {
+        if (class_exists($preparedPropertyType)) {
+            $propertyValue = $this->getValue($object, $property);
+            if (!is_array($value)) {
+                return true;
+            }
+            if ($property->isInitialized($object) && $propertyValue) {
+                $value = $this->convert($value, $propertyValue, $tags);
+            } else {
+                $value = $this->convert($value, new $preparedPropertyType, $tags);
+            }
+        }
+        return false;
+    }
+
+    protected function grabValue(\ReflectionProperty $property, array $data, array $tags)
+    {
+        if ($dataPath = $this->grabDataPath($property, $data, $tags)) {
+            return $data[$dataPath] ?? null;
+        }
+
+        return null;
+    }
+
+    protected function grabDataPath(\ReflectionProperty $property, array $data, array $tags): ?string
     {
         $propertyName = $property->getName();
         $propertyExtractor = new PropertyExtractor($property->class, $propertyName);
         /** @var PropertyPath $propertyPath */
         if ($propertyPath = $propertyExtractor->fetch(PropertyPath::class)) {
-            return $propertyPath->path;
+            $filteredTags = array_diff($tags, $propertyPath->tags);
+            if (count($filteredTags) !== count($tags)) {
+                if (array_key_exists($propertyPath->path, $data)) {
+                    return $propertyPath->path;
+                }
+            }
         }
 
-        if (key_exists($propertyName, $data)) {
+        if (array_key_exists($propertyName, $data)) {
             return $propertyName;
         }
 
@@ -90,7 +193,7 @@ class Data2DtoConverter
             u($propertyName)->snake()->upper()->toString(),
         ];
         foreach ($variants as $variant) {
-            if (key_exists($variant, $data)) {
+            if (array_key_exists($variant, $data)) {
                 return $variant;
             }
         }
@@ -98,33 +201,71 @@ class Data2DtoConverter
         return null;
     }
 
-    protected function processTransformers(\ReflectionProperty $property, &$data): void
+    /**
+     * Получаем теги для обработки
+     */
+    protected function processTags(object $object, array $data, 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, ...[$data, $tags]);
+                if (!$reflectionMethod->isPublic()) {
+                    $reflectionMethod->setAccessible(false);
+                }
+                return $methodTags;
+            }
+        }
+
+        return $tags;
+    }
+
+    /**
+     * Трнансформируем на уровне класса
+     */
+    protected function processClassTransformers(\ReflectionObject $object, &$data, array $tags): void
+    {
+        $className = $object->getName();
+        $classExtractor = new ClassExtractor($className);
+        /** @var Meta $transformMeta */
+        while ($transformMeta = $classExtractor->fetch(Meta::class)) {
+            $transformMeta->returnType = $className;
+            $data = $this->transformer->transform($data, $transformMeta, $tags);
+        }
+    }
+
+    /**
+     * Трнансформируем на уровне свойст объекта
+     */
+    protected function processTransformers(\ReflectionProperty $property, &$data, array $tags): void
     {
         $propertyName = $property->getName();
         $propertyExtractor = new PropertyExtractor($property->class, $propertyName);
         /** @var Meta $transformMeta */
-        if ($transformMeta = $propertyExtractor->fetch(Meta::class)) {
-            $transformer = $this->grabTransformer($transformMeta);
-            $transformer->transform($data, $transformMeta);
+        while ($transformMeta = $propertyExtractor->fetch(Meta::class)) {
+            /** @var \ReflectionNamedType $reflectionPropertyType */
+            $reflectionPropertyType = $property->getType();
+            $propertyType = $reflectionPropertyType->getName();
+            $transformMeta->retrnType = $propertyType;
+            $transformMeta->allowsNull = $reflectionPropertyType->allowsNull();
+            $data = $this->transformer->transform($data, $transformMeta, $tags);
         }
     }
 
-    protected function grabTransformer(Meta $meta): TransformerInterface
-    {
-        $storage = TransformerResolverStorage::getInstance();
-        $resolver = $storage->get($meta::TYPE);
-        return $resolver->resolve($meta);
-    }
-
     /**
      * Если значение в $data = null, но поле не может его принять - пропустим
      */
-    private function checkNullRule($value, \ReflectionNamedType $reflectionPropertyType): bool
+    private function processNull(\ReflectionNamedType $reflectionPropertyType, $value): bool
     {
         return $value === null && !$reflectionPropertyType->allowsNull();
     }
 
-    private function transformArray(&$value, \ReflectionProperty $property): bool
+    private function processArray(\ReflectionProperty $property, &$value, array $tags): bool
     {
         $attributedPropertyClass = $this->grabPropertyDTOClass($property);
 
@@ -136,26 +277,63 @@ class Data2DtoConverter
         if ($propertyType === 'array' && $attributedPropertyClass) {
             // Если тип у ДТО - массив, а в значении не массив - пропустим
             if (!is_array($value)) {
-                return false;
+                return true;
             }
             $tempValue = [];
             foreach ($value as $itemValue) {
-                $tempValue[] = $this->convert($itemValue, $attributedPropertyClass);
+                if (!is_array($itemValue)) {
+                    continue;
+                }
+                $tempValue[] = $this->convert($itemValue, new $attributedPropertyClass, $tags);
             }
             $value = $tempValue;
         }
-        return true;
+        return false;
     }
 
     private function grabPropertyDTOClass(\ReflectionProperty $property): ?string
     {
-        $attributedPropertyClass = null;
         $propertyName = $property->getName();
         $propertyExtractor = new PropertyExtractor($property->class, $propertyName);
         /** @var DTOMeta $dtoMeta */
         if ($dtoMeta = $propertyExtractor->fetch(DTOMeta::class)) {
-            $attributedPropertyClass = $dtoMeta->class;
+            return $dtoMeta->class;
         }
-        return $attributedPropertyClass;
+        return null;
     }
-}
+
+    private function setValue(object $object, \ReflectionProperty $property, $value)
+    {
+        if (!$property->isPublic()) {
+            $property->setAccessible(true);
+        }
+
+        $property->setValue($object, $value);
+
+        if (!$property->isPublic()) {
+            $property->setAccessible(false);
+        }
+    }
+
+    private function getValue(object $object, \ReflectionProperty $property)
+    {
+        if (!$property->isPublic()) {
+            $property->setAccessible(true);
+        }
+
+        if (!$property->isInitialized($object)) {
+            if (!$property->isPublic()) {
+                $property->setAccessible(false);
+            }
+            return null;
+        }
+
+        $value = $property->getValue($object);
+
+        if (!$property->isPublic()) {
+            $property->setAccessible(false);
+        }
+
+        return $value;
+    }
+}

src/Resolver/SimpleResolver.php

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

src/Resolver/TransformerResolverInterface.php

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

src/Resolver/TransformerResolverStorage.php

@@ -1,32 +0,0 @@
-<?php
-
-namespace Rinsvent\Data2DTO\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];
-    }
-}

src/Transformer/Meta.php

@@ -1,9 +0,0 @@
-<?php
-
-namespace Rinsvent\Data2DTO\Transformer;
-
-#[\Attribute]
-abstract class Meta
-{
-    public const TYPE = 'simple';
-}

src/Transformer/TransformerInterface.php

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

src/Transformer/Trim.php

@@ -1,9 +0,0 @@
-<?php
-
-namespace Rinsvent\Data2DTO\Transformer;
-
-#[\Attribute]
-class Trim extends Meta
-{
-   public string $characters = " \t\n\r\0\x0B";
-}

src/Transformer/TrimTransformer.php

@@ -1,18 +0,0 @@
-<?php
-
-namespace Rinsvent\Data2DTO\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);
-    }
-}

tests/unit/Converter/ClassTransformersTest.php

@@ -0,0 +1,51 @@
+<?php
+
+namespace Rinsvent\Data2DTO\Tests\Converter;
+
+use Rinsvent\Data2DTO\Data2DtoConverter;
+use Rinsvent\Data2DTO\Tests\unit\Converter\fixtures\FillTest\HelloClassTransformersRequest;
+use Rinsvent\Data2DTO\Tests\unit\Converter\fixtures\FillTest\HelloClassTransformersRequest2;
+use Rinsvent\Data2DTO\Tests\unit\Converter\fixtures\FillTest\HelloTagsRequest;
+
+class ClassTransformersTest extends \Codeception\Test\Unit
+{
+    /**
+     * @var \UnitTester
+     */
+    protected $tester;
+
+    protected function _before()
+    {
+    }
+
+    protected function _after()
+    {
+    }
+
+    // tests
+    public function testSuccessWithReturnData()
+    {
+        $data2DtoConverter = new Data2DtoConverter();
+
+        $data = [
+            'surname' => 'Surname1234',
+            'age' => 3,
+        ];
+        $dto = $data2DtoConverter->convert($data, new HelloClassTransformersRequest);
+        $this->assertInstanceOf(HelloClassTransformersRequest::class, $dto);
+        $this->assertEquals(123454321, $dto->surname);
+    }
+
+    public function testSuccessWithReturnObject()
+    {
+        $data2DtoConverter = new Data2DtoConverter();
+
+        $data = [
+            'surname' => 'Surname1234',
+            'age' => 3,
+        ];
+        $dto = $data2DtoConverter->convert($data, new HelloClassTransformersRequest2());
+        $this->assertInstanceOf(HelloClassTransformersRequest2::class, $dto);
+        $this->assertEquals(98789, $dto->surname);
+    }
+}

tests/unit/Converter/DataObjectTest.php

@@ -0,0 +1,43 @@
+<?php
+
+namespace Rinsvent\Data2DTO\Tests\Converter;
+
+use Rinsvent\Data2DTO\Data2DtoConverter;
+use Rinsvent\Data2DTO\Tests\unit\Converter\fixtures\FillTest\Bar;
+use Rinsvent\Data2DTO\Tests\unit\Converter\fixtures\FillTest\BuyRequest;
+use Rinsvent\Data2DTO\Tests\unit\Converter\fixtures\FillTest\HelloRequest;
+
+class DataObjectTest extends \Codeception\Test\Unit
+{
+    /**
+     * @var \UnitTester
+     */
+    protected $tester;
+
+    protected function _before()
+    {
+    }
+
+    protected function _after()
+    {
+    }
+
+    // tests
+    public function testSuccessFillRequestData()
+    {
+        $data2DtoConverter = new Data2DtoConverter();
+
+        $buy = new BuyRequest();
+        $buy->phrase = 'Buy buy!!!';
+        $buy->length = 10;
+        $buy->isFirst = true;
+
+        $dto = $data2DtoConverter->convert([
+            'surname' => '   asdf',
+            'buy' => $buy
+        ], new HelloRequest);
+
+        $this->assertInstanceOf(HelloRequest::class, $dto);
+        $this->assertEquals($buy, $dto->buy);
+    }
+}

tests/unit/Converter/FillTest.php

@@ -52,7 +52,7 @@ class FillTest extends \Codeception\Test\Unit
                 'barField' => 32
             ],
             'extraData1' => 'qwer'
-        ], HelloRequest::class);
+        ], new HelloRequest);
         $this->assertInstanceOf(HelloRequest::class, $dto);
         $this->assertEquals('asdf', $dto->surname);
         $this->assertEquals(3, $dto->age);

tests/unit/Converter/TagsTest.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace Rinsvent\Data2DTO\Tests\Converter;
+
+use Rinsvent\Data2DTO\Data2DtoConverter;
+use Rinsvent\Data2DTO\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()
+    {
+        $data2DtoConverter = new Data2DtoConverter();
+
+        $data = [
+            'surname' => 'Surname1234',
+            'fake_age' => 3,
+            'fake_age2' => 7,
+            'emails' => [
+                'sfdgsa',
+                'af234f',
+                'asdf33333'
+            ],
+        ];
+        $tags = $data2DtoConverter->getTags($data, new HelloTagsRequest);
+        $dto = $data2DtoConverter->convert($data, new HelloTagsRequest, $tags);
+        $this->assertInstanceOf(HelloTagsRequest::class, $dto);
+        $this->assertEquals(7, $dto->age);
+
+    }
+}

tests/unit/Converter/fixtures/FillTest/HelloClassTransformersRequest.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace Rinsvent\Data2DTO\Tests\unit\Converter\fixtures\FillTest;
+
+use Rinsvent\Data2DTO\Tests\unit\Converter\fixtures\FillTest\Transformer\ClassData;
+
+#[ClassData]
+class HelloClassTransformersRequest
+{
+    public string $surname;
+    public int $age;
+}

tests/unit/Converter/fixtures/FillTest/HelloClassTransformersRequest2.php

@@ -0,0 +1,12 @@
+<?php
+
+namespace Rinsvent\Data2DTO\Tests\unit\Converter\fixtures\FillTest;
+
+use Rinsvent\Data2DTO\Tests\unit\Converter\fixtures\FillTest\Transformer\ClassObject;
+
+#[ClassObject]
+class HelloClassTransformersRequest2
+{
+    public string $surname;
+    public int $age;
+}

tests/unit/Converter/fixtures/FillTest/HelloRequest.php

@@ -4,7 +4,7 @@ namespace Rinsvent\Data2DTO\Tests\unit\Converter\fixtures\FillTest;
 
 use Rinsvent\Data2DTO\Attribute\DTOMeta;
 use Rinsvent\Data2DTO\Attribute\PropertyPath;
-use Rinsvent\Data2DTO\Transformer\Trim;
+use Rinsvent\Transformer\Transformer\Trim;
 
 class HelloRequest
 {
@@ -18,4 +18,16 @@ class HelloRequest
     public BuyRequest $buy;
     #[DTOMeta(class: Bar::class)]
     public BarInterface $bar;
+
+    private BuyRequest $buy2;
+
+    public function getBuy2(): BuyRequest
+    {
+        return $this->buy2;
+    }
+
+    public function setBuy2(BuyRequest $buy2): void
+    {
+        $this->buy2 = $buy2;
+    }
 }

tests/unit/Converter/fixtures/FillTest/HelloTagsRequest.php

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

tests/unit/Converter/fixtures/FillTest/Transformer/ClassData.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Rinsvent\Data2DTO\Tests\unit\Converter\fixtures\FillTest\Transformer;
+
+use Rinsvent\Transformer\Transformer\Meta;
+
+#[\Attribute]
+class ClassData extends Meta
+{
+
+}

tests/unit/Converter/fixtures/FillTest/Transformer/ClassDataTransformer.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace Rinsvent\Data2DTO\Tests\unit\Converter\fixtures\FillTest\Transformer;
+
+use Rinsvent\Transformer\Transformer\Meta;
+use Rinsvent\Transformer\Transformer\TransformerInterface;
+
+class ClassDataTransformer implements TransformerInterface
+{
+    /**
+     * @param array|null $data
+     * @param ClassData $meta
+     */
+    public function transform(mixed $data, Meta $meta): mixed
+    {
+        if ($data === null) {
+            return $data;
+        }
+
+        if (isset($data['surname'])) {
+            $data['surname'] = '123454321';
+        }
+        return $data;
+    }
+}

tests/unit/Converter/fixtures/FillTest/Transformer/ClassObject.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Rinsvent\Data2DTO\Tests\unit\Converter\fixtures\FillTest\Transformer;
+
+use Rinsvent\Transformer\Transformer\Meta;
+
+#[\Attribute]
+class ClassObject extends Meta
+{
+
+}

tests/unit/Converter/fixtures/FillTest/Transformer/ClassObjectTransformer.php

@@ -0,0 +1,24 @@
+<?php
+
+namespace Rinsvent\Data2DTO\Tests\unit\Converter\fixtures\FillTest\Transformer;
+
+use Rinsvent\Data2DTO\Tests\unit\Converter\fixtures\FillTest\HelloClassTransformersRequest2;
+use Rinsvent\Transformer\Transformer\Meta;
+use Rinsvent\Transformer\Transformer\TransformerInterface;
+
+class ClassObjectTransformer implements TransformerInterface
+{
+    /**
+     * @param array|null $data
+     * @param ClassData $meta
+     */
+    public function transform(mixed $data, Meta $meta): mixed
+    {
+        if ($data === null) {
+            return $data;
+        }
+        $object = new HelloClassTransformersRequest2();
+        $object->surname = '98789';
+        return $object;
+    }
+}