Add support for prefix, suffix parsers and literal strings as parsers

Author: marcdejonge

Cargo.toml

@@ -25,6 +25,13 @@ path = "src/lib.rs"
 name = "basic_struct_with_members"
 path = "examples/basic_struct_with_members.rs"
 
+[[example]]
+name = "use_matching_string"
+path = "examples/use_matching_string.rs"
+
+[[example]]
+name = "use_prefix_and_suffix"
+path = "examples/use_prefix_and_suffix.rs"
 
 [dependencies]
 quote = "1.0"

examples/basic_struct_with_members.rs

@@ -1,7 +1,7 @@
 use nom_parse_macros::parse_from;
 use nom_parse_trait::ParseFrom;
 
-#[parse_from(split = delimited(space0, tag(","), space0))]
+#[parse_from(split = delimited(space0, ",", space0))]
 #[derive(Debug, PartialEq)]
 struct NumberPair {
     x: u32,

examples/use_matching_string.rs

@@ -1,7 +1,7 @@
 use nom_parse_macros::parse_from;
 use nom_parse_trait::ParseFrom;
 
-#[parse_from(match = "({},{},{})")]
+#[parse_from("({},{},{})")]
 #[derive(Debug, PartialEq)]
 struct Vector3 {
     x: u32,

examples/use_prefix_and_suffix.rs

@@ -0,0 +1,16 @@
+use nom_parse_macros::parse_from;
+use nom_parse_trait::ParseFrom;
+
+#[parse_from(prefix = '('; split = delimited(space0, ',', space0); suffix = ')')]
+#[derive(Debug, PartialEq)]
+struct Vector3 {
+    x: u32,
+    y: u32,
+    z: u32,
+}
+
+fn main() {
+    let input = "(1,3,4)";
+    let pair = Vector3::parse(input).unwrap();
+    println!("Parsed \"{}\" as {:?}", input, pair.1);
+}

src/nom_packages.rs

@@ -1,10 +1,13 @@
-use syn::{Expr, Path, Stmt};
+use proc_macro2::Span;
+use quote::quote_spanned;
+use syn::{parse, parse_str, Expr, ExprArray, ExprLit, Lit, Path, Stmt};
+use syn::__private::IntoSpans;
 
 const NOM_FUNCTIONS: phf::Map<&'static str, &'static str> = phf::phf_map! {
     // From the nom::branch module
     "alt" => "nom::branch::alt",
     // From the nom::bytes::complete module
-    "tag" => "nom::bytes::complete::tag",
+    // "tag" => "nom::bytes::complete::tag", tag is no longer explicitly supported, we use a raw string literal instead
     "tag_no_case" => "nom::bytes::complete::tag_no_case",
     "is_not" => "nom::bytes::complete::is_not",
     "is_a" => "nom::bytes::complete::is_a",
@@ -90,6 +93,7 @@ const NOM_FUNCTIONS: phf::Map<&'static str, &'static str> = phf::phf_map! {
     "terminated" => "nom::sequence::terminated",
     "separated_pair" => "nom::sequence::separated_pair",
     "delimited" => "nom::sequence::delimited",
+    "tuple" => "nom::sequence::tuple",
 };
 
 pub fn apply_nom_namespaces(expr: &mut Expr) {
@@ -159,6 +163,21 @@ pub fn apply_nom_namespaces(expr: &mut Expr) {
         Expr::Let(let_expr) => {
             apply_nom_namespaces(&mut let_expr.expr);
         }
+        Expr::Lit(lit_expr) => match &lit_expr.lit {
+            Lit::Str(value) => {
+                *expr = match_bytes(value.value().as_bytes(), value.span());
+            }
+            Lit::ByteStr(value) => {
+                *expr = match_bytes(&value.value(), value.span());
+            }
+            Lit::Byte(value) => {
+                *expr = match_bytes(&[value.value()], value.span());
+            }
+            Lit::Char(value) => {
+                *expr = match_bytes(value.value().to_string().as_bytes(), value.span());
+            }
+            _ => {}
+        },
         Expr::Loop(loop_expr) => {
             loop_expr.body.stmts.iter_mut().for_each(|stmt| {
                 apply_nom_namespaces_stmt(stmt);
@@ -184,7 +203,7 @@ pub fn apply_nom_namespaces(expr: &mut Expr) {
             if segments.len() == 1 {
                 let ident = &segments[0].ident;
                 if let Some(nom_path) = NOM_FUNCTIONS.get(ident.to_string().as_str()) {
-                    path_expr.path.segments = syn::parse_str::<Path>(nom_path).unwrap().segments;
+                    path_expr.path.segments = parse_str::<Path>(nom_path).unwrap().segments;
                 }
             }
         }
@@ -251,6 +270,18 @@ pub fn apply_nom_namespaces(expr: &mut Expr) {
     }
 }
 
+fn match_bytes(value: &[u8], span: Span) -> Expr {
+    let mut array = parse_str::<ExprArray>(format!("{:?}", value).as_str()).unwrap();
+    array.bracket_token.span = span.into_spans();
+    array.elems.iter_mut().for_each(|elem| {
+        if let Expr::Lit(ExprLit { lit, .. }) = elem {
+            lit.set_span(span);
+        }
+    });
+    parse::<Expr>(quote_spanned! { span => nom::bytes::complete::tag(#array.as_ref()) }.into())
+        .unwrap()
+}
+
 fn apply_nom_namespaces_stmt(statement: &mut Stmt) {
     match statement {
         Stmt::Local(local) => {

src/settings.rs

@@ -1,40 +1,54 @@
 use crate::fields::Field;
 use crate::nom_packages::apply_nom_namespaces;
 use itertools::Itertools;
+use proc_macro::Span;
 use proc_macro2::TokenStream;
 use quote::{quote, ToTokens};
 use syn::parse::{Parse, ParseStream};
 use syn::{parse, Error, Expr, LitStr, Token};
 
 pub enum ParseSettings {
-    Split(Expr),
+    Split {
+        prefix: Option<Expr>,
+        split: Expr,
+        suffix: Option<Expr>,
+    },
     Match(LitStr),
 }
 
 impl ParseSettings {
     pub fn from(attrs: TokenStream) -> syn::Result<Self> {
-        let arguments = parse::<Arguments>(attrs.into())?;
-
-        match arguments {
-            Arguments::Split { expr, .. } => Ok(ParseSettings::Split(expr)),
-            Arguments::Match { lit, .. } => Ok(ParseSettings::Match(lit)),
-            Arguments::LiteralMatch { lit } => Ok(ParseSettings::Match(lit)),
-        }
+        parse::<ParseSettings>(attrs.into())
     }
 
     pub fn generate_parse_expressions(&self, fields: &[Field]) -> Vec<TokenStream> {
         match self {
-            ParseSettings::Split(expr) => {
-                let mut expr = expr.clone();
-                apply_nom_namespaces(&mut expr);
-                let expr = quote! { let (input, _) = #expr.parse(input)?; };
-                Itertools::intersperse(
+            ParseSettings::Split{ prefix, split, suffix} => {
+                let mut split = split.clone();
+                apply_nom_namespaces(&mut split);
+
+                let mut expressions: Vec<_> = Itertools::intersperse(
                     fields
                         .iter()
                         .map(|field| field.generate_expression().into_token_stream()),
-                    expr,
+                    quote! { let (input, _) = split.parse(input)?; },
                 )
-                .collect()
+                .collect();
+
+                if let Some(prefix) = prefix {
+                    let mut prefix = prefix.clone();
+                    apply_nom_namespaces(&mut prefix);
+                    expressions.insert(0, quote! { let (input, _) = #prefix.parse(input)?; });
+                }
+
+                if let Some(suffix) = suffix {
+                    let mut suffix = suffix.clone();
+                    apply_nom_namespaces(&mut suffix);
+                    expressions.push(quote! { let (input, _) = #suffix.parse(input)?; });
+                }
+
+                expressions.insert(0, quote! { let mut split = #split; });
+                expressions
             }
             ParseSettings::Match(literal) => {
                 let value = literal.value();
@@ -68,50 +82,57 @@ impl ParseSettings {
 mod keywords {
     use syn::custom_keyword;
 
+    custom_keyword!(prefix);
     custom_keyword!(split);
+    custom_keyword!(suffix);
 }
 
-#[allow(dead_code)]
-enum Arguments {
-    Split {
-        token: keywords::split,
-        eq_token: Token![=],
-        expr: Expr,
-    },
-    Match {
-        token: Token![match],
-        eq_token: Token![=],
-        lit: LitStr,
-    },
-    LiteralMatch {
-        lit: LitStr,
-    },
-}
-
-impl Parse for Arguments {
+impl Parse for ParseSettings {
     fn parse(input: ParseStream) -> syn::Result<Self> {
         let lookahead = input.lookahead1();
-        if lookahead.peek(keywords::split) {
-            let token = input.parse::<keywords::split>()?;
-            let eq_token = input.parse::<Token![=]>()?;
-            let expr = input.parse::<Expr>()?;
-            Ok(Arguments::Split {
-                token,
-                eq_token,
-                expr,
-            })
-        } else if lookahead.peek(Token![match]) {
-            let token = input.parse::<Token![match]>()?;
-            let eq_token = input.parse::<Token![=]>()?;
+        if lookahead.peek(LitStr) {
             let lit = input.parse::<LitStr>()?;
-            Ok(Arguments::Match {
-                token,
-                eq_token,
-                lit,
+            return Ok(ParseSettings::Match(lit));
+        }
+
+        let mut prefix: Option<Expr> = None;
+        let mut split: Option<Expr> = None;
+        let mut suffix: Option<Expr> = None;
+        let mut first = true;
+
+        while !input.is_empty() {
+            if first {
+                first = false;
+            } else {
+                input.parse::<Token![;]>()?;
+            }
+
+            let lookahead = input.lookahead1();
+            if lookahead.peek(keywords::prefix) {
+                input.parse::<keywords::prefix>()?;
+                input.parse::<Token![=]>()?;
+                prefix = Some(input.parse()?);
+            } else if lookahead.peek(keywords::split) {
+                input.parse::<keywords::split>()?;
+                input.parse::<Token![=]>()?;
+                split = Some(input.parse()?);
+            } else if lookahead.peek(keywords::suffix) {
+                input.parse::<keywords::suffix>()?;
+                input.parse::<Token![=]>()?;
+                suffix = Some(input.parse()?);
+            } else {
+                return Err(lookahead.error());
+            }
+        }
+
+        if let Some(split) = split {
+            Ok(ParseSettings::Split {
+                prefix,
+                split,
+                suffix,
             })
         } else {
-            let lit = input.parse::<LitStr>()?;
-            Ok(Arguments::LiteralMatch { lit })
+            Err(Error::new(Span::call_site().into(), "Missing `split` keyword"))
         }
     }
 }