Refactor normalization

Author: chapterjason

src/Doctrine/DBAL/Types/DurationType.php

@@ -32,7 +32,7 @@ public function convertToPHPValue($value, AbstractPlatform $platform): ?Duration
          */
         $databaseUnit = new static::$databaseUnitClass($value);
 
-        return new Duration($databaseUnit->normalize());
+        return new Duration($databaseUnit);
     }
 
     public function convertToDatabaseValue($value, AbstractPlatform $platform): ?string

src/Form/DistanceType.php

@@ -33,7 +33,7 @@ function (?Distance $data): ?array {
                     return null;
                 }
 
-                $value = $data->getValue();
+                $value = $data->getValue()->normalize();
 
                 return [
                     'value' => (string) $value->getValue(),

src/Model/AbstractUnit.php

@@ -209,27 +209,48 @@ public function convert(string $targetUnitClassOrType): UnitInterface
     public function normalize(): UnitInterface
     {
         $mapping = static::getMapping();
-        $sourceUnitClass = $mapping[static::getUnitType()] ?? null;
 
-        if (null === $sourceUnitClass) {
-            throw new \InvalidArgumentException(\sprintf("Normalization from '%s' is not supported.", static::class));
+        if (0 === $this->value->compare(new Number(0))) {
+            return new static(0);
         }
 
-        $shortest = $this;
+        $candidates = [];
 
-        foreach ($mapping as $targetUnitClass) {
-            if (static::class === $targetUnitClass) {
-                continue;
+        foreach ($mapping as $unitClass) {
+            $converted = $this->convert($unitClass);
+            $absValue = abs((float) $converted->getValue()->value);
+
+            // Collect candidates where the number is at least 1.
+            if ($absValue >= 1) {
+                $candidates[] = [
+                    'unit' => $converted,
+                    'value' => $absValue,
+                ];
             }
+        }
+
+        // >= 1
+        if (0 !== \count($candidates)) {
+            usort($candidates, static function ($a, $b) {
+                return $a['value'] <=> $b['value'];
+            });
+
+            return $candidates[0]['unit'];
+        }
+
+        // < 1
+        $bestCandidate = null;
 
-            $converted = $this->convert($targetUnitClass);
+        foreach ($mapping as $unitClass) {
+            $converted = $this->convert($unitClass);
+            $absValue = abs((float) $converted->getValue()->value);
 
-            if (\strlen($converted->format()) < \strlen($shortest->format())) {
-                $shortest = $converted;
+            if (null === $bestCandidate || $absValue > $bestCandidate['value']) {
+                $bestCandidate = ['unit' => $converted, 'value' => $absValue];
             }
         }
 
-        return $shortest;
+        return $bestCandidate['unit'] ?? $this;
     }
 
     public static function create(Number|string|int|float $value, string $unitType): static

tests/Doctrine/TypesTest.php

@@ -58,23 +58,23 @@ public static function distanceTypeDataProvider(): array
             ['0.0', '0m'],
             ['1.0', '1m'],
             ['-1.0', '-1m'],
-            ['123.456', '123.456m'],
-            ['-987.654', '-987.654m'],
+            ['123.456', '1.23456hm'],
+            ['-987.654', '-9.87654hm'],
             ['0.00001', '10μm'],
             ['-0.00001', '-10μm'],
             ['1.23456789', '1.23456789m'],
-            ['999999.9999', '999999.9999m'],
-            ['-999999.9999', '-999999.9999m'],
+            ['999999.9999', '999.9999999km'],
+            ['-999999.9999', '-999.9999999km'],
             ['3.1415926535', '3.1415926535m'],
             ['2.7182818284', '2.7182818284m'],
-            ['123456789.123', '123456789.123m'],
+            ['123456789.123', '123456.789123km'],
 
             ['0', '0m'],
-            ['+123.45', '123.45m'],
+            ['+123.45', '1.2345hm'],
             ['-0.0', '0m'],
             ['0001.000', '1m'],
-            ['123.', '123m'],
-            ['.456', '456mm'],
+            ['123.', '1.23hm'],
+            ['.456', '4.56dm'],
             ['0.000000001', '1nm'],
             ['1e-5', '10μm'],
             ['1e5', '100km'],

tests/Form/DistanceTypeTest.php

@@ -3,6 +3,7 @@
 namespace Form;
 
 use SoureCode\Bundle\Unit\Form\DistanceType;
+use SoureCode\Bundle\Unit\Model\Distance;
 use SoureCode\Bundle\Unit\Model\Length\Centimeter;
 use SoureCode\Bundle\Unit\Model\Length\Kilometer;
 use SoureCode\Bundle\Unit\Model\Length\LengthUnitType;
@@ -23,7 +24,7 @@ public function testSubmitValidData(): void
 
         // Assert
         $this->assertTrue($form->isSynchronized());
-        $this->assertEquals('106mm', $form->getData()->format());
+        $this->assertEquals('1.06dm', $form->getData()->format());
     }
 
     public function testSubmitNull(): void
@@ -42,14 +43,15 @@ public function testSubmitNull(): void
     public function testWithPreData(): void
     {
         // Arrange
-        $form = $this->factory->create(DistanceType::class, new Centimeter("10.6"));
+        $distance = new Distance(new Centimeter("10.6"));
+        $form = $this->factory->create(DistanceType::class, $distance);
 
         // Act
         $view = $form->createView();
 
         // Assert
-        $this->assertEquals('10.6', $view->children['value']->vars['value']);
-        $this->assertEquals(LengthUnitType::CENTIMETER->value, $view->children['unit']->vars['value']);
+        $this->assertEquals('1.06', $view->children['value']->vars['value']);
+        $this->assertEquals(LengthUnitType::DECIMETER->value, $view->children['unit']->vars['value']);
     }
 
     public function testWithNullPreData(): void