fusible 0.15.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

//! Export presets: `fab`, `cad`, `docs` and `all`.

use std::path::Path;

use super::{extract_zip_archive, ExportError, ExportJob};
use crate::commands::check::CheckError;

/// Rejects any preset name other than `fab`, `cad`, `docs` or `all`.
pub(super) fn validate_preset(preset: &str) -> Result<(), ExportError> {
    match preset {
        "fab" | "cad" | "docs" | "all" => Ok(()),
        other => Err(ExportError::UnknownPreset {
            preset: other.to_string(),
        }),
    }
}

/// Runs the named preset for `job`.
pub(super) fn run_preset(job: &ExportJob, preset: &str) -> Result<(), ExportError> {
    validate_preset(preset)?;
    let circuit_json = match preset {
        "cad" => String::new(),
        _ => job.circuit_json()?,
    };
    match preset {
        "fab" => export_fab(job, &circuit_json),
        "cad" => export_cad(job),
        "docs" => export_docs(job, &circuit_json),
        _ => export_all(job, &circuit_json),
    }
}

/// Runs the fab, cad and docs presets in sequence.
fn export_all(job: &ExportJob, circuit_json: &str) -> Result<(), ExportError> {
    export_fab(job, circuit_json)?;
    println!();
    export_cad(job)?;
    println!();
    export_docs(job, circuit_json)
}

/// Writes gerbers and Circuit JSON into the fab output directory.
fn export_fab(job: &ExportJob, circuit_json: &str) -> Result<(), ExportError> {
    let base = job.output_or("fab");
    std::fs::create_dir_all(&base)?;
    println!("📦 Running fabrication export preset (fab)...");
    println!("  • Exporting RS-274X gerbers & drill files via native Rust engine...");
    crate::gerber::export_fab_bundle(circuit_json, &job.board_title, &base)?;
    println!(
        "✅ Fabrication artifacts generated in \"{}\" (gerbers.zip, circuit.json)",
        base.display()
    );
    Ok(())
}

/// Exports the KiCad project and STEP model through the tscircuit runner.
fn export_cad(job: &ExportJob) -> Result<(), ExportError> {
    let runner = job.runner()?;
    let base = job.output_or("cad");
    std::fs::create_dir_all(&base)?;
    println!("📦 Running CAD export preset (cad)...");
    let kicad = base.join("kicad.zip");
    println!("  • Exporting KiCad project -> {}", kicad.display());
    runner.export(&job.entry, "kicad_zip", Some(&kicad))?;

    let kicad_dir = base.join("kicad");
    std::fs::create_dir_all(&kicad_dir)?;
    extract_zip_archive(&kicad, &kicad_dir)?;
    println!(
        "  • KiCad project files extracted -> {}",
        kicad_dir.display()
    );

    let step = base.join("board.step");
    println!("  • Exporting 3D STEP -> {}", step.display());
    runner.export(&job.entry, "step", Some(&step))?;
    println!("✅ CAD artifacts generated in \"{}\"", base.display());
    Ok(())
}

/// Renders schematic and PCB SVGs into the docs output directory.
fn export_docs(job: &ExportJob, circuit_json: &str) -> Result<(), ExportError> {
    let base = job.output_or("docs");
    std::fs::create_dir_all(&base)?;
    println!("📦 Running documentation export preset (docs)...");
    println!("  • Exporting schematic SVG & PCB layout SVG via native Rust engine...");

    let circuit =
        crate::parser::parse(circuit_json, Path::new("circuit.json")).map_err(CheckError::from)?;
    let netlist = crate::netlist::Netlist::from_circuit(&circuit);

    crate::svg::export_docs_bundle(circuit_json, &circuit, &netlist, &base)?;
    let pdf =
        super::pdf::print_svg_to_pdf(&base.join("schematic.svg"), &base.join("schematic.pdf"));
    let files = if pdf {
        "schematic.svg, pcb.svg, schematic.pdf"
    } else {
        "schematic.svg, pcb.svg"
    };
    println!(
        "✅ Documentation artifacts generated in \"{}\" ({files})",
        base.display()
    );
    Ok(())
}