SYN-363 - PT100 4-wire RTD analog front end board

crates/synth-cli/src/release.rs

@@ -220,6 +220,10 @@ pub struct ReleaseManifest {
     pub schema_version: String,
     pub tool_version: String,
     pub input: String,
+    /// Commit named by `SYNTH_SOURCE_REVISION` when the package was built.
+    /// `None` means the caller did not name one.
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub source_revision: Option<String>,
     pub fab_requested: bool,
     pub production_status: ProductionStatus,
     pub release_ready: bool,
@@ -270,6 +274,25 @@ fn gate_scope() -> String {
         .to_string()
 }
 
+/// The input path as a checkout-relative path where possible, so a package
+/// does not record the absolute directory of the machine that built it.
+fn display_input(input: &Path) -> String {
+    std::env::current_dir()
+        .ok()
+        .and_then(|cwd| input.strip_prefix(cwd).ok())
+        .unwrap_or(input)
+        .display()
+        .to_string()
+}
+
+/// The source revision a caller names in `SYNTH_SOURCE_REVISION`. An empty
+/// value names none, so an unset or blank variable is not stamped as a commit.
+fn revision_from(value: Option<String>) -> Option<String> {
+    value
+        .map(|v| v.trim().to_string())
+        .filter(|v| !v.is_empty())
+}
+
 impl ReleaseManifest {
     pub fn new(
         tool_version: &str,
@@ -283,7 +306,8 @@ impl ReleaseManifest {
         Self {
             schema_version: SCHEMA_VERSION.to_string(),
             tool_version: tool_version.to_string(),
-            input: input.display().to_string(),
+            input: display_input(input),
+            source_revision: revision_from(std::env::var("SYNTH_SOURCE_REVISION").ok()),
             fab_requested,
             production_status: if clean {
                 ProductionStatus::Production
@@ -522,6 +546,27 @@ mod tests {
         )
     }
 
+    #[test]
+    fn an_input_under_the_current_directory_is_recorded_relative() {
+        let cwd = std::env::current_dir().expect("cwd");
+        let absolute = cwd.join("qualification/class-b/rtd-afe/rtd_afe.synth");
+        assert_eq!(
+            display_input(&absolute),
+            "qualification/class-b/rtd-afe/rtd_afe.synth"
+        );
+        assert_eq!(display_input(Path::new("board.synth")), "board.synth");
+    }
+
+    #[test]
+    fn a_named_source_revision_is_kept_and_a_blank_one_is_not() {
+        assert_eq!(
+            revision_from(Some(" abc123\n".into())).as_deref(),
+            Some("abc123")
+        );
+        assert_eq!(revision_from(Some("  ".into())), None);
+        assert_eq!(revision_from(None), None);
+    }
+
     fn unverified() -> OverrideRecord {
         OverrideRecord::new(
             OverrideKind::UnverifiedParts,

crates/synth-kicad/src/bom.rs

@@ -2,8 +2,10 @@
 
 //! Bill of materials CSV writer.
 //!
-//! Columns: `refdes,value,kind,description`. Fields containing
-//! commas, quotes, or newlines are RFC-4180 quoted. Output is
+//! Columns: `refdes,value,kind,description`, the KiCad symbol and
+//! footprint, supplier identities, and the source's structured
+//! `dielectric`, `voltage`, `tolerance` and `power` attributes. Fields
+//! containing commas, quotes, or newlines are RFC-4180 quoted. Output is
 //! sorted by refdes for diff stability.
 //!
 //! Do-not-populate parts are left out: a DNP line in the BOM would
@@ -39,6 +41,10 @@ fn build_bom_csv_filtered(board: &Board, extra_dnp: &BTreeSet<&str>) -> String {
         String,
         String,
         String,
+        String,
+        String,
+        String,
+        String,
     )> = board
         .components
         .iter()
@@ -78,6 +84,7 @@ fn build_bom_csv_filtered(board: &Board, extra_dnp: &BTreeSet<&str>) -> String {
                 .as_ref()
                 .and_then(|p| p.mpn.clone())
                 .unwrap_or_default();
+            let attribute = |key: &str| c.properties.get(key).cloned().unwrap_or_default();
             (
                 c.refdes.clone(),
                 value,
@@ -87,14 +94,35 @@ fn build_bom_csv_filtered(board: &Board, extra_dnp: &BTreeSet<&str>) -> String {
                 kicad_footprint,
                 lcsc_pn,
                 mpn,
+                attribute("Dielectric"),
+                attribute("Voltage"),
+                attribute("Tolerance"),
+                attribute("Power"),
             )
         })
         .collect();
     rows.sort();
 
     let mut out = String::new();
-    out.push_str("refdes,value,kind,description,kicad_symbol,kicad_footprint,lcsc_pn,mpn\n");
-    for (refdes, value, kind, description, kicad_symbol, kicad_footprint, lcsc_pn, mpn) in rows {
+    out.push_str(
+        "refdes,value,kind,description,kicad_symbol,kicad_footprint,lcsc_pn,mpn,\
+         dielectric,voltage,tolerance,power\n",
+    );
+    for (
+        refdes,
+        value,
+        kind,
+        description,
+        kicad_symbol,
+        kicad_footprint,
+        lcsc_pn,
+        mpn,
+        dielectric,
+        voltage,
+        tolerance,
+        power,
+    ) in rows
+    {
         write_field(&mut out, &refdes);
         out.push(',');
         write_field(&mut out, &value);
@@ -110,6 +138,14 @@ fn build_bom_csv_filtered(board: &Board, extra_dnp: &BTreeSet<&str>) -> String {
         write_field(&mut out, &lcsc_pn);
         out.push(',');
         write_field(&mut out, &mpn);
+        out.push(',');
+        write_field(&mut out, &dielectric);
+        out.push(',');
+        write_field(&mut out, &voltage);
+        out.push(',');
+        write_field(&mut out, &tolerance);
+        out.push(',');
+        write_field(&mut out, &power);
         out.push('\n');
     }
     out
@@ -192,6 +228,61 @@ mod tests {
         assert!(lite.contains("R1") && !lite.contains("R2") && !lite.contains("R3"));
     }
 
+    #[test]
+    fn structured_attributes_get_their_own_columns() {
+        use std::collections::BTreeMap;
+        use synth_ir::{Component, ComponentId};
+        let mut properties = BTreeMap::new();
+        properties.insert("Dielectric".to_string(), "C0G".to_string());
+        properties.insert("Voltage".to_string(), "50V".to_string());
+        properties.insert("Tolerance".to_string(), "0.1%".to_string());
+        let board = Board {
+            schematic_overflow: None,
+            schematic_paper: None,
+            groups: Vec::new(),
+            legends: false,
+            name: "b".to_string(),
+            layers: 2,
+            manufacturer: None,
+            revision: None,
+            company: None,
+            components: vec![Component {
+                id: ComponentId(0),
+                refdes: "C1".to_string(),
+                kind: "capacitor".to_string(),
+                part: None,
+                value: Some("100nF".to_string()),
+                dnp: false,
+                properties,
+                placement_hint: None,
+                escape: None,
+                group: None,
+                sheet: None,
+                source_span: synth_diagnostics::Span::new(0, 0),
+            }],
+            nets: vec![],
+            diff_pairs: vec![],
+            notes: vec![],
+            keepouts: vec![],
+            stackup: None,
+            netclasses: vec![],
+            buses: vec![],
+            modules: vec![],
+            variants: vec![],
+            required_processes: std::collections::BTreeSet::new(),
+            source_span: synth_diagnostics::Span::new(0, 0),
+        };
+        let csv = build_bom_csv(&board);
+        assert!(
+            csv.starts_with(
+                "refdes,value,kind,description,kicad_symbol,kicad_footprint,lcsc_pn,mpn,\
+                 dielectric,voltage,tolerance,power\n"
+            ),
+            "{csv}"
+        );
+        assert!(csv.contains(",C0G,50V,0.1%,"), "{csv}");
+    }
+
     #[test]
     fn quoting_doubles_internal_quotes() {
         let mut s = String::new();

crates/synth-kicad/src/export.rs

@@ -465,17 +465,23 @@ fn export_inner(
     // external router, which reads this file and writes its own candidate
     // back; Synth does not synthesize traces here, so nothing downstream
     // can mistake them for router output.
-    let (label_overrides, fixed_vias) = sidecars
+    let placement_sidecar = sidecars
         .placement_path()
-        .and_then(synth_layout::sidecar::SidecarLayout::load_from_file)
-        .map(|sidecar| (sidecar.labels, sidecar.vias))
+        .and_then(synth_layout::sidecar::SidecarLayout::load_from_file);
+    let (label_overrides, fixed_vias) = placement_sidecar
+        .as_ref()
+        .map(|sidecar| (sidecar.labels.clone(), sidecar.vias.clone()))
         .unwrap_or_default();
+    let outline: &[synth_layout::sidecar::SidecarPoint] = placement_sidecar
+        .as_ref()
+        .map_or(&[], |sidecar| sidecar.outline.as_slice());
     let pcb_text = pcb::build_pcb(
         board,
         &placement,
         &synth_pcb::Routing::default(),
         &project_namespace,
         &label_overrides,
+        outline,
         &fixed_vias,
     )
     .map_err(|error| ExportError::PlaneFanout {