hecks 3.13.0 → 4.0.0

data/rust/build/src/translation_pass.rs

@@ -2,7 +2,7 @@
 //! edge made of renames and moves needs: the declared rules plus the SQL expression
 //! `Translation::RuleCompiler.compile_rules` builds for them.
 //!
-//! A rule kind this pass does not compile (convert, drop, retype, compute, rekey, backfill) is
+//! A rule kind this pass does not compile (convert, drop, retype, backfill) is
 //! refused by name, so a domain never ships an edge whose SQL was silently left out.
 
 use std::path::Path;
@@ -20,7 +20,9 @@ struct Aggregate {
 /// The `translations` IR list for the `.bluebook` files under `bluebook_dir/translations`, ordered
 /// by file name (an era-step id), as the registry loads them.
 pub fn edges(bluebook_dir: &Path) -> Result<Vec<Json>, String> {
-    let Ok(entries) = std::fs::read_dir(bluebook_dir.join("translations")) else { return Ok(Vec::new()) };
+    let Ok(entries) = std::fs::read_dir(bluebook_dir.join("translations")) else {
+        return Ok(Vec::new());
+    };
     let mut paths: Vec<_> = entries
         .filter_map(Result::ok)
         .map(|entry| entry.path())
@@ -29,7 +31,8 @@ pub fn edges(bluebook_dir: &Path) -> Result<Vec<Json>, String> {
     paths.sort();
     let mut edges = Vec::new();
     for path in paths {
-        let text = std::fs::read_to_string(&path).map_err(|e| format!("reading {}: {e}", path.display()))?;
+        let text = std::fs::read_to_string(&path)
+            .map_err(|e| format!("reading {}: {e}", path.display()))?;
         edges.push(edge(&text).map_err(|why| format!("{}: {why}", path.display()))?);
     }
     Ok(edges)
@@ -44,16 +47,31 @@ fn edge(text: &str) -> Result<Json, String> {
             continue;
         }
         if let Some(rest) = line.strip_prefix("Hecks.data_translation") {
-            header = Some((first_string(rest)?, keyword(rest, "from")?, keyword(rest, "to")?));
+            header = Some((
+                first_string(rest)?,
+                keyword(rest, "from")?,
+                keyword(rest, "to")?,
+            ));
         } else if let Some(rest) = line.strip_prefix("aggregate ") {
             let was = keyword(rest, "was").ok();
-            aggregates.push(Aggregate { name: first_string(rest)?, was, renames: Vec::new(), moves: Vec::new() });
+            aggregates.push(Aggregate {
+                name: first_string(rest)?,
+                was,
+                renames: Vec::new(),
+                moves: Vec::new(),
+            });
         } else if let Some(rest) = line.strip_prefix("move ") {
             let aggregate = aggregates.last_mut().ok_or("a move outside an aggregate")?;
-            aggregate.moves.push((first_word(rest)?, keyword(rest, "to")?));
+            aggregate
+                .moves
+                .push((first_word(rest)?, keyword(rest, "to")?));
         } else if let Some(rest) = line.strip_prefix("rename ") {
-            let aggregate = aggregates.last_mut().ok_or("a rename outside an aggregate")?;
-            aggregate.renames.push((first_word(rest)?, keyword(rest, "to")?));
+            let aggregate = aggregates
+                .last_mut()
+                .ok_or("a rename outside an aggregate")?;
+            aggregate
+                .renames
+                .push((first_word(rest)?, keyword(rest, "to")?));
         } else {
             return Err(format!(
                 "hecks-build cannot compile the translation rule `{line}` yet (only rename and move are ported), \
@@ -67,30 +85,46 @@ fn edge(text: &str) -> Result<Json, String> {
         ("from".into(), Json::String(from)),
         ("to".into(), Json::String(to)),
         ("retired".into(), Json::Array(Vec::new())),
-        ("aggregates".into(), Json::Array(aggregates.iter().map(aggregate_json).collect())),
+        (
+            "aggregates".into(),
+            Json::Array(aggregates.iter().map(aggregate_json).collect()),
+        ),
     ]))
 }
 
 fn aggregate_json(aggregate: &Aggregate) -> Json {
-    let renames = aggregate.renames.iter().map(|(old, new)| (old.clone(), Json::String(new.clone()))).collect();
+    let renames = aggregate
+        .renames
+        .iter()
+        .map(|(old, new)| (old.clone(), Json::String(new.clone())))
+        .collect();
     let moves = aggregate
         .moves
         .iter()
-        .map(|(from, to)| Json::Object(vec![("from".into(), Json::String(from.clone())), ("to".into(), Json::String(to.clone()))]))
+        .map(|(from, to)| {
+            Json::Object(vec![
+                ("from".into(), Json::String(from.clone())),
+                ("to".into(), Json::String(to.clone())),
+            ])
+        })
         .collect();
     let empty = || Json::Array(Vec::new());
     Json::Object(vec![
         ("name".into(), Json::String(aggregate.name.clone())),
-        ("was".into(), aggregate.was.clone().map_or(Json::Null, Json::String)),
+        (
+            "was".into(),
+            aggregate.was.clone().map_or(Json::Null, Json::String),
+        ),
         ("renames".into(), Json::Object(renames)),
         ("moves".into(), Json::Array(moves)),
         ("converts".into(), empty()),
         ("drops".into(), empty()),
         ("retypes".into(), empty()),
-        ("computes".into(), empty()),
-        ("rekeys".into(), empty()),
         ("backfills".into(), empty()),
-        ("compiled_state_expression".into(), Json::String(compile(aggregate))),
+        (
+            "compiled_state_expression".into(),
+            Json::String(compile(aggregate)),
+        ),
         ("compiled_id_expression".into(), Json::Null),
     ])
 }
@@ -99,7 +133,11 @@ fn aggregate_json(aggregate: &Aggregate) -> Json {
 fn compile(aggregate: &Aggregate) -> String {
     let mut sql = "state".to_string();
     for (old, new) in &aggregate.renames {
-        sql = format!("hecks_tr_rename({sql}, {}, {})", text_literal(old), text_literal(new));
+        sql = format!(
+            "hecks_tr_rename({sql}, {}, {})",
+            text_literal(old),
+            text_literal(new)
+        );
     }
     for (from, to) in &aggregate.moves {
         sql = format!(
@@ -123,9 +161,13 @@ fn path_literal(path: &str) -> String {
 
 /// The first `"quoted"` string of `text`.
 fn first_string(text: &str) -> Result<String, String> {
-    let open = text.find('"').ok_or_else(|| format!("no quoted name in `{text}`"))?;
+    let open = text
+        .find('"')
+        .ok_or_else(|| format!("no quoted name in `{text}`"))?;
     let rest = &text[open + 1..];
-    let close = rest.find('"').ok_or_else(|| format!("unterminated string in `{text}`"))?;
+    let close = rest
+        .find('"')
+        .ok_or_else(|| format!("unterminated string in `{text}`"))?;
     Ok(rest[..close].to_string())
 }
 
@@ -133,16 +175,24 @@ fn first_string(text: &str) -> Result<String, String> {
 fn first_word(text: &str) -> Result<String, String> {
     let word = text.split(',').next().unwrap_or_default().trim();
     let word = word.strip_prefix(':').unwrap_or(word).trim_matches('"');
-    if word.is_empty() { Err(format!("no source in `{text}`")) } else { Ok(word.to_string()) }
+    if word.is_empty() {
+        Err(format!("no source in `{text}`"))
+    } else {
+        Ok(word.to_string())
+    }
 }
 
 /// The value of `key: value` in `text`, a string or a symbol.
 fn keyword(text: &str, key: &str) -> Result<String, String> {
     let marker = format!("{key}:");
-    let at = text.find(&marker).ok_or_else(|| format!("no `{key}:` in `{text}`"))?;
+    let at = text
+        .find(&marker)
+        .ok_or_else(|| format!("no `{key}:` in `{text}`"))?;
     let value = text[at + marker.len()..].trim_start();
     if let Some(symbol) = value.strip_prefix(':') {
-        let end = symbol.find(|c: char| !(c.is_alphanumeric() || c == '_')).unwrap_or(symbol.len());
+        let end = symbol
+            .find(|c: char| !(c.is_alphanumeric() || c == '_'))
+            .unwrap_or(symbol.len());
         return Ok(symbol[..end].to_string());
     }
     first_string(value)
@@ -161,7 +211,7 @@ mod tests {
 
     #[test]
     fn refuses_a_rule_it_cannot_compile() {
-        let text = "Hecks.data_translation \"A\", from: \"1\", to: \"2\" do\n  aggregate \"B\" do\n    compute :a, to: \"b\", sql: \"1\"\n  end\nend\n";
+        let text = "Hecks.data_translation \"A\", from: \"1\", to: \"2\" do\n  aggregate \"B\" do\n    backfill :a, default: 1\n  end\nend\n";
         assert!(edge(text).unwrap_err().contains("cannot compile"));
     }
 }

data/rust/build/src/world_pass.rs

@@ -0,0 +1,109 @@
+//! The `world` fact: what the domain's `.world` file says about persistence, read through
+//! `hecks-parse world`, so `rust/host` can refuse a world it has no backend for. Only the
+//! setting names travel, never their values.
+
+use std::path::Path;
+
+use crate::json::Json;
+use crate::subprocess;
+
+/// Sets `world` right after `adapters`. With no `.world` file beside the domain it is the empty fact.
+///
+/// # Errors
+///
+/// Returns the parser's failure, or a message naming output that is not the JSON array
+/// `hecks-parse world` prints.
+pub fn run(ir: &mut Json, parser_bin: &Path, world: Option<&Path>) -> Result<(), String> {
+    let Some(world) = world else {
+        ir.set("world", fact(None));
+        return Ok(());
+    };
+    let domain = ir
+        .get("name")
+        .and_then(Json::as_str)
+        .unwrap_or_default()
+        .to_string();
+    let world_arg = world.to_string_lossy();
+    let printed = subprocess::run_capture(&parser_bin.to_string_lossy(), &["world", &world_arg])?;
+    let parsed = Json::parse(&printed).map_err(|e| format!("parsing hecks-parse world: {e}"))?;
+    let entry = parsed
+        .each()
+        .iter()
+        .find(|w| w.get("domain").and_then(Json::as_str) == Some(domain.as_str()));
+    ir.set("world", fact(entry));
+    Ok(())
+}
+
+fn fact(entry: Option<&Json>) -> Json {
+    let default_adapter = entry
+        .and_then(|w| w.get("default_adapter"))
+        .and_then(Json::as_str)
+        .map_or(Json::Null, |a| Json::String(a.to_string()));
+    let default_database = entry
+        .and_then(|w| w.get("default_database"))
+        .is_some_and(|v| matches!(v, Json::Bool(true)));
+    Json::Object(vec![
+        ("default_adapter".to_string(), default_adapter),
+        ("default_database".to_string(), Json::Bool(default_database)),
+        ("persistence".to_string(), Json::Array(persistence(entry))),
+    ])
+}
+
+fn persistence(entry: Option<&Json>) -> Vec<Json> {
+    let bindings = entry
+        .and_then(|w| w.get("bindings"))
+        .map_or(&[][..], Json::each);
+    bindings
+        .iter()
+        .filter(|b| b.get("verb").and_then(Json::as_str) == Some("persisted_by"))
+        .map(|b| {
+            Json::Object(vec![
+                (
+                    "adapter".to_string(),
+                    b.get("adapter").cloned().unwrap_or(Json::Null),
+                ),
+                (
+                    "settings".to_string(),
+                    b.get("settings")
+                        .cloned()
+                        .unwrap_or(Json::Array(Vec::new())),
+                ),
+            ])
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn parsed(text: &str) -> Json {
+        Json::parse(text).expect("fixture json")
+    }
+
+    #[test]
+    fn fact_keeps_only_persisted_by_bindings_and_the_defaults() {
+        let entry = parsed(
+            r#"{"domain":"C","default_adapter":"PostgresEra","default_database":true,"bindings":[
+              {"verb":"persisted_by","adapter":"PostgresEra","settings":["allow_superuser"]},
+              {"verb":"deployed_to","adapter":"AwsLambda","settings":["region"]}]}"#,
+        );
+        let got = fact(Some(&entry));
+        assert_eq!(
+            got.get("default_adapter").and_then(Json::as_str),
+            Some("PostgresEra")
+        );
+        assert_eq!(got.get("persistence").map(|p| p.each().len()), Some(1));
+        assert!(matches!(
+            got.get("default_database"),
+            Some(Json::Bool(true))
+        ));
+    }
+
+    #[test]
+    fn fact_for_a_missing_domain_is_empty_not_absent() {
+        let got = fact(None);
+        assert!(matches!(got.get_raw("default_adapter"), Some(Json::Null)));
+        assert_eq!(got.get("persistence").map(|p| p.each().len()), Some(0));
+    }
+}

data/rust/clippy.toml

@@ -0,0 +1,4 @@
+# The restriction lints (unwrap, expect, panic) guard library code; a test panics to fail.
+allow-unwrap-in-tests = true
+allow-expect-in-tests = true
+allow-panic-in-tests = true

data/rust/codegen/Cargo.toml

@@ -18,3 +18,39 @@ path = "src/main.rs"
 # Debug info is off: CI binaries are run once and never attached to a debugger.
 [profile.dev]
 debug = 0
+
+# Clippy beyond its defaults: pedantic and nursery, plus the restriction lints that keep a panic
+# out of library code. `hecks gate_run.gate stage=ci only=rust_clippy` makes each of these an error.
+# The same table is in every crate's Cargo.toml; change them together.
+[lints.clippy]
+pedantic = { level = "warn", priority = -1 }
+nursery = { level = "warn", priority = -1 }
+unwrap_used = "warn"
+expect_used = "warn"
+panic = "warn"
+dbg_macro = "warn"
+todo = "warn"
+unimplemented = "warn"
+# Lints that ask for prose or an attribute on every item rather than for better code.
+missing_errors_doc = "allow"
+missing_panics_doc = "allow"
+must_use_candidate = "allow"
+return_self_not_must_use = "allow"
+module_name_repetitions = "allow"
+too_many_lines = "allow"
+too_long_first_doc_paragraph = "allow"
+doc_markdown = "allow"
+# Numeric conversions here are deliberate: JSON numbers are f64 and ids are small.
+cast_possible_truncation = "allow"
+cast_possible_wrap = "allow"
+cast_precision_loss = "allow"
+cast_sign_loss = "allow"
+# Naming heuristics that fire on ordinary short names.
+similar_names = "allow"
+many_single_char_names = "allow"
+struct_field_names = "allow"
+# Heuristics that cost more clarity than they buy here.
+redundant_pub_crate = "allow"
+future_not_send = "allow"
+significant_drop_tightening = "allow"
+match_same_arms = "allow"

data/rust/codegen/clippy.toml

@@ -0,0 +1,4 @@
+# The restriction lints (unwrap, expect, panic) guard library code; a test panics to fail.
+allow-unwrap-in-tests = true
+allow-expect-in-tests = true
+allow-panic-in-tests = true

data/rust/codegen/src/asks.rs

@@ -2,8 +2,8 @@
 //! mirroring `Hecks::Bluebook::AskResolution`: by the event's aggregate and the ask's name, with
 //! `chosen` (`ask_via`) breaking a tie between ports.
 
+use crate::hecks_naming;
 use crate::json::Json;
-use crate::naming;
 
 /// Policies whose `ask` is replaced by the `Aggregate::Port.Operation` trigger it resolves to,
 /// so every table below reads the verb as it reads a port-naming `trigger`.
@@ -26,14 +26,23 @@ fn with_trigger(policy: &Json, verb: String) -> Json {
     resolved
 }
 
+#[allow(
+    clippy::panic,
+    reason = "a drifted exemplar or invalid IR aborts generation on purpose"
+)]
 fn resolve(policy: &Json, ask: &str, aggregates: &[Json]) -> String {
     let name = policy.get("name").map(Json::to_s).unwrap_or_default();
     let on_event = policy.get("on_event").map(Json::to_s).unwrap_or_default();
-    let aggregate = event_aggregate(&on_event, aggregates)
-        .unwrap_or_else(|| panic!("policy {name}: ask :{ask} reacts to {on_event:?}, whose aggregate is not declared"));
+    let aggregate = event_aggregate(&on_event, aggregates).unwrap_or_else(|| {
+        panic!("policy {name}: ask :{ask} reacts to {on_event:?}, whose aggregate is not declared")
+    });
     let agg_name = aggregate.get("name").map(Json::to_s).unwrap_or_default();
     let mut found = candidates(aggregate, ask);
-    if found.len() > 1 && found.iter().any(|(_, op)| op.get("chosen").is_some_and(Json::as_bool)) {
+    if found.len() > 1
+        && found
+            .iter()
+            .any(|(_, op)| op.get("chosen").is_some_and(Json::as_bool))
+    {
         found.retain(|(_, op)| op.get("chosen").is_some_and(Json::as_bool));
     }
     match found.as_slice() {
@@ -45,13 +54,16 @@ fn resolve(policy: &Json, ask: &str, aggregates: &[Json]) -> String {
 
 // The aggregate the event is qualified with, or else the one whose commands emit the bare event.
 fn event_aggregate<'a>(on_event: &str, aggregates: &'a [Json]) -> Option<&'a Json> {
-    let named = |wanted: &str| aggregates.iter().find(|a| a.get("name").map(Json::to_s).unwrap_or_default() == wanted);
+    let named = |wanted: &str| {
+        aggregates
+            .iter()
+            .find(|a| a.get("name").map(Json::to_s).unwrap_or_default() == wanted)
+    };
     match on_event.split_once('.') {
         Some((qualifier, _)) => named(qualifier.rsplit("::").next().unwrap_or(qualifier)),
         None => aggregates.iter().find(|a| {
             a.get("commands")
-                .map(Json::each)
-                .unwrap_or(&[])
+                .map_or_default(Json::each)
                 .iter()
                 .any(|c| c.get("emits").map(Json::to_s).unwrap_or_default() == on_event)
         }),
@@ -61,11 +73,11 @@ fn event_aggregate<'a>(on_event: &str, aggregates: &'a [Json]) -> Option<&'a Jso
 // Every outbound operation of the aggregate's ports whose snake-cased name is the ask.
 fn candidates<'a>(aggregate: &'a Json, ask: &str) -> Vec<(String, &'a Json)> {
     let mut found = Vec::new();
-    for port in aggregate.get("ports").map(Json::each).unwrap_or(&[]) {
+    for port in aggregate.get("ports").map_or_default(Json::each) {
         let port_name = port.get("name").map(Json::to_s).unwrap_or_default();
-        for op in port.get("operations").map(Json::each).unwrap_or(&[]) {
+        for op in port.get("operations").map_or_default(Json::each) {
             let outbound = op.get("direction").map(Json::to_s).as_deref() == Some("outbound");
-            let spelled = naming::snake(&op.get("name").map(Json::to_s).unwrap_or_default());
+            let spelled = hecks_naming::snake(&op.get("name").map(Json::to_s).unwrap_or_default());
             if outbound && spelled == ask {
                 found.push((port_name.clone(), op));
             }
@@ -82,7 +94,9 @@ mod tests {
     // The neutral corpus fixture `spec/corpus/asks/errand.json`: the Ruby spec holds the same
     // `targets` against the Ruby runtime's reaction log, so the two cannot drift.
     fn corpus(name: &str) -> Json {
-        let path = PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../spec/corpus/asks").join(name);
+        let path = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .join("../../spec/corpus/asks")
+            .join(name);
         Json::parse(&std::fs::read_to_string(path).expect("corpus file")).expect("corpus json")
     }
 
@@ -91,12 +105,24 @@ mod tests {
         let ir = corpus("errand.ir.json");
         let expect = corpus("errand.json");
         let domain = ir.get("name").map(Json::to_s).unwrap_or_default();
-        let resolved = resolve_asks(ir.get("policies").unwrap().each(), ir.get("aggregates").unwrap().each());
+        let resolved = resolve_asks(
+            ir.get("policies").unwrap().each(),
+            ir.get("aggregates").unwrap().each(),
+        );
 
         for policy in &resolved {
             let name = policy.get("name").map(Json::to_s).unwrap_or_default();
-            let target = format!("{domain}::{}", policy.get("trigger_command").map(Json::to_s).unwrap_or_default());
-            let frozen = expect.get("targets").and_then(|t| t.get(&name)).map(Json::to_s);
+            let target = format!(
+                "{domain}::{}",
+                policy
+                    .get("trigger_command")
+                    .map(Json::to_s)
+                    .unwrap_or_default()
+            );
+            let frozen = expect
+                .get("targets")
+                .and_then(|t| t.get(&name))
+                .map(Json::to_s);
             assert_eq!(frozen, Some(target), "{name}");
         }
     }

data/rust/codegen/src/attr.rs

@@ -12,11 +12,11 @@ pub fn type_name(attr: &Json) -> &str {
 }
 
 pub fn list(attr: &Json) -> bool {
-    attr.get("list").map(Json::as_bool).unwrap_or(false)
+    attr.get("list").is_some_and(Json::as_bool)
 }
 
 pub fn optional(attr: &Json) -> bool {
-    attr.get("optional").map(Json::as_bool).unwrap_or(false)
+    attr.get("optional").is_some_and(Json::as_bool)
 }
 
 pub fn default(attr: &Json) -> Option<&Json> {