Propagate parser input as field on self

This simplifies the implementation and will make it easier to add parser configurations like RFC 8941 vs RFC 9651. We also add a Parser::from_str method to simplify callers.
undef1nd · Feb 11, 2025 · 6b100b6 · 6b100b6
1 parent c7eaa2f
commit 6b100b6
Show file tree

Hide file tree

Showing 11 changed files with 383 additions and 437 deletions.
diff --git a/benches/bench.rs b/benches/bench.rs
@@ -17,7 +17,7 @@ fn parsing_item(c: &mut Criterion) {
         BenchmarkId::new("parsing_item", fixture),
         &fixture,
         move |bench, &input| {
-            bench.iter(|| Parser::parse_item(input.as_bytes()).unwrap());
+            bench.iter(|| Parser::from_str(input).parse_item().unwrap());
         },
     );
 }
@@ -28,7 +28,7 @@ fn parsing_list(c: &mut Criterion) {
         BenchmarkId::new("parsing_list", fixture),
         &fixture,
         move |bench, &input| {
-            bench.iter(|| Parser::parse_list(input.as_bytes()).unwrap());
+            bench.iter(|| Parser::from_str(input).parse_list().unwrap());
         },
     );
 }
@@ -39,7 +39,7 @@ fn parsing_dict(c: &mut Criterion) {
         BenchmarkId::new("parsing_dict", fixture),
         &fixture,
         move |bench, &input| {
-            bench.iter(|| Parser::parse_dictionary(input.as_bytes()).unwrap());
+            bench.iter(|| Parser::from_str(input).parse_dictionary().unwrap());
         },
     );
 }
@@ -58,7 +58,7 @@ fn serializing_item(c: &mut Criterion) {
         BenchmarkId::new("serializing_item", fixture),
         &fixture,
         move |bench, &input| {
-            let parsed_item = Parser::parse_item(input.as_bytes()).unwrap();
+            let parsed_item = Parser::from_str(input).parse_item().unwrap();
             bench.iter(|| parsed_item.serialize_value().unwrap());
         },
     );
@@ -70,7 +70,7 @@ fn serializing_list(c: &mut Criterion) {
         BenchmarkId::new("serializing_list", fixture),
         &fixture,
         move |bench, &input| {
-            let parsed_list = Parser::parse_list(input.as_bytes()).unwrap();
+            let parsed_list = Parser::from_str(input).parse_list().unwrap();
             bench.iter(|| parsed_list.serialize_value().unwrap());
         },
     );
@@ -82,7 +82,7 @@ fn serializing_dict(c: &mut Criterion) {
         BenchmarkId::new("serializing_dict", fixture),
         &fixture,
         move |bench, &input| {
-            let parsed_dict = Parser::parse_dictionary(input.as_bytes()).unwrap();
+            let parsed_dict = Parser::from_str(input).parse_dictionary().unwrap();
             bench.iter(|| parsed_dict.serialize_value().unwrap());
         },
     );

diff --git a/fuzz/fuzz_targets/parse_dictionary.rs b/fuzz/fuzz_targets/parse_dictionary.rs
@@ -3,5 +3,5 @@
 use libfuzzer_sys::fuzz_target;
 
 fuzz_target!(|data: &[u8]| {
-    let _ = sfv::Parser::parse_dictionary(data);
+    let _ = sfv::Parser::from_bytes(data).parse_dictionary();
 });
diff --git a/fuzz/fuzz_targets/parse_item.rs b/fuzz/fuzz_targets/parse_item.rs
@@ -3,5 +3,5 @@
 use libfuzzer_sys::fuzz_target;
 
 fuzz_target!(|data: &[u8]| {
-    let _ = sfv::Parser::parse_item(data);
+    let _ = sfv::Parser::from_bytes(data).parse_item();
 });
diff --git a/fuzz/fuzz_targets/parse_list.rs b/fuzz/fuzz_targets/parse_list.rs
@@ -3,5 +3,5 @@
 use libfuzzer_sys::fuzz_target;
 
 fuzz_target!(|data: &[u8]| {
-    let _ = sfv::Parser::parse_list(data);
+    let _ = sfv::Parser::from_bytes(data).parse_list();
 });
diff --git a/src/lib.rs b/src/lib.rs
@@ -25,19 +25,19 @@ use sfv::Parser;
 
 // Parsing structured field value of Item type.
 let item_header_input = "12.445;foo=bar";
-let item = Parser::parse_item(item_header_input.as_bytes());
+let item = Parser::from_str(item_header_input).parse_item();
 assert!(item.is_ok());
 println!("{:#?}", item);
 
 // Parsing structured field value of List type.
 let list_header_input = "1;a=tok, (\"foo\" \"bar\");baz, ()";
-let list = Parser::parse_list(list_header_input.as_bytes());
+let list = Parser::from_str(list_header_input).parse_list();
 assert!(list.is_ok());
 println!("{:#?}", list);
 
 // Parsing structured field value of Dictionary type.
 let dict_header_input = "a=?0, b, c; foo=bar, rating=1.5, fruits=(apple pear)";
-let dict = Parser::parse_dictionary(dict_header_input.as_bytes());
+let dict = Parser::from_str(dict_header_input).parse_dictionary();
 assert!(dict.is_ok());
 println!("{:#?}", dict);
 ```
@@ -47,52 +47,52 @@ println!("{:#?}", dict);
 use sfv::*;
 
 let dict_header = "u=2, n=(* foo 2)";
-    let dict = Parser::parse_dictionary(dict_header.as_bytes()).unwrap();
+let dict = Parser::from_str(dict_header).parse_dictionary().unwrap();
 
-    // Case 1 - handling value if it's an Item of Integer type
-    let u_val = match dict.get("u") {
-        Some(ListEntry::Item(item)) => item.bare_item.as_int(),
-        _ => None,
-    };
+// Case 1 - handling value if it's an Item of Integer type
+let u_val = match dict.get("u") {
+    Some(ListEntry::Item(item)) => item.bare_item.as_int(),
+    _ => None,
+};
 
-    if let Some(u_val) = u_val {
-        println!("{}", u_val);
-    }
+if let Some(u_val) = u_val {
+    println!("{}", u_val);
+}
 
-    // Case 2 - matching on all possible types
-    match dict.get("u") {
-        Some(ListEntry::Item(item)) => match &item.bare_item {
-            BareItem::Token(val) => {
-                // do something if it's a Token
-                println!("{}", val);
-            }
-            BareItem::Integer(val) => {
-                // do something if it's an Integer
-                println!("{}", val);
-            }
-            BareItem::Boolean(val) => {
-                // do something if it's a Boolean
-                println!("{}", val);
-            }
-            BareItem::Decimal(val) => {
-                // do something if it's a Decimal
-                println!("{}", val);
-            }
-            BareItem::String(val) => {
-                // do something if it's a String
-                println!("{}", val);
-            }
-            BareItem::ByteSeq(val) => {
-                // do something if it's a ByteSeq
-                println!("{:?}", val);
-            }
-        },
-        Some(ListEntry::InnerList(inner_list)) => {
-            // do something if it's an InnerList
-            println!("{:?}", inner_list.items);
+// Case 2 - matching on all possible types
+match dict.get("u") {
+    Some(ListEntry::Item(item)) => match &item.bare_item {
+        BareItem::Token(val) => {
+            // do something if it's a Token
+            println!("{}", val);
+        }
+        BareItem::Integer(val) => {
+            // do something if it's an Integer
+            println!("{}", val);
+        }
+        BareItem::Boolean(val) => {
+            // do something if it's a Boolean
+            println!("{}", val);
         }
-        None => panic!("key not found"),
+        BareItem::Decimal(val) => {
+            // do something if it's a Decimal
+            println!("{}", val);
+        }
+        BareItem::String(val) => {
+            // do something if it's a String
+            println!("{}", val);
+        }
+        BareItem::ByteSeq(val) => {
+            // do something if it's a ByteSeq
+            println!("{:?}", val);
+        }
+    },
+    Some(ListEntry::InnerList(inner_list)) => {
+        // do something if it's an InnerList
+        println!("{:?}", inner_list.items);
     }
+    None => panic!("key not found"),
+}
 ```
 
 ### Structured Field Value Construction and Serialization