Add helpers for token validation

src/parser.rs

@@ -290,7 +290,7 @@ impl<'a> Parser<'a> {
         // https://httpwg.org/specs/rfc8941.html#parse-token
 
         if let Some(first_char) = self.input.peek() {
-            if !first_char.is_ascii_alphabetic() && first_char != &b'*' {
+            if !utils::is_token_start(*first_char) {
                 return Err("parse_token: first character is not ALPHA or '*'");
             }
         } else {
@@ -299,7 +299,7 @@ impl<'a> Parser<'a> {
 
         let mut output_string = String::from("");
         while let Some(curr_char) = self.input.peek() {
-            if !utils::is_tchar(*curr_char) && curr_char != &b':' && curr_char != &b'/' {
+            if !utils::is_token_continue(*curr_char) {
                 return Ok(output_string);
             }
 

src/serializer.rs

@@ -274,19 +274,18 @@ impl Serializer {
             return Err("serialize_token: non-ascii character");
         }
 
-        match value.chars().next() {
+        let mut bytes = value.bytes();
+
+        match bytes.next() {
             None => return Err("serialize_token: token is empty"),
-            Some(char) => {
-                if !(char.is_ascii_alphabetic() || char == '*') {
+            Some(c) => {
+                if !utils::is_token_start(c) {
                     return Err("serialize_token: first character is not ALPHA or '*'");
                 }
             }
         }
 
-        if value
-            .bytes()
-            .any(|c| !(utils::is_tchar(c) || c == b':' || c == b'/'))
-        {
+        if bytes.any(|c| !utils::is_token_continue(c)) {
             return Err("serialize_token: disallowed character");
         }
 

src/utils.rs

@@ -8,8 +8,16 @@ pub(crate) const BASE64: engine::GeneralPurpose = engine::GeneralPurpose::new(
         .with_encode_padding(true),
 );
 
-pub(crate) fn is_tchar(c: u8) -> bool {
+fn is_tchar(c: u8) -> bool {
     // See tchar values list in https://tools.ietf.org/html/rfc7230#section-3.2.6
     let tchars = b"!#$%&'*+-.^_`|~";
     tchars.contains(&c) || c.is_ascii_alphanumeric()
 }
+
+pub(crate) fn is_token_start(c: u8) -> bool {
+    c.is_ascii_alphabetic() || c == b'*'
+}
+
+pub(crate) fn is_token_continue(c: u8) -> bool {
+    is_tchar(c) || c == b':' || c == b'/'
+}