omni_cli/

macros.rs

//! omni macro runner — parse a human-writable keystroke macro file into an
//! ordered list of steps (semantic commands + inter-step waits) for `omni run`
//! (bd-fdb154).
//!
//! A macro file is one directive per line:
//!
//! ```text
//! # a comment line (full-line only; ignored)
//! text hello world     # -> a .text command ("hello world")
//! wait 200             # -> sleep 200ms before the next step
//! key enter            # -> a .key command
//! combo ctrl,a,g       # -> a .combo command
//! scroll 3             # -> a .scroll command
//! ```
//!
//! Command lines reuse [`crate::wire::parse_send_tokens`]; the macro layer adds
//! only the `wait <ms>` directive, full-line `#` comments, and blank-line
//! skipping — it introduces no new wire types and does not touch the transports.

use std::time::Duration;

use crate::AppError;
use crate::wire::{InjectionCommand, parse_send_tokens};

/// One step in a parsed macro: either a command to dispatch, or a delay to
/// apply before the following step.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum MacroStep {
    /// A semantic injection command (text/key/combo/scroll).
    Command(InjectionCommand),
    /// A delay before the next step (from a `wait <ms>` directive).
    Wait(Duration),
}

/// Parse a macro file body into an ordered list of [`MacroStep`]s.
///
/// Blank lines and full-line `#` comments are skipped (a `#` is only a comment
/// when it is the first non-whitespace character, so `text a#b` keeps its `#`).
/// A `wait <ms>` line becomes a [`MacroStep::Wait`]; every other line is parsed
/// as a semantic command via [`parse_send_tokens`].
///
/// # Errors
/// Returns [`AppError::validation`] on the first malformed line, tagged with the
/// 1-based line number for a precise diagnostic.
pub fn parse_macro(input: &str) -> Result<Vec<MacroStep>, AppError> {
    let mut steps = Vec::new();
    for (idx, raw) in input.lines().enumerate() {
        let line_no = idx + 1;
        let line = raw.trim();
        if line.is_empty() || line.starts_with('#') {
            continue;
        }
        let tokens: Vec<String> = line.split_whitespace().map(str::to_owned).collect();
        if tokens[0] == "wait" {
            steps.push(MacroStep::Wait(Duration::from_millis(parse_wait(
                &tokens, line_no,
            )?)));
        } else {
            let cmd = parse_send_tokens(&tokens)
                .map_err(|e| AppError::validation("macro_line", format!("line {line_no}: {e}")))?;
            steps.push(MacroStep::Command(cmd));
        }
    }
    Ok(steps)
}

/// Group parsed steps into `(commands, delay_after)` batches so consecutive
/// commands dispatch together and only `wait` boundaries incur a sleep.
///
/// Faithful to the source timing: a leading/standalone `wait` yields an
/// empty-command batch carrying the delay, and a trailing run of commands
/// yields a final batch with a zero delay.
#[must_use]
pub fn batch_steps(steps: &[MacroStep]) -> Vec<(Vec<InjectionCommand>, Duration)> {
    let mut batches = Vec::new();
    let mut current = Vec::new();
    for step in steps {
        match step {
            MacroStep::Command(cmd) => current.push(cmd.clone()),
            MacroStep::Wait(delay) => batches.push((std::mem::take(&mut current), *delay)),
        }
    }
    if !current.is_empty() {
        batches.push((current, Duration::ZERO));
    }
    batches
}

fn parse_wait(tokens: &[String], line_no: usize) -> Result<u64, AppError> {
    match tokens {
        [_, ms] => ms.parse::<u64>().map_err(|_| {
            AppError::validation(
                "macro_wait",
                format!("line {line_no}: wait amount must be a non-negative integer in ms: {ms}"),
            )
        }),
        _ => Err(AppError::validation(
            "macro_wait_arity",
            format!("line {line_no}: wait requires exactly one value (milliseconds)"),
        )),
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn parses_commands_waits_comments_and_blanks() {
        let src = "\
# a keyboard macro
text hello world
wait 200
key enter

  # indented comment
combo ctrl,a,g
scroll -3
";
        let steps = parse_macro(src).unwrap();
        assert_eq!(
            steps,
            vec![
                MacroStep::Command(InjectionCommand::text("hello world")),
                MacroStep::Wait(Duration::from_millis(200)),
                MacroStep::Command(InjectionCommand::key("enter")),
                MacroStep::Command(InjectionCommand::combo("ctrl,a,g")),
                MacroStep::Command(InjectionCommand::scroll(-3)),
            ]
        );
    }

    #[test]
    fn hash_inside_text_is_not_a_comment() {
        // '#' is only a comment when it starts the line; a text payload keeps it.
        let steps = parse_macro("text ping #general").unwrap();
        assert_eq!(
            steps,
            vec![MacroStep::Command(InjectionCommand::text("ping #general"))]
        );
    }

    #[test]
    fn empty_input_is_no_steps() {
        assert!(parse_macro("").unwrap().is_empty());
        assert!(parse_macro("\n  \n# only comments\n").unwrap().is_empty());
    }

    #[test]
    fn wait_errors_are_line_tagged() {
        assert_eq!(parse_macro("wait").unwrap_err().code(), "macro_wait_arity");
        assert_eq!(
            parse_macro("wait 1 2").unwrap_err().code(),
            "macro_wait_arity"
        );
        let err = parse_macro("text ok\nwait nope").unwrap_err();
        assert_eq!(err.code(), "macro_wait");
        assert!(err.to_string().contains("line 2"), "want line 2 in: {err}");
    }

    #[test]
    fn bad_command_line_is_line_tagged() {
        let err = parse_macro("text ok\n\nbogus xyz").unwrap_err();
        assert_eq!(err.code(), "macro_line");
        assert!(err.to_string().contains("line 3"), "want line 3 in: {err}");
    }

    #[test]
    fn batch_groups_commands_between_waits() {
        let steps = parse_macro("text a\nkey b\nwait 100\nscroll 2\n").unwrap();
        let batches = batch_steps(&steps);
        assert_eq!(
            batches,
            vec![
                (
                    vec![InjectionCommand::text("a"), InjectionCommand::key("b")],
                    Duration::from_millis(100)
                ),
                (vec![InjectionCommand::scroll(2)], Duration::ZERO),
            ]
        );
    }

    #[test]
    fn batch_preserves_leading_and_standalone_wait() {
        let steps = parse_macro("wait 50\ntext a\nwait 10\n").unwrap();
        let batches = batch_steps(&steps);
        assert_eq!(
            batches,
            vec![
                (vec![], Duration::from_millis(50)),
                (vec![InjectionCommand::text("a")], Duration::from_millis(10)),
            ]
        );
    }
}