comlexr_macro 1.5.0

extern crate quote;
extern crate syn;

use quote::quote;
use syn::parse_macro_input;

mod cmd;
mod macros;
mod pipe;

/// Generates a command expression by combining static strings, conditional logic, loops,
/// pattern matching, and closures to dynamically build and format command-line arguments.
///
/// The `cmd!` macro supports flexible syntax constructs such as:
/// - **Static arguments**: Basic string arguments.
/// - **Conditional inclusion**: Using `if` or `if let` to conditionally include arguments.
/// - **Iterative inclusion**: Using `for` loops to include multiple arguments from collections.
/// - **Pattern matching**: Using `match` expressions for dynamic argument selection.
/// - **Closures**: Dynamically generating arguments at runtime.
///
/// # Examples
///
/// ## Basic Usage
/// ```
/// # use comlexr_macro::cmd;
/// let command = cmd!("echo", "test");
/// assert_eq!(format!("{command:?}"), r#""echo" "test""#.to_string());
/// ```
///
/// ## Current Directory
/// ```
/// # use comlexr_macro::cmd;
/// let command = cmd!(
///     cd "~/";
///     "echo",
///     "test",
/// );
///
/// assert_eq!(format!("{command:?}"), r#"cd "~/" && "echo" "test""#);
/// ```
///
/// ## Environment Vars
/// ```
/// # use comlexr_macro::cmd;
/// const NEW_VAR: &str = "NEW_VAR";
///
/// let command = cmd!(
///     env {
///         "TEST": "test",
///         NEW_VAR: "new_var"
///     };
///     "echo",
///     "test",
/// );
///
/// assert_eq!(format!("{command:?}"), r#"NEW_VAR="new_var" TEST="test" "echo" "test""#);
/// ```
///
/// #### Conditional
/// You can have a default value set for an environment variable.
///
/// ```rust
/// # use comlexr_macro::cmd;
/// const NEW_VAR: &str = "NEW_VAR";
/// std::env::set_var("TEST", "realvalue");
///
/// let command = cmd!(
///     env {
///         "TEST":? "test",
///         NEW_VAR: "new_var"
///     };
///     "echo",
///     "test",
/// );
///
/// assert_eq!(format!("{command:?}"), r#"NEW_VAR="new_var" "echo" "test""#);
/// ```
///
/// ### Current Directory and Environment Variable Order
/// ```
/// # use comlexr_macro::cmd;
/// let command = cmd!(
///     cd "~/";
///     env {
///         "TEST": "test",
///     };
///     "echo",
///     "test",
/// );
///
/// assert_eq!(
///     format!("{command:?}"),
///     r#"cd "~/" && TEST="test" "echo" "test""#
/// );
///
/// ```
///
/// ## Conditional Arguments
/// ```
/// # use comlexr_macro::cmd;
/// let include_arg = true;
///
/// let command = cmd!("echo", "test", if include_arg => "optional_arg");
/// assert_eq!(format!("{command:?}"), r#""echo" "test" "optional_arg""#.to_string());
/// ```
///
/// ## Conditional Pattern Matching
/// ```
/// # use comlexr_macro::cmd;
/// let single_option = Some("single");
/// let multi_option: Option<&str> = None;
///
/// let command = cmd!(
///     "echo",
///     "test",
///     if let Some(arg) = single_option => arg,
///     if let Some(arg) = multi_option => [
///         "multi",
///         arg,
///     ],
/// );
/// assert_eq!(format!("{command:?}"), r#""echo" "test" "single""#.to_string());
/// ```
///
/// ## Iterative Argument Inclusion
/// ```
/// # use comlexr_macro::cmd;
/// let args = &["arg1", "arg2"];
///
/// let command = cmd!("echo", for args);
/// assert_eq!(format!("{command:?}"), r#""echo" "arg1" "arg2""#.to_string());
/// ```
///
/// ## Iteration with `for in`
/// ```
/// # use comlexr_macro::cmd;
/// let single_iter = &["arg1", "arg2"];
/// let multi_iter = &["multi1", "multi2"];
///
/// let command = cmd!(
///     "echo",
///     "test",
///     for arg in single_iter => arg,
///     for arg in multi_iter => [
///         "multi",
///         arg,
///     ],
/// );
/// assert_eq!(format!("{command:?}"), r#""echo" "test" "arg1" "arg2" "multi" "multi1" "multi" "multi2""#.to_string());
/// ```
///
/// ## Match Statements
/// ```
/// # use comlexr_macro::cmd;
/// enum TestArgs {
///     Arg1,
///     Arg2,
///     Arg3,
/// }
///
/// let match_arg = TestArgs::Arg2;
/// let command = cmd!(
///     "echo",
///     "test",
///     match match_arg {
///         TestArgs::Arg1 => "arg1",
///         TestArgs::Arg2 => ["arg1", "arg2"],
///         TestArgs::Arg3 => ["arg1", "arg2", "arg3"],
///     }
/// );
/// assert_eq!(format!("{command:?}"), r#""echo" "test" "arg1" "arg2""#.to_string());
/// ```
///
/// ## Dynamic Closures
/// ```
/// # use comlexr_macro::cmd;
/// let numbers = vec![1, 2, 3];
/// let multiplier = 2;
///
/// let command = cmd!("echo", || numbers.into_iter().map(|n| format!("{}", n * multiplier)));
/// assert_eq!(format!("{command:?}"), r#""echo" "2" "4" "6""#.to_string());
/// ```
#[proc_macro]
pub fn cmd(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let command = parse_macro_input!(input as cmd::Command);
    quote! { #command }.into()
}

/// Mutates a command by combining static strings, conditional logic, loops,
/// pattern matching, and closures to dynamically build and format command-line arguments.
///
/// Arguments and environment variables are appended to the existing `Command`. The working
/// directory is replaced if set with this macro.
///
/// The `cmd_mut!` macro supports flexible syntax constructs such as:
/// - **Static arguments**: Basic string arguments.
/// - **Conditional inclusion**: Using `if` or `if let` to conditionally include arguments.
/// - **Iterative inclusion**: Using `for` loops to include multiple arguments from collections.
/// - **Pattern matching**: Using `match` expressions for dynamic argument selection.
/// - **Closures**: Dynamically generating arguments at runtime.
///
/// # Examples
///
/// ## Basic Usage
/// ```
/// # use comlexr_macro::{cmd, cmd_mut};
/// let mut command = cmd!("echo");
/// cmd_mut!(&mut command, "test");
/// assert_eq!(format!("{command:?}"), r#""echo" "test""#.to_string());
/// ```
///
/// ## Current Directory
/// ```
/// # use comlexr_macro::{cmd, cmd_mut};
/// let mut command = cmd!("echo");
/// cmd_mut!(
///     cd "~/";
///     &mut command,
///     "test",
/// );
///
/// assert_eq!(format!("{command:?}"), r#"cd "~/" && "echo" "test""#);
/// ```
///
/// ## Environment Vars
/// ```
/// # use comlexr_macro::{cmd, cmd_mut};
/// const NEW_VAR: &str = "NEW_VAR";
///
/// let mut command = cmd!("echo");
/// cmd_mut!(
///     env {
///         "TEST": "test",
///         NEW_VAR: "new_var"
///     };
///     &mut command,
///     "test",
/// );
///
/// assert_eq!(format!("{command:?}"), r#"NEW_VAR="new_var" TEST="test" "echo" "test""#);
/// ```
///
/// #### Conditional
/// You can have a default value set for an environment variable.
///
/// ```rust
/// # use comlexr_macro::{cmd, cmd_mut};
/// const NEW_VAR: &str = "NEW_VAR";
/// std::env::set_var("TEST", "realvalue");
///
/// let mut command = cmd!("echo");
/// cmd_mut!(
///     env {
///         "TEST":? "test",
///         NEW_VAR: "new_var"
///     };
///     &mut command,
///     "test",
/// );
///
/// assert_eq!(format!("{command:?}"), r#"NEW_VAR="new_var" "echo" "test""#);
/// ```
///
/// ### Current Directory and Environment Variable Order
/// ```
/// # use comlexr_macro::{cmd, cmd_mut};
/// let mut command = cmd!("echo");
/// cmd_mut!(
///     cd "~/";
///     env {
///         "TEST": "test",
///     };
///     &mut command,
///     "test",
/// );
///
/// assert_eq!(
///     format!("{command:?}"),
///     r#"cd "~/" && TEST="test" "echo" "test""#
/// );
///
/// ```
///
/// ## Conditional Arguments
/// ```
/// # use comlexr_macro::{cmd, cmd_mut};
/// let include_arg = true;
///
/// let mut command = cmd!("echo");
/// cmd_mut!(&mut command, "test", if include_arg => "optional_arg");
/// assert_eq!(format!("{command:?}"), r#""echo" "test" "optional_arg""#.to_string());
/// ```
///
/// ## Conditional Pattern Matching
/// ```
/// # use comlexr_macro::{cmd, cmd_mut};
/// let single_option = Some("single");
/// let multi_option: Option<&str> = None;
///
/// let mut command = cmd!("echo");
/// cmd_mut!(
///     &mut command,
///     "test",
///     if let Some(arg) = single_option => arg,
///     if let Some(arg) = multi_option => [
///         "multi",
///         arg,
///     ],
/// );
/// assert_eq!(format!("{command:?}"), r#""echo" "test" "single""#.to_string());
/// ```
///
/// ## Iterative Argument Inclusion
/// ```
/// # use comlexr_macro::{cmd, cmd_mut};
/// let args = &["arg1", "arg2"];
///
/// let mut command = cmd!("echo");
/// cmd_mut!(&mut command, for args);
/// assert_eq!(format!("{command:?}"), r#""echo" "arg1" "arg2""#.to_string());
/// ```
///
/// ## Iteration with `for in`
/// ```
/// # use comlexr_macro::{cmd, cmd_mut};
/// let single_iter = &["arg1", "arg2"];
/// let multi_iter = &["multi1", "multi2"];
///
/// let mut command = cmd!("echo");
/// cmd_mut!(
///     &mut command,
///     "test",
///     for arg in single_iter => arg,
///     for arg in multi_iter => [
///         "multi",
///         arg,
///     ],
/// );
/// assert_eq!(format!("{command:?}"), r#""echo" "test" "arg1" "arg2" "multi" "multi1" "multi" "multi2""#.to_string());
/// ```
///
/// ## Match Statements
/// ```
/// # use comlexr_macro::{cmd, cmd_mut};
/// enum TestArgs {
///     Arg1,
///     Arg2,
///     Arg3,
/// }
///
/// let match_arg = TestArgs::Arg2;
/// let mut command = cmd!("echo");
/// cmd_mut!(
///     &mut command,
///     "test",
///     match match_arg {
///         TestArgs::Arg1 => "arg1",
///         TestArgs::Arg2 => ["arg1", "arg2"],
///         TestArgs::Arg3 => ["arg1", "arg2", "arg3"],
///     }
/// );
/// assert_eq!(format!("{command:?}"), r#""echo" "test" "arg1" "arg2""#.to_string());
/// ```
///
/// ## Dynamic Closures
/// ```
/// # use comlexr_macro::{cmd, cmd_mut};
/// let numbers = vec![1, 2, 3];
/// let multiplier = 2;
///
/// let mut command = cmd!("echo");
/// cmd_mut!(&mut command, || numbers.into_iter().map(|n| format!("{}", n * multiplier)));
/// assert_eq!(format!("{command:?}"), r#""echo" "2" "4" "6""#.to_string());
/// ```
#[proc_macro]
pub fn cmd_mut(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let command = parse_macro_input!(input as cmd::CommandMut);
    quote! { #command }.into()
}

/// Chain the stdout of commands to stdin. Execution is lazy so commands aren't run until `status()` or `output()` is called.
///
/// ```ignore
/// use comlexr::{pipe, cmd};
///
/// let dir = tempfile::tempdir().unwrap();
/// let file = dir.path().join("out");
/// let mut pipe = pipe!(cmd!("echo", "test") | cmd!("sed", "s|e|oa|") | cmd!("tee", &file));
///
/// let output = pipe.output().unwrap();
/// assert!(output.status.success());
/// assert_eq!(String::from_utf8_lossy(&output.stdout), "toast\n");
/// ```
///
/// Or pass data via stdin.
///
/// NOTE: Data must implement `AsRef<[u8]>`.
///
/// ```ignore
/// use comlexr::{pipe, cmd};
///
/// let mut pipe = pipe!(stdin = "test"; cmd!("sed", "s|e|oa|"));
///
/// let output = pipe.output().unwrap();
/// assert!(output.status.success());
/// assert_eq!(String::from_utf8_lossy(&output.stdout), "toast");
/// ```
#[proc_macro]
pub fn pipe(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let pipe = parse_macro_input!(input as pipe::Pipe);
    quote! { #pipe }.into()
}