fusible 0.11.3

Electronic linter: a fuse that blows to block firmware code generation
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

//! Subcommand: `fusible export` — export circuit artifacts.

mod formats;
mod pdf;
mod presets;

use std::path::{Path, PathBuf};

use miette::Diagnostic;
use thiserror::Error;

use crate::commands::check::{self, CheckError};
use crate::commands::target::resolve_entry;
use crate::tscircuit::{Runner, RunnerError};

/// Unified error enum for the export pipeline.
#[derive(Debug, Error, Diagnostic)]
pub enum ExportError {
    #[error(transparent)]
    #[diagnostic(transparent)]
    Check(#[from] CheckError),

    #[error(transparent)]
    #[diagnostic(transparent)]
    Runner(#[from] RunnerError),

    #[error("failed to export manufacturing files: {0}")]
    #[diagnostic(code(fusible::export::io_error))]
    Io(#[from] std::io::Error),

    #[error("unknown export preset \"{preset}\"")]
    #[diagnostic(
        code(fusible::export::unknown_preset),
        help("valid presets are: `fab` (gerbers + json), `cad` (kicad + step), `docs` (svg + pdf), or `all`")
    )]
    UnknownPreset { preset: String },
}

/// Everything an export step needs once the fuse check has passed.
struct ExportJob {
    runner: Option<Runner>,
    entry: PathBuf,
    board_title: String,
    output: Option<PathBuf>,
    source: Option<String>,
}

impl ExportJob {
    /// Returns the detected runner, or a not-found error for runner-backed formats.
    fn runner(&self) -> Result<&Runner, RunnerError> {
        self.runner.as_ref().ok_or(RunnerError::NotFound)
    }

    /// Returns the custom output path, or `default` when none was given.
    fn output_or(&self, default: &str) -> PathBuf {
        self.output
            .clone()
            .unwrap_or_else(|| PathBuf::from(default))
    }

    /// Returns the Circuit JSON loaded by the fuse gate, loading it when the gate was skipped.
    fn circuit_json(&self) -> Result<String, ExportError> {
        match &self.source {
            Some(source) => Ok(source.clone()),
            None => Ok(check::load_circuit_source(&self.entry)?.1),
        }
    }
}

/// Exports tscircuit source files into various formats (Gerbers, SVG, 3D, KiCad, etc.).
///
/// By default, all exports are **fuse-gated**: electrical rules are checked first.
/// If any violation is found, the process halts and no export occurs.
pub fn run(
    file: Option<PathBuf>,
    preset: Option<&str>,
    format: &str,
    output: Option<PathBuf>,
    skip_lint: bool,
) -> Result<(), ExportError> {
    if let Some(preset_name) = preset {
        presets::validate_preset(preset_name)?;
    }

    let (entry, source) = fuse_gate(file, skip_lint)?;

    let job = ExportJob {
        runner: Runner::detect().ok(),
        entry,
        board_title: check::resolve_board_name(),
        output,
        source,
    };

    match preset {
        Some(preset_name) => presets::run_preset(&job, preset_name),
        None => formats::run_format(&job, format),
    }
}

/// Runs the electrical check unless the user asked to skip it.
///
/// Returns the entry file and, when the check ran, the Circuit JSON it validated.
fn fuse_gate(
    file: Option<PathBuf>,
    skip_lint: bool,
) -> Result<(PathBuf, Option<String>), ExportError> {
    if skip_lint {
        println!("⚠️  Skipping electrical rule verification (--skip-lint requested).\n");
        let entry = resolve_entry(file).unwrap_or_else(|_| PathBuf::from("index.tsx"));
        return Ok((entry, None));
    }
    println!("🔍 Verifying electrical rules before export (fuse check)...");
    let entry = resolve_entry(file).map_err(CheckError::from)?;
    let (_, source) = check::lint_source(&entry, None)?;
    println!("⚡ Fuse intact — proceeding with artifact export.\n");
    Ok((entry, Some(source)))
}

/// Extracts every entry of `zip_path` into `target_dir`.
fn extract_zip_archive(zip_path: &Path, target_dir: &Path) -> Result<(), ExportError> {
    let file = std::fs::File::open(zip_path)?;
    zip::ZipArchive::new(file)
        .and_then(|mut archive| archive.extract(target_dir))
        .map_err(|err| ExportError::Io(std::io::Error::other(err)))
}