Improve decoupling from Parser

nyamsprod · nyamsprod · commit 7f6636299089 · 2023-04-22T13:56:41.000+02:00
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -2,6 +2,24 @@
 
 All Notable changes to `bakame/http-strucured-fields` will be documented in this file.
 
+## [Next] - TBD
+
+### Added
+
+- None
+
+### Fixed
+
+- `Item::parameter` and `InnerList::parameter` now supports accessing parameters value per index.
+
+### Deprecated
+
+- None
+
+### Removed
+
+- None
+
 ## [1.0.1] - 2023-04-20
 
 ### Added
diff --git a/src/InnerList.php b/src/InnerList.php
@@ -135,10 +135,13 @@ public function parameters(): Parameters
         return $this->parameters;
     }
 
-    public function parameter(string $key): Token|ByteSequence|DateTimeImmutable|int|float|string|bool|null
+    public function parameter(string|int $key): Token|ByteSequence|DateTimeImmutable|int|float|string|bool|null
     {
         try {
-            return $this->parameters->get($key)->value();
+            return match (true) {
+                is_int($key) => $this->parameters->pair($key)[1]->value(),
+                default => $this->parameters->get($key)->value(),
+            };
         } catch (StructuredFieldError) {
             return null;
         }
diff --git a/src/InnerListTest.php b/src/InnerListTest.php
@@ -132,6 +132,9 @@ public function it_can_access_its_parameter_values(): void
 
         self::assertSame('bar', $instance->parameters()->get('foo')->value());
         self::assertSame('bar', $instance->parameter('foo'));
+        self::assertSame('bar', $instance->parameter(0));
+        self::assertNull($instance->parameter('non-existing-key'));
+        self::assertNull($instance->parameter(-42));
     }
 
     #[Test]
diff --git a/src/Item.php b/src/Item.php
@@ -219,10 +219,13 @@ public function parameters(): Parameters
         return $this->parameters;
     }
 
-    public function parameter(string $key): Token|ByteSequence|DateTimeImmutable|int|float|string|bool|null
+    public function parameter(string|int $key): Token|ByteSequence|DateTimeImmutable|int|float|string|bool|null
     {
         try {
-            return $this->parameters->get($key)->value();
+            return match (true) {
+                is_int($key) => $this->parameters->pair($key)[1]->value(),
+                default => $this->parameters->get($key)->value(),
+            };
         } catch (StructuredFieldError) {
             return null;
         }
diff --git a/src/ItemTest.php b/src/ItemTest.php
@@ -429,8 +429,11 @@ public function it_can_create_via_parameters_access_methods_a_new_object(): void
         self::assertEquals($instance1->value(), $instance3->value());
         self::assertSame($instance1, $instance4);
         self::assertTrue($instance1->parameter('a'));
+        self::assertTrue($instance1->parameter(0));
         self::assertNull($instance5->parameter('a'));
         self::assertTrue($instance5->parameters()->hasNoMembers());
         self::assertTrue($instance6->parameters()->hasNoMembers());
+        self::assertNull($instance1->parameter('non-existing-key'));
+        self::assertNull($instance1->parameter(-42));
     }
 }
diff --git a/src/Parser.php b/src/Parser.php
@@ -51,7 +51,7 @@ public static function parseItem(Stringable|string $httpValue): array
             throw new SyntaxError('The HTTP textual representation "'.$httpValue.'" for an item contains invalid characters.');
         }
 
-        [$value, $offset] = Parser::parseBareItem($itemString);
+        [$value, $offset] = Parser::parseValue($itemString);
         $remainder = substr($itemString, $offset);
         if ('' !== $remainder && !str_contains($remainder, ';')) {
             throw new SyntaxError('The HTTP textual representation "'.$httpValue.'" for an item contains invalid characters.');
@@ -72,7 +72,7 @@ public static function parseItem(Stringable|string $httpValue): array
     public static function parseParameters(Stringable|string $httpValue): array
     {
         $httpValue = trim((string) $httpValue);
-        [$parameters, $offset] = Parser::parseContainedParameters($httpValue);
+        [$parameters, $offset] = Parser::parseParametersValues($httpValue);
         if (strlen($httpValue) !== $offset) {
             throw new SyntaxError('The HTTP textual representation "'.$httpValue.'" for Parameters contains invalid characters.');
         }
@@ -194,7 +194,7 @@ private static function parseItemOrInnerList(string $httpValue): array
             return self::parseInnerListValue($httpValue);
         }
 
-        [$item, $remainder] = self::parseContainedItem($httpValue);
+        [$item, $remainder] = self::parseItemValue($httpValue);
 
         return [$item, strlen($httpValue) - strlen($remainder)];
     }
@@ -215,13 +215,13 @@ private static function parseInnerListValue(string $httpValue): array
 
             if (')' === $remainder[0]) {
                 $remainder = substr($remainder, 1);
-                [$parameters, $offset] = self::parseContainedParameters($remainder);
+                [$parameters, $offset] = self::parseParametersValues($remainder);
                 $remainder = substr($remainder, $offset);
 
                 return [[$list, $parameters], strlen($httpValue) - strlen($remainder)];
             }
 
-            [$list[], $remainder] = self::parseContainedItem($remainder);
+            [$list[], $remainder] = self::parseItemValue($remainder);
 
             if ('' !== $remainder && !in_array($remainder[0], [' ', ')'], true)) {
                 throw new SyntaxError("The HTTP textual representation \"$remainder\" for a inner list is using invalid characters.");
@@ -236,11 +236,11 @@ private static function parseInnerListValue(string $httpValue): array
      *
      * @return array{0:array{0:SfType, 1:array<string, SfType>}, 1:string}
      */
-    private static function parseContainedItem(string $remainder): array
+    private static function parseItemValue(string $remainder): array
     {
-        [$value, $offset] = self::parseBareItem($remainder);
+        [$value, $offset] = self::parseValue($remainder);
         $remainder = substr($remainder, $offset);
-        [$parameters, $offset] = self::parseContainedParameters($remainder);
+        [$parameters, $offset] = self::parseParametersValues($remainder);
 
         return [[$value, $parameters], substr($remainder, $offset)];
     }
@@ -252,7 +252,7 @@ private static function parseContainedItem(string $remainder): array
      *
      * @return array{0:SfType, 1:int}
      */
-    private static function parseBareItem(string $httpValue): array
+    private static function parseValue(string $httpValue): array
     {
         return match (true) {
             '"' === $httpValue[0] => self::parseString($httpValue),
@@ -272,7 +272,7 @@ private static function parseBareItem(string $httpValue): array
      *
      * @return array{0:array<string, SfType>, 1:int}
      */
-    private static function parseContainedParameters(Stringable|string $httpValue): array
+    private static function parseParametersValues(Stringable|string $httpValue): array
     {
         $map = [];
         $httpValue = (string) $httpValue;
@@ -287,7 +287,7 @@ private static function parseContainedParameters(Stringable|string $httpValue):
             if ('' !== $remainder && '=' === $remainder[0]) {
                 $remainder = substr($remainder, 1);
 
-                [$map[$key], $offset] = self::parseBareItem($remainder);
+                [$map[$key], $offset] = self::parseValue($remainder);
                 $remainder = substr($remainder, $offset);
             }
         }

Original file line number	Diff line number	Diff line change
`@@ -135,10 +135,13 @@ public function parameters(): Parameters`
`135`	`135`	`return $this->parameters;`
`136`	`136`	`}`
`137`	`137`
`138`		`- public function parameter(string $key): Token\|ByteSequence\|DateTimeImmutable\|int\|float\|string\|bool\|null`
	`138`	`+ public function parameter(string\|int $key): Token\|ByteSequence\|DateTimeImmutable\|int\|float\|string\|bool\|null`
`139`	`139`	`{`
`140`	`140`	`try {`
`141`		`- return $this->parameters->get($key)->value();`
	`141`	`+ return match (true) {`
	`142`	`+ is_int($key) => $this->parameters->pair($key)[1]->value(),`
	`143`	`+ default => $this->parameters->get($key)->value(),`
	`144`	`+ };`
`142`	`145`	`} catch (StructuredFieldError) {`
`143`	`146`	`return null;`
`144`	`147`	`}`
Original file line number	Diff line number	Diff line change
`@@ -132,6 +132,9 @@ public function it_can_access_its_parameter_values(): void`
`132`	`132`
`133`	`133`	`self::assertSame('bar', $instance->parameters()->get('foo')->value());`
`134`	`134`	`self::assertSame('bar', $instance->parameter('foo'));`
	`135`	`+ self::assertSame('bar', $instance->parameter(0));`
	`136`	`+ self::assertNull($instance->parameter('non-existing-key'));`
	`137`	`+ self::assertNull($instance->parameter(-42));`
`135`	`138`	`}`
`136`	`139`
`137`	`140`	`#[Test]`
Original file line number	Diff line number	Diff line change
`@@ -219,10 +219,13 @@ public function parameters(): Parameters`
`219`	`219`	`return $this->parameters;`
`220`	`220`	`}`
`221`	`221`
`222`		`- public function parameter(string $key): Token\|ByteSequence\|DateTimeImmutable\|int\|float\|string\|bool\|null`
	`222`	`+ public function parameter(string\|int $key): Token\|ByteSequence\|DateTimeImmutable\|int\|float\|string\|bool\|null`
`223`	`223`	`{`
`224`	`224`	`try {`
`225`		`- return $this->parameters->get($key)->value();`
	`225`	`+ return match (true) {`
	`226`	`+ is_int($key) => $this->parameters->pair($key)[1]->value(),`
	`227`	`+ default => $this->parameters->get($key)->value(),`
	`228`	`+ };`
`226`	`229`	`} catch (StructuredFieldError) {`
`227`	`230`	`return null;`
`228`	`231`	`}`
Original file line number	Diff line number	Diff line change
`@@ -429,8 +429,11 @@ public function it_can_create_via_parameters_access_methods_a_new_object(): void`
`429`	`429`	`self::assertEquals($instance1->value(), $instance3->value());`
`430`	`430`	`self::assertSame($instance1, $instance4);`
`431`	`431`	`self::assertTrue($instance1->parameter('a'));`
	`432`	`+ self::assertTrue($instance1->parameter(0));`
`432`	`433`	`self::assertNull($instance5->parameter('a'));`
`433`	`434`	`self::assertTrue($instance5->parameters()->hasNoMembers());`
`434`	`435`	`self::assertTrue($instance6->parameters()->hasNoMembers());`
	`436`	`+ self::assertNull($instance1->parameter('non-existing-key'));`
	`437`	`+ self::assertNull($instance1->parameter(-42));`
`435`	`438`	`}`
`436`	`439`	`}`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ public static function parseItem(Stringable\|string $httpValue): array`
`51`	`51`	`throw new SyntaxError('The HTTP textual representation "'.$httpValue.'" for an item contains invalid characters.');`
`52`	`52`	`}`
`53`	`53`
`54`		`- [$value, $offset] = Parser::parseBareItem($itemString);`
	`54`	`+ [$value, $offset] = Parser::parseValue($itemString);`
`55`	`55`	`$remainder = substr($itemString, $offset);`
`56`	`56`	`if ('' !== $remainder && !str_contains($remainder, ';')) {`
`57`	`57`	`throw new SyntaxError('The HTTP textual representation "'.$httpValue.'" for an item contains invalid characters.');`
`@@ -72,7 +72,7 @@ public static function parseItem(Stringable\|string $httpValue): array`
`72`	`72`	`public static function parseParameters(Stringable\|string $httpValue): array`
`73`	`73`	`{`
`74`	`74`	`$httpValue = trim((string) $httpValue);`
`75`		`- [$parameters, $offset] = Parser::parseContainedParameters($httpValue);`
	`75`	`+ [$parameters, $offset] = Parser::parseParametersValues($httpValue);`
`76`	`76`	`if (strlen($httpValue) !== $offset) {`
`77`	`77`	`throw new SyntaxError('The HTTP textual representation "'.$httpValue.'" for Parameters contains invalid characters.');`
`78`	`78`	`}`
`@@ -194,7 +194,7 @@ private static function parseItemOrInnerList(string $httpValue): array`
`194`	`194`	`return self::parseInnerListValue($httpValue);`
`195`	`195`	`}`
`196`	`196`
`197`		`- [$item, $remainder] = self::parseContainedItem($httpValue);`
	`197`	`+ [$item, $remainder] = self::parseItemValue($httpValue);`
`198`	`198`
`199`	`199`	`return [$item, strlen($httpValue) - strlen($remainder)];`
`200`	`200`	`}`
`@@ -215,13 +215,13 @@ private static function parseInnerListValue(string $httpValue): array`
`215`	`215`
`216`	`216`	`if (')' === $remainder[0]) {`
`217`	`217`	`$remainder = substr($remainder, 1);`
`218`		`- [$parameters, $offset] = self::parseContainedParameters($remainder);`
	`218`	`+ [$parameters, $offset] = self::parseParametersValues($remainder);`
`219`	`219`	`$remainder = substr($remainder, $offset);`
`220`	`220`
`221`	`221`	`return [[$list, $parameters], strlen($httpValue) - strlen($remainder)];`
`222`	`222`	`}`
`223`	`223`
`224`		`- [$list[], $remainder] = self::parseContainedItem($remainder);`
	`224`	`+ [$list[], $remainder] = self::parseItemValue($remainder);`
`225`	`225`
`226`	`226`	`if ('' !== $remainder && !in_array($remainder[0], [' ', ')'], true)) {`
`227`	`227`	`throw new SyntaxError("The HTTP textual representation \"$remainder\" for a inner list is using invalid characters.");`
`@@ -236,11 +236,11 @@ private static function parseInnerListValue(string $httpValue): array`
`236`	`236`	`*`
`237`	`237`	`* @return array{0:array{0:SfType, 1:array<string, SfType>}, 1:string}`
`238`	`238`	`*/`
`239`		`- private static function parseContainedItem(string $remainder): array`
	`239`	`+ private static function parseItemValue(string $remainder): array`
`240`	`240`	`{`
`241`		`- [$value, $offset] = self::parseBareItem($remainder);`
	`241`	`+ [$value, $offset] = self::parseValue($remainder);`
`242`	`242`	`$remainder = substr($remainder, $offset);`
`243`		`- [$parameters, $offset] = self::parseContainedParameters($remainder);`
	`243`	`+ [$parameters, $offset] = self::parseParametersValues($remainder);`
`244`	`244`
`245`	`245`	`return [[$value, $parameters], substr($remainder, $offset)];`
`246`	`246`	`}`
`@@ -252,7 +252,7 @@ private static function parseContainedItem(string $remainder): array`
`252`	`252`	`*`
`253`	`253`	`* @return array{0:SfType, 1:int}`
`254`	`254`	`*/`
`255`		`- private static function parseBareItem(string $httpValue): array`
	`255`	`+ private static function parseValue(string $httpValue): array`
`256`	`256`	`{`
`257`	`257`	`return match (true) {`
`258`	`258`	`'"' === $httpValue[0] => self::parseString($httpValue),`
`@@ -272,7 +272,7 @@ private static function parseBareItem(string $httpValue): array`
`272`	`272`	`*`
`273`	`273`	`* @return array{0:array<string, SfType>, 1:int}`
`274`	`274`	`*/`
`275`		`- private static function parseContainedParameters(Stringable\|string $httpValue): array`
	`275`	`+ private static function parseParametersValues(Stringable\|string $httpValue): array`
`276`	`276`	`{`
`277`	`277`	`$map = [];`
`278`	`278`	`$httpValue = (string) $httpValue;`
`@@ -287,7 +287,7 @@ private static function parseContainedParameters(Stringable\|string $httpValue):`
`287`	`287`	`if ('' !== $remainder && '=' === $remainder[0]) {`
`288`	`288`	`$remainder = substr($remainder, 1);`
`289`	`289`
`290`		`- [$map[$key], $offset] = self::parseBareItem($remainder);`
	`290`	`+ [$map[$key], $offset] = self::parseValue($remainder);`
`291`	`291`	`$remainder = substr($remainder, $offset);`
`292`	`292`	`}`
`293`	`293`	`}`