fusible 0.20.0

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

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

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

use crate::commands::check::{load_circuit_source, CheckError};
use crate::commands::target::{resolve_entry, TargetError};
use crate::router::{route_circuit, RouteOptions};

#[derive(Debug, Error, Diagnostic)]
pub enum RouteCommandError {
    #[error(transparent)]
    #[diagnostic(transparent)]
    Target(#[from] TargetError),

    #[error(transparent)]
    #[diagnostic(transparent)]
    Check(#[from] CheckError),

    #[error("failed to execute autorouter: {0}")]
    #[diagnostic(code(fusible::route::engine_error))]
    Engine(String),

    #[error("failed to write routed output: {0}")]
    #[diagnostic(code(fusible::route::io_error))]
    Io(#[from] std::io::Error),

    #[error("the fuse blew: {count} unrouted net(s) could not be connected: {nets:?}")]
    #[diagnostic(
        code(fusible::route::unrouted_nets),
        help("adjust component placement or relax clearance rules to resolve routing congestion")
    )]
    UnroutedNets { count: usize, nets: Vec<String> },
}

/// Autoroutes the target circuit and writes the routed Circuit JSON unless `options.dry_run`.
pub fn run(
    file: Option<PathBuf>,
    output: Option<PathBuf>,
    options: RouteOptions,
) -> Result<(), RouteCommandError> {
    let entry = resolve_entry(file)?;
    println!("⚡ Initializing autorouter for \"{}\"...", entry.display());

    let (_json_path, source) = load_circuit_source(&entry)?;
    let result = route_circuit(&source, &options).map_err(RouteCommandError::Engine)?;

    println!(
        "📊 Autorouting complete: {}/{} net(s) routed ({} trace(s), {} via(s))",
        result.routed_nets, result.total_nets, result.generated_traces, result.generated_vias
    );

    if !result.unrouted_nets.is_empty() {
        return Err(RouteCommandError::UnroutedNets {
            count: result.unrouted_nets.len(),
            nets: result.unrouted_nets,
        });
    }

    if options.dry_run {
        println!("🔍 Dry run complete — verified all nets routable (fuse intact).");
        return Ok(());
    }

    let dest = output.unwrap_or_else(|| default_destination(&entry));
    write_routed(&dest, &result.output_json)
}

/// Writes the routed Circuit JSON to `dest`, creating its parent directory.
fn write_routed(dest: &Path, json: &str) -> Result<(), RouteCommandError> {
    if let Some(parent) = dest.parent() {
        std::fs::create_dir_all(parent)?;
    }
    std::fs::write(dest, json)?;
    println!(
        "✅ Successfully exported routed circuit to \"{}\"!",
        dest.display()
    );
    Ok(())
}

/// Overwrites a JSON entry in place; other entries go to `dist/circuit.routed.json`.
fn default_destination(entry: &Path) -> PathBuf {
    if entry.extension().and_then(|e| e.to_str()) == Some("json") {
        entry.to_path_buf()
    } else {
        PathBuf::from("dist").join("circuit.routed.json")
    }
}