Normalize variable name and SyntaxError messages

nyamsprod · nyamsprod · commit 7b16f3dc7c4f · 2022-03-12T16:06:20.000+01:00
diff --git a/src/Dictionary.php b/src/Dictionary.php
@@ -27,23 +27,23 @@ public function __construct(iterable $elements = [])
         }
     }
 
-    public static function fromHttpValue(string $field): self
+    public static function fromHttpValue(string $httpValue): self
     {
         $instance = new self();
-        $field = trim($field, ' ');
-        if ('' === $field) {
+        $httpValue = trim($httpValue, ' ');
+        if ('' === $httpValue) {
             return $instance;
         }
 
-        if (1 === preg_match("/[^\x20-\x7E\t]/", $field) || str_starts_with($field, "\t")) {
-            throw new SyntaxError("Dictionary field `$field` contains invalid characters.");
+        if (1 === preg_match("/[^\x20-\x7E\t]/", $httpValue) || str_starts_with($httpValue, "\t")) {
+            throw new SyntaxError("The HTTP textual representation `$httpValue` for dictionary contains invalid characters.");
         }
 
         $parser = fn (string $element): Item|InnerList => str_starts_with($element, '(')
             ? InnerList::fromHttpValue($element)
             : Item::fromHttpValue($element);
 
-        return array_reduce(explode(',', $field), function (self $instance, string $element) use ($parser): self {
+        return array_reduce(explode(',', $httpValue), function (self $instance, string $element) use ($parser): self {
             [$key, $value] = self::extractPair($element);
 
             $instance->set($key, $parser($value));
@@ -66,11 +66,11 @@ private static function extractPair(string $element): array
         }
 
         if (1 !== preg_match('/^(?<key>[a-z*][a-z0-9.*_-]*)(=)?(?<value>.*)/', $element, $found)) {
-            throw new SyntaxError("Dictionary pair `$element` contains invalid characters.");
+            throw new SyntaxError("The HTTP textual representation `$element` for a dictionary pair contains invalid characters.");
         }
 
         if (rtrim($found['key']) !== $found['key'] || ltrim($found['value']) !== $found['value']) {
-            throw new SyntaxError("Dictionary pair `$element` contains invalid characters.");
+            throw new SyntaxError("The HTTP textual representation `$element` for a dictionary pair contains invalid characters.");
         }
 
         $found['value'] = trim($found['value']);
@@ -161,7 +161,7 @@ public function set(string $key, InnerList|Item|ByteSequence|Token|bool|int|floa
     private static function validateKey(string $key): void
     {
         if (1 !== preg_match('/^[a-z*][a-z0-9.*_-]*$/', $key)) {
-            throw new SyntaxError("Key `$key` contains invalid characters.");
+            throw new SyntaxError("The dictionary key `$key` contains invalid characters.");
         }
     }
 
diff --git a/src/InnerList.php b/src/InnerList.php
@@ -31,16 +31,16 @@ public function __construct(iterable $elements = [], iterable $parameters = [])
         $this->parameters = $parameters instanceof Parameters ? $parameters : Parameters::fromItems($parameters);
     }
 
-    public static function fromHttpValue(string $field): self
+    public static function fromHttpValue(string $httpValue): self
     {
-        $field = trim($field);
+        $field = trim($httpValue);
 
         if (1 !== preg_match("/^\((?<content>.*)\)(?<parameters>[^,]*)/", $field, $found)) {
-            throw new SyntaxError("InnerList field `$field` contains invalid characters.");
+            throw new SyntaxError("InnerList field `$httpValue` contains invalid characters.");
         }
 
         if ('' !== $found['parameters'] && !str_starts_with($found['parameters'], ';')) {
-            throw new SyntaxError("InnerList field `$field` contains invalid characters.");
+            throw new SyntaxError("InnerList field `$httpValue` contains invalid characters.");
         }
 
         /** @var string $content */
diff --git a/src/Item.php b/src/Item.php
@@ -54,19 +54,19 @@ private static function filterInteger(int $value): int
         return $value;
     }
 
-    public static function fromHttpValue(string $field): self
+    public static function fromHttpValue(string $httpValue): self
     {
-        $field = trim($field, ' ');
+        $httpValue = trim($httpValue, ' ');
         [$value, $parameters] = match (true) {
-            $field === '',
-            1 === preg_match("/[\r\t\n]/", $field),
-            1 === preg_match("/[^\x20-\x7E]/", $field) => throw new SyntaxError("Item field `$field` contains invalid characters."),
-            1 === preg_match('/^(-?[0-9])/', $field) => self::parseNumber($field),
-            $field[0] == '"' => self::parseString($field),
-            $field[0] == ':' => self::parseBytesSequence($field),
-            $field[0] == '?' => self::parseBoolean($field),
-            1 === preg_match('/^([a-z*])/i', $field) => self::parseToken($field),
-            default => throw new SyntaxError("Item field `$field` is unknown or unsupported."),
+            $httpValue === '',
+            1 === preg_match("/[\r\t\n]/", $httpValue),
+            1 === preg_match("/[^\x20-\x7E]/", $httpValue) => throw new SyntaxError("Item field `$httpValue` contains invalid characters."),
+            1 === preg_match('/^(-?[0-9])/', $httpValue) => self::parseNumber($httpValue),
+            $httpValue[0] == '"' => self::parseString($httpValue),
+            $httpValue[0] == ':' => self::parseBytesSequence($httpValue),
+            $httpValue[0] == '?' => self::parseBoolean($httpValue),
+            1 === preg_match('/^([a-z*])/i', $httpValue) => self::parseToken($httpValue),
+            default => throw new SyntaxError("Item field `$httpValue` is unknown or unsupported."),
         };
 
         return new self($value, Parameters::fromHttpValue($parameters));
diff --git a/src/OrderedList.php b/src/OrderedList.php
@@ -27,10 +27,10 @@ public function __construct(iterable $elements = [])
         }
     }
 
-    public static function fromHttpValue(string $field): self
+    public static function fromHttpValue(string $httpValue): self
     {
-        $field = trim($field, ' ');
-        if ('' === $field) {
+        $httpValue = trim($httpValue, ' ');
+        if ('' === $httpValue) {
             return new self();
         }
 
@@ -40,7 +40,7 @@ public static function fromHttpValue(string $field): self
             return $carry;
         };
 
-        return array_reduce(explode(',', $field), $reducer, new self());
+        return array_reduce(explode(',', $httpValue), $reducer, new self());
     }
 
     private static function parseItemOrInnerList(string $element): Item|InnerList
diff --git a/src/Parameters.php b/src/Parameters.php
@@ -48,18 +48,17 @@ private static function filterElement(Item|ByteSequence|Token|bool|int|float|str
         };
     }
 
-    public static function fromHttpValue(string $field): self
+    public static function fromHttpValue(string $httpValue): self
     {
-        $instance = new self();
-        if ('' === $field) {
-            return $instance;
+        $parameters = new self();
+        if ('' === $httpValue) {
+            return $parameters;
         }
 
-        $parameters = new self();
-        foreach (explode(';', $field) as $pair) {
+        foreach (explode(';', $httpValue) as $pair) {
             [$key, $value] = explode('=', $pair, 2) + [1 => '?1'];
             if (rtrim($key) !== $key || ltrim($value) !== $value) {
-                throw new SyntaxError("Invalid parameter pair: `$field`.");
+                throw new SyntaxError("The HTTP textual representation `$pair` for a parameter pair contains invalid characters.");
             }
 
             $key = trim($key);
@@ -145,7 +144,7 @@ public function toHttpValue(): string
 
         foreach ($this->elements as $key => $val) {
             if (!$val->parameters()->isEmpty()) {
-                throw new SyntaxError('the Item cannot be parameterized.');
+                throw new SyntaxError('Parameters instances can not contain parameterized Items.');
             }
 
             $value = ';'.$key;
@@ -170,11 +169,11 @@ public function set(string $key, Item|ByteSequence|Token|bool|int|float|string $
     private static function validate(string $key, Item $item): void
     {
         if (1 !== preg_match('/^[a-z*][a-z0-9.*_-]*$/', $key)) {
-            throw new SyntaxError('Invalid characters in key: `'.$key.'`');
+            throw new SyntaxError("The Parameters key `$key` contains invalid characters.");
         }
 
         if (!$item->parameters()->isEmpty()) {
-            throw new SyntaxError('the Item cannot be parameterized.');
+            throw new SyntaxError('Parameters instances can not contain parameterized Items.');
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -27,23 +27,23 @@ public function __construct(iterable $elements = [])`
`27`	`27`	`}`
`28`	`28`	`}`
`29`	`29`
`30`		`- public static function fromHttpValue(string $field): self`
	`30`	`+ public static function fromHttpValue(string $httpValue): self`
`31`	`31`	`{`
`32`	`32`	`$instance = new self();`
`33`		`- $field = trim($field, ' ');`
`34`		`- if ('' === $field) {`
	`33`	`+ $httpValue = trim($httpValue, ' ');`
	`34`	`+ if ('' === $httpValue) {`
`35`	`35`	`return $instance;`
`36`	`36`	`}`
`37`	`37`
`38`		`- if (1 === preg_match("/[^\x20-\x7E\t]/", $field) \|\| str_starts_with($field, "\t")) {`
`39`		- throw new SyntaxError("Dictionary field `$field` contains invalid characters.");
	`38`	`+ if (1 === preg_match("/[^\x20-\x7E\t]/", $httpValue) \|\| str_starts_with($httpValue, "\t")) {`
	`39`	+ throw new SyntaxError("The HTTP textual representation `$httpValue` for dictionary contains invalid characters.");
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`$parser = fn (string $element): Item\|InnerList => str_starts_with($element, '(')`
`43`	`43`	`? InnerList::fromHttpValue($element)`
`44`	`44`	`: Item::fromHttpValue($element);`
`45`	`45`
`46`		`- return array_reduce(explode(',', $field), function (self $instance, string $element) use ($parser): self {`
	`46`	`+ return array_reduce(explode(',', $httpValue), function (self $instance, string $element) use ($parser): self {`
`47`	`47`	`[$key, $value] = self::extractPair($element);`
`48`	`48`
`49`	`49`	`$instance->set($key, $parser($value));`
`@@ -66,11 +66,11 @@ private static function extractPair(string $element): array`
`66`	`66`	`}`
`67`	`67`
`68`	`68`	`if (1 !== preg_match('/^(?<key>[a-z][a-z0-9._-])(=)?(?<value>.)/', $element, $found)) {`
`69`		- throw new SyntaxError("Dictionary pair `$element` contains invalid characters.");
	`69`	+ throw new SyntaxError("The HTTP textual representation `$element` for a dictionary pair contains invalid characters.");
`70`	`70`	`}`
`71`	`71`
`72`	`72`	`if (rtrim($found['key']) !== $found['key'] \|\| ltrim($found['value']) !== $found['value']) {`
`73`		- throw new SyntaxError("Dictionary pair `$element` contains invalid characters.");
	`73`	+ throw new SyntaxError("The HTTP textual representation `$element` for a dictionary pair contains invalid characters.");
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`$found['value'] = trim($found['value']);`
`@@ -161,7 +161,7 @@ public function set(string $key, InnerList\|Item\|ByteSequence\|Token\|bool\|int\|floa`
`161`	`161`	`private static function validateKey(string $key): void`
`162`	`162`	`{`
`163`	`163`	`if (1 !== preg_match('/^[a-z][a-z0-9._-]*$/', $key)) {`
`164`		- throw new SyntaxError("Key `$key` contains invalid characters.");
	`164`	+ throw new SyntaxError("The dictionary key `$key` contains invalid characters.");
`165`	`165`	`}`
`166`	`166`	`}`
`167`	`167`
Original file line number	Diff line number	Diff line change
`@@ -31,16 +31,16 @@ public function __construct(iterable $elements = [], iterable $parameters = [])`
`31`	`31`	`$this->parameters = $parameters instanceof Parameters ? $parameters : Parameters::fromItems($parameters);`
`32`	`32`	`}`
`33`	`33`
`34`		`- public static function fromHttpValue(string $field): self`
	`34`	`+ public static function fromHttpValue(string $httpValue): self`
`35`	`35`	`{`
`36`		`- $field = trim($field);`
	`36`	`+ $field = trim($httpValue);`
`37`	`37`
`38`	`38`	`if (1 !== preg_match("/^\((?<content>.)\)(?<parameters>[^,])/", $field, $found)) {`
`39`		- throw new SyntaxError("InnerList field `$field` contains invalid characters.");
	`39`	+ throw new SyntaxError("InnerList field `$httpValue` contains invalid characters.");
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`if ('' !== $found['parameters'] && !str_starts_with($found['parameters'], ';')) {`
`43`		- throw new SyntaxError("InnerList field `$field` contains invalid characters.");
	`43`	+ throw new SyntaxError("InnerList field `$httpValue` contains invalid characters.");
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`/** @var string $content */`
Original file line number	Diff line number	Diff line change
`@@ -27,10 +27,10 @@ public function __construct(iterable $elements = [])`
`27`	`27`	`}`
`28`	`28`	`}`
`29`	`29`
`30`		`- public static function fromHttpValue(string $field): self`
	`30`	`+ public static function fromHttpValue(string $httpValue): self`
`31`	`31`	`{`
`32`		`- $field = trim($field, ' ');`
`33`		`- if ('' === $field) {`
	`32`	`+ $httpValue = trim($httpValue, ' ');`
	`33`	`+ if ('' === $httpValue) {`
`34`	`34`	`return new self();`
`35`	`35`	`}`
`36`	`36`
`@@ -40,7 +40,7 @@ public static function fromHttpValue(string $field): self`
`40`	`40`	`return $carry;`
`41`	`41`	`};`
`42`	`42`
`43`		`- return array_reduce(explode(',', $field), $reducer, new self());`
	`43`	`+ return array_reduce(explode(',', $httpValue), $reducer, new self());`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`private static function parseItemOrInnerList(string $element): Item\|InnerList`
Original file line number	Diff line number	Diff line change
`@@ -48,18 +48,17 @@ private static function filterElement(Item\|ByteSequence\|Token\|bool\|int\|float\|str`
`48`	`48`	`};`
`49`	`49`	`}`
`50`	`50`
`51`		`- public static function fromHttpValue(string $field): self`
	`51`	`+ public static function fromHttpValue(string $httpValue): self`
`52`	`52`	`{`
`53`		`- $instance = new self();`
`54`		`- if ('' === $field) {`
`55`		`- return $instance;`
	`53`	`+ $parameters = new self();`
	`54`	`+ if ('' === $httpValue) {`
	`55`	`+ return $parameters;`
`56`	`56`	`}`
`57`	`57`
`58`		`- $parameters = new self();`
`59`		`- foreach (explode(';', $field) as $pair) {`
	`58`	`+ foreach (explode(';', $httpValue) as $pair) {`
`60`	`59`	`[$key, $value] = explode('=', $pair, 2) + [1 => '?1'];`
`61`	`60`	`if (rtrim($key) !== $key \|\| ltrim($value) !== $value) {`
`62`		- throw new SyntaxError("Invalid parameter pair: `$field`.");
	`61`	+ throw new SyntaxError("The HTTP textual representation `$pair` for a parameter pair contains invalid characters.");
`63`	`62`	`}`
`64`	`63`
`65`	`64`	`$key = trim($key);`
`@@ -145,7 +144,7 @@ public function toHttpValue(): string`
`145`	`144`
`146`	`145`	`foreach ($this->elements as $key => $val) {`
`147`	`146`	`if (!$val->parameters()->isEmpty()) {`
`148`		`- throw new SyntaxError('the Item cannot be parameterized.');`
	`147`	`+ throw new SyntaxError('Parameters instances can not contain parameterized Items.');`
`149`	`148`	`}`
`150`	`149`
`151`	`150`	`$value = ';'.$key;`
`@@ -170,11 +169,11 @@ public function set(string $key, Item\|ByteSequence\|Token\|bool\|int\|float\|string $`
`170`	`169`	`private static function validate(string $key, Item $item): void`
`171`	`170`	`{`
`172`	`171`	`if (1 !== preg_match('/^[a-z][a-z0-9._-]*$/', $key)) {`
`173`		- throw new SyntaxError('Invalid characters in key: `'.$key.'`');
	`172`	+ throw new SyntaxError("The Parameters key `$key` contains invalid characters.");
`174`	`173`	`}`
`175`	`174`
`176`	`175`	`if (!$item->parameters()->isEmpty()) {`
`177`		`- throw new SyntaxError('the Item cannot be parameterized.');`
	`176`	`+ throw new SyntaxError('Parameters instances can not contain parameterized Items.');`
`178`	`177`	`}`
`179`	`178`	`}`
`180`	`179`