rec/export/

gitlab_ci.rs

use std::fmt::Write;

use crate::models::Session;

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

/// Export a session as a GitLab CI configuration YAML.
///
/// Generates a `.gitlab-ci.yml` with:
/// - Metadata header comments (session name, date, command count)
/// - Single `build` stage and job
/// - `ubuntu:22.04` Docker image
/// - `variables:` block when parameters are provided
/// - `cd` commands in the script array when cwd changes
/// - Commands passed through `escape_yaml()` for safe YAML output
/// - Annotations for failed commands (non-zero exit codes)
///
/// When `params` is `Some`, a `variables:` block is added at job level
/// and commands use `$VAR` references.
///
/// Empty sessions produce a valid config with a placeholder script entry
/// (GitLab CI requires at least one script entry).
#[must_use]
pub fn export_gitlab_ci(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();

    // Job structure
    out.push_str("stages:\n");
    out.push_str("  - build\n");
    out.push_str("build:\n");
    out.push_str("  stage: build\n");
    out.push_str("  image: ubuntu:22.04\n");

    // Variables for parameters
    if let Some(params) = params {
        if !params.is_empty() {
            out.push_str("  variables:\n");
            for param in params {
                let val = param.value.as_deref().unwrap_or(&param.original);
                writeln!(out, "    {}: {}", param.name, escape_yaml(val)).unwrap();
            }
        }
    }

    out.push_str("  script:\n");

    if session.commands.is_empty() {
        out.push_str("    - echo '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())
            };

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

            if need_cd {
                writeln!(out, "    - cd {}", escape_yaml(&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, "    - {}", escape_yaml(&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_gitlab_ci(&session, None);

        assert!(result.contains("echo 'No commands recorded'"));
        assert!(result.contains("stages:"));
        assert!(result.contains("  - build"));
        assert!(result.contains("build:"));
        assert!(result.contains("  stage: build"));
        assert!(result.contains("  image: ubuntu:22.04"));
        assert!(result.contains("  script:"));
        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_gitlab_ci(&session, None);

        assert!(result.contains("    - cd /home/user"));
        assert!(result.contains("    - npm install"));
    }

    #[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_gitlab_ci(&session, None);

        // Should have 2 cd entries: first command + change to /tmp
        let cd_count = result.matches("    - cd ").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_gitlab_ci(&session, None);

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

    #[test]
    fn test_yaml_escaping() {
        let session = make_session(vec![make_cmd(0, "echo hello: world", "/home", Some(0))]);
        let result = export_gitlab_ci(&session, None);

        assert!(result.contains("    - \"echo hello: world\""));
    }

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