cs/parse/

key_extractor.rs

// src/parse/key_extractor.rs

use crate::error::Result;
use std::path::Path;
use walkdir::WalkDir;

use super::json_parser::JsonParser;
use super::translation::TranslationEntry;
use super::yaml_parser::YamlParser;

/// `KeyExtractor` provides functionality to search translation entries across
/// multiple YAML translation files, returning the full dot‑notation key path,
/// associated file path and line number for each match.
pub struct KeyExtractor {
    exclusions: Vec<String>,
    verbose: bool,
}

impl Default for KeyExtractor {
    fn default() -> Self {
        Self::new()
    }
}

impl KeyExtractor {
    /// Create a new `KeyExtractor`.
    pub fn new() -> Self {
        Self {
            exclusions: Vec::new(),
            verbose: false,
        }
    }

    /// Set exclusion patterns (e.g., directories or files to ignore)
    pub fn set_exclusions(&mut self, exclusions: Vec<String>) {
        self.exclusions = exclusions;
    }

    /// Set verbose mode for detailed error messages
    pub fn set_verbose(&mut self, verbose: bool) {
        self.verbose = verbose;
    }

    /// Recursively walk `base_dir` for `*.yml` (or `*.yaml`) files, parse each,
    /// and return entries whose **value** contains `query`.
    ///
    /// Matching is case‑insensitive by default.
    pub fn extract(&self, base_dir: &Path, query: &str) -> Result<Vec<TranslationEntry>> {
        let mut matches = Vec::new();
        let lowered = query.to_lowercase();
        let mut skipped_files = 0;

        let walker = WalkDir::new(base_dir).into_iter();
        for entry in walker
            .filter_entry(|e| {
                if is_ignored(e) {
                    return false;
                }
                let name = e.file_name().to_string_lossy();
                for excl in &self.exclusions {
                    if name == excl.as_str() {
                        return false;
                    }
                }
                true
            })
            .filter_map(|e| e.ok())
            .filter(|e| e.file_type().is_file())
        {
            let path = entry.path();
            if let Some(ext) = path.extension() {
                let ext_str = ext.to_string_lossy();
                if ext_str == "yml" || ext_str == "yaml" {
                    match YamlParser::parse_file(path) {
                        Ok(entries) => {
                            use colored::Colorize;
                            eprint!("{}", ".".green()); // Successfully parsed
                            for e in entries {
                                if e.value.to_lowercase().contains(&lowered) {
                                    matches.push(e);
                                }
                            }
                        }
                        Err(e) => {
                            use colored::Colorize;
                            skipped_files += 1;
                            eprint!("{}", "S".yellow()); // Skipped due to parse error
                            if self.verbose {
                                eprintln!(
                                    "\nWarning: Failed to parse YAML file {}: {}",
                                    path.display(),
                                    e
                                );
                            }
                        }
                    }
                } else if ext_str == "json" {
                    match JsonParser::parse_file(path) {
                        Ok(entries) => {
                            use colored::Colorize;
                            eprint!("{}", ".".green()); // Successfully parsed
                            for e in entries {
                                if e.value.to_lowercase().contains(&lowered) {
                                    matches.push(e);
                                }
                            }
                        }
                        Err(e) => {
                            use colored::Colorize;
                            skipped_files += 1;
                            eprint!("{}", "S".yellow()); // Skipped due to parse error
                            if self.verbose {
                                eprintln!(
                                    "\nWarning: Failed to parse JSON file {}: {}",
                                    path.display(),
                                    e
                                );
                            }
                        }
                    }
                }
            }
        }

        // Print newline and summary if files were skipped
        if skipped_files > 0 {
            eprintln!(); // Newline after the S indicators
            eprintln!(
                "(Skipped {} invalid translation file{})",
                skipped_files,
                if skipped_files == 1 { "" } else { "s" }
            );
        }

        Ok(matches)
    }
}

fn is_ignored(entry: &walkdir::DirEntry) -> bool {
    // Always allow the root directory of the search
    if entry.depth() == 0 {
        return false;
    }

    entry
        .file_name()
        .to_str()
        .map(|s| {
            s.starts_with('.') // Hidden files/dirs
                || s == "node_modules"
                || s == "target"
                || s == "dist"
                || s == "build"
                || s == "vendor"
        })
        .unwrap_or(false)
}

#[cfg(test)]
mod tests {
    use super::*;
    use std::fs;

    use tempfile::tempdir;

    #[test]
    fn test_key_extractor_simple() -> Result<()> {
        let dir = tempdir()?;
        let en_path = dir.path().join("en.yml");
        let fr_path = dir.path().join("fr.yml");

        // Write simple yaml files with proper format
        fs::write(
            &en_path,
            "greeting:\n  hello: \"Hello World\"\n  goodbye: \"Goodbye\"",
        )?;
        fs::write(
            &fr_path,
            "greeting:\n  hello: \"Bonjour World\"\n  goodbye: \"Au revoir\"",
        )?;

        let extractor = KeyExtractor::new();
        let results = extractor.extract(dir.path(), "world")?;

        // Should find two entries (en and fr)
        assert_eq!(results.len(), 2);
        let keys: Vec<_> = results.iter().map(|e| e.key.clone()).collect();
        assert!(keys.contains(&"greeting.hello".to_string()));
        Ok(())
    }

    #[test]
    fn test_key_extractor_case_insensitive() -> Result<()> {
        let dir = tempdir()?;
        let yaml_path = dir.path().join("test.yml");

        fs::write(
            &yaml_path,
            "app:\n  title: \"My Application\"\n  description: \"A great APP for everyone\"",
        )?;

        let extractor = KeyExtractor::new();

        // Test case insensitive search
        let results = extractor.extract(dir.path(), "APP")?;
        assert_eq!(results.len(), 2); // Should match both "Application" and "APP"

        let values: Vec<_> = results.iter().map(|e| e.value.clone()).collect();
        assert!(values.contains(&"My Application".to_string()));
        assert!(values.contains(&"A great APP for everyone".to_string()));

        Ok(())
    }

    #[test]
    fn test_key_extractor_multiple_files() -> Result<()> {
        let dir = tempdir()?;

        // Create multiple language files
        let en_path = dir.path().join("en.yml");
        let fr_path = dir.path().join("fr.yml");
        let de_path = dir.path().join("de.yml");

        fs::write(&en_path, "common:\n  action: \"Save Data\"")?;
        fs::write(&fr_path, "common:\n  action: \"Sauvegarder Data\"")?;
        fs::write(&de_path, "common:\n  action: \"Speichern Data\"")?;

        let extractor = KeyExtractor::new();
        let results = extractor.extract(dir.path(), "data")?;

        // Should find all three files (case-insensitive)
        assert_eq!(results.len(), 3);

        let files: Vec<_> = results
            .iter()
            .map(|e| e.file.file_name().unwrap().to_string_lossy().to_string())
            .collect();
        assert!(files.contains(&"en.yml".to_string()));
        assert!(files.contains(&"fr.yml".to_string()));
        assert!(files.contains(&"de.yml".to_string()));

        Ok(())
    }

    #[test]
    fn test_key_extractor_deep_nested() -> Result<()> {
        let dir = tempdir()?;
        let yaml_path = dir.path().join("nested.yml");

        fs::write(
            &yaml_path,
            "level1:\n  level2:\n    level3:\n      deep_key: \"Deep nested value\"\n      another: \"test value\"",
        )?;

        let extractor = KeyExtractor::new();
        let results = extractor.extract(dir.path(), "deep")?;

        assert_eq!(results.len(), 1);
        assert_eq!(results[0].key, "level1.level2.level3.deep_key");
        assert_eq!(results[0].value, "Deep nested value");

        Ok(())
    }

    #[test]
    fn test_key_extractor_no_matches() -> Result<()> {
        let dir = tempdir()?;
        let yaml_path = dir.path().join("test.yml");

        fs::write(
            &yaml_path,
            "greeting:\n  hello: \"Hello\"\n  goodbye: \"Goodbye\"",
        )?;

        let extractor = KeyExtractor::new();
        let results = extractor.extract(dir.path(), "nonexistent")?;

        assert_eq!(results.len(), 0);

        Ok(())
    }

    #[test]
    fn test_key_extractor_supports_json_and_yaml() -> Result<()> {
        let dir = tempdir()?;
        let yaml_path = dir.path().join("test.yml");
        let txt_path = dir.path().join("test.txt");
        let json_path = dir.path().join("test.json");

        fs::write(&yaml_path, "key: \"test value\"")?;
        fs::write(&txt_path, "key: test value")?; // This should be ignored
        fs::write(&json_path, "{\"key\": \"test value\"}")?; // This should be ignored

        let extractor = KeyExtractor::new();
        let results = extractor.extract(dir.path(), "test")?;

        // Should find both YAML and JSON files
        assert_eq!(results.len(), 2);
        let extensions: Vec<_> = results
            .iter()
            .map(|e| e.file.extension().unwrap().to_string_lossy().to_string())
            .collect();
        assert!(extensions.contains(&"yml".to_string()));
        assert!(extensions.contains(&"json".to_string()));

        Ok(())
    }

    #[test]
    fn test_key_extractor_malformed_file() -> Result<()> {
        let dir = tempdir()?;
        let good_path = dir.path().join("good.yml");
        let bad_path = dir.path().join("bad.yml");

        fs::write(&good_path, "key: \"value\"")?;
        fs::write(&bad_path, "key: value: invalid: yaml")?; // Malformed YAML

        let extractor = KeyExtractor::new();
        // This should NOT return an error, but just skip the bad file
        let results = extractor.extract(dir.path(), "value")?;

        // Should find the good file
        assert_eq!(results.len(), 1);
        assert_eq!(results[0].value, "value");

        Ok(())
    }
}