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
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

//! Code Size Metrics
//!
//! Implements size-related metrics including LOC, SLOC, LLOC, and code density.

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SizeMetrics {
    pub total_lines: usize,
    pub source_lines: usize,
    pub logical_lines: usize,
    pub comment_lines: usize,
    pub blank_lines: usize,
    pub num_classes: usize,
    pub num_methods: usize,
    pub num_functions: usize,
    pub code_density: f64,
    pub comment_ratio: f64,
}

impl SizeMetrics {
    pub fn new() -> Self {
        Self {
            total_lines: 0,
            source_lines: 0,
            logical_lines: 0,
            comment_lines: 0,
            blank_lines: 0,
            num_classes: 0,
            num_methods: 0,
            num_functions: 0,
            code_density: 0.0,
            comment_ratio: 0.0,
        }
    }

    pub fn calculate_ratios(&mut self) {
        if self.total_lines > 0 {
            self.code_density = self.source_lines as f64 / self.total_lines as f64;
        }
        if self.source_lines > 0 {
            self.comment_ratio = self.comment_lines as f64 / self.source_lines as f64;
        }
    }
}

pub fn calculate_size_metrics(content: &str, ext: &str) -> SizeMetrics {
    let mut metrics = SizeMetrics::new();

    let lines: Vec<&str> = content.lines().collect();
    metrics.total_lines = lines.len();

    let is_comment_line = |line: &str, ext: &str| -> bool {
        let trimmed = line.trim();
        match ext {
            "rs" | "c" | "cpp" | "java" | "js" | "ts" | "go" | "kt" => {
                trimmed.starts_with("//") || trimmed.starts_with("/*") || trimmed.starts_with("*")
            }
            "py" | "rb" | "sh" => trimmed.starts_with("#"),
            _ => false,
        }
    };

    let is_logical_line = |line: &str, ext: &str| -> bool {
        let trimmed = line.trim();
        if trimmed.is_empty() || is_comment_line(line, ext) {
            return false;
        }

        match ext {
            "rs" | "c" | "cpp" | "java" | "js" | "ts" | "go" | "kt" => {
                trimmed.ends_with(';')
                    || trimmed.contains("if ")
                    || trimmed.contains("for ")
                    || trimmed.contains("while ")
                    || trimmed.contains("return")
            }
            "py" => {
                !trimmed.ends_with(':')
                    && (trimmed.contains('=')
                        || trimmed.starts_with("return")
                        || trimmed.starts_with("if ")
                        || trimmed.starts_with("for "))
            }
            _ => !trimmed.is_empty(),
        }
    };

    for line in &lines {
        let trimmed = line.trim();

        if trimmed.is_empty() {
            metrics.blank_lines += 1;
        } else if is_comment_line(line, ext) {
            metrics.comment_lines += 1;
        } else {
            metrics.source_lines += 1;

            if is_logical_line(line, ext) {
                metrics.logical_lines += 1;
            }
        }
    }

    metrics.num_classes = crate::codemetrics::helpers::count_classes(content, ext);
    metrics.num_functions = crate::codemetrics::helpers::count_functions(content, ext);
    metrics.num_methods = metrics.num_functions;

    metrics.calculate_ratios();
    metrics
}