codesearch 0.1.9

A fast, intelligent CLI tool with multiple search modes (regex, fuzzy, semantic), code analysis, and dead code detection for popular programming languages
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

//! Helper Functions for Code Metrics
//!
//! Provides utility functions for counting code elements and analyzing structure.

pub fn count_classes(content: &str, ext: &str) -> usize {
    let patterns = match ext {
        "rs" => vec![r"struct\s+\w+", r"enum\s+\w+", r"trait\s+\w+"],
        "py" => vec![r"class\s+\w+"],
        "java" | "kt" => vec![r"class\s+\w+", r"interface\s+\w+"],
        "js" | "ts" => vec![r"class\s+\w+"],
        "go" => vec![r"type\s+\w+\s+struct"],
        _ => vec![],
    };

    let mut count = 0;
    for pattern in patterns {
        if let Ok(re) = regex::Regex::new(pattern) {
            count += re.find_iter(content).count();
        }
    }
    count
}

pub fn count_functions(content: &str, ext: &str) -> usize {
    let patterns = match ext {
        "rs" => vec![r"fn\s+\w+"],
        "py" => vec![r"def\s+\w+"],
        "java" | "kt" => vec![r"(?:public|private|protected)?\s*\w+\s+\w+\s*\("],
        "js" | "ts" => vec![r"function\s+\w+", r"\w+\s*:\s*\([^)]*\)\s*=>"],
        "go" => vec![r"func\s+\w+"],
        _ => vec![],
    };

    let mut count = 0;
    for pattern in patterns {
        if let Ok(re) = regex::Regex::new(pattern) {
            count += re.find_iter(content).count();
        }
    }
    count
}

pub fn count_fields(content: &str, ext: &str) -> usize {
    let patterns = match ext {
        "rs" => vec![r"\w+:\s*\w+,"],
        "py" => vec![r"self\.\w+\s*="],
        "java" | "kt" => vec![r"(?:private|public|protected)\s+\w+\s+\w+;"],
        "js" | "ts" => vec![r"this\.\w+\s*="],
        _ => vec![],
    };

    let mut count = 0;
    for pattern in patterns {
        if let Ok(re) = regex::Regex::new(pattern) {
            count += re.find_iter(content).count();
        }
    }
    count.max(1)
}

pub fn calculate_max_nesting(content: &str) -> usize {
    let mut max_depth = 0;
    let mut current_depth = 0;

    for ch in content.chars() {
        match ch {
            '{' | '(' | '[' => {
                current_depth += 1;
                max_depth = max_depth.max(current_depth);
            }
            '}' | ')' | ']' => {
                if current_depth > 0 {
                    current_depth -= 1;
                }
            }
            _ => {}
        }
    }

    max_depth
}