rec/export/

dockerfile.rs

use std::fmt::Write;

use crate::models::Session;

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

/// Export a session as a Dockerfile.
///
/// Generates a Dockerfile with:
/// - Metadata header comments (session name, date, command count)
/// - `FROM ubuntu:22.04` base image
/// - `ARG` declarations when parameters are provided
/// - `WORKDIR` instructions when the working directory changes
/// - One `RUN` instruction per command (no escaping needed)
/// - Annotations for failed commands (non-zero exit codes)
///
/// When `params` is `Some`, `ARG` declarations are added after the FROM line
/// and commands use `$VAR` references.
///
/// Empty sessions produce a valid Dockerfile with a "No commands recorded" comment.
#[must_use]
pub fn export_dockerfile(session: &Session, params: Option<&[Parameter]>) -> String {
    let mut out = String::new();

    // Header comments
    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();

    out.push_str("FROM ubuntu:22.04\n");

    // ARG declarations for parameters
    if let Some(params) = params {
        if !params.is_empty() {
            for param in params {
                let val = param.value.as_deref().unwrap_or(&param.original);
                writeln!(out, "ARG {}={}", param.name, val).unwrap();
            }
        }
    }

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

        for cmd in &session.commands {
            // Apply parameterization
            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())
            };

            // Emit WORKDIR when cwd changes
            let need_workdir = match &prev_cwd {
                Some(prev) => prev != &cwd_str,
                None => true,
            };

            if need_workdir {
                writeln!(out, "WORKDIR {cwd_str}").unwrap();
            }

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

            writeln!(out, "RUN {cmd_text}").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_dockerfile(&session, None);

        assert!(result.contains("FROM ubuntu:22.04"));
        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, "npm install", "/home/user", Some(0))]);
        let result = export_dockerfile(&session, None);

        assert!(result.contains("WORKDIR /home/user"));
        assert!(result.contains("RUN npm install"));
    }

    #[test]
    fn test_workdir_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_dockerfile(&session, None);

        // Should have 2 WORKDIR: first command + change to /tmp
        let workdir_count = result.matches("WORKDIR ").count();
        assert_eq!(
            workdir_count, 2,
            "Expected 2 WORKDIR instructions, got {workdir_count}"
        );
        assert!(result.contains("WORKDIR /home/user"));
        assert!(result.contains("WORKDIR /tmp"));
    }

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

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

    #[test]
    fn test_no_escaping_dollar_signs() {
        let session = make_session(vec![make_cmd(0, "echo $HOME", "/home", Some(0))]);
        let result = export_dockerfile(&session, None);

        // Dollar signs should NOT be escaped in Dockerfile
        assert!(result.contains("RUN echo $HOME"));
        assert!(!result.contains("$$HOME"));
    }

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