@hasna/terminal 2.3.0 → 2.3.2

package/temp/rtk/src/format_cmd.rs

@@ -1,386 +0,0 @@
-use crate::prettier_cmd;
-use crate::ruff_cmd;
-use crate::tracking;
-use crate::utils::package_manager_exec;
-use anyhow::{Context, Result};
-use std::path::Path;
-use std::process::Command;
-
-/// Detect formatter from project files or explicit argument
-fn detect_formatter(args: &[String]) -> String {
-    detect_formatter_in_dir(args, Path::new("."))
-}
-
-/// Detect formatter with explicit directory (for testing)
-fn detect_formatter_in_dir(args: &[String], dir: &Path) -> String {
-    // Check if first arg is a known formatter
-    if !args.is_empty() {
-        let first_arg = &args[0];
-        if matches!(first_arg.as_str(), "prettier" | "black" | "ruff" | "biome") {
-            return first_arg.clone();
-        }
-    }
-
-    // Auto-detect from project files
-    // Priority: pyproject.toml > package.json > fallback
-    let pyproject_path = dir.join("pyproject.toml");
-    if pyproject_path.exists() {
-        // Read pyproject.toml to detect formatter
-        if let Ok(content) = std::fs::read_to_string(&pyproject_path) {
-            // Check for [tool.black] section
-            if content.contains("[tool.black]") {
-                return "black".to_string();
-            }
-            // Check for [tool.ruff.format] section
-            if content.contains("[tool.ruff.format]") || content.contains("[tool.ruff]") {
-                return "ruff".to_string();
-            }
-        }
-    }
-
-    // Check for package.json or prettier config
-    if dir.join("package.json").exists()
-        || dir.join(".prettierrc").exists()
-        || dir.join(".prettierrc.json").exists()
-        || dir.join(".prettierrc.js").exists()
-    {
-        return "prettier".to_string();
-    }
-
-    // Fallback: try ruff -> black -> prettier in order
-    "ruff".to_string()
-}
-
-pub fn run(args: &[String], verbose: u8) -> Result<()> {
-    let timer = tracking::TimedExecution::start();
-
-    // Detect formatter
-    let formatter = detect_formatter(args);
-
-    // Determine start index for actual arguments
-    let start_idx = if !args.is_empty() && args[0] == formatter {
-        1 // Skip formatter name if it was explicitly provided
-    } else {
-        0 // Use all args if formatter was auto-detected
-    };
-
-    if verbose > 0 {
-        eprintln!("Detected formatter: {}", formatter);
-        eprintln!("Arguments: {}", args[start_idx..].join(" "));
-    }
-
-    // Build command based on formatter
-    let mut cmd = match formatter.as_str() {
-        "prettier" => package_manager_exec("prettier"),
-        "black" | "ruff" => Command::new(formatter.as_str()),
-        "biome" => package_manager_exec("biome"),
-        _ => Command::new(formatter.as_str()),
-    };
-
-    // Add formatter-specific flags
-    let user_args = args[start_idx..].to_vec();
-
-    match formatter.as_str() {
-        "black" => {
-            // Inject --check if not present for check mode
-            if !user_args.iter().any(|a| a == "--check" || a == "--diff") {
-                cmd.arg("--check");
-            }
-        }
-        "ruff" => {
-            // Add "format" subcommand if not present
-            if user_args.is_empty() || !user_args[0].starts_with("format") {
-                cmd.arg("format");
-            }
-        }
-        _ => {}
-    }
-
-    // Add user arguments
-    for arg in &user_args {
-        cmd.arg(arg);
-    }
-
-    // Default to current directory if no path specified
-    if user_args.iter().all(|a| a.starts_with('-')) {
-        cmd.arg(".");
-    }
-
-    if verbose > 0 {
-        eprintln!("Running: {} {}", formatter, user_args.join(" "));
-    }
-
-    let output = cmd.output().context(format!(
-        "Failed to run {}. Is it installed? Try: pip install {} (or npm/pnpm for JS formatters)",
-        formatter, formatter
-    ))?;
-
-    let stdout = String::from_utf8_lossy(&output.stdout);
-    let stderr = String::from_utf8_lossy(&output.stderr);
-    let raw = format!("{}\n{}", stdout, stderr);
-
-    // Dispatch to appropriate filter based on formatter
-    let filtered = match formatter.as_str() {
-        "prettier" => prettier_cmd::filter_prettier_output(&raw),
-        "ruff" => ruff_cmd::filter_ruff_format(&raw),
-        "black" => filter_black_output(&raw),
-        _ => raw.trim().to_string(),
-    };
-
-    println!("{}", filtered);
-
-    timer.track(
-        &format!("{} {}", formatter, user_args.join(" ")),
-        &format!("rtk format {} {}", formatter, user_args.join(" ")),
-        &raw,
-        &filtered,
-    );
-
-    // Preserve exit code for CI/CD
-    if !output.status.success() {
-        std::process::exit(output.status.code().unwrap_or(1));
-    }
-
-    Ok(())
-}
-
-/// Filter black output - show files that need formatting
-fn filter_black_output(output: &str) -> String {
-    let mut files_to_format: Vec<String> = Vec::new();
-    let mut files_unchanged = 0;
-    let mut files_would_reformat = 0;
-    let mut all_done = false;
-    let mut oh_no = false;
-
-    for line in output.lines() {
-        let trimmed = line.trim();
-        let lower = trimmed.to_lowercase();
-
-        // Check for "would reformat" lines
-        if lower.starts_with("would reformat:") {
-            // Extract filename from "would reformat: path/to/file.py"
-            if let Some(filename) = trimmed.split(':').nth(1) {
-                files_to_format.push(filename.trim().to_string());
-            }
-        }
-
-        // Parse summary line like "2 files would be reformatted, 3 files would be left unchanged."
-        if lower.contains("would be reformatted") || lower.contains("would be left unchanged") {
-            // Split by comma to handle both parts
-            for part in trimmed.split(',') {
-                let part_lower = part.to_lowercase();
-                let words: Vec<&str> = part.trim().split_whitespace().collect();
-
-                if part_lower.contains("would be reformatted") {
-                    // Parse "X file(s) would be reformatted"
-                    for (i, word) in words.iter().enumerate() {
-                        if (word == &"file" || word == &"files") && i > 0 {
-                            if let Ok(count) = words[i - 1].parse::<usize>() {
-                                files_would_reformat = count;
-                                break;
-                            }
-                        }
-                    }
-                }
-
-                if part_lower.contains("would be left unchanged") {
-                    // Parse "X file(s) would be left unchanged"
-                    for (i, word) in words.iter().enumerate() {
-                        if (word == &"file" || word == &"files") && i > 0 {
-                            if let Ok(count) = words[i - 1].parse::<usize>() {
-                                files_unchanged = count;
-                                break;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        // Check for "left unchanged" (standalone)
-        if lower.contains("left unchanged") && !lower.contains("would be") {
-            let words: Vec<&str> = trimmed.split_whitespace().collect();
-            for (i, word) in words.iter().enumerate() {
-                if (word == &"file" || word == &"files") && i > 0 {
-                    if let Ok(count) = words[i - 1].parse::<usize>() {
-                        files_unchanged = count;
-                        break;
-                    }
-                }
-            }
-        }
-
-        // Check for success/failure indicators
-        if lower.contains("all done!") || lower.contains("all done ✨") {
-            all_done = true;
-        }
-        if lower.contains("oh no!") {
-            oh_no = true;
-        }
-    }
-
-    // Build output
-    let mut result = String::new();
-
-    // Determine if all files are formatted
-    let needs_formatting = !files_to_format.is_empty() || files_would_reformat > 0 || oh_no;
-
-    if !needs_formatting && (all_done || files_unchanged > 0) {
-        // All files formatted correctly
-        result.push_str("✓ Format (black): All files formatted");
-        if files_unchanged > 0 {
-            result.push_str(&format!(" ({} files checked)", files_unchanged));
-        }
-    } else if needs_formatting {
-        // Files need formatting
-        let count = if !files_to_format.is_empty() {
-            files_to_format.len()
-        } else {
-            files_would_reformat
-        };
-
-        result.push_str(&format!(
-            "Format (black): {} files need formatting\n",
-            count
-        ));
-        result.push_str("═══════════════════════════════════════\n");
-
-        if !files_to_format.is_empty() {
-            for (i, file) in files_to_format.iter().take(10).enumerate() {
-                result.push_str(&format!("{}. {}\n", i + 1, compact_path(file)));
-            }
-
-            if files_to_format.len() > 10 {
-                result.push_str(&format!(
-                    "\n... +{} more files\n",
-                    files_to_format.len() - 10
-                ));
-            }
-        }
-
-        if files_unchanged > 0 {
-            result.push_str(&format!(
-                "\n✓ {} files already formatted\n",
-                files_unchanged
-            ));
-        }
-
-        result.push_str("\n💡 Run `black .` to format these files\n");
-    } else {
-        // Fallback: show raw output
-        result.push_str(output.trim());
-    }
-
-    result.trim().to_string()
-}
-
-/// Compact file path (remove common prefixes)
-fn compact_path(path: &str) -> String {
-    let path = path.replace('\\', "/");
-
-    if let Some(pos) = path.rfind("/src/") {
-        format!("src/{}", &path[pos + 5..])
-    } else if let Some(pos) = path.rfind("/lib/") {
-        format!("lib/{}", &path[pos + 5..])
-    } else if let Some(pos) = path.rfind("/tests/") {
-        format!("tests/{}", &path[pos + 7..])
-    } else if let Some(pos) = path.rfind('/') {
-        path[pos + 1..].to_string()
-    } else {
-        path
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::fs;
-    use std::io::Write;
-    use tempfile::TempDir;
-
-    #[test]
-    fn test_detect_formatter_from_explicit_arg() {
-        let args = vec!["black".to_string(), "--check".to_string()];
-        let formatter = detect_formatter(&args);
-        assert_eq!(formatter, "black");
-
-        let args = vec!["prettier".to_string(), ".".to_string()];
-        let formatter = detect_formatter(&args);
-        assert_eq!(formatter, "prettier");
-
-        let args = vec!["ruff".to_string(), "format".to_string()];
-        let formatter = detect_formatter(&args);
-        assert_eq!(formatter, "ruff");
-    }
-
-    #[test]
-    fn test_detect_formatter_from_pyproject_black() {
-        let temp_dir = TempDir::new().unwrap();
-        let pyproject_path = temp_dir.path().join("pyproject.toml");
-        let mut file = fs::File::create(&pyproject_path).unwrap();
-        writeln!(file, "[tool.black]\nline-length = 88").unwrap();
-
-        let formatter = detect_formatter_in_dir(&[], temp_dir.path());
-        assert_eq!(formatter, "black");
-    }
-
-    #[test]
-    fn test_detect_formatter_from_pyproject_ruff() {
-        let temp_dir = TempDir::new().unwrap();
-        let pyproject_path = temp_dir.path().join("pyproject.toml");
-        let mut file = fs::File::create(&pyproject_path).unwrap();
-        writeln!(file, "[tool.ruff.format]\nindent-width = 4").unwrap();
-
-        let formatter = detect_formatter_in_dir(&[], temp_dir.path());
-        assert_eq!(formatter, "ruff");
-    }
-
-    #[test]
-    fn test_detect_formatter_from_package_json() {
-        let temp_dir = TempDir::new().unwrap();
-        let package_path = temp_dir.path().join("package.json");
-        let mut file = fs::File::create(&package_path).unwrap();
-        writeln!(file, "{{\"name\": \"test\"}}").unwrap();
-
-        let formatter = detect_formatter_in_dir(&[], temp_dir.path());
-        assert_eq!(formatter, "prettier");
-    }
-
-    #[test]
-    fn test_filter_black_all_formatted() {
-        let output = "All done! ✨ 🍰 ✨\n5 files left unchanged.";
-        let result = filter_black_output(output);
-        assert!(result.contains("✓ Format (black)"));
-        assert!(result.contains("All files formatted"));
-        assert!(result.contains("5 files checked"));
-    }
-
-    #[test]
-    fn test_filter_black_needs_formatting() {
-        let output = r#"would reformat: src/main.py
-would reformat: tests/test_utils.py
-Oh no! 💥 💔 💥
-2 files would be reformatted, 3 files would be left unchanged."#;
-
-        let result = filter_black_output(output);
-        assert!(result.contains("2 files need formatting"));
-        assert!(result.contains("main.py"));
-        assert!(result.contains("test_utils.py"));
-        assert!(result.contains("3 files already formatted"));
-        assert!(result.contains("Run `black .`"));
-    }
-
-    #[test]
-    fn test_compact_path() {
-        assert_eq!(
-            compact_path("/Users/foo/project/src/main.py"),
-            "src/main.py"
-        );
-        assert_eq!(compact_path("/home/user/app/lib/utils.py"), "lib/utils.py");
-        assert_eq!(
-            compact_path("C:\\Users\\foo\\project\\tests\\test.py"),
-            "tests/test.py"
-        );
-        assert_eq!(compact_path("relative/file.py"), "file.py");
-    }
-}