compare-changes 0.12.1

Reimplementation of GitHub file paths pattern matcher
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

mod cli;
mod exitcode;
mod find;
mod parse;
mod validate;

use compare_changes::paths_match;

fn main() {
    let args = cli::parse_args();

    if args.find {
        if let Err(err) = find::run(args.debug) {
            eprintln!("{}", err);
            std::process::exit(exitcode::find_error());
        }
        return;
    }

    if args.validate {
        if let Err(err) = validate::run(args.debug) {
            eprintln!("{}", err);
            std::process::exit(exitcode::validate_error());
        }
        return;
    }

    let workflow = args.workflow.as_ref();
    let inline_paths = args.paths.as_deref();
    let changes = args.changes.as_ref().expect("changes is required unless --find");

    let paths_result = if let Some(inline) = inline_paths {
        parse::parse_inline_paths(inline).map(|paths| {
            if args.debug {
                println!("inline paths:");
                for path in &paths {
                    println!("- {}", path);
                }
            }
            paths
        })
    } else {
        let workflow = workflow.expect("workflow is required unless --find or --paths");
        parse::get_paths(workflow).map(|paths| {
            if args.debug {
                println!("{}.on.push.paths:", workflow.display());
                for path in &paths {
                    println!("- {}", path);
                }
            }
            paths
        })
    };

    let paths = match paths_result {
        Ok(paths) => paths,
        Err(err) => {
            eprintln!("{}", err);
            std::process::exit(exitcode::path_error());
        }
    };

    let files = match parse::get_files(changes) {
        Ok(files) => {
            if args.debug {
                println!("files:");
                for file in &files {
                    println!("- {}", file);
                }
            }
            files
        }
        Err(err) => {
            eprintln!("{}", err);
            std::process::exit(exitcode::file_error());
        }
    };

    let file_refs: Vec<&str> = files.iter().map(|s| s.as_str()).collect();
    let path_refs: Vec<&str> = paths.iter().map(|s| s.as_str()).collect();

    let changed = match paths_match(&path_refs, &file_refs) {
        Ok(Some((pi, fi))) => {
            println!("path '{}' matched file '{}'", paths[pi], files[fi]);
            true
        }
        Ok(None) => false,
        Err(e) => {
            eprintln!("Failed to compare paths: {}", e);
            std::process::exit(exitcode::match_error());
        }
    };

    println!("changed={}", changed);

    if let Ok(github_output) = std::env::var("GITHUB_OUTPUT") {
        if !github_output.is_empty() {
            use std::fs::OpenOptions;
            use std::io::Write;
            if let Ok(mut file) = OpenOptions::new().append(true).open(github_output) {
                let _ = writeln!(file, "changed={}", changed);
            }
        }
    }
}