code-search-cli 0.3.3

Intelligent code search tool for tracing text (UI text, function names, variables) to implementation code
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

use std::path::Path;

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ProjectType {
    Node,
    Ruby,
    Python,
    Rust,
    Go,
    Generic,
}

pub fn detect_project_type(base_dir: &Path) -> ProjectType {
    if base_dir.join("package.json").exists() {
        ProjectType::Node
    } else if base_dir.join("Gemfile").exists() {
        ProjectType::Ruby
    } else if base_dir.join("requirements.txt").exists()
        || base_dir.join("pyproject.toml").exists()
        || base_dir.join("setup.py").exists()
    {
        ProjectType::Python
    } else if base_dir.join("Cargo.toml").exists() {
        ProjectType::Rust
    } else if base_dir.join("go.mod").exists() {
        ProjectType::Go
    } else {
        ProjectType::Generic
    }
}

pub fn get_default_exclusions(project_type: ProjectType) -> Vec<&'static str> {
    let mut exclusions = vec![".git", ".svn", ".hg", ".idea", ".vscode", ".DS_Store"];

    match project_type {
        ProjectType::Node => {
            exclusions.extend_from_slice(&[
                "node_modules",
                "dist",
                "build",
                "coverage",
                ".next",
                ".nuxt",
            ]);
        }
        ProjectType::Ruby => {
            exclusions.extend_from_slice(&["vendor", ".bundle", "log", "tmp", "coverage"]);
        }
        ProjectType::Python => {
            exclusions.extend_from_slice(&[
                "venv",
                ".venv",
                "env",
                ".env",
                "__pycache__",
                "*.egg-info",
                ".pytest_cache",
                ".mypy_cache",
            ]);
        }
        ProjectType::Rust => {
            exclusions.extend_from_slice(&["target"]);
        }
        ProjectType::Go => {
            exclusions.extend_from_slice(&["vendor"]);
        }
        ProjectType::Generic => {
            // Add common exclusions for generic projects if needed
            exclusions.extend_from_slice(&[
                "node_modules", // Common enough to include by default?
                "vendor",
                "dist",
                "build",
                "target",
            ]);
        }
    }

    exclusions
}

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

    #[test]
    fn test_detect_node_project() {
        let dir = tempdir().unwrap();
        fs::write(dir.path().join("package.json"), "{}").unwrap();
        assert_eq!(detect_project_type(dir.path()), ProjectType::Node);
    }

    #[test]
    fn test_detect_rust_project() {
        let dir = tempdir().unwrap();
        fs::write(dir.path().join("Cargo.toml"), "").unwrap();
        assert_eq!(detect_project_type(dir.path()), ProjectType::Rust);
    }

    #[test]
    fn test_detect_generic_project() {
        let dir = tempdir().unwrap();
        assert_eq!(detect_project_type(dir.path()), ProjectType::Generic);
    }

    #[test]
    fn test_default_exclusions_node() {
        let exclusions = get_default_exclusions(ProjectType::Node);
        assert!(exclusions.contains(&"node_modules"));
        assert!(exclusions.contains(&".git"));
    }
}