provenant-cli 1.0.0

Fast Rust scanner for licenses, copyrights, package metadata, SBOMs, and provenance data.
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

// SPDX-FileCopyrightText: Provenant contributors
// SPDX-License-Identifier: Apache-2.0

mod collect;
pub(crate) mod process;

use crate::license_detection::LicenseDetectionEngine;
use crate::models::FileInfo;

pub struct ProcessResult {
    pub files: Vec<FileInfo>,
    pub excluded_count: usize,
}

#[derive(Debug, Clone, Copy)]
pub struct LicenseScanOptions {
    pub include_text: bool,
    pub include_text_diagnostics: bool,
    pub include_diagnostics: bool,
    pub unknown_licenses: bool,
    pub enable_sequence_matching: bool,
    pub min_score: u8,
}

impl Default for LicenseScanOptions {
    fn default() -> Self {
        Self {
            include_text: false,
            include_text_diagnostics: false,
            include_diagnostics: false,
            unknown_licenses: false,
            enable_sequence_matching: true,
            min_score: 0,
        }
    }
}

#[derive(Debug, Clone)]
pub struct TextDetectionOptions {
    pub collect_info: bool,
    pub detect_packages: bool,
    pub detect_application_packages: bool,
    pub detect_system_packages: bool,
    pub detect_packages_in_compiled: bool,
    pub detect_copyrights: bool,
    pub detect_generated: bool,
    pub detect_emails: bool,
    pub detect_urls: bool,
    pub max_emails: usize,
    pub max_urls: usize,
    pub timeout_seconds: f64,
}

impl Default for TextDetectionOptions {
    fn default() -> Self {
        Self {
            collect_info: false,
            detect_packages: false,
            detect_application_packages: false,
            detect_system_packages: false,
            detect_packages_in_compiled: false,
            detect_copyrights: true,
            detect_generated: false,
            detect_emails: false,
            detect_urls: false,
            max_emails: 50,
            max_urls: 50,
            timeout_seconds: 120.0,
        }
    }
}

pub fn scan_options_fingerprint(
    text_options: &TextDetectionOptions,
    license_options: LicenseScanOptions,
    license_engine: Option<&LicenseDetectionEngine>,
) -> String {
    let (license_enabled, dataset_fingerprint, rules_count, first_rule_id, last_rule_id) =
        match license_engine {
            Some(engine) => {
                let rules = &engine.index().rules_by_rid;
                (
                    true,
                    engine
                        .license_index_provenance()
                        .map(|provenance| provenance.dataset_fingerprint.as_str())
                        .unwrap_or(""),
                    rules.len(),
                    rules
                        .first()
                        .map(|rule| rule.identifier.as_str())
                        .unwrap_or(""),
                    rules
                        .last()
                        .map(|rule| rule.identifier.as_str())
                        .unwrap_or(""),
                )
            }
            None => (false, "", 0, "", ""),
        };

    format!(
        "tool_version={};info={};packages={};app_packages={};system_packages={};compiled_packages={};copyrights={};generated={};emails={};urls={};max_emails={};max_urls={};timeout={:.6};license_enabled={};license_dataset_fingerprint={};rules_count={};first_rule_id={};last_rule_id={};license_text={};license_text_diagnostics={};license_diagnostics={};unknown_licenses={};sequence_matching={};license_score={}",
        crate::version::BUILD_VERSION,
        text_options.collect_info,
        text_options.detect_packages,
        text_options.detect_application_packages,
        text_options.detect_system_packages,
        text_options.detect_packages_in_compiled,
        text_options.detect_copyrights,
        text_options.detect_generated,
        text_options.detect_emails,
        text_options.detect_urls,
        text_options.max_emails,
        text_options.max_urls,
        text_options.timeout_seconds,
        license_enabled,
        dataset_fingerprint,
        rules_count,
        first_rule_id,
        last_rule_id,
        license_options.include_text,
        license_options.include_text_diagnostics,
        license_options.include_diagnostics,
        license_options.unknown_licenses,
        license_options.enable_sequence_matching,
        license_options.min_score,
    )
}

pub use self::collect::{
    CollectedPaths, CollectionFrontier, CollectionLimits, collect_paths, collect_paths_with_limits,
    collect_selected_paths, collect_selected_paths_with_limits,
};
#[allow(unused_imports)]
pub use self::process::{
    MemoryMode, process_collected, process_collected_sequential,
    process_collected_with_memory_limit, process_collected_with_memory_limit_sequential,
};

#[cfg(test)]
mod tests;