Fixup Macro

Signed-off-by: Joe Grund <[email protected]>

Author: Joe Grund

commandeer-macros/src/lib.rs

@@ -1,6 +1,61 @@
 use proc_macro::TokenStream;
 use quote::quote;
-use syn::{Expr, Ident, ItemFn, parse_macro_input, parse_quote};
+use syn::{
+    Expr, Ident, ItemFn, Result,
+    parse::{Parse, ParseStream},
+    parse_macro_input, parse_quote,
+};
+
+struct CommandeerArgs {
+    mode: Ident,
+    commands: Vec<String>,
+}
+
+const RECORD: &str = "Record";
+const REPLAY: &str = "Replay";
+
+impl Parse for CommandeerArgs {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let mut commands = vec![];
+
+        let ident: Ident = input.parse()?;
+
+        let mode = match ident.to_string().as_str() {
+            x if [RECORD, REPLAY].contains(&x) => Ident::new(x, proc_macro2::Span::call_site()),
+            _ => {
+                return Err(syn::Error::new(
+                    ident.span(),
+                    format!("Expected '{RECORD}' or '{REPLAY}'"),
+                ));
+            }
+        };
+
+        input.parse::<syn::Token![,]>()?;
+
+        while !input.is_empty() {
+            if input.peek(syn::LitStr) {
+                let lit: syn::LitStr = input.parse()?;
+
+                commands.push(lit.value());
+            } else {
+                return Err(input.error("Expected a command string"));
+            }
+
+            if input.peek(syn::Token![,]) {
+                input.parse::<syn::Token![,]>()?;
+            }
+        }
+
+        if commands.is_empty() {
+            return Err(syn::Error::new(
+                input.span(),
+                "Expected at least one command string",
+            ));
+        }
+
+        Ok(CommandeerArgs { mode, commands })
+    }
+}
 
 /// Procedural macro for setting up commandeer test environment
 ///
@@ -9,35 +64,17 @@ use syn::{Expr, Ident, ItemFn, parse_macro_input, parse_quote};
 /// This expands to code that creates a Commandeer instance and mocks the specified commands
 #[proc_macro_attribute]
 pub fn commandeer(args: TokenStream, input: TokenStream) -> TokenStream {
+    let args = parse_macro_input!(args as CommandeerArgs);
     let mut input_fn = parse_macro_input!(input as ItemFn);
 
-    // Parse arguments manually since AttributeArgs was removed in syn 2.0
-    let args_str = args.to_string();
     let fn_name = &input_fn.sig.ident;
 
-    // Generate test file name from function name
     let test_file_name = format!("cmds_{fn_name}.json");
 
-    // Simple parsing - look for Record/Replay and string literals
-    let mut mode_str = "Record"; // default
-    let mut commands = vec![];
-
     // Split by commas and parse each part
-    for part in args_str.split(',') {
-        let part = part.trim();
-        if part == "Record" || part == "Replay" {
-            mode_str = part;
-        } else if part.starts_with('"') && part.ends_with('"') {
-            // Remove quotes and add to commands
-            let cmd = &part[1..part.len() - 1];
-            commands.push(cmd.to_string());
-        }
-    }
-
-    let mode_ident = Ident::new(mode_str, proc_macro2::Span::call_site());
 
-    // Generate mock_command calls
-    let mock_commands: Vec<Expr> = commands
+    let mock_commands: Vec<Expr> = args
+        .commands
         .iter()
         .map(|cmd| {
             parse_quote! {
@@ -46,9 +83,11 @@ pub fn commandeer(args: TokenStream, input: TokenStream) -> TokenStream {
         })
         .collect();
 
+    let mode = args.mode;
+
     // Create the setup statements
     let setup_stmts: Vec<syn::Stmt> = vec![parse_quote! {
-        let commandeer = commandeer_test::Commandeer::new(#test_file_name, commandeer_test::Mode::#mode_ident);
+        let commandeer = commandeer_test::Commandeer::new(#test_file_name, commandeer_test::Mode::#mode);
     }];
 
     let mock_stmts: Vec<syn::Stmt> = mock_commands