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

//! One pass of the KiCad sync: compare a board file with the Circuit JSON, then write positions.

use std::path::Path;

use super::changes::design_differences;
use super::diff::{compare_kicad_with_circuit, parse_circuit_elements, DiffReport, PlacementDiff};
use super::sexpr::{extract_footprints, parse_sexpr};
use super::tsx::rewrite_tree;

/// A KiCad board compared with the design.
pub struct Comparison {
    report: DiffReport,
    /// Parts added, removed or renamed and nets rewired in KiCad; reported, never written.
    pub differences: Vec<String>,
}

impl Comparison {
    /// Designators whose placement KiCad changed.
    pub fn moved(&self) -> Vec<String> {
        self.report
            .diffs
            .iter()
            .filter(|d| d.is_placement_change())
            .map(|d| d.designator.clone())
            .collect()
    }
}

/// Compares the board file at `pcb` with `circuit_json`.
///
/// Fails when either side cannot be parsed; unparseable Circuit JSON is never read as an
/// empty circuit.
pub fn compare_board(pcb: &Path, circuit_json: &str) -> Result<Comparison, String> {
    let content =
        std::fs::read_to_string(pcb).map_err(|e| format!("cannot read {}: {e}", pcb.display()))?;
    let sexpr = parse_sexpr(&content).map_err(|e| format!("invalid KiCad file: {e}"))?;
    let footprints = extract_footprints(&sexpr);
    let elements =
        parse_circuit_elements(circuit_json).map_err(|e| format!("invalid Circuit JSON: {e}"))?;
    let report = compare_kicad_with_circuit(&footprints, &elements);
    let differences = design_differences(&report, &footprints, &elements);
    Ok(Comparison {
        report,
        differences,
    })
}

/// Writes the parts KiCad moved into the TSX files under `dir`, after copying each file it
/// changes to `backup_dir`.
///
/// Only plain-number `pcbX`, `pcbY` and `pcbRotation` props are rewritten. Returns the
/// designators written; the other moved parts stay different until the TSX is edited.
pub fn sync_positions(
    comparison: &Comparison,
    dir: &Path,
    backup_dir: &Path,
    name: &str,
) -> Result<Vec<String>, String> {
    let moved: Vec<&PlacementDiff> = comparison
        .report
        .diffs
        .iter()
        .filter(|d| d.is_placement_change())
        .collect();
    match moved.is_empty() {
        true => Ok(Vec::new()),
        false => rewrite_tree(dir, &moved, backup_dir, name),
    }
}