rec/export/

circleci.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, truncate_step_name};

/// Export a session as a `CircleCI` configuration YAML.
///
/// Generates a `.circleci/config.yml` with:
/// - Metadata header comments (session name, date, command count)
/// - Version 2.1 config
/// - Single `build` job using `cimg/base:current` Docker image
/// - `environment:` block when parameters are provided
/// - Checkout step followed by expanded `run:` steps
/// - `working_directory` on every step
/// - `workflows` section at the end
/// - Annotations for failed commands (non-zero exit codes)
///
/// When `params` is `Some`, an `environment:` block is added at job level
/// and commands use `$VAR` references.
///
/// Empty sessions produce a valid config with a "No commands recorded" comment.
#[must_use]
pub fn export_circleci(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("version: 2.1\n");
    out.push_str("jobs:\n");
    out.push_str("  build:\n");
    out.push_str("    docker:\n");
    out.push_str("      - image: cimg/base:current\n");

    // Environment variables for parameters
    if let Some(params) = params {
        if !params.is_empty() {
            out.push_str("    environment:\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("    steps:\n");
    out.push_str("      - checkout\n");

    if session.commands.is_empty() {
        out.push_str("      # No commands recorded\n");
    } else {
        for (i, cmd) in session.commands.iter().enumerate() {
            let step = i + 1;

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

            let step_name = truncate_step_name(&cmd_text, 60);
            out.push_str("      - run:\n");
            writeln!(out, "          name: \"Step {step}: {step_name}\"").unwrap();

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

            writeln!(out, "          command: {}", escape_yaml(&cmd_text)).unwrap();
            writeln!(out, "          working_directory: {cwd_str}").unwrap();
        }
    }

    // Workflows section
    out.push_str("workflows:\n");
    out.push_str("  main:\n");
    out.push_str("    jobs:\n");
    out.push_str("      - build\n");

    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_circleci(&session, None);

        assert!(result.contains("- checkout"));
        assert!(result.contains("# No commands recorded"));
        assert!(result.contains("workflows:"));
        assert!(result.contains("version: 2.1"));
        assert!(result.contains("cimg/base:current"));
        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_circleci(&session, None);

        assert!(result.contains("      - run:"));
        assert!(result.contains("          name: \"Step 1: npm install\""));
        assert!(result.contains("          command: npm install"));
        assert!(result.contains("          working_directory: /home/user"));
    }

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

        // Both steps should have working_directory
        let wd_count = result
            .matches("          working_directory: /home/user")
            .count();
        assert_eq!(
            wd_count, 2,
            "Expected 2 working_directory entries, got {wd_count}"
        );
    }

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

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

    #[test]
    fn test_step_name_truncation() {
        let long_cmd = "a".repeat(100);
        let session = make_session(vec![make_cmd(0, &long_cmd, "/home", Some(0))]);
        let result = export_circleci(&session, None);

        // Step name should be truncated
        let expected_name = format!("\"Step 1: {}...\"", "a".repeat(60));
        assert!(result.contains(&expected_name));

        // But command value should have full command
        assert!(result.contains(&format!("command: {long_cmd}")));
    }

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

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

    #[test]
    fn test_workflows_section_present() {
        let session = make_session(vec![make_cmd(0, "ls", "/home", Some(0))]);
        let result = export_circleci(&session, None);

        assert!(result.contains("workflows:"));
        assert!(result.contains("      - build"));
    }

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