Default value for properties

teamneusta · Oct 9, 2023 · f3255b3 · f3255b3
1 parent 0d82ffd
commit f3255b3
Show file tree

Hide file tree

Showing 7 changed files with 70 additions and 9 deletions.
diff --git a/src/DependencyInjection/Configuration.php b/src/DependencyInjection/Configuration.php
@@ -52,7 +52,16 @@ private function addConverterSection(ArrayNodeDefinition $rootNode): void
                                 ->info('Mapping of source properties (value) to target properties (key)')
                                 ->normalizeKeys(false)
                                 ->useAttributeAsKey('target')
-                                ->prototype('scalar')->end()
+                                ->arrayPrototype()
+                                    ->beforeNormalization()
+                                    ->ifString()
+                                        ->then(fn (string $v) => ['source' => $v, 'default' => null])
+                                    ->end()
+                                    ->children()
+                                        ->scalarNode('source')->end()
+                                        ->scalarNode('default')->end()
+                                    ->end()
+                                ->end()
                             ->end()
                             ->arrayNode('context')
                                 ->info('Mapping of context properties (value) to target properties (key)')

diff --git a/src/DependencyInjection/NeustaConverterExtension.php b/src/DependencyInjection/NeustaConverterExtension.php
@@ -40,12 +40,13 @@ public function loadInternal(array $mergedConfig, ContainerBuilder $container):
      */
     private function registerConverterConfiguration(string $id, array $config, ContainerBuilder $container): void
     {
-        foreach ($config['properties'] ?? [] as $targetProperty => $sourceProperty) {
+        foreach ($config['properties'] ?? [] as $targetProperty => $sourceConfig) {
             $config['populators'][] = $propertyPopulatorId = "{$id}.populator.{$targetProperty}";
             $container->register($propertyPopulatorId, PropertyMappingPopulator::class)
                 ->setArguments([
                     '$targetProperty' => $targetProperty,
-                    '$sourceProperty' => $sourceProperty ?? $targetProperty,
+                    '$sourceProperty' => $sourceConfig['source'] ?? $targetProperty,
+                    '$defaultValue' => $sourceConfig['default'] ?? null,
                     '$mapper' => null,
                     '$accessor' => new Reference('property_accessor'),
                 ]);

diff --git a/src/Populator/ConvertingPopulator.php b/src/Populator/ConvertingPopulator.php
@@ -38,8 +38,8 @@ public function __construct(
         $this->populator = new PropertyMappingPopulator(
             $targetPropertyName,
             $sourcePropertyName,
-            \Closure::fromCallable([$converter, 'convert']),
-            $accessor,
+            mapper: \Closure::fromCallable([$converter, 'convert']),
+            accessor: $accessor,
         );
     }
 

diff --git a/src/Populator/PropertyMappingPopulator.php b/src/Populator/PropertyMappingPopulator.php
@@ -28,6 +28,7 @@ final class PropertyMappingPopulator implements Populator
     public function __construct(
         private string $targetProperty,
         private string $sourceProperty,
+        private mixed $defaultValue = null,
         \Closure $mapper = null,
         PropertyAccessorInterface $accessor = null,
     ) {
@@ -41,10 +42,12 @@ public function __construct(
     public function populate(object $target, object $source, object $ctx = null): void
     {
         try {
+            $value = $this->accessor->getValue($source, $this->sourceProperty);
+
             $this->accessor->setValue(
                 $target,
                 $this->targetProperty,
-                ($this->mapper)($this->accessor->getValue($source, $this->sourceProperty), $ctx),
+                ($this->mapper)($value ?? $this->defaultValue, $ctx),
             );
         } catch (\Throwable $exception) {
             throw new PopulationException($this->sourceProperty, $this->targetProperty, $exception);

diff --git a/tests/DependencyInjection/NeustaConverterExtensionTest.php b/tests/DependencyInjection/NeustaConverterExtensionTest.php
@@ -242,6 +242,43 @@ public function test_with_array_converting_populator_with_inner_property_first()
         self::assertSame('value', $populator->getArgument('$sourceArrayItemPropertyName'));
     }
 
+    public function test_with_array_converting_populator_with_default_value(): void
+    {
+        $container = $this->buildContainer([
+            'converter' => [
+                'foobar' => [
+                    'target_factory' => PersonFactory::class,
+                    'properties' => [
+                        'name' => [
+                            'source' => null,
+                            'default' => 'John Doe',
+                        ],
+                        'ageInYears' => [
+                            'source' => 'age',
+                            'default' => 42,
+                        ],
+                    ],
+                ],
+            ],
+        ]);
+
+        // name property populator
+        $namePopulator = $container->getDefinition('foobar.populator.name');
+        self::assertSame(PropertyMappingPopulator::class, $namePopulator->getClass());
+        self::assertIsReference('property_accessor', $namePopulator->getArgument('$accessor'));
+        self::assertSame('name', $namePopulator->getArgument('$targetProperty'));
+        self::assertSame('name', $namePopulator->getArgument('$sourceProperty'));
+        self::assertSame('John Doe', $namePopulator->getArgument('$defaultValue'));
+
+        // ageInYears property populator
+        $ageInYearsPopulator = $container->getDefinition('foobar.populator.ageInYears');
+        self::assertSame(PropertyMappingPopulator::class, $ageInYearsPopulator->getClass());
+        self::assertIsReference('property_accessor', $ageInYearsPopulator->getArgument('$accessor'));
+        self::assertSame('ageInYears', $ageInYearsPopulator->getArgument('$targetProperty'));
+        self::assertSame('age', $ageInYearsPopulator->getArgument('$sourceProperty'));
+        self::assertSame(42, $ageInYearsPopulator->getArgument('$defaultValue'));
+    }
+
     private static function assertIsReference(string $expected, mixed $actual): void
     {
         self::assertInstanceOf(Reference::class, $actual);

diff --git a/tests/Fixtures/Model/User.php b/tests/Fixtures/Model/User.php
@@ -9,7 +9,7 @@ class User
     private int $uuid;
     private string $firstname;
     private string $lastname;
-    private string $fullName;
+    private ?string $fullName;
     private int $ageInYears;
     private Address $address;
 
@@ -60,12 +60,12 @@ public function setLastname(string $lastname): self
         return $this;
     }
 
-    public function getFullName(): string
+    public function getFullName(): ?string
     {
         return $this->fullName;
     }
 
-    public function setFullName(string $fullName): self
+    public function setFullName(?string $fullName): self
     {
         $this->fullName = $fullName;
 

diff --git a/tests/Populator/PropertyMappingPopulatorTest.php b/tests/Populator/PropertyMappingPopulatorTest.php
@@ -24,4 +24,15 @@ public function test_populate(): void
 
         self::assertEquals(37, $person->getAge());
     }
+
+    public function test_populate_default_value(): void
+    {
+        $populator = new PropertyMappingPopulator('fullName', 'fullName', 'default');
+        $user = (new User())->setFullName(null);
+        $person = new Person();
+
+        $populator->populate($person, $user);
+
+        self::assertSame('default', $person->getFullName());
+    }
 }