hecks 3.14.0 → 4.0.0

data/rust/host/src/storage_shape.rs

@@ -31,7 +31,11 @@ fn project(ir: &Value) -> String {
         .map(|list| {
             list.iter()
                 .map(|aggregate| {
-                    let name = aggregate.get("name").and_then(Value::as_str).unwrap_or("").to_string();
+                    let name = aggregate
+                        .get("name")
+                        .and_then(Value::as_str)
+                        .unwrap_or("")
+                        .to_string();
                     (name, project_aggregate(aggregate))
                 })
                 .collect()
@@ -47,7 +51,10 @@ fn project_aggregate(aggregate: &Value) -> String {
 
     // Ruby's `Array(aggregate["identified_by"]).map(&:to_s)`: absent or null is `[]`.
     let identity: Vec<String> = match aggregate.get("identified_by") {
-        Some(Value::Array(items)) => items.iter().filter_map(|item| item.as_str().map(str::to_string)).collect(),
+        Some(Value::Array(items)) => items
+            .iter()
+            .filter_map(|item| item.as_str().map(str::to_string))
+            .collect(),
         Some(Value::String(s)) => vec![s.clone()],
         _ => Vec::new(),
     };
@@ -57,8 +64,7 @@ fn project_aggregate(aggregate: &Value) -> String {
         .get("lifecycle")
         .and_then(|lifecycle| lifecycle.get("field"))
         .and_then(Value::as_str)
-        .map(json_string)
-        .unwrap_or_else(|| "null".to_string());
+        .map_or_else(|| "null".to_string(), json_string);
 
     let mut attributes: Vec<(String, String)> = aggregate
         .get("attributes")
@@ -66,7 +72,11 @@ fn project_aggregate(aggregate: &Value) -> String {
         .map(|list| {
             list.iter()
                 .map(|attribute| {
-                    let name = attribute.get("name").and_then(Value::as_str).unwrap_or("").to_string();
+                    let name = attribute
+                        .get("name")
+                        .and_then(Value::as_str)
+                        .unwrap_or("")
+                        .to_string();
                     (name, project_attribute(aggregate, attribute, &[]))
                 })
                 .collect()
@@ -82,7 +92,10 @@ fn project_aggregate(aggregate: &Value) -> String {
 
 fn project_attribute(aggregate: &Value, attribute: &Value, seen: &[String]) -> String {
     let name = json_string(attribute.get("name").and_then(Value::as_str).unwrap_or(""));
-    let list = attribute.get("list").and_then(Value::as_bool).unwrap_or(false);
+    let list = attribute
+        .get("list")
+        .and_then(Value::as_bool)
+        .unwrap_or(false);
     let type_name = attribute.get("type").and_then(Value::as_str).unwrap_or("");
     let type_json = type_signature(aggregate, type_name, seen);
     format!("{{\"name\":{name},\"list\":{list},\"type\":{type_json}}}")
@@ -107,7 +120,11 @@ fn type_signature(aggregate: &Value, type_name: &str, seen: &[String]) -> String
         .map(|list| {
             list.iter()
                 .map(|member| {
-                    let name = member.get("name").and_then(Value::as_str).unwrap_or("").to_string();
+                    let name = member
+                        .get("name")
+                        .and_then(Value::as_str)
+                        .unwrap_or("")
+                        .to_string();
                     (name, project_attribute(aggregate, member, &next_seen))
                 })
                 .collect()
@@ -122,9 +139,13 @@ fn type_signature(aggregate: &Value, type_name: &str, seen: &[String]) -> String
 
 fn nested_type<'a>(aggregate: &'a Value, type_name: &str) -> Option<&'a Value> {
     let in_list = |key: &str| -> Option<&'a Value> {
-        aggregate.get(key).and_then(Value::as_array).and_then(|list| {
-            list.iter().find(|entry| entry.get("name").and_then(Value::as_str) == Some(type_name))
-        })
+        aggregate
+            .get(key)
+            .and_then(Value::as_array)
+            .and_then(|list| {
+                list.iter()
+                    .find(|entry| entry.get("name").and_then(Value::as_str) == Some(type_name))
+            })
     };
     in_list("value_objects").or_else(|| in_list("entities"))
 }
@@ -135,7 +156,7 @@ fn join_array<I: Iterator<Item = String>>(items: I) -> String {
 
 // Leaf escaping is one unambiguous spec, so serde_json is safe here; key order is not.
 fn json_string(s: &str) -> String {
-    serde_json::to_string(s).expect("a plain &str always serializes")
+    serde_json::Value::String(s.to_string()).to_string()
 }
 
 #[cfg(test)]
@@ -143,29 +164,75 @@ mod tests {
     use super::*;
     use std::fs;
 
-    // The real ir.json for examples/pizzas, not a fixture, so drift from Ruby fails here.
-    fn pizzas_ir() -> Value {
-        let path = concat!(env!("CARGO_MANIFEST_DIR"), "/../src/generated/pizzas/ir.json");
-        let text = fs::read_to_string(path).expect("rust/src/generated/pizzas/ir.json — run hecks project_rust examples/pizzas first");
+    const REPO: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/../..");
+
+    // spec/fixtures/storage_shape_vectors.json is asserted by spec/runtime/storage_shape_spec.rb
+    // too, so a drift in either implementation fails a test on its own side.
+    fn vectors() -> Vec<Value> {
+        serde_json::from_str(include_str!(
+            "../../../spec/fixtures/storage_shape_vectors.json"
+        ))
+        .expect("valid vectors JSON")
+    }
+
+    // A vector carries its IR inline, or names an ir.json in the repo (the real pizzas one).
+    fn ir_of(vector: &Value) -> Value {
+        if let Some(ir) = vector.get("ir") {
+            return ir.clone();
+        }
+        let file = vector["ir_file"].as_str().expect("ir or ir_file");
+        let text = fs::read_to_string(format!("{REPO}/{file}"))
+            .unwrap_or_else(|e| panic!("{file}: {e} - run hecks project_rust examples/pizzas"));
         serde_json::from_str(&text).expect("valid JSON")
     }
 
     #[test]
-    fn mint_label_reproduces_the_real_translation_edge_s_own_to_label() {
+    fn every_golden_vector_matches_the_ruby_canonical_hash_and_label() {
+        let vectors = vectors();
+        assert!(vectors.len() >= 8, "the vector file went missing");
+        for vector in &vectors {
+            let name = vector["name"].as_str().unwrap();
+            let ir = ir_of(vector);
+            assert_eq!(
+                canonical(&ir),
+                vector["canonical"].as_str().unwrap(),
+                "{name}"
+            );
+            assert_eq!(mint_hash(&ir), vector["hash"].as_str().unwrap(), "{name}");
+            assert_eq!(mint_label(&ir), vector["label"].as_str().unwrap(), "{name}");
+        }
+    }
+
+    #[test]
+    fn the_real_translation_edge_label_is_among_the_vectors() {
         // examples/pizzas/bluebook/translations/2-77625c.bluebook names "77625c" as the label Ruby
         // computed for this shape (Minter#mint! requires `edge.to == label`).
-        let ir = pizzas_ir();
-        assert_eq!(mint_label(&ir), "77625c");
+        let labels: Vec<String> = vectors()
+            .iter()
+            .map(|v| v["label"].as_str().unwrap().to_string())
+            .collect();
+        assert!(labels.iter().any(|label| label == "77625c"));
     }
 
     #[test]
     fn a_reordered_but_otherwise_identical_ir_hashes_the_same() {
         // Pins that attribute order is normalised: reordering must not look like a schema change.
-        let ir = pizzas_ir();
+        let ir = ir_of(
+            vectors()
+                .iter()
+                .find(|v| v["name"] == "pizzas_translation_edge_77625c")
+                .unwrap(),
+        );
         let mut reordered = ir.clone();
-        if let Some(aggregates) = reordered.get_mut("aggregates").and_then(Value::as_array_mut) {
+        if let Some(aggregates) = reordered
+            .get_mut("aggregates")
+            .and_then(Value::as_array_mut)
+        {
             for aggregate in aggregates.iter_mut() {
-                if let Some(attributes) = aggregate.get_mut("attributes").and_then(Value::as_array_mut) {
+                if let Some(attributes) = aggregate
+                    .get_mut("attributes")
+                    .and_then(Value::as_array_mut)
+                {
                     attributes.reverse();
                 }
             }

data/rust/host/src/test_pg.rs

@@ -16,25 +16,35 @@ fn host() -> String {
 }
 
 fn password_part() -> String {
-    env("PGPASSWORD").map(|p| format!(" password={p}")).unwrap_or_default()
+    env("PGPASSWORD")
+        .map(|p| format!(" password={p}"))
+        .unwrap_or_default()
 }
 
 /// Connection string for the admin role (`PGUSER`, else the OS user) on `dbname`.
 pub fn conninfo(dbname: &str) -> String {
-    let user = env("PGUSER").map(|u| format!(" user={u}")).unwrap_or_default();
+    let user = env("PGUSER")
+        .map(|u| format!(" user={u}"))
+        .unwrap_or_default();
     format!("host={} dbname={dbname}{user}{}", host(), password_part())
 }
 
 /// Connection string for a role the test created with [`login_clause`] on `dbname`.
 pub fn conninfo_as(dbname: &str, role: &str) -> String {
-    format!("host={} dbname={dbname} user={role}{}", host(), password_part())
+    format!(
+        "host={} dbname={dbname} user={role}{}",
+        host(),
+        password_part()
+    )
 }
 
 /// The `LOGIN` clause of a `CREATE ROLE` the test later connects as: it carries
 /// `PGPASSWORD` as the role's password when one is set, so `conninfo_as` can log in.
+// Shared by several harnesses; not every one that includes this file calls it.
+#[allow(dead_code)]
 pub fn login_clause() -> String {
-    match env("PGPASSWORD") {
-        Some(p) => format!("LOGIN PASSWORD '{}'", p.replace('\'', "''")),
-        None => "LOGIN".to_string(),
-    }
+    env("PGPASSWORD").map_or_else(
+        || "LOGIN".to_string(),
+        |p| format!("LOGIN PASSWORD '{}'", p.replace('\'', "''")),
+    )
 }