loc-rs 0.1.5

Advanced Lines of Code counter with function extraction, git integration, and parallel processing
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
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

// Author: kelexine (https://github.com/kelexine)
// models.rs — Core data structures for the LOC counter

use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
use std::path::PathBuf;

/// Information about a single function, method, or class extracted from source code.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FunctionInfo {
    pub name: String,
    pub line_start: usize,
    pub line_end: usize,
    pub parameters: Vec<String>,
    pub is_async: bool,
    pub is_method: bool,
    pub is_class: bool,
    pub docstring: Option<String>,
    pub decorators: Vec<String>,
    /// Cyclomatic complexity (simplified branch-count heuristic)
    pub complexity: u32,
}

impl FunctionInfo {
    #[inline]
    pub fn line_count(&self) -> usize {
        self.line_end.saturating_sub(self.line_start) + 1
    }

    /// Truncate docstring to 100 chars for export compactness.
    pub fn truncated_docstring(&self) -> Option<String> {
        self.docstring.as_ref().map(|d| {
            if d.chars().count() > 100 {
                let truncated: String = d.chars().take(100).collect();
                format!("{}...", truncated)
            } else {
                d.clone()
            }
        })
    }
}

/// Aggregated information about a single source file.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FileInfo {
    pub path: PathBuf,
    pub lines: usize,
    pub is_binary: bool,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub last_modified: Option<DateTime<Utc>>,
    pub functions: Vec<FunctionInfo>,
}

impl FileInfo {
    pub fn new(
        path: PathBuf,
        lines: usize,
        is_binary: bool,
        last_modified: Option<DateTime<Utc>>,
    ) -> Self {
        Self {
            path,
            lines,
            is_binary,
            last_modified,
            functions: Vec::new(),
        }
    }

    pub fn with_functions(mut self, functions: Vec<FunctionInfo>) -> Self {
        self.functions = functions;
        self
    }

    #[inline]
    pub fn function_count(&self) -> usize {
        self.functions.len()
    }

    #[inline]
    pub fn class_count(&self) -> usize {
        self.functions.iter().filter(|f| f.is_class).count()
    }

    pub fn avg_function_length(&self) -> f64 {
        let non_class: Vec<_> = self.functions.iter().filter(|f| !f.is_class).collect();
        if non_class.is_empty() {
            return 0.0;
        }
        let total: usize = non_class.iter().map(|f| f.line_count()).sum();
        total as f64 / non_class.len() as f64
    }

    /// File extension without the leading dot, or empty string.
    pub fn extension(&self) -> &str {
        self.path.extension().and_then(|e| e.to_str()).unwrap_or("")
    }
}

/// Per-extension aggregated statistics.
#[derive(Debug, Default, Clone, Serialize)]
pub struct ExtensionStats {
    pub lines: usize,
    pub files: usize,
    pub functions: usize,
}

/// Breakdown map: extension → stats.
pub type Breakdown = HashMap<String, ExtensionStats>;

/// The full scan result returned from the counter.
#[derive(Debug)]
pub struct ScanResult {
    pub files: Vec<FileInfo>,
    pub breakdown: Breakdown,
}

impl ScanResult {
    pub fn total_lines(&self) -> usize {
        self.files
            .iter()
            .filter(|f| !f.is_binary)
            .map(|f| f.lines)
            .sum()
    }

    pub fn text_file_count(&self) -> usize {
        self.files.iter().filter(|f| !f.is_binary).count()
    }

    pub fn binary_file_count(&self) -> usize {
        self.files.iter().filter(|f| f.is_binary).count()
    }

    pub fn total_functions(&self) -> usize {
        self.files.iter().map(|f| f.function_count()).sum()
    }

    pub fn total_classes(&self) -> usize {
        self.files.iter().map(|f| f.class_count()).sum()
    }
}