rec/export/

bash.rs

use std::fmt::Write;

use crate::models::Session;

use super::parameterize::{FormatType, Parameter, apply_parameters, render_for_format};
use super::{format_duration, format_timestamp};

/// Export a session as a bash script.
///
/// Generates a self-contained bash script with:
/// - Shebang and strict mode (`set -euo pipefail`)
/// - Metadata header (session name, date, command count)
/// - Variable declarations when parameters are provided
/// - Commands with `cd` when working directory changes
/// - Annotations for failed commands (non-zero exit codes)
/// - Footer comment
///
/// When `params` is `Some`, commands have auto-detected values replaced with
/// `$VAR` references and variable declarations are added after `set -euo pipefail`.
///
/// Empty sessions produce a valid script with a "No commands recorded" note.
#[must_use]
pub fn export_bash(session: &Session, params: Option<&[Parameter]>) -> String {
    let mut out = String::new();

    // Header
    out.push_str("#!/bin/bash\n");
    out.push_str("# Generated by rec\n");
    writeln!(out, "# Session: {}", session.header.name).unwrap();
    writeln!(
        out,
        "# Recorded: {}",
        format_timestamp(session.header.started_at)
    )
    .unwrap();
    writeln!(out, "# Commands: {}", session.commands.len()).unwrap();

    // Duration if available
    if let Some(ref footer) = session.footer {
        let duration = footer.ended_at - session.header.started_at;
        writeln!(out, "# Duration: {}", format_duration(duration)).unwrap();
    }

    out.push_str("set -euo pipefail\n");

    // Parameter declarations
    if let Some(params) = params {
        if !params.is_empty() {
            out.push('\n');
            out.push_str("# Parameters\n");
            for param in params {
                let val = param.value.as_deref().unwrap_or(&param.original);
                writeln!(out, "{}=\"{}\"", param.name, val).unwrap();
            }
        }
    }

    if session.commands.is_empty() {
        out.push('\n');
        out.push_str("# No commands recorded\n");
    } else {
        let mut prev_cwd: Option<String> = None;

        for (i, cmd) in session.commands.iter().enumerate() {
            out.push('\n');

            // Apply parameterization to command and cwd
            let (cmd_text, cwd_str) = if let Some(p) = params {
                let parameterized_cmd = apply_parameters(&cmd.command, p);
                let rendered_cmd = render_for_format(&parameterized_cmd, FormatType::Shell);
                let parameterized_cwd = apply_parameters(&cmd.cwd.display().to_string(), p);
                let rendered_cwd = render_for_format(&parameterized_cwd, FormatType::Shell);
                (rendered_cmd, rendered_cwd)
            } else {
                (cmd.command.clone(), cmd.cwd.display().to_string())
            };

            // Step comment with index and command summary
            writeln!(out, "# [{}] {} (from {})", i + 1, cmd_text, cwd_str).unwrap();

            // Emit cd if cwd changed from previous command
            let need_cd = match &prev_cwd {
                Some(prev) => prev != &cwd_str,
                None => true, // First command always gets cd
            };

            if need_cd {
                writeln!(out, "cd {cwd_str}").unwrap();
            }

            // The command itself
            writeln!(out, "{cmd_text}").unwrap();

            // Annotate failed commands
            if let Some(code) = cmd.exit_code {
                if code != 0 {
                    writeln!(out, "# NOTE: exited with code {code}").unwrap();
                }
            }

            prev_cwd = Some(cwd_str);
        }
    }

    out.push('\n');
    out.push_str("# Generated by rec\n");

    out
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::models::{Command, Session, SessionFooter, SessionHeader, SessionStatus};
    use std::collections::HashMap;
    use std::path::PathBuf;
    use uuid::Uuid;

    fn make_session(commands: Vec<Command>) -> Session {
        Session {
            header: SessionHeader {
                version: 2,
                id: Uuid::new_v4(),
                name: "test-session".to_string(),
                shell: "bash".to_string(),
                os: "linux".to_string(),
                hostname: "host".to_string(),
                env: HashMap::new(),
                tags: vec![],
                recovered: None,
                started_at: 1700000000.0,
            },
            commands,
            footer: Some(SessionFooter {
                ended_at: 1700000060.0,
                command_count: 0,
                status: SessionStatus::Completed,
            }),
        }
    }

    fn make_cmd(index: u32, command: &str, cwd: &str, exit_code: Option<i32>) -> Command {
        Command {
            index,
            command: command.to_string(),
            cwd: PathBuf::from(cwd),
            started_at: 1700000000.0 + f64::from(index),
            ended_at: Some(1700000001.0 + f64::from(index)),
            exit_code,
            duration_ms: Some(1000),
        }
    }

    #[test]
    fn test_empty_session() {
        let session = make_session(vec![]);
        let result = export_bash(&session, None);

        assert!(result.starts_with("#!/bin/bash\n"));
        assert!(result.contains("set -euo pipefail"));
        assert!(result.contains("# No commands recorded"));
        assert!(result.contains("# Generated by rec"));
        assert!(result.ends_with('\n'));
    }

    #[test]
    fn test_single_command() {
        let session = make_session(vec![make_cmd(0, "echo hello", "/home/user", Some(0))]);
        let result = export_bash(&session, None);

        assert!(result.contains("#!/bin/bash"));
        assert!(result.contains("set -euo pipefail"));
        assert!(result.contains("# [1] echo hello (from /home/user)"));
        assert!(result.contains("cd /home/user"));
        assert!(result.contains("echo hello"));
        assert!(!result.contains("NOTE: exited with code"));
        assert!(result.ends_with('\n'));
    }

    #[test]
    fn test_cd_only_on_change() {
        let session = make_session(vec![
            make_cmd(0, "echo a", "/home/user", Some(0)),
            make_cmd(1, "echo b", "/home/user", Some(0)),
            make_cmd(2, "echo c", "/tmp", Some(0)),
        ]);
        let result = export_bash(&session, None);

        // Count how many times "cd " appears (should be 2: initial + change)
        let cd_count = result.matches("\ncd ").count();
        assert_eq!(cd_count, 2, "Expected 2 cd commands, got {cd_count}");
    }

    #[test]
    fn test_failed_command_annotation() {
        let session = make_session(vec![make_cmd(0, "false", "/home", Some(1))]);
        let result = export_bash(&session, None);

        assert!(result.contains("# NOTE: exited with code 1"));
    }

    #[test]
    fn test_output_ends_with_newline() {
        let session = make_session(vec![make_cmd(0, "ls", "/home", Some(0))]);
        let result = export_bash(&session, None);
        assert!(result.ends_with('\n'));
    }

    #[test]
    fn test_parameterized_bash() {
        let session = make_session(vec![make_cmd(
            0,
            "ls /home/alice/docs",
            "/home/alice",
            Some(0),
        )]);
        let params = vec![Parameter {
            name: "HOME_DIR".to_string(),
            original: "/home/alice".to_string(),
            value: Some("/opt/app".to_string()),
            auto_detected: true,
        }];
        let result = export_bash(&session, Some(&params));

        // Should have variable declaration
        assert!(result.contains("# Parameters\n"));
        assert!(result.contains("HOME_DIR=\"/opt/app\""));
        // Commands should use $HOME_DIR
        assert!(result.contains("$HOME_DIR/docs"));
        assert!(result.contains("cd $HOME_DIR"));
        // Original value should NOT appear in commands
        assert!(!result.contains("cd /home/alice"));
    }
}