Creates separate parse_match macro for string matching

Author: marcdejonge

examples/use_matching_string.rs

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

src/lib.rs

@@ -1,14 +1,15 @@
 extern crate proc_macro;
 mod fields;
 mod nom_packages;
-mod settings;
+mod string_matching;
 
 use proc_macro::TokenStream;
 
 use crate::fields::parse_fields;
 use crate::nom_packages::update_nom_expression;
 use quote::quote;
 use syn::{parse_macro_input, Expr, ItemStruct, LitStr};
+use crate::string_matching::parse_string_match;
 
 #[proc_macro_attribute]
 pub fn parse_from(attrs: TokenStream, object: TokenStream) -> TokenStream {
@@ -39,3 +40,34 @@ pub fn parse_from(attrs: TokenStream, object: TokenStream) -> TokenStream {
 
     tokens.into()
 }
+
+#[proc_macro_attribute]
+pub fn parse_match(attrs: TokenStream, object: TokenStream) -> TokenStream {
+    let literal = parse_macro_input! { attrs as LitStr };
+
+    let object = parse_macro_input!(object as ItemStruct);
+    let fields = parse_fields(&object.fields);
+    let name = object.ident.clone();
+
+    match parse_string_match(&fields, literal) {
+        Ok(parts) => {
+            let names: Vec<_> = fields.iter().map(|field| field.get_name()).collect();
+            let tokens = quote! {
+                #object
+
+                impl nom_parse_trait::ParseFrom<&str> for #name {
+                    fn parse(input: &str) -> nom::IResult<&str, Self> {
+                        use nom::*;
+
+                        let mut input = input;
+                        #(#parts)*
+                        Ok((input, Self { #(#names),* }))
+                    }
+                }
+            };
+
+            tokens.into()
+        }
+        Err(e) => e.to_compile_error().into(),
+    }
+}

src/settings.rs

@@ -0,0 +1,34 @@
+use crate::fields::Field;
+use crate::nom_packages::generate_match_expression;
+use itertools::Itertools;
+use proc_macro2::TokenStream;
+use quote::{quote_spanned, ToTokens};
+use syn::parse::Parse;
+use syn::spanned::Spanned;
+use syn::{Error, LitStr, Result};
+
+pub fn parse_string_match(fields: &[Field], literal: LitStr) -> Result<Vec<TokenStream>> {
+    let value = literal.value();
+    let parts: Vec<_> = value
+        .split("{}")
+        .map(|part| {
+            let expr = generate_match_expression(part.as_bytes(), literal.span());
+            quote_spanned! { literal.span() => let (input, _) = #expr.parse(input)?; }
+        })
+        .collect();
+
+    if parts.len() != fields.len() + 1 {
+        return Err(Error::new(
+            literal.span(),
+            "Number of {} parts in the literal is not equal to the number of fields",
+        ));
+    }
+
+    Ok(Itertools::interleave(
+        parts.into_iter(),
+        fields
+            .iter()
+            .map(|field| field.generate_expression().into_token_stream()),
+    )
+    .collect())
+}