symfony · priyadi · Jan 2, 2024 · Mar 18, 2024 · Mar 18, 2024 · Mar 19, 2024
@@ -355,6 +355,53 @@ public function testMergeZeroIndexedCollection()
         $this->assertNotNull($itemsForm->get('0')->get('file'));
     }
 
+    public function testMergePartialDataFromCollection()
+    {
+        $form = $this->createForm('root', 'POST', true);
+        $form->add('items', CollectionType::class, [
+            'entry_type' => ItemFileType::class,
+            'allow_add' => true,
+        ]);
+
+        $file = $this->getUploadedFile();
+        $file2 = $this->getUploadedFile();
+
+        $this->setRequestData('POST', [
+            'root' => [
+                'items' => [
+                    1 => [
+                        'item' => 'test',
+                    ],
+                ],
+            ],
+        ], [
+            'root' => [
+                'items' => [
+                    0 => [
+                        'file' => $file,
+                    ],
+                    1 => [
+                        'file' => $file2,
+                    ],
+                ],
+            ],
+        ]);
+
+        $this->requestHandler->handleRequest($form, $this->request);
+
+        $itemsForm = $form->get('items');
+        $data = $itemsForm->getData();
+        $this->assertTrue($form->isSubmitted());
+        $this->assertTrue($form->isValid());
+
+        $this->assertCount(2, $data);
+        $this->assertArrayHasKey(0, $data);
+        $this->assertArrayHasKey(1, $data);
+
+        $this->assertEquals(
8000
9;test', $itemsForm->get('1')->get('item')->getData());
+        $this->assertNotNull($itemsForm->get('0')->get('file'));
+    }
+
     /**
      * @dataProvider methodExceptGetProvider
      */

@@ -43,30 +43,10 @@ public static function isEmpty($data)
     }
 
     /**
-     * Recursively replaces or appends elements of the first array with elements
-     * of second array. If the key is an integer, the values will be appended to
-     * the new array; otherwise, the value from the second array will replace
-     * the one from the first array.
+     * Merges query string or post parameters with uploaded files.
      */
     public static function mergeParamsAndFiles(array $params, array $files): array
     {
-        $isFilesList = array_is_list($files);
-
-        foreach ($params as $key => $value) {
-            if (\is_array($value) && \is_array($files[$key] ?? null)) {
-                $params[$key] = self::mergeParamsAndFiles($value, $files[$key]);
-                unset($files[$key]);
-            }
-        }
-
-        if (!$isFilesList) {
-            return array_replace($params, $files);
-        }
-
-        foreach ($files as $value) {
-            $params[] = $value;
-        }
-
-        return $params;
+        return (new ParamFilesMerger([], $params, $files))->getResult();
     }
 }
diff --git a/src/Symfony/Component/Form/Util/ParamFilesMerger.php b/src/Symfony/Component/Form/Util/ParamFilesMerger.php
@@ -0,0 +1,159 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Form\Util;
+
+use Symfony\Component\HttpFoundation\File\UploadedFile;
+
+/**
+ * @author Priyadi Iman Nurcahyo <priyadi@rekalogika.com>
+ *
+ * @internal
+ */
+class ParamFilesMerger
+{
+    private array $path;
+    private array $params;
+    private array $files;
+
+    /**
+     * @param array $path The path to the current element, empty means the root
+     */
+    public function __construct(array $path, array $params, array $files)
+    {
+        $this->path = $path;
+        $this->params = $params;
+        $this->files = $files;
+    }
+
+    public function getResult()
+    {
+        $paramsValue = $this->getParamsValue();
+        $filesValue = $this->getFilesValue();
+
+        if (null === $paramsValue) {
+            return $filesValue;
+        } elseif (\is_array($paramsValue)) {
+            if (self::isFileUpload($filesValue)) {
+                return $filesValue; // if the array is a file upload field, it has the precedence
+            } elseif (\is_array($filesValue)) {
+                return $this->getResultArray($paramsValue, $filesValue);
+            }
+
+            return $paramsValue; // params has the precedence
+        } else { // $paramsValue has a non-array value
+            if (self::isFileUpload($filesValue)) {
+                return $filesValue; // if the array is a file upload field, it has the precedence
+            }
+
+            return $paramsValue;
+        }
+    }
+
+    /**
+     * @param UploadedFile|array $value
+     */
+    private static function isFileUpload($value): bool
+    {
+        if ($value instanceof UploadedFile) {
+            return true;
+        }
+
+        if (!\is_array($value) || !\in_array(\count($value), [5, 6], true)) {
+            return false;
+        }
+
+        if (\array_key_exists('full_path', $value)) {
+            unset($value['full_path']);
+        }
+
+        $keys = array_keys($value);
+        sort($keys);
+
+        return ['error', 'name', 'size', 'tmp_name', 'type'] === $keys;
+    }
+
+    private static function doesNotContainNonFileUploadArray(array $array): bool
+    {
+        foreach ($array as $value) {
+            if (\is_array($value) && !self::isFileUpload($value)) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    private function getResultArray(array $paramsValue, array $filesValue): array
+    {
+        // if both are lists and both does not contains array, then merge them and return
+        if (
+            array_is_list($paramsValue)
+            && self::doesNotContainNonFileUploadArray($paramsValue)
+            && array_is_list($filesValue)
+            && self::doesNotContainNonFileUploadArray($filesValue)
+        ) {
+            return array_merge($paramsValue, $filesValue);
+        }
+
+        // heuristics to preserve order, the bigger array wins
+        if (\count($filesValue) > \count($paramsValue)) {
+            $keys = array_unique(array_merge(array_keys($filesValue), array_keys($paramsValue)));
+        } else {
+            $keys = array_unique(array_merge(array_keys($paramsValue), array_keys($filesValue)));
+        }
+
+        $result = [];
+
+        foreach ($keys as $key) {
+            $path = $this->path;
+            $path[] = $key;
+
+            $node = new self($path, $this->params, $this->files);
+
+            $result[$key] = $node->getResult();
+        }
+
+        return $result;
+    }
+
+    /**
+     * Gets the value of the current element in the params according to the path.
+     */
+    private function getParamsValue()
+    {
+        $params = $this->params;
+
+        foreach ($this->path as $key) {
+            if (null === $params = $params[$key] ?? null) {
+                return null;
+            }
+        }
+
+        return $params;
+    }
+
+    /**
+     * Gets the value of the current element in the files according to the path.
+     */
+    private function getFilesValue()
+    {
+        $files = $this->files;
+
+        foreach ($this->path as $key) {
+            if (null === $files = $files[$key] ?? null) {
+                return null;
+            }
+        }
+
+        return $files;
+    }
+}