qualifier 0.3.0

Deterministic quality attestations for software artifacts
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

use clap::Args as ClapArgs;
use std::path::Path;

use crate::cli::output;
use crate::qual_file::{self, find_project_root};
use crate::scoring;

#[derive(ClapArgs)]
pub struct Args {
    /// The artifact to show
    pub artifact: String,

    /// Output format (human, json)
    #[arg(long, default_value = "human")]
    pub format: String,

    /// Path to the dependency graph file
    #[arg(long)]
    pub graph: Option<String>,

    /// Disable .gitignore and .qualignore filtering
    #[arg(long)]
    pub no_ignore: bool,
}

pub fn run(args: Args) -> crate::Result<()> {
    let root = find_project_root(Path::new("."));
    let graph = crate::cli::config::load_graph(args.graph.as_deref(), root.as_deref());
    let discover_root = root.as_deref().unwrap_or(Path::new("."));
    let all_qual_files = qual_file::discover(discover_root, !args.no_ignore)?;

    let records = qual_file::find_records_for(&args.artifact, &all_qual_files);

    if records.is_empty() {
        return Err(crate::Error::Validation(format!(
            "No records found for '{}'",
            args.artifact
        )));
    }

    let scores = scoring::effective_scores(&graph, &all_qual_files);
    let owned_records: Vec<crate::attestation::Record> =
        records.iter().map(|r| (*r).clone()).collect();
    let report = scores
        .get(&args.artifact)
        .cloned()
        .unwrap_or(scoring::ScoreReport {
            raw: scoring::raw_score(&owned_records),
            effective: scoring::raw_score(&owned_records),
            limiting_path: None,
        });

    if args.format == "json" {
        println!(
            "{}",
            output::show_json(&args.artifact, &report, &owned_records)
        );
        return Ok(());
    }

    // Human output
    println!();
    println!("  {}", args.artifact);
    println!("  Raw score:       {}", report.raw);
    if let Some(ref path) = report.limiting_path {
        println!(
            "  Effective score: {} (limited by {})",
            report.effective,
            path.join(" -> ")
        );
    } else {
        println!("  Effective score: {}", report.effective);
    }

    let active = scoring::filter_superseded(&owned_records);
    println!();
    println!("  Records ({}):", active.len());
    for record in &active {
        if let Some(att) = record.as_attestation() {
            let date = att.created_at.format("%Y-%m-%d");
            let issuer_short = att
                .issuer
                .strip_prefix("mailto:")
                .and_then(|e| e.split('@').next())
                .unwrap_or(&att.issuer);
            println!(
                "    {} {}  {:?}  {}  {}",
                output::format_score(att.body.score),
                att.body.kind,
                att.body.summary,
                issuer_short,
                date,
            );
        } else if let Some(epoch) = record.as_epoch() {
            let date = epoch.created_at.format("%Y-%m-%d");
            println!(
                "    {} epoch  {:?}  {}  {}",
                output::format_score(epoch.body.score),
                epoch.body.summary,
                epoch.issuer,
                date,
            );
        }
    }
    println!();

    Ok(())
}