loctree 0.13.0

Structural code intelligence for AI agents. Scan once, query everything.
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
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
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166

//! Canonical repository metrics derived from the snapshot graph.

use std::collections::{HashMap, HashSet};

use serde::{Deserialize, Serialize};

use crate::snapshot::Snapshot;

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct RepositoryMetrics {
    pub file_count: usize,
    pub edge_count: usize,
    pub total_loc: usize,
}

#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct IncomingImportMetric {
    pub file: String,
    pub importers_direct: usize,
    pub import_edges: usize,
    pub loc: usize,
}

pub fn repository_metrics(snapshot: &Snapshot) -> RepositoryMetrics {
    RepositoryMetrics {
        file_count: snapshot.canonical_file_count(),
        edge_count: snapshot.edges.len(),
        total_loc: snapshot.files.iter().map(|file| file.loc).sum(),
    }
}

pub fn incoming_import_metrics(snapshot: &Snapshot) -> HashMap<String, IncomingImportMetric> {
    let mut metrics: HashMap<String, IncomingImportMetric> = snapshot
        .files
        .iter()
        .map(|file| {
            (
                file.path.clone(),
                IncomingImportMetric {
                    file: file.path.clone(),
                    importers_direct: 0,
                    import_edges: 0,
                    loc: file.loc,
                },
            )
        })
        .collect();
    let mut importers_by_file: HashMap<String, HashSet<String>> = HashMap::new();

    for edge in &snapshot.edges {
        let imported = snapshot.normalize_path(&edge.to);
        let importer = snapshot.normalize_path(&edge.from);
        metrics
            .entry(imported.clone())
            .or_insert_with(|| IncomingImportMetric {
                file: imported.clone(),
                importers_direct: 0,
                import_edges: 0,
                loc: 0,
            })
            .import_edges += 1;
        importers_by_file
            .entry(imported)
            .or_default()
            .insert(importer);
    }

    for (file, importers) in importers_by_file {
        if let Some(metric) = metrics.get_mut(&file) {
            metric.importers_direct = importers.len();
        }
    }

    metrics
}

pub fn importer_counts_direct(snapshot: &Snapshot) -> HashMap<String, usize> {
    incoming_import_metrics(snapshot)
        .into_iter()
        .map(|(file, metric)| (file, metric.importers_direct))
        .collect()
}

pub fn import_edge_counts(snapshot: &Snapshot) -> HashMap<String, usize> {
    incoming_import_metrics(snapshot)
        .into_iter()
        .map(|(file, metric)| (file, metric.import_edges))
        .collect()
}

pub fn top_hubs_by_importers_direct(
    snapshot: &Snapshot,
    limit: usize,
) -> Vec<IncomingImportMetric> {
    top_hubs_by_importers_direct_filtered(snapshot, limit, |_| true)
}

pub fn top_hubs_by_importers_direct_filtered<F>(
    snapshot: &Snapshot,
    limit: usize,
    mut include: F,
) -> Vec<IncomingImportMetric>
where
    F: FnMut(&IncomingImportMetric) -> bool,
{
    let mut ranked: Vec<IncomingImportMetric> = incoming_import_metrics(snapshot)
        .into_values()
        .filter(|metric| metric.importers_direct > 0)
        .filter(|metric| include(metric))
        .collect();
    ranked.sort_by(|a, b| {
        b.importers_direct
            .cmp(&a.importers_direct)
            .then_with(|| b.import_edges.cmp(&a.import_edges))
            .then_with(|| a.file.cmp(&b.file))
    });
    ranked.truncate(limit);
    ranked
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::snapshot::GraphEdge;
    use crate::types::FileAnalysis;

    fn fixture_snapshot() -> Snapshot {
        let mut snapshot = Snapshot::new(vec![".".to_string()]);
        for name in ["hub.rs", "consumer_a.rs", "consumer_b.rs"] {
            snapshot.files.push(FileAnalysis::new(name.to_string()));
        }
        for symbol in ["A", "B"] {
            snapshot.edges.push(GraphEdge {
                from: "consumer_a.rs".to_string(),
                to: "hub.rs".to_string(),
                label: symbol.to_string(),
            });
        }
        snapshot.edges.push(GraphEdge {
            from: "consumer_b.rs".to_string(),
            to: "hub.rs".to_string(),
            label: "C".to_string(),
        });
        snapshot
    }

    #[test]
    fn importer_metrics_separate_unique_importers_from_raw_edges() {
        let snapshot = fixture_snapshot();
        let metrics = incoming_import_metrics(&snapshot);
        let hub = metrics.get("hub.rs").expect("hub metric");

        assert_eq!(hub.importers_direct, 2);
        assert_eq!(hub.import_edges, 3);
    }

    #[test]
    fn top_hubs_rank_by_unique_importers_before_raw_edges() {
        let snapshot = fixture_snapshot();
        let hubs = top_hubs_by_importers_direct(&snapshot, 1);

        assert_eq!(hubs[0].file, "hub.rs");
        assert_eq!(hubs[0].importers_direct, 2);
        assert_eq!(hubs[0].import_edges, 3);
    }
}