Use appropriate type hinting to the SnakeCaseToCamelCaseConverter

Author: jeromegamez

src/Firebase/Valinor/Converter/SnakeCaseToCamelCaseConverter.php

@@ -4,33 +4,57 @@
 
 namespace Kreait\Firebase\Valinor\Converter;
 
-use Traversable;
-
 /**
  * @internal
- *
- * @see https://valinor.cuyz.io/latest/how-to/convert-input/#converting-keys-format-from-snake_case-to-camelcase
  */
 final class SnakeCaseToCamelCaseConverter
 {
-    public function __invoke(mixed $values, callable $next): object
+    /**
+     * @pure
+     *
+     * @param iterable<mixed> $source
+     * @param pure-callable(iterable<mixed>): iterable<mixed> $next
+     *
+     * @return iterable<mixed>
+     */
+    public function __invoke(iterable $source, callable $next): iterable
     {
-        if ($values instanceof Traversable) {
-            $values = iterator_to_array($values);
-        }
+        return $next(self::camelCase($source));
+    }
+
+    /**
+     * @pure
+     *
+     * @param iterable<mixed> $source
+     *
+     * @return array<array-key, mixed>
+     */
+    private static function camelCase(iterable $source): array
+    {
+        $result = [];
 
-        if (!is_array($values)) {
-            return $next($values);
+        foreach ($source as $key => $value) {
+            if (is_iterable($value)) {
+                $value = self::camelCase($value);
+            }
+
+            if (is_string($key) && $key !== '') {
+                $key = self::convert($key);
+            }
+
+            $result[$key] = $value;
         }
 
-        $camelCaseConverted = array_combine(
-            array_map(
-                fn($key): string => lcfirst(str_replace('_', '', ucwords((string) $key, '_'))),
-                array_keys($values),
-            ),
-            $values,
-        );
+        return $result;
+    }
 
-        return $next($camelCaseConverted);
+    /**
+     * @pure
+     *
+     * @param non-empty-string $key
+     */
+    private static function convert(string $key): string
+    {
+        return lcfirst(str_replace('_', '', ucwords($key, '_'))); // @phpstan-ignore possiblyImpure.functionCall
     }
 }

src/Firebase/Valinor/Mapper.php

@@ -27,9 +27,12 @@ public function __construct(private readonly mixed $cache = null, ?MapperBuilder
         $this->mapperBuilder = $builder;
     }
 
+    /**
+     * @param pure-callable $converter
+     */
     public function withConverter(callable $converter): self
     {
-        $mapperBuilder = $this->mapperBuilder->registerConverter($converter); // @phpstan-ignore-line argument.type
+        $mapperBuilder = $this->mapperBuilder->registerConverter($converter);
 
         return new self($this->cache, $mapperBuilder);
     }

tests/Unit/Valinor/Converter/SnakeCaseToCamelCaseConverterTest.php

@@ -0,0 +1,63 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Kreait\Firebase\Tests\Unit\Valinor\Converter;
+
+use CuyZ\Valinor\MapperBuilder;
+use Kreait\Firebase\Tests\UnitTestCase;
+use Kreait\Firebase\Valinor\Converter\SnakeCaseToCamelCaseConverter;
+use PHPUnit\Framework\Attributes\DataProvider;
+use PHPUnit\Framework\Attributes\Test;
+
+class SnakeCaseToCamelCaseConverterTest extends UnitTestCase
+{
+    /**
+     * @param iterable<mixed> $expected
+     * @param non-empty-string $signature
+     * @param iterable<mixed> $input
+     */
+    #[DataProvider('dataProvider')]
+    #[Test]
+    public function itWorks(iterable $expected, string $signature, iterable $input): void
+    {
+        $mapper = (new MapperBuilder())
+            ->registerConverter(new SnakeCaseToCamelCaseConverter())
+            ->mapper()
+        ;
+
+        $result = $mapper->map($signature, $input);
+
+        $this->assertSame($expected, $result);
+    }
+
+    /**
+     * @return iterable<mixed>
+     */
+    public static function dataProvider(): iterable
+    {
+        yield 'flat' => [
+            ['firstKey' => 'first_value'],
+            'array<string, string>',
+            ['first_key' => 'first_value'],
+        ];
+
+        yield 'nested' => [
+            [
+                'firstKey' => 'first_value',
+                'secondKey' => [
+                    'firstSubKey' => 'first_sub_value',
+                    'secondSubKey' => 'second_sub_value',
+                ],
+            ],
+            'array<non-empty-string, non-empty-string|array<non-empty-string, non-empty-string>>',
+            [
+                'first_key' => 'first_value',
+                'second_key' => [
+                    'first_sub_key' => 'first_sub_value',
+                    'second_sub_key' => 'second_sub_value',
+                ],
+            ],
+        ];
+    }
+}