Added skip unitialized values context param

Author: Korbeil

CHANGELOG.md

@@ -9,6 +9,11 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ### Added
 - [GH#223](https://github.com/jolicode/automapper/pull/223) Handle array to Doctrine Collection transformations
 - [GH#225](https://github.com/jolicode/automapper/pull/225) Add mapCollection method to base interface
+- [GH#200](https://github.com/jolicode/automapper/pull/200) Added skip_uninitialized_values context to skip non initialized properties
+- [GH#200](https://github.com/jolicode/automapper/pull/200) Changed skip_null_values behavior to not handle initialized properties anymore
+
+### Removed
+- [GH#200](https://github.com/jolicode/automapper/pull/200) Drop nikic/php-parser < 5.0 compatibility
 
 ## [9.2.1] - 2025-01-31
 ### Fixed

composer.json

@@ -17,7 +17,7 @@
     ],
     "require": {
         "php": "^8.2",
-        "nikic/php-parser": "^4.18 || ^5.0",
+        "nikic/php-parser": "^5.0",
         "symfony/deprecation-contracts": "^3.0",
         "symfony/event-dispatcher": "^6.4 || ^7.0",
         "symfony/expression-language": "^6.4 || ^7.0",

docs/getting-started/context.md

@@ -121,6 +121,26 @@ $target = $autoMapper->map($source, $target, ['skip_null_values' => true]);
 assert($target->name === 'Jane'); // true
 ```
 
+### Skip uninitialized values
+
+Like for null values and `skip_null_values`, in some case having an uninitialized value may precise that the value should not be mapped and the target should keep its value.
+
+You can enable this behavior by passing the `skip_uninitialized_values` option.
+
+```php
+class User
+{
+    public string $name;
+}
+
+$source = new User(); // do not initialize $name property
+$target = new UserDTO();
+$target->name = 'Jane';
+$target = $autoMapper->map($source, $target, ['skip_uninitialized_values' => true]);
+
+assert($target->name === 'Jane'); // true
+```
+
 ### Date Time format
 
 When mapping a `DateTimeInterface` object to a string, AutoMapper will format the date, you can change the format by

src/Extractor/ReadAccessor.php

@@ -188,18 +188,18 @@ public function getIsNullExpression(Expr\Variable $input): Expr
             /*
              * Use the property fetch to read the value
              *
-             * isset($input->property_name)
+             * isset($input->property_name) && null === $input->property_name
              */
-            return new Expr\BooleanNot(new Expr\Isset_([new Expr\PropertyFetch($input, $this->accessor)]));
+            return new Expr\BinaryOp\LogicalAnd(new Expr\BooleanNot(new Expr\Isset_([new Expr\PropertyFetch($input, $this->accessor)])), new Expr\BinaryOp\Identical(new Expr\ConstFetch(new Name('null')), new Expr\PropertyFetch($input, $this->accessor)));
         }
 
         if (self::TYPE_ARRAY_DIMENSION === $this->type) {
             /*
              * Use the array dim fetch to read the value
              *
-             * isset($input['property_name'])
+             * isset($input['property_name']) && null === $input->property_name
              */
-            return new Expr\BooleanNot(new Expr\Isset_([new Expr\ArrayDimFetch($input, new Scalar\String_($this->accessor))]));
+            return new Expr\BinaryOp\LogicalAnd(new Expr\BooleanNot(new Expr\Isset_([new Expr\PropertyFetch($input, $this->accessor)])), new Expr\BinaryOp\Identical(new Expr\ConstFetch(new Name('null')), new Expr\PropertyFetch($input, $this->accessor)));
         }
 
         if (self::TYPE_SOURCE === $this->type) {
@@ -212,6 +212,52 @@ public function getIsNullExpression(Expr\Variable $input): Expr
         throw new CompileException('Invalid accessor for read expression');
     }
 
+    public function getIsUndefinedExpression(Expr\Variable $input): Expr
+    {
+        if (\in_array($this->type, [self::TYPE_METHOD, self::TYPE_SOURCE])) {
+            /*
+             * false
+             */
+            return new Expr\ConstFetch(new Name('false'));
+        }
+
+        if (self::TYPE_PROPERTY === $this->type) {
+            if ($this->private) {
+                /*
+                 * When the property is private we use the extract callback that can read this value
+                 *
+                 * @see \AutoMapper\Extractor\ReadAccessor::getExtractIsUndefinedCallback()
+                 *
+                 * $this->extractIsUndefinedCallbacks['property_name']($input)
+                 */
+                return new Expr\FuncCall(
+                    new Expr\ArrayDimFetch(new Expr\PropertyFetch(new Expr\Variable('this'), 'extractIsUndefinedCallbacks'), new Scalar\String_($this->accessor)),
+                    [
+                        new Arg($input),
+                    ]
+                );
+            }
+
+            /*
+             * Use the property fetch to read the value
+             *
+             * !array_key_exists($property_name, (object) $input)
+             */
+            return new Expr\BooleanNot(new Expr\FuncCall(new Name('array_key_exists'), [new Arg(new Scalar\String_($this->accessor)), new Arg(new Expr\Cast\Array_($input))]));
+        }
+
+        if (self::TYPE_ARRAY_DIMENSION === $this->type) {
+            /*
+             * Use the array dim fetch to read the value
+             *
+             * !array_key_exists('property_name', $input)
+             */
+            return new Expr\BooleanNot(new Expr\FuncCall(new Name('array_key_exists'), [new Arg(new Scalar\String_($this->accessor)), new Arg($input)]));
+        }
+
+        throw new CompileException('Invalid accessor for read expression');
+    }
+
     /**
      * Get AST expression for binding closure when dealing with a private property.
      */
@@ -261,6 +307,38 @@ public function getExtractIsNullCallback(string $className): ?Expr
             return null;
         }
 
+        /*
+         * Create extract is null callback for this accessor
+         *
+         *  \Closure::bind(function ($object) {
+         *      return !isset($object->property_name) && null === $object->property_name;
+         *  }, null, $className)
+         */
+        return new Expr\StaticCall(new Name\FullyQualified(\Closure::class), 'bind', [
+            new Arg(
+                new Expr\Closure([
+                    'params' => [
+                        new Param(new Expr\Variable('object')),
+                    ],
+                    'stmts' => [
+                        new Stmt\Return_(new Expr\BinaryOp\LogicalAnd(new Expr\BooleanNot(new Expr\Isset_([new Expr\PropertyFetch(new Expr\Variable('object'), $this->accessor)])), new Expr\BinaryOp\Identical(new Expr\ConstFetch(new Name('null')), new Expr\PropertyFetch(new Expr\Variable('object'), $this->accessor)))),
+                    ],
+                ])
+            ),
+            new Arg(new Expr\ConstFetch(new Name('null'))),
+            new Arg(new Scalar\String_($className)),
+        ]);
+    }
+
+    /**
+     * Get AST expression for binding closure when dealing with a private property.
+     */
+    public function getExtractIsUndefinedCallback(string $className): ?Expr
+    {
+        if ($this->type !== self::TYPE_PROPERTY || !$this->private) {
+            return null;
+        }
+
         /*
          * Create extract is null callback for this accessor
          *

src/GeneratedMapper.php

@@ -48,6 +48,9 @@ public function registerMappers(AutoMapperRegistryInterface $registry): void
     /** @var array<string, callable(): bool>) */
     protected array $extractIsNullCallbacks = [];
 
+    /** @var array<string, callable(): bool>) */
+    protected array $extractIsUndefinedCallbacks = [];
+
     /** @var Target|\ReflectionClass<object> */
     protected mixed $cachedTarget;
 }

src/Generator/MapperConstructorGenerator.php

@@ -31,6 +31,7 @@ public function getStatements(GeneratorMetadata $metadata): array
         foreach ($metadata->propertiesMetadata as $propertyMetadata) {
             $constructStatements[] = $this->extractCallbackForProperty($metadata, $propertyMetadata);
             $constructStatements[] = $this->extractIsNullCallbackForProperty($metadata, $propertyMetadata);
+            $constructStatements[] = $this->extractIsUndefinedCallbackForProperty($metadata, $propertyMetadata);
             $constructStatements[] = $this->hydrateCallbackForProperty($metadata, $propertyMetadata);
         }
 
@@ -83,6 +84,28 @@ private function extractIsNullCallbackForProperty(GeneratorMetadata $metadata, P
             ));
     }
 
+    /**
+     * Add read callback to the constructor of the generated mapper.
+     *
+     * ```php
+     * $this->extractIsUndefinedCallbacks['propertyName'] = $extractIsNullCallback;
+     * ```
+     */
+    private function extractIsUndefinedCallbackForProperty(GeneratorMetadata $metadata, PropertyMetadata $propertyMetadata): ?Stmt\Expression
+    {
+        $extractUndefinedCallback = $propertyMetadata->source->accessor?->getExtractIsUndefinedCallback($metadata->mapperMetadata->source);
+
+        if (!$extractUndefinedCallback) {
+            return null;
+        }
+
+        return new Stmt\Expression(
+            new Expr\Assign(
+                new Expr\ArrayDimFetch(new Expr\PropertyFetch(new Expr\Variable('this'), 'extractIsUndefinedCallbacks'), new Scalar\String_($propertyMetadata->source->property)),
+                $extractUndefinedCallback
+            ));
+    }
+
     /**
      * Add hydrate callback to the constructor of the generated mapper.
      *

src/Generator/PropertyConditionsGenerator.php

@@ -138,7 +138,11 @@ private function isAllowedAttribute(GeneratorMetadata $metadata, PropertyMetadat
         return new Expr\StaticCall(new Name\FullyQualified(MapperContext::class), 'isAllowedAttribute', [
             new Arg($variableRegistry->getContext()),
             new Arg(new Scalar\String_($propertyMetadata->source->property)),
-            new Arg($propertyMetadata->source->accessor->getIsNullExpression($variableRegistry->getSourceInput())),
+            new Arg(new Expr\Closure([
+                'uses' => [new Expr\ClosureUse($variableRegistry->getSourceInput())],
+                'stmts' => [new Stmt\Return_($propertyMetadata->source->accessor->getIsNullExpression($variableRegistry->getSourceInput()))],
+            ])),
+            new Arg($propertyMetadata->source->accessor->getIsUndefinedExpression($variableRegistry->getSourceInput())),
         ]);
     }
 

src/MapperContext.php

@@ -28,6 +28,7 @@
  *   "deep_target_to_populate"?: bool,
  *   "constructor_arguments"?: array<string, array<string, mixed>>,
  *   "skip_null_values"?: bool,
+ *   "skip_uninitialized_values"?: bool,
  *   "allow_readonly_target_to_populate"?: bool,
  *   "datetime_format"?: string,
  *   "datetime_force_timezone"?: string,
@@ -49,6 +50,7 @@ class MapperContext
     public const DEEP_TARGET_TO_POPULATE = 'deep_target_to_populate';
     public const CONSTRUCTOR_ARGUMENTS = 'constructor_arguments';
     public const SKIP_NULL_VALUES = 'skip_null_values';
+    public const SKIP_UNINITIALIZED_VALUES = 'skip_uninitialized_values';
     public const ALLOW_READONLY_TARGET_TO_POPULATE = 'allow_readonly_target_to_populate';
     public const DATETIME_FORMAT = 'datetime_format';
     public const DATETIME_FORCE_TIMEZONE = 'datetime_force_timezone';
@@ -135,6 +137,13 @@ public function setSkipNullValues(bool $skipNullValues): self
         return $this;
     }
 
+    public function setSkipUnitializedValues(bool $skipUnitializedValues): self
+    {
+        $this->context[self::SKIP_UNINITIALIZED_VALUES] = $skipUnitializedValues;
+
+        return $this;
+    }
+
     public function setAllowReadOnlyTargetToPopulate(bool $allowReadOnlyTargetToPopulate): self
     {
         $this->context[self::ALLOW_READONLY_TARGET_TO_POPULATE] = $allowReadOnlyTargetToPopulate;
@@ -231,9 +240,13 @@ public static function withReference(array $context, string $reference, mixed &$
      *
      * @internal
      */
-    public static function isAllowedAttribute(array $context, string $attribute, bool $valueIsNullOrUndefined): bool
+    public static function isAllowedAttribute(array $context, string $attribute, callable $valueIsNull, bool $valueIsUndefined): bool
     {
-        if (($context[self::SKIP_NULL_VALUES] ?? false) && $valueIsNullOrUndefined) {
+        if (($context[self::SKIP_UNINITIALIZED_VALUES] ?? false) && $valueIsUndefined) {
+            return false;
+        }
+
+        if (($context[self::SKIP_NULL_VALUES] ?? false) && !$valueIsUndefined && $valueIsNull()) {
             return false;
         }
 

tests/AutoMapperTest.php

@@ -44,6 +44,8 @@
 use AutoMapper\Tests\Fixtures\Issue111\Colour;
 use AutoMapper\Tests\Fixtures\Issue111\ColourTransformer;
 use AutoMapper\Tests\Fixtures\Issue111\FooDto;
+use AutoMapper\Tests\Fixtures\Issue189\User as Issue189User;
+use AutoMapper\Tests\Fixtures\Issue189\UserPatchInput as Issue189UserPatchInput;
 use AutoMapper\Tests\Fixtures\ObjectsUnion\Bar;
 use AutoMapper\Tests\Fixtures\ObjectsUnion\Foo;
 use AutoMapper\Tests\Fixtures\ObjectsUnion\ObjectsUnionProperty;
@@ -1013,7 +1015,7 @@ public function testSkipNullValues(): void
         $input = new Fixtures\SkipNullValues\Input();
 
         /** @var Fixtures\SkipNullValues\Entity $entity */
-        $entity = $this->autoMapper->map($input, $entity, ['skip_null_values' => true]);
+        $entity = $this->autoMapper->map($input, $entity, [MapperContext::SKIP_NULL_VALUES => true]);
         self::assertEquals('foobar', $entity->getName());
     }
 
@@ -1377,7 +1379,7 @@ public function testNoErrorWithUninitializedProperty(): void
 
         self::assertSame(
             ['bar' => 'bar'],
-            $this->autoMapper->map(new Uninitialized(), 'array', ['skip_null_values' => true])
+            $this->autoMapper->map(new Uninitialized(), 'array', [MapperContext::SKIP_UNINITIALIZED_VALUES => true])
         );
     }
 
@@ -1760,4 +1762,18 @@ public function testMapCollectionToArray(): void
         self::assertIsArray($userDatas[1]['address']);
         self::assertIsString($userDatas[1]['createdAt']);
     }
+
+    public function testUninitializedProperties(): void
+    {
+        $payload = new Issue189UserPatchInput();
+        $payload->firstName = 'John';
+        $payload->lastName = 'Doe';
+
+        /** @var Issue189User $data */
+        $data = $this->autoMapper->map($payload, Issue189User::class, [MapperContext::SKIP_UNINITIALIZED_VALUES => true]);
+
+        $this->assertEquals('John', $data->getFirstName());
+        $this->assertEquals('Doe', $data->getLastName());
+        $this->assertTrue(!isset($data->birthDate));
+    }
 }

tests/Fixtures/Issue189/User.php

@@ -0,0 +1,48 @@
+<?php
+
+declare(strict_types=1);
+
+namespace AutoMapper\Tests\Fixtures\Issue189;
+
+class User
+{
+    public string $lastName;
+    public string $firstName;
+    public ?\DateTimeImmutable $birthDate;
+
+    public function getLastName(): string
+    {
+        return $this->lastName;
+    }
+
+    public function setLastName(string $lastName): self
+    {
+        $this->lastName = $lastName;
+
+        return $this;
+    }
+
+    public function getFirstName(): string
+    {
+        return $this->firstName;
+    }
+
+    public function setFirstName(string $firstName): self
+    {
+        $this->firstName = $firstName;
+
+        return $this;
+    }
+
+    public function getBirthDate(): ?\DateTimeImmutable
+    {
+        return $this->birthDate;
+    }
+
+    public function setBirthDate(?\DateTimeImmutable $birthDate): self
+    {
+        $this->birthDate = $birthDate;
+
+        return $this;
+    }
+}