Properly use the expected field from the httpwg test suite

Author: nyamsprod

composer.json

@@ -36,7 +36,8 @@
         "phpstan/phpstan-deprecation-rules": "^1.1.4",
         "phpunit/phpunit": "^10.5.5",
         "phpbench/phpbench": "^1.2.15",
-        "symfony/var-dumper": "^6.4.0"
+        "symfony/var-dumper": "^6.4.0",
+        "bakame/aide-base32": "dev-main"
     },
     "autoload": {
         "psr-4": {

phpstan.neon

@@ -13,4 +13,6 @@ parameters:
           path: tests/ItemTest.php
         - message: '#Method Bakame\\Http\\StructuredFields\\DataType::build\(\) has parameter \$data with no value type specified in iterable type iterable.#'
           path: src/DataType.php
+    excludePaths:
+        - tests/Record.php
     reportUnmatchedIgnoredErrors: true

src/DisplayString.php

@@ -50,7 +50,12 @@ public static function fromEncoded(Stringable|string $encodedValue): self
             throw new SyntaxError('The string '.$value.' contains invalid utf-8 encoded sequence.');
         }
 
-        $value = (string) preg_replace_callback(',%[A-Fa-f0-9]{2},', fn (array $matches) =>  rawurldecode($matches[0]), $value);
+        $value = (string) preg_replace_callback(
+            ',%[A-Fa-f0-9]{2},',
+            fn (array $matches): string => rawurldecode($matches[0]),
+            $value
+        );
+
         if (1 !== preg_match('//u', $value)) {
             throw new SyntaxError('The string contains invalid characters.'.$value);
         }
@@ -79,21 +84,11 @@ public function decoded(): string
      */
     public function encoded(): string
     {
-        $value = $this->value;
-
-        $encodeMatches = static fn (array $matches): string => match (1) {
-            preg_match('/[^A-Za-z\d_\-.~]/', rawurldecode($matches[0])) => strtolower(rawurlencode($matches[0])),
-            default => $matches[0],
-        };
-
-        return match (true) {
-            '' === $value => $value,
-            default => (string) preg_replace_callback(
-                '/[^A-Za-z\d_\-.~\!\$&\'\(\)\*\+,;\=%\\\\:@\/? ]+|%(?![A-Fa-f\d]{2})/',
-                $encodeMatches(...),
-                $value
-            ),
-        };
+        return (string) preg_replace_callback(
+            '/[%"\x00-\x1F\x7F-\xFF]/',
+            static fn (array $matches): string => strtolower(rawurlencode($matches[0])),
+            $this->value
+        );
     }
 
     public function equals(mixed $other): bool

tests/Record.php

@@ -4,15 +4,20 @@
 
 namespace Bakame\Http\StructuredFields;
 
+use DateTimeImmutable;
+use ValueError;
+
 /**
  * @phpstan-type RecordData array{
  *     name: string,
  *     header_type: 'dictionary'|'list'|'item',
  *     raw: array<string>,
  *     canonical?: array<string>,
  *     must_fail?: bool,
- *     can_fail?: bool
+ *     can_fail?: bool,
+ *     expected?: array,
  * }
+ * @phpstan-type itemValue array{__type:string, value:int|string}|string|bool|int|float|null
  */
 final class Record
 {
@@ -26,6 +31,7 @@ private function __construct(
         public readonly array $canonical,
         public readonly bool $mustFail,
         public readonly bool $canFail,
+        public readonly ?StructuredField $expected
     ) {
     }
 
@@ -34,7 +40,7 @@ private function __construct(
      */
     public static function fromDecoded(array $data): self
     {
-        $data += ['canonical' => $data['raw'], 'must_fail' => false, 'can_fail' => false];
+        $data += ['canonical' => $data['raw'], 'must_fail' => false, 'can_fail' => false, 'expected' => []];
 
         return new self(
             $data['name'],
@@ -43,6 +49,89 @@ public static function fromDecoded(array $data): self
             $data['canonical'],
             $data['must_fail'],
             $data['can_fail'],
+            self::parseExpected($data['header_type'], $data['expected'])
         );
     }
+
+    private static function parseExpected(string $dataTypeValue, array $expected): ?StructuredField
+    {
+        return match (DataType::tryFrom($dataTypeValue)) {
+            DataType::Dictionary => self::parseDictionary($expected),
+            DataType::List => self::parseList($expected),
+            DataType::Item => self::parseItem($expected),
+            default => null,
+        };
+    }
+
+    /**
+     * @param itemValue $data
+     */
+    private static function parseValue(array|string|bool|int|float|null $data): Token|DateTimeImmutable|ByteSequence|DisplayString|string|bool|int|float|null
+    {
+        return match (true) {
+            !is_array($data) => $data,
+            2 !== count($data),
+            !isset($data['__type'], $data['value']) => throw new ValueError('Unknown or unsupported type: '.json_encode($data)),
+            default => match (Type::tryFrom($data['__type'])) {
+                Type::Token => Token::fromString($data['value']),
+                Type::Date => (new DateTimeImmutable())->setTimestamp((int) $data['value']),
+                Type::DisplayString => DisplayString::fromDecoded($data['value']),
+                Type::ByteSequence => ByteSequence::fromDecoded(base32_decode(encoded: $data['value'], strict: true)),
+                default => throw new ValueError('Unknown or unsupported type: '.json_encode($data)),
+            },
+        };
+    }
+
+    /**
+     * @param array<array{0:string, 1:itemValue> $parameters
+     */
+    private static function parseParameters(array $parameters): Parameters
+    {
+        return Parameters::fromPairs(array_map(
+            fn ($value) => [$value[0], self::parseValue($value[1])],
+            $parameters
+        ));
+    }
+
+    /**
+     * @param array{0:itemValue, 1:array<array{0:string, 1:itemValue}>}|itemValue $value
+     */
+    private static function parseItem(mixed $value): ?Item
+    {
+        return match (true) {
+            !is_array($value) => Item::new($value),
+            [] === $value => null,
+            default => Item::new([
+                self::parseValue($value[0]),
+                self::parseParameters($value[1]),
+            ]),
+        };
+    }
+
+    private static function parseInnerList(array $innerListPair): InnerList
+    {
+        return InnerList::fromPair([
+            array_map(fn ($value) => self::parseItem($value), $innerListPair[0]),
+            self::parseParameters($innerListPair[1]),
+        ]);
+    }
+
+    private static function parseList(array $listPairs): OuterList
+    {
+        return OuterList::fromPairs(array_map(
+            fn ($value) => is_array($value[0]) && array_is_list($value[0]) ? self::parseInnerList($value) : self::parseItem($value),
+            $listPairs
+        ));
+    }
+
+    private static function parseDictionary(array $dictionaryPair): Dictionary
+    {
+        return Dictionary::fromPairs(array_map(
+            fn ($value) => [
+                $value[0],
+                is_array($value[1][0]) && array_is_list($value[1][0]) ? self::parseInnerList($value[1]) : self::parseItem($value[1]),
+            ],
+            $dictionaryPair
+        ));
+    }
 }

tests/StructuredFieldTestCase.php

@@ -30,7 +30,10 @@ public function it_can_pass_http_wg_tests(Record $test): void
         $structuredField = DataType::from($test->type)->parse(implode(',', $test->raw));
 
         if (!$test->mustFail) {
-            self::assertSame(implode(',', $test->canonical), $structuredField->toHttpValue());
+            self::assertSame(
+                $test->expected?->toHttpValue() ?? implode(',', $test->canonical),
+                $structuredField->toHttpValue()
+            );
         }
     }