xacli_testing/spec/

tape.rs

//! VHS Tape file format and conversion

use std::{collections::HashMap, path::Path, time::Duration};

use serde::Serialize;

use super::xacli::{self, CliConfig};
use crate::Result;

/// A VHS tape file containing test configuration
#[derive(Debug, Clone, Serialize)]
pub struct TapeFile {
    /// Output configuration
    #[serde(skip_serializing_if = "Option::is_none")]
    pub output: Option<TapeOutput>,

    /// Alias configuration (alias_name, full_path)
    #[serde(skip)]
    pub alias: Option<(String, String)>,

    /// Test cases
    pub tests: Vec<TapeTest>,
}

/// Output configuration for tape recording
#[derive(Debug, Clone, Serialize)]
pub struct TapeOutput {
    /// Output file path for the recording
    pub path: String,

    /// Width of the terminal (columns)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub width: Option<u16>,

    /// Height of the terminal (rows)
    #[serde(skip_serializing_if = "Option::is_none")]
    pub height: Option<u16>,
}

/// A single test case in tape format
#[derive(Debug, Clone, Serialize)]
pub struct TapeTest {
    /// Test name
    pub name: String,

    /// Command to execute (full command line)
    pub command: Vec<String>,

    /// Input instructions
    #[serde(skip_serializing_if = "Vec::is_empty")]
    pub inputs: Vec<TapeInstruction>,

    /// Optional description
    #[serde(skip_serializing_if = "Option::is_none")]
    pub description: Option<String>,
}

impl TapeFile {
    /// Create a new empty tape file
    pub fn new() -> Self {
        Self {
            output: None,
            alias: None,
            tests: Vec::new(),
        }
    }

    /// Save tape file to VHS format
    pub fn save(&self, path: impl AsRef<Path>) -> Result<()> {
        let content = self.to_vhs_format();
        std::fs::write(path, content)?;
        Ok(())
    }

    /// Convert to VHS tape format string
    pub fn to_vhs_format(&self) -> String {
        let mut output = String::new();

        // Write output configuration if present
        if let Some(out) = &self.output {
            output.push_str(&format!("Output {}\n", out.path));
            output.push('\n');
        }

        // Terminal settings
        output.push_str("# Terminal settings\n");
        output.push_str("Set Shell \"bash\"\n");
        output.push_str("Set Width 2400\n");
        output.push_str("Set Height 400\n");
        output.push_str("Set FontSize 36\n");
        output.push_str("Set Theme \"Catppuccin Mocha\"\n");
        output.push_str("Set Padding 20\n");
        output.push_str("Set Framerate 30\n");
        output.push('\n');

        // Set up alias if configured (hidden from display)
        if let Some((alias_name, full_path)) = &self.alias {
            output.push_str("Hide\n");
            output.push_str(&format!(
                "Type \"alias {}='{}' && clear\"\n",
                alias_name, full_path
            ));
            output.push_str("Enter\n");
            output.push_str("Show\n");
            output.push_str("Sleep 100ms\n");
            output.push('\n');
        }

        // Write each test
        for (idx, test) in self.tests.iter().enumerate() {
            if idx > 0 {
                output.push_str("\n\n");
            }

            // Test comment
            output.push_str(&format!("# Test: {}\n", test.name));
            if let Some(desc) = &test.description {
                output.push_str(&format!("# {}\n", desc));
            }

            // Command
            if !test.command.is_empty() {
                let cmd = test.command.join(" ");
                output.push_str(&format!("Type \"{}\"\n", cmd));
                output.push_str("Enter\n");

                // If there are inputs, add a small delay before typing them
                if !test.inputs.is_empty() {
                    output.push_str("Sleep 500ms\n");
                }
            }

            // Input instructions
            for instruction in &test.inputs {
                output.push_str(&instruction.to_vhs_command());
                output.push('\n');
                output.push_str("Sleep 300ms\n");
            }

            // Sleep after test completes
            output.push_str("Sleep 1s\n");
        }

        output
    }
}

impl Default for TapeFile {
    fn default() -> Self {
        Self::new()
    }
}

/// Convert SpecFile to TapeFile (without program name)
impl From<&xacli::SpecFile> for TapeFile {
    fn from(spec: &xacli::SpecFile) -> Self {
        let mut tape = TapeFile::new();

        for suite in spec.suite.values() {
            // Skip suite if marked as skip
            if suite.features.skip {
                continue;
            }

            for (name, test_case) in &suite.test {
                // Skip tests marked as skip
                if test_case.features.skip {
                    continue;
                }

                tape.tests.push(TapeTest::from((name.as_str(), test_case)));
            }
        }

        tape
    }
}

/// Convert SpecFile with program name to TapeFile
impl From<(&str, &xacli::SpecFile)> for TapeFile {
    fn from((program_name, spec): (&str, &xacli::SpecFile)) -> Self {
        let mut tape = TapeFile::new();

        for suite in spec.suite.values() {
            // Skip suite if marked as skip
            if suite.features.skip {
                continue;
            }

            for (name, test_case) in &suite.test {
                // Skip tests marked as skip
                if test_case.features.skip {
                    continue;
                }

                let mut test = TapeTest::from((name.as_str(), test_case));
                // Prepend program name to command
                test.command.insert(0, program_name.to_string());
                tape.tests.push(test);
            }
        }

        tape
    }
}

/// Convert test case to TapeTest
impl From<(&str, &xacli::TestCase)> for TapeTest {
    fn from((name, test_case): (&str, &xacli::TestCase)) -> Self {
        // Build command: [commands..., args...]
        let mut command = Vec::new();
        command.extend(test_case.commands.iter().cloned());
        command.extend(test_case.args.iter().cloned());

        // Convert input events to tape instructions
        let inputs = test_case
            .input_events
            .iter()
            .flat_map(Vec::<TapeInstruction>::from)
            .collect();

        Self {
            name: name.to_string(),
            command,
            inputs,
            description: None,
        }
    }
}

/// Convert InputEvent to TapeInstructions
impl From<&xacli::InputEvent> for Vec<TapeInstruction> {
    fn from(event: &xacli::InputEvent) -> Self {
        match event {
            xacli::InputEvent::Key { key, repeat } => {
                let instruction = match key.as_str() {
                    "Enter" | "enter" => TapeInstruction::Enter,
                    "Backspace" | "backspace" => TapeInstruction::Backspace(*repeat),
                    "Up" | "up" => TapeInstruction::Up,
                    "Down" | "down" => TapeInstruction::Down,
                    "Left" | "left" => TapeInstruction::Left,
                    "Right" | "right" => TapeInstruction::Right,
                    "Space" | "space" => TapeInstruction::Space,
                    "Escape" | "escape" | "Esc" | "esc" => TapeInstruction::Escape,
                    "Home" | "home" => TapeInstruction::Home,
                    "End" | "end" => TapeInstruction::End,
                    "Tab" | "tab" => TapeInstruction::Tab,
                    _ => {
                        // Try to parse as Ctrl+key
                        if let Some(stripped) = key
                            .strip_prefix("Ctrl+")
                            .or_else(|| key.strip_prefix("ctrl+"))
                        {
                            if let Some(c) = stripped.chars().next() {
                                TapeInstruction::Ctrl(c)
                            } else {
                                return vec![];
                            }
                        } else if key.len() == 1 {
                            // Single character key - treat as Type
                            return vec![TapeInstruction::Type(key.clone()); *repeat];
                        } else {
                            // Unsupported multi-character key
                            return vec![];
                        }
                    }
                };

                // Repeat the instruction if needed (but Backspace already has repeat built in)
                if matches!(instruction, TapeInstruction::Backspace(_)) {
                    vec![instruction]
                } else {
                    vec![instruction; *repeat]
                }
            }
            xacli::InputEvent::Text { text } => {
                vec![TapeInstruction::Type(text.clone())]
            }
        }
    }
}

/// A VHS tape instruction
#[derive(Debug, Clone, PartialEq, Serialize)]
pub enum TapeInstruction {
    /// Type a string of characters
    Type(String),
    /// Press Enter key
    Enter,
    /// Press Backspace key N times (default 1)
    Backspace(usize),
    /// Press Up arrow key
    Up,
    /// Press Down arrow key
    Down,
    /// Press Left arrow key
    Left,
    /// Press Right arrow key
    Right,
    /// Press Space key
    Space,
    /// Press Escape key
    Escape,
    /// Press Ctrl+key combination
    Ctrl(char),
    /// Sleep duration (ignored in tests, but parsed for completeness)
    Sleep(Duration),
    /// Home key
    Home,
    /// End key
    End,
    /// Tab key
    Tab,
}

impl TapeInstruction {
    /// Convert instruction to VHS tape command
    pub fn to_vhs_command(&self) -> String {
        match self {
            TapeInstruction::Type(s) => format!("Type \"{}\"", s),
            TapeInstruction::Enter => "Enter".to_string(),
            TapeInstruction::Backspace(n) => {
                if *n == 1 {
                    "Backspace".to_string()
                } else {
                    format!("Backspace {}", n)
                }
            }
            TapeInstruction::Up => "Up".to_string(),
            TapeInstruction::Down => "Down".to_string(),
            TapeInstruction::Left => "Left".to_string(),
            TapeInstruction::Right => "Right".to_string(),
            TapeInstruction::Space => "Space".to_string(),
            TapeInstruction::Escape => "Escape".to_string(),
            TapeInstruction::Ctrl(c) => format!("Ctrl+{}", c),
            TapeInstruction::Sleep(d) => format!("Sleep {}ms", d.as_millis()),
            TapeInstruction::Home => "Home".to_string(),
            TapeInstruction::End => "End".to_string(),
            TapeInstruction::Tab => "Tab".to_string(),
        }
    }
}

/// Convert ExampleBlock to TapeTest (without CLI path prefix)
/// Note: This converts only the first step. Use the TapeFile conversion for multi-step examples.
impl From<(&str, &xacli::ExampleBlock)> for TapeTest {
    fn from((name, example): (&str, &xacli::ExampleBlock)) -> Self {
        // Use first step if available
        if let Some(step) = example.steps.first() {
            let mut command = Vec::new();
            command.extend(step.commands.iter().cloned());
            command.extend(step.args.iter().cloned());

            let inputs = step
                .input_events
                .iter()
                .flat_map(Vec::<TapeInstruction>::from)
                .collect();

            Self {
                name: format!("{}: {}", name, example.title),
                command,
                inputs,
                description: example.description.clone(),
            }
        } else {
            // Empty example
            Self {
                name: format!("{}: {}", name, example.title),
                command: vec![],
                inputs: vec![],
                description: example.description.clone(),
            }
        }
    }
}

/// Convert ExampleBlock with CliConfig to TapeFile
/// Each step in the example becomes a separate TapeTest
impl From<(&CliConfig, &HashMap<String, xacli::ExampleBlock>)> for TapeFile {
    fn from((cli_config, examples): (&CliConfig, &HashMap<String, xacli::ExampleBlock>)) -> Self {
        let mut tape = TapeFile::new();

        // Set alias if configured
        if let Some(alias) = &cli_config.alias {
            tape.alias = Some((alias.clone(), cli_config.path.clone()));
        }

        for (name, example) in examples {
            // Convert each step to a TapeTest
            for (step_idx, step) in example.steps.iter().enumerate() {
                // Use alias if available, otherwise use full path
                let program = cli_config.alias.as_deref().unwrap_or(&cli_config.path);
                let mut command = vec![program.to_string()];
                command.extend(step.commands.iter().cloned());
                command.extend(step.args.iter().cloned());

                let inputs = step
                    .input_events
                    .iter()
                    .flat_map(Vec::<TapeInstruction>::from)
                    .collect();

                let test_name = if example.steps.len() == 1 {
                    format!("{}: {}", name, example.title)
                } else {
                    format!("{}: {} (step {})", name, example.title, step_idx + 1)
                };

                tape.tests.push(TapeTest {
                    name: test_name,
                    command,
                    inputs,
                    description: step
                        .description
                        .clone()
                        .or_else(|| example.description.clone()),
                });
            }
        }

        tape
    }
}