fusible 0.20.7

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

//! Command construction and execution formatting for tscircuit runners.

use std::path::Path;
use std::process::Command;

use crate::tscircuit::RunnerKind;

/// Builds the `Command` for the interactive `dev` server.
pub fn dev_command(kind: &RunnerKind, file: &Path, port: Option<u16>) -> Command {
    let mut cmd = base_command(kind);
    cmd.arg("dev").arg(file);
    if let Some(port) = port {
        cmd.arg("-p").arg(port.to_string());
    }
    cmd
}

/// Builds the `Command` for exporting a circuit to a given format.
pub fn export_command(
    kind: &RunnerKind,
    file: &Path,
    format: &str,
    output: Option<&Path>,
) -> Command {
    let mut cmd = base_command(kind);
    cmd.arg("export").arg(file).arg("-f").arg(format);
    if let Some(output) = output {
        cmd.arg("-o").arg(output);
    }
    cmd
}

/// Builds the `Command` for building circuit json from a circuit file.
pub fn build_command(kind: &RunnerKind, file: &Path) -> Command {
    let mut cmd = base_command(kind);
    cmd.arg("build").arg(file).arg("--ignore-errors");
    cmd
}

/// Builds the `Command` for adding tscircuit packages or registry components.
pub fn add_command(kind: &RunnerKind, packages: &[String]) -> Command {
    let mut cmd = base_command(kind);
    cmd.arg("add");
    for pkg in packages {
        cmd.arg(pkg);
    }
    cmd
}

/// Builds the `Command` for installing dependencies in a tscircuit project.
pub fn install_command(kind: &RunnerKind) -> Command {
    let mut cmd = base_command(kind);
    cmd.arg("install");
    cmd
}

/// Builds the `Command` for searching packages/footprints in the tscircuit registry.
pub fn search_command(kind: &RunnerKind, query: &[String]) -> Command {
    let mut cmd = base_command(kind);
    cmd.arg("search");
    for q in query {
        cmd.arg(q);
    }
    cmd
}

/// Constructs a base `Command` with the binary configured.
pub fn base_command(kind: &RunnerKind) -> Command {
    match kind {
        RunnerKind::Local(p) | RunnerKind::Global(p) => Command::new(p),
        RunnerKind::Bun(bun) => {
            let mut cmd = Command::new(bun);
            cmd.args(["x", "--bun", "tsci"]);
            cmd
        }
    }
}