@hasna/terminal 2.3.0 → 2.3.1

package/temp/rtk/src/go_cmd.rs

@@ -1,592 +0,0 @@
-use crate::tracking;
-use crate::utils::truncate;
-use anyhow::{Context, Result};
-use serde::Deserialize;
-use std::collections::HashMap;
-use std::ffi::OsString;
-use std::process::Command;
-
-#[derive(Debug, Deserialize)]
-#[allow(dead_code)]
-struct GoTestEvent {
-    #[serde(rename = "Time")]
-    time: Option<String>,
-    #[serde(rename = "Action")]
-    action: String,
-    #[serde(rename = "Package")]
-    package: Option<String>,
-    #[serde(rename = "Test")]
-    test: Option<String>,
-    #[serde(rename = "Output")]
-    output: Option<String>,
-    #[serde(rename = "Elapsed")]
-    elapsed: Option<f64>,
-    #[serde(rename = "ImportPath")]
-    import_path: Option<String>,
-    #[serde(rename = "FailedBuild")]
-    failed_build: Option<String>,
-}
-
-#[derive(Debug, Default)]
-struct PackageResult {
-    pass: usize,
-    fail: usize,
-    skip: usize,
-    build_failed: bool,
-    build_errors: Vec<String>,
-    failed_tests: Vec<(String, Vec<String>)>, // (test_name, output_lines)
-}
-
-pub fn run_test(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    let mut cmd = Command::new("go");
-    cmd.arg("test");
-
-    // Force JSON output if not already specified
-    if !args.iter().any(|a| a == "-json") {
-        cmd.arg("-json");
-    }
-
-    for arg in args {
-        cmd.arg(arg);
-    }
-
-    if verbose > 0 {
-        eprintln!("Running: go test -json {}", args.join(" "));
-    }
-
-    let output = cmd
-        .output()
-        .context("Failed to run go test. Is Go installed?")?;
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    let exit_code = output
-        .status
-        .code()
-        .unwrap_or(if output.status.success() { 0 } else { 1 });
-    let filtered = filter_go_test_json(&stdout);
-
-    if let Some(hint) = crate::tee::tee_and_hint(&raw, "go_test", exit_code) {
-        println!("{}\n{}", filtered, hint);
-    } else {
-        println!("{}", filtered);
-    }
-
-    // Include stderr if present (build errors, etc.)
-    if !stderr.trim().is_empty() {
-        eprintln!("{}", stderr.trim());
-    }
-
-    timer.track(
-        &format!("go test {}", args.join(" ")),
-        &format!("rtk go test {}", args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    // Preserve exit code for CI/CD
-    if !output.status.success() {
-        std::process::exit(exit_code);
-    }
-
-    Ok(())
-}
-
-pub fn run_build(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    let mut cmd = Command::new("go");
-    cmd.arg("build");
-
-    for arg in args {
-        cmd.arg(arg);
-    }
-
-    if verbose > 0 {
-        eprintln!("Running: go build {}", args.join(" "));
-    }
-
-    let output = cmd
-        .output()
-        .context("Failed to run go build. Is Go installed?")?;
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    let exit_code = output
-        .status
-        .code()
-        .unwrap_or(if output.status.success() { 0 } else { 1 });
-    let filtered = filter_go_build(&raw);
-
-    if let Some(hint) = crate::tee::tee_and_hint(&raw, "go_build", exit_code) {
-        if !filtered.is_empty() {
-            println!("{}\n{}", filtered, hint);
-        } else {
-            println!("{}", hint);
-        }
-    } else if !filtered.is_empty() {
-        println!("{}", filtered);
-    }
-
-    timer.track(
-        &format!("go build {}", args.join(" ")),
-        &format!("rtk go build {}", args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    // Preserve exit code for CI/CD
-    if !output.status.success() {
-        std::process::exit(exit_code);
-    }
-
-    Ok(())
-}
-
-pub fn run_vet(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    let mut cmd = Command::new("go");
-    cmd.arg("vet");
-
-    for arg in args {
-        cmd.arg(arg);
-    }
-
-    if verbose > 0 {
-        eprintln!("Running: go vet {}", args.join(" "));
-    }
-
-    let output = cmd
-        .output()
-        .context("Failed to run go vet. Is Go installed?")?;
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    let exit_code = output
-        .status
-        .code()
-        .unwrap_or(if output.status.success() { 0 } else { 1 });
-    let filtered = filter_go_vet(&raw);
-
-    if let Some(hint) = crate::tee::tee_and_hint(&raw, "go_vet", exit_code) {
-        if !filtered.is_empty() {
-            println!("{}\n{}", filtered, hint);
-        } else {
-            println!("{}", hint);
-        }
-    } else if !filtered.is_empty() {
-        println!("{}", filtered);
-    }
-
-    timer.track(
-        &format!("go vet {}", args.join(" ")),
-        &format!("rtk go vet {}", args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    // Preserve exit code for CI/CD
-    if !output.status.success() {
-        std::process::exit(exit_code);
-    }
-
-    Ok(())
-}
-
-pub fn run_other(args: &[OsString], verbose: u8) -> Result<()> {
-    if args.is_empty() {
-        anyhow::bail!("go: no subcommand specified");
-    }
-
-    let timer = tracking::TimedExecution::start();
-
-    let subcommand = args[0].to_string_lossy();
-    let mut cmd = Command::new("go");
-    cmd.arg(&*subcommand);
-
-    for arg in &args[1..] {
-        cmd.arg(arg);
-    }
-
-    if verbose > 0 {
-        eprintln!("Running: go {} ...", subcommand);
-    }
-
-    let output = cmd
-        .output()
-        .with_context(|| format!("Failed to run go {}", subcommand))?;
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    print!("{}", stdout);
-    eprint!("{}", stderr);
-
-    timer.track(
-        &format!("go {}", subcommand),
-        &format!("rtk go {}", subcommand),
-        &raw,
-        &raw, // No filtering for unsupported commands
-    );
-
-    // Preserve exit code
-    if !output.status.success() {
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    Ok(())
-}
-
-/// Parse go test -json output (NDJSON format)
-fn filter_go_test_json(output: &str) -> String {
-    let mut packages: HashMap<String, PackageResult> = HashMap::new();
-    let mut current_test_output: HashMap<(String, String), Vec<String>> = HashMap::new(); // (package, test) -> outputs
-    let mut build_output: HashMap<String, Vec<String>> = HashMap::new(); // import_path -> error lines
-
-    for line in output.lines() {
-        let trimmed = line.trim();
-        if trimmed.is_empty() {
-            continue;
-        }
-
-        let event: GoTestEvent = match serde_json::from_str(trimmed) {
-            Ok(e) => e,
-            Err(_) => continue, // Skip non-JSON lines
-        };
-
-        // Handle build-output/build-fail events (use ImportPath, no Package)
-        match event.action.as_str() {
-            "build-output" => {
-                if let (Some(import_path), Some(output_text)) = (&event.import_path, &event.output)
-                {
-                    let text = output_text.trim_end().to_string();
-                    if !text.is_empty() {
-                        build_output
-                            .entry(import_path.clone())
-                            .or_default()
-                            .push(text);
-                    }
-                }
-                continue;
-            }
-            "build-fail" => {
-                // build-fail has ImportPath — we'll handle it when the package-level fail arrives
-                continue;
-            }
-            _ => {}
-        }
-
-        let package = event.package.unwrap_or_else(|| "unknown".to_string());
-        let pkg_result = packages.entry(package.clone()).or_default();
-
-        match event.action.as_str() {
-            "pass" => {
-                if event.test.is_some() {
-                    pkg_result.pass += 1;
-                }
-            }
-            "fail" => {
-                if let Some(test) = &event.test {
-                    // Individual test failure
-                    pkg_result.fail += 1;
-
-                    // Collect output for failed test
-                    let key = (package.clone(), test.clone());
-                    let outputs = current_test_output.remove(&key).unwrap_or_default();
-                    pkg_result.failed_tests.push((test.clone(), outputs));
-                } else if event.failed_build.is_some() {
-                    // Package-level build failure
-                    pkg_result.build_failed = true;
-                    // Collect build errors from the import path
-                    if let Some(import_path) = &event.failed_build {
-                        if let Some(errors) = build_output.remove(import_path) {
-                            pkg_result.build_errors = errors;
-                        }
-                    }
-                }
-            }
-            "skip" => {
-                if event.test.is_some() {
-                    pkg_result.skip += 1;
-                }
-            }
-            "output" => {
-                // Collect output for current test
-                if let (Some(test), Some(output_text)) = (&event.test, &event.output) {
-                    let key = (package.clone(), test.clone());
-                    current_test_output
-                        .entry(key)
-                        .or_default()
-                        .push(output_text.trim_end().to_string());
-                }
-            }
-            _ => {} // run, pause, cont, etc.
-        }
-    }
-
-    // Build summary
-    let total_packages = packages.len();
-    let total_pass: usize = packages.values().map(|p| p.pass).sum();
-    let total_fail: usize = packages.values().map(|p| p.fail).sum();
-    let total_skip: usize = packages.values().map(|p| p.skip).sum();
-    let total_build_fail: usize = packages.values().filter(|p| p.build_failed).count();
-
-    let has_failures = total_fail > 0 || total_build_fail > 0;
-
-    if !has_failures && total_pass == 0 {
-        return "Go test: No tests found".to_string();
-    }
-
-    if !has_failures {
-        return format!(
-            "✓ Go test: {} passed in {} packages",
-            total_pass, total_packages
-        );
-    }
-
-    let mut result = String::new();
-    result.push_str(&format!(
-        "Go test: {} passed, {} failed",
-        total_pass,
-        total_fail + total_build_fail
-    ));
-    if total_skip > 0 {
-        result.push_str(&format!(", {} skipped", total_skip));
-    }
-    result.push_str(&format!(" in {} packages\n", total_packages));
-    result.push_str("═══════════════════════════════════════\n");
-
-    // Show build failures first
-    for (package, pkg_result) in packages.iter() {
-        if !pkg_result.build_failed {
-            continue;
-        }
-
-        result.push_str(&format!(
-            "\n📦 {} [build failed]\n",
-            compact_package_name(package)
-        ));
-
-        for line in &pkg_result.build_errors {
-            let trimmed = line.trim();
-            // Skip the "# package" header line
-            if !trimmed.starts_with('#') && !trimmed.is_empty() {
-                result.push_str(&format!("  {}\n", truncate(trimmed, 120)));
-            }
-        }
-    }
-
-    // Show failed tests grouped by package
-    for (package, pkg_result) in packages.iter() {
-        if pkg_result.fail == 0 {
-            continue;
-        }
-
-        result.push_str(&format!(
-            "\n📦 {} ({} passed, {} failed)\n",
-            compact_package_name(package),
-            pkg_result.pass,
-            pkg_result.fail
-        ));
-
-        for (test, outputs) in &pkg_result.failed_tests {
-            result.push_str(&format!("  ❌ {}\n", test));
-
-            // Show failure output (limit to key lines)
-            let relevant_lines: Vec<&String> = outputs
-                .iter()
-                .filter(|line| {
-                    let lower = line.to_lowercase();
-                    !line.trim().is_empty()
-                        && !line.starts_with("=== RUN")
-                        && !line.starts_with("--- FAIL")
-                        && (lower.contains("error")
-                            || lower.contains("expected")
-                            || lower.contains("got")
-                            || lower.contains("panic")
-                            || line.trim().starts_with("at "))
-                })
-                .take(5)
-                .collect();
-
-            for line in relevant_lines {
-                result.push_str(&format!("     {}\n", truncate(line, 100)));
-            }
-        }
-    }
-
-    result.trim().to_string()
-}
-
-/// Filter go build output - show only errors
-fn filter_go_build(output: &str) -> String {
-    let mut errors: Vec<String> = Vec::new();
-
-    for line in output.lines() {
-        let trimmed = line.trim();
-        let lower = trimmed.to_lowercase();
-
-        // Skip package markers (# package/name lines without errors)
-        if trimmed.starts_with('#') && !lower.contains("error") {
-            continue;
-        }
-
-        // Collect error lines (file:line:col format or error keywords)
-        if !trimmed.is_empty()
-            && (lower.contains("error")
-                || trimmed.contains(".go:")
-                || lower.contains("undefined")
-                || lower.contains("cannot"))
-        {
-            errors.push(trimmed.to_string());
-        }
-    }
-
-    if errors.is_empty() {
-        return "✓ Go build: Success".to_string();
-    }
-
-    let mut result = String::new();
-    result.push_str(&format!("Go build: {} errors\n", errors.len()));
-    result.push_str("═══════════════════════════════════════\n");
-
-    for (i, error) in errors.iter().take(20).enumerate() {
-        result.push_str(&format!("{}. {}\n", i + 1, truncate(error, 120)));
-    }
-
-    if errors.len() > 20 {
-        result.push_str(&format!("\n... +{} more errors\n", errors.len() - 20));
-    }
-
-    result.trim().to_string()
-}
-
-/// Filter go vet output - show issues
-fn filter_go_vet(output: &str) -> String {
-    let mut issues: Vec<String> = Vec::new();
-
-    for line in output.lines() {
-        let trimmed = line.trim();
-
-        // Collect issue lines (vet reports issues with file:line:col format)
-        if !trimmed.is_empty() && !trimmed.starts_with('#') && trimmed.contains(".go:") {
-            issues.push(trimmed.to_string());
-        }
-    }
-
-    if issues.is_empty() {
-        return "✓ Go vet: No issues found".to_string();
-    }
-
-    let mut result = String::new();
-    result.push_str(&format!("Go vet: {} issues\n", issues.len()));
-    result.push_str("═══════════════════════════════════════\n");
-
-    for (i, issue) in issues.iter().take(20).enumerate() {
-        result.push_str(&format!("{}. {}\n", i + 1, truncate(issue, 120)));
-    }
-
-    if issues.len() > 20 {
-        result.push_str(&format!("\n... +{} more issues\n", issues.len() - 20));
-    }
-
-    result.trim().to_string()
-}
-
-/// Compact package name (remove long paths)
-fn compact_package_name(package: &str) -> String {
-    // Remove common module prefixes like github.com/user/repo/
-    if let Some(pos) = package.rfind('/') {
-        package[pos + 1..].to_string()
-    } else {
-        package.to_string()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_filter_go_test_all_pass() {
-        let output = r#"{"Time":"2024-01-01T10:00:00Z","Action":"run","Package":"example.com/foo","Test":"TestBar"}
-{"Time":"2024-01-01T10:00:01Z","Action":"output","Package":"example.com/foo","Test":"TestBar","Output":"=== RUN   TestBar\n"}
-{"Time":"2024-01-01T10:00:02Z","Action":"pass","Package":"example.com/foo","Test":"TestBar","Elapsed":0.5}
-{"Time":"2024-01-01T10:00:02Z","Action":"pass","Package":"example.com/foo","Elapsed":0.5}"#;
-
-        let result = filter_go_test_json(output);
-        assert!(result.contains("✓ Go test"));
-        assert!(result.contains("1 passed"));
-        assert!(result.contains("1 packages"));
-    }
-
-    #[test]
-    fn test_filter_go_test_with_failures() {
-        let output = r#"{"Time":"2024-01-01T10:00:00Z","Action":"run","Package":"example.com/foo","Test":"TestFail"}
-{"Time":"2024-01-01T10:00:01Z","Action":"output","Package":"example.com/foo","Test":"TestFail","Output":"=== RUN   TestFail\n"}
-{"Time":"2024-01-01T10:00:02Z","Action":"output","Package":"example.com/foo","Test":"TestFail","Output":"    Error: expected 5, got 3\n"}
-{"Time":"2024-01-01T10:00:03Z","Action":"fail","Package":"example.com/foo","Test":"TestFail","Elapsed":0.5}
-{"Time":"2024-01-01T10:00:03Z","Action":"fail","Package":"example.com/foo","Elapsed":0.5}"#;
-
-        let result = filter_go_test_json(output);
-        assert!(result.contains("1 failed"));
-        assert!(result.contains("TestFail"));
-        assert!(result.contains("expected 5, got 3"));
-    }
-
-    #[test]
-    fn test_filter_go_build_success() {
-        let output = "";
-        let result = filter_go_build(output);
-        assert!(result.contains("✓ Go build"));
-        assert!(result.contains("Success"));
-    }
-
-    #[test]
-    fn test_filter_go_build_errors() {
-        let output = r#"# example.com/foo
-main.go:10:5: undefined: missingFunc
-main.go:15:2: cannot use x (type int) as type string"#;
-
-        let result = filter_go_build(output);
-        assert!(result.contains("2 errors"));
-        assert!(result.contains("undefined: missingFunc"));
-        assert!(result.contains("cannot use x"));
-    }
-
-    #[test]
-    fn test_filter_go_vet_no_issues() {
-        let output = "";
-        let result = filter_go_vet(output);
-        assert!(result.contains("✓ Go vet"));
-        assert!(result.contains("No issues found"));
-    }
-
-    #[test]
-    fn test_filter_go_vet_with_issues() {
-        let output = r#"main.go:42:2: Printf format %d has arg x of wrong type string
-utils.go:15:5: unreachable code"#;
-
-        let result = filter_go_vet(output);
-        assert!(result.contains("2 issues"));
-        assert!(result.contains("Printf format"));
-        assert!(result.contains("unreachable code"));
-    }
-
-    #[test]
-    fn test_compact_package_name() {
-        assert_eq!(compact_package_name("github.com/user/repo/pkg"), "pkg");
-        assert_eq!(compact_package_name("example.com/foo"), "foo");
-        assert_eq!(compact_package_name("simple"), "simple");
-    }
-}