cadmpeg 0.6.8

Convert and inspect native CAD files.
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

// SPDX-License-Identifier: Apache-2.0
//! Command wrappers for the reproduction library.
use crate::application::{
    artifact_store::FileDestination,
    refusal::{ApplicationError, CheckOperation, ConversionRefusal},
};
use anyhow::{bail, Context, Result};
use cadmpeg_ir::report::check::Finding;
use cadmpeg_registry::{
    repro::{check, cut, Bundle, CutOptions},
    InputCatalog,
};
use clap::Args;
use std::io::Write as _;
use std::path::{Path, PathBuf};

const MAX_REPRO_INPUT_BYTES: u64 = 256 * 1024 * 1024;

/// Select a finding from a persisted command report.
#[derive(Debug, Args)]
pub(crate) struct ReproArgs {
    /// Command report written by check.
    #[arg(long)]
    from: PathBuf,
    /// Zero-based finding index.
    #[arg(long)]
    finding: usize,
    /// Bundle destination.
    #[arg(short, long)]
    output: PathBuf,
    /// Return an error after writing a bundle that needs more context.
    #[arg(long)]
    require_reproduction: bool,
}

pub(crate) fn run(inputs: &InputCatalog, args: &ReproArgs) -> Result<()> {
    let text =
        crate::application::artifact_store::read_bounded_text(&args.from, MAX_REPRO_INPUT_BYTES)?;
    let report: serde_json::Value = serde_json::from_str(&text)?;
    let finding: Finding = serde_json::from_value(
        report["check_report"]["findings"]
            .get(args.finding)
            .context("finding index is outside the report")?
            .clone(),
    )?;
    let input = report["input_path"]
        .as_str()
        .context("report needs input_path; run check --report with the current build")?;
    let document = crate::loader::load_artifact(
        inputs,
        Path::new(input),
        cadmpeg_ir::codec::DecodeOptions::default(),
        None,
    )?;
    let bundle = cut(&document.ir, &finding, &CutOptions::default())?;
    let bytes = serde_json::to_vec(&bundle)?;
    let mut output = std::fs::OpenOptions::new()
        .write(true)
        .create_new(true)
        .open(&args.output)?;
    output.write_all(&bytes)?;
    if let Some(reason) = &bundle.incomplete_reason {
        eprintln!("bundle written; incomplete: {reason}");
        if args.require_reproduction {
            bail!("bundle requires more context to reproduce its selected finding");
        }
    }
    Ok(())
}

pub(crate) fn check_fragment(
    path: &Path,
    json: bool,
    output: Option<&FileDestination>,
) -> Result<(), ApplicationError> {
    let text = crate::application::artifact_store::read_bounded_text(path, MAX_REPRO_INPUT_BYTES)?;
    let bundle: Bundle = serde_json::from_str(&text).map_err(anyhow::Error::from)?;
    if !bundle.document.fragment {
        return Err(anyhow::anyhow!("bundle document must carry fragment=true").into());
    }
    let findings = check(&bundle);
    let report = cadmpeg_ir::report::check::ValidationReport {
        entity_counts: bundle.document.census(),
        findings,
        losses: Vec::new(),
    };
    let body = serde_json::json!({"check_report": report});
    let refusal = (!report.is_ok()).then(|| ConversionRefusal::CheckFailed {
        operation: CheckOperation::Check,
        decode_report: None,
        validation: report.clone(),
    });
    let text = match refusal.as_ref() {
        Some(refusal) => crate::commands::reporting::payload_report_json(
            "check",
            crate::commands::reporting::Payload::Refused(&body, refusal),
        )?,
        None => crate::commands::reporting::command_report_json("check", &body)?,
    };
    crate::commands::reporting::write_report_text(path, output, &text)?;
    if json {
        println!("{text}");
    } else {
        crate::commands::reporting::print_check_report(&mut std::io::stdout(), &report)?;
    }
    match refusal {
        Some(refusal) => Err(refusal.into()),
        None => Ok(()),
    }
}