tokmd-core 1.13.1

High-level API façade for tokmd. The recommended entry point for library usage.
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

//! In-memory analysis export preparation.

use std::path::PathBuf;

use anyhow::Result;
use tokmd_settings::ScanOptions;
use tokmd_types::{ChildIncludeMode, ExportData, ExportReceipt, FileRow};

use crate::settings::ExportSettings;
use crate::{InMemoryFile, build_export_receipt};

use super::super::{collect_pure_in_memory_rows, strip_virtual_export_prefix};

pub(super) struct PreparedAnalysisInput {
    pub(super) export_receipt: ExportReceipt,
    pub(super) logical_inputs: Vec<String>,
    pub(super) root: PathBuf,
    // Keeps the temporary materialized scan root alive while analysis reads it.
    pub(super) materialized_scan: Option<tokmd_scan::MaterializedScan>,
}

pub(super) fn prepare_rootless_in_memory_export(
    inputs: &[InMemoryFile],
    scan_opts: &ScanOptions,
    export: &ExportSettings,
) -> Result<PreparedAnalysisInput> {
    let (paths, rows) = collect_pure_in_memory_rows(
        inputs,
        scan_opts,
        &export.module_roots,
        export.module_depth,
        export.children,
    )?;
    let data = tokmd_model::create_export_data_from_rows(
        rows,
        &export.module_roots,
        export.module_depth,
        export.children,
        export.min_code,
        export.max_rows,
    );
    let logical_inputs: Vec<String> = paths
        .iter()
        .map(|path| tokmd_model::normalize_path(path, None))
        .collect();
    let export_receipt = build_export_receipt(&paths, scan_opts, export, data);

    Ok(PreparedAnalysisInput {
        export_receipt,
        logical_inputs,
        root: PathBuf::new(),
        materialized_scan: None,
    })
}

pub(super) fn prepare_materialized_in_memory_export(
    inputs: &[InMemoryFile],
    scan_opts: &ScanOptions,
    export: &ExportSettings,
) -> Result<PreparedAnalysisInput> {
    let scan = tokmd_scan::scan_in_memory(inputs, scan_opts)?;
    let data = collect_materialized_export_data(&scan, export);
    let logical_inputs: Vec<String> = scan
        .logical_paths()
        .iter()
        .map(|path| tokmd_model::normalize_path(path, None))
        .collect();
    let root = scan.strip_prefix().to_path_buf();
    let export_receipt = build_export_receipt(scan.logical_paths(), scan_opts, export, data);

    Ok(PreparedAnalysisInput {
        export_receipt,
        logical_inputs,
        root,
        materialized_scan: Some(scan),
    })
}

fn collect_materialized_rows(
    scan: &tokmd_scan::MaterializedScan,
    module_roots: &[String],
    module_depth: usize,
    children: ChildIncludeMode,
) -> Vec<FileRow> {
    tokmd_model::collect_file_rows(
        scan.languages(),
        module_roots,
        module_depth,
        children,
        Some(scan.strip_prefix()),
    )
}

fn collect_materialized_export_data(
    scan: &tokmd_scan::MaterializedScan,
    export: &ExportSettings,
) -> ExportData {
    let mut rows = collect_materialized_rows(
        scan,
        &export.module_roots,
        export.module_depth,
        export.children,
    );

    if let Some(strip_prefix) = export.strip_prefix.as_deref() {
        rows = strip_virtual_export_prefix(
            rows,
            strip_prefix,
            &export.module_roots,
            export.module_depth,
        );
    }

    tokmd_model::create_export_data_from_rows(
        rows,
        &export.module_roots,
        export.module_depth,
        export.children,
        export.min_code,
        export.max_rows,
    )
}