provenant-cli 0.0.8

Provenant is a high-performance Rust scanner for licenses, packages, and source provenance.
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

use super::*;
use std::fs;
use std::path::PathBuf;

#[test]
fn is_included_path_requires_include_match_before_excludes() {
    assert!(is_included_path(
        "user/src/test/sample.doc",
        &["*.doc".to_string()],
        &[]
    ));
    assert!(!is_included_path(
        "user/src/test/sample.txt",
        &["*.doc".to_string()],
        &[]
    ));
}

#[test]
fn is_included_path_applies_exclude_after_include() {
    assert!(!is_included_path(
        "src/dist/build/mylib.so",
        &["/src/*".to_string()],
        &["/src/*.so".to_string()]
    ));
    assert!(is_included_path(
        "some/src/this/that",
        &["src".to_string()],
        &["src/*.so".to_string()]
    ));
}

#[test]
fn apply_user_path_filters_to_collected_filters_files_without_pruning_directories() {
    let scan_root = PathBuf::from("/scan");
    let placeholder_metadata = fs::metadata(std::env::temp_dir()).expect("temp dir metadata");
    let mut collected = crate::scanner::CollectedPaths {
        files: vec![
            (
                scan_root.join("src/test/sample.doc"),
                placeholder_metadata.clone(),
            ),
            (
                scan_root.join("src/test/sample.txt"),
                placeholder_metadata.clone(),
            ),
        ],
        directories: vec![
            (scan_root.clone(), placeholder_metadata.clone()),
            (scan_root.join("src"), placeholder_metadata.clone()),
            (scan_root.join("src/test"), placeholder_metadata.clone()),
            (scan_root.join("other"), placeholder_metadata.clone()),
        ],
        excluded_count: 0,
        total_file_bytes: 0,
        collection_errors: Vec::new(),
    };

    let removed = apply_user_path_filters_to_collected(
        &mut collected,
        &scan_root,
        &["*.doc".to_string()],
        &[],
    );

    assert_eq!(removed, 2);
    assert_eq!(collected.files.len(), 1);
    let kept_dirs: Vec<_> = collected
        .directories
        .iter()
        .map(|(path, _)| normalize_scan_relative_path(path, &scan_root))
        .collect();
    assert_eq!(
        kept_dirs,
        vec!["".to_string(), "src".to_string(), "src/test".to_string()]
    );
    assert_eq!(
        normalize_scan_relative_path(&collected.files[0].0, &scan_root),
        "src/test/sample.doc"
    );
}

#[test]
fn is_included_path_treats_directory_include_patterns_recursively() {
    assert!(is_included_path(
        "src/foo/bar/baz.txt",
        &["src/foo".to_string()],
        &[]
    ));
    assert!(!is_included_path(
        "src/other/bar.txt",
        &["src/foo".to_string()],
        &[]
    ));
}

#[test]
fn resolve_native_scan_inputs_builds_common_prefix_and_synthetic_includes() {
    let (scan_root, includes) =
        resolve_native_scan_inputs(&["src/foo".to_string(), "src/bar/baz".to_string()])
            .expect("multiple relative inputs should resolve");

    assert_eq!(scan_root, "src");
    assert_eq!(includes, vec!["src/foo", "src/bar/baz"]);
}

#[test]
fn resolve_native_scan_inputs_uses_component_aware_prefix_for_siblings() {
    let temp_dir = tempfile::tempdir().expect("tempdir");
    let parent = temp_dir.path().join("src");
    fs::create_dir_all(parent.join("bar")).expect("create bar dir");
    fs::create_dir_all(parent.join("baz")).expect("create baz dir");

    let old_cwd = std::env::current_dir().expect("current dir");
    std::env::set_current_dir(temp_dir.path()).expect("set cwd");

    let result = resolve_native_scan_inputs(&["src/bar".to_string(), "src/baz".to_string()]);

    std::env::set_current_dir(old_cwd).expect("restore cwd");

    let (scan_root, includes) = result.expect("sibling inputs should resolve");
    assert_eq!(scan_root, "src");
    assert_eq!(includes, vec!["src/bar", "src/baz"]);
}