repotoire 0.5.3

Graph-powered code analysis CLI. 106 detectors for security, architecture, and code quality.
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

//! Stage 2: Tree-sitter parsing.

use crate::engine::ProgressFn;
use crate::parsers::ParseResult;
use anyhow::Result;
use rayon::prelude::*;
use std::path::PathBuf;
use std::sync::Arc;

/// Input for the parse stage.
pub struct ParseInput {
    pub files: Vec<PathBuf>,
    pub workers: usize,
    pub progress: Option<ProgressFn>,
}

/// Statistics from the parse stage.
pub struct ParseStats {
    pub files_parsed: usize,
    pub files_skipped: usize,
    pub total_functions: usize,
    pub total_classes: usize,
    pub total_loc: usize,
}

/// Output from the parse stage.
pub struct ParseOutput {
    pub results: Vec<(PathBuf, Arc<ParseResult>)>,
    pub stats: ParseStats,
}

/// Run tree-sitter parsers on source files in parallel via rayon.
pub fn parse_stage(input: &ParseInput) -> Result<ParseOutput> {
    // Configure rayon thread pool if non-default worker count
    let pool = rayon::ThreadPoolBuilder::new()
        .num_threads(input.workers.max(1))
        .build()
        .unwrap_or_else(|_| {
            rayon::ThreadPoolBuilder::new()
                .build()
                .expect("failed to build fallback rayon thread pool")
        });

    let results: Vec<Option<(PathBuf, Arc<ParseResult>)>> = pool.install(|| {
        input
            .files
            .par_iter()
            .map(|path| {
                match crate::parsers::parse_file_with_values(path) {
                    Ok(pr) if !pr.is_empty() => Some((path.clone(), Arc::new(pr))),
                    Ok(_) => {
                        // Empty result (unsupported extension, oversized, etc.) — skip
                        None
                    }
                    Err(e) => {
                        tracing::warn!("Parse error for {}: {}", path.display(), e);
                        None
                    }
                }
            })
            .collect()
    });

    let mut parsed = Vec::with_capacity(results.len());
    let mut files_skipped = 0usize;
    let mut total_functions = 0usize;
    let mut total_classes = 0usize;
    let mut total_loc = 0usize;

    for item in results {
        match item {
            Some((path, pr)) => {
                total_functions += pr.functions.len();
                total_classes += pr.classes.len();
                // Estimate LOC from max line_end across functions and classes
                let file_loc = pr
                    .functions
                    .iter()
                    .map(|f| f.line_end as usize)
                    .chain(pr.classes.iter().map(|c| c.line_end as usize))
                    .max()
                    .unwrap_or(0);
                total_loc += file_loc;
                parsed.push((path, pr));
            }
            None => {
                files_skipped += 1;
            }
        }
    }

    let files_parsed = parsed.len();

    Ok(ParseOutput {
        results: parsed,
        stats: ParseStats {
            files_parsed,
            files_skipped,
            total_functions,
            total_classes,
            total_loc,
        },
    })
}