hecks 3.13.0 → 4.0.0

data/rust/codegen/src/reactions.rs

@@ -8,7 +8,7 @@ use crate::registry::AggregateEntry;
 
 pub fn policy_event_qualifier(on_event: &str) -> Option<String> {
     if on_event.contains('.') {
-        Some(on_event.splitn(2, '.').next().unwrap_or("").to_string())
+        Some(on_event.split('.').next().unwrap_or("").to_string())
     } else {
         None
     }
@@ -16,13 +16,18 @@ pub fn policy_event_qualifier(on_event: &str) -> Option<String> {
 
 pub fn policy_event_name(on_event: &str) -> String {
     if on_event.contains('.') {
-        on_event.splitn(2, '.').nth(1).unwrap_or("").to_string()
+        on_event.split_once('.').map_or("", |x| x.1).to_string()
     } else {
         on_event.to_string()
     }
 }
 
-pub fn emit_policy_table(exemplar: &Exemplar, domain_name: &str, policies: &[Json], aggregates: &[Json]) -> String {
+pub fn emit_policy_table(
+    exemplar: &Exemplar,
+    domain_name: &str,
+    policies: &[Json],
+    aggregates: &[Json],
+) -> String {
     let fns = where_fns(policies);
     let rows = local_policy_rows(domain_name, policies, aggregates);
     let table = exemplar.render(
@@ -38,7 +43,12 @@ pub fn emit_policy_table(exemplar: &Exemplar, domain_name: &str, policies: &[Jso
 
 // A policy's `where { … }` becomes a generated function the kernel calls.
 fn where_fn_name(policy: &Json) -> String {
-    format!("where_{}", naming::dispatch_fn_name(&naming::rust_ident(&policy.get("name").map(Json::to_s).unwrap_or_default())))
+    format!(
+        "where_{}",
+        naming::dispatch_fn_name(&naming::rust_ident(
+            &policy.get("name").map(Json::to_s).unwrap_or_default()
+        ))
+    )
 }
 
 fn where_expr(policy: &Json) -> String {
@@ -48,13 +58,28 @@ fn where_expr(policy: &Json) -> String {
     }
 }
 
+#[allow(
+    clippy::panic,
+    reason = "a drifted exemplar or invalid IR aborts generation on purpose"
+)]
 fn where_fns(policies: &[Json]) -> Vec<String> {
     policies
         .iter()
-        .filter(|policy| policy.get("where").map(Json::to_s).map(|w| !w.is_empty()).unwrap_or(false))
+        .filter(|policy| {
+            policy
+                .get("where")
+                .map(Json::to_s)
+                .is_some_and(|w| !w.is_empty())
+        })
         .map(|policy| {
-            let ast = policy.get("where_ast").unwrap_or_else(|| panic!("policy with a where has no where_ast: {policy:?}"));
-            format!("fn {}() -> crate::kernel::Expr {{\n    use crate::kernel::Expr;\n    {}\n}}", where_fn_name(policy), crate::expr_emitter::emit_ast(ast))
+            let ast = policy
+                .get("where_ast")
+                .unwrap_or_else(|| panic!("policy with a where has no where_ast: {policy:?}"));
+            format!(
+                "fn {}() -> crate::kernel::Expr {{\n    use crate::kernel::Expr;\n    {}\n}}",
+                where_fn_name(policy),
+                crate::expr_emitter::emit_ast(ast)
+            )
         })
         .collect()
 }
@@ -63,7 +88,7 @@ fn local_policy_rows(domain_name: &str, policies: &[Json], aggregates: &[Json])
     crate::asks::resolve_asks(policies, aggregates)
         .iter()
         .filter_map(|policy| {
-            let target_domain = policy.get("target_domain").map(Json::to_s).unwrap_or_else(|| domain_name.to_string());
+            let target_domain = policy.get("target_domain").map_or_else(|| domain_name.to_string(), Json::to_s);
             if target_domain != domain_name {
                 return None;
             }
@@ -71,10 +96,7 @@ fn local_policy_rows(domain_name: &str, policies: &[Json], aggregates: &[Json])
             let on_event = policy.get("on_event").map(Json::to_s).unwrap_or_default();
             let event_name = policy_event_name(&on_event);
             let qualifier = policy_event_qualifier(&on_event);
-            let qualifier_expr = match qualifier {
-                Some(q) => format!("Some({})", naming::ruby_inspect_string(&q)),
-                None => "None".to_string(),
-            };
+            let qualifier_expr = qualifier.map_or_else(|| "None".to_string(), |q| format!("Some({})", naming::ruby_inspect_string(&q)));
             let target_verb = format!("{target_domain}::{}", policy.get("trigger_command").map(Json::to_s).unwrap_or_default());
             let name = policy.get("name").map(Json::to_s).unwrap_or_default();
 
@@ -97,7 +119,7 @@ fn cross_domain_policy_rows(domain_name: &str, policies: &[Json]) -> Vec<String>
     policies
         .iter()
         .filter_map(|policy| {
-            let target_domain = policy.get("target_domain").map(Json::to_s).unwrap_or_else(|| domain_name.to_string());
+            let target_domain = policy.get("target_domain").map_or_else(|| domain_name.to_string(), Json::to_s);
             if target_domain == domain_name {
                 return None;
             }
@@ -105,10 +127,7 @@ fn cross_domain_policy_rows(domain_name: &str, policies: &[Json]) -> Vec<String>
             let on_event = policy.get("on_event").map(Json::to_s).unwrap_or_default();
             let event_name = policy_event_name(&on_event);
             let qualifier = policy_event_qualifier(&on_event);
-            let qualifier_expr = match qualifier {
-                Some(q) => format!("Some({})", naming::ruby_inspect_string(&q)),
-                None => "None".to_string(),
-            };
+            let qualifier_expr = qualifier.map_or_else(|| "None".to_string(), |q| format!("Some({})", naming::ruby_inspect_string(&q)));
             let target_verb = format!("{target_domain}::{}", policy.get("trigger_command").map(Json::to_s).unwrap_or_default());
             let name = policy.get("name").map(Json::to_s).unwrap_or_default();
 
@@ -124,7 +143,11 @@ fn cross_domain_policy_rows(domain_name: &str, policies: &[Json]) -> Vec<String>
         .collect()
 }
 
-pub fn emit_cross_domain_policy_table(exemplar: &Exemplar, domain_name: &str, policies: &[Json]) -> String {
+pub fn emit_cross_domain_policy_table(
+    exemplar: &Exemplar,
+    domain_name: &str,
+    policies: &[Json],
+) -> String {
     let rows = cross_domain_policy_rows(domain_name, policies);
 
     if !rows.is_empty() {
@@ -153,8 +176,16 @@ pub struct PolicySource<'a> {
 /// Each source's `target_verb` is qualified against its own domain, never the target's;
 /// omitting a chapter's policies would leave them out of the table `kernel::orchestrate` reads.
 pub fn emit_merged_policy_table(exemplar: &Exemplar, sources: &[PolicySource]) -> String {
-    let rows: Vec<String> = sources.iter().flat_map(|source| local_policy_rows(source.domain_name, source.policies, source.aggregates)).collect();
-    let fns: Vec<String> = sources.iter().flat_map(|source| where_fns(source.policies)).collect();
+    let rows: Vec<String> = sources
+        .iter()
+        .flat_map(|source| {
+            local_policy_rows(source.domain_name, source.policies, source.aggregates)
+        })
+        .collect();
+    let fns: Vec<String> = sources
+        .iter()
+        .flat_map(|source| where_fns(source.policies))
+        .collect();
 
     let table = exemplar.render(
         "policy_table",
@@ -168,8 +199,14 @@ pub fn emit_merged_policy_table(exemplar: &Exemplar, sources: &[PolicySource]) -
 }
 
 /// The cross-domain policy table for `merged.rs`, folding in every attached chapter.
-pub fn emit_merged_cross_domain_policy_table(exemplar: &Exemplar, sources: &[PolicySource]) -> String {
-    let rows: Vec<String> = sources.iter().flat_map(|source| cross_domain_policy_rows(source.domain_name, source.policies)).collect();
+pub fn emit_merged_cross_domain_policy_table(
+    exemplar: &Exemplar,
+    sources: &[PolicySource],
+) -> String {
+    let rows: Vec<String> = sources
+        .iter()
+        .flat_map(|source| cross_domain_policy_rows(source.domain_name, source.policies))
+        .collect();
 
     if !rows.is_empty() {
         println!("cross-domain policy table: {} row(s) — delivered by rust/host's lambda_client.rs, not locally dispatched", rows.len());
@@ -189,18 +226,36 @@ fn with_value_parsed(raw: &str) -> Literal {
 }
 
 // Renders a parsed `with:` literal as a Rust expression building the equivalent `Json`.
+#[allow(
+    clippy::panic,
+    reason = "a drifted exemplar or invalid IR aborts generation on purpose"
+)]
 fn json_literal_expr(value: &Literal) -> String {
     match value {
         Literal::Hash(pairs) => {
-            let fields: Vec<String> = pairs.iter().map(|(k, v)| format!("({}.to_string(), {})", naming::ruby_inspect_string(k), json_literal_expr(v))).collect();
+            let fields: Vec<String> = pairs
+                .iter()
+                .map(|(k, v)| {
+                    format!(
+                        "({}.to_string(), {})",
+                        naming::ruby_inspect_string(k),
+                        json_literal_expr(v)
+                    )
+                })
+                .collect();
             format!("crate::kernel::Json::Object(vec![{}])", fields.join(", "))
         }
-        Literal::Str(s) => format!("crate::kernel::Json::Str({}.to_string())", naming::ruby_inspect_string(s)),
+        Literal::Str(s) => format!(
+            "crate::kernel::Json::Str({}.to_string())",
+            naming::ruby_inspect_string(s)
+        ),
         Literal::Int(n) => format!("crate::kernel::Json::int({n})"),
         Literal::Float(n) => format!("crate::kernel::Json::Num({}f64, None)", ruby_float_text(*n)),
         Literal::Bool(b) => format!("crate::kernel::Json::Bool({b})"),
         Literal::Nil => "crate::kernel::Json::Null".to_string(),
-        other => panic!("unsupported with: literal {other:?} — json_literal_expr doesn't cover this shape"),
+        other => panic!(
+            "unsupported with: literal {other:?} — json_literal_expr doesn't cover this shape"
+        ),
     }
 }
 
@@ -216,20 +271,29 @@ fn ruby_float_text(n: f64) -> String {
 // `compensates` (saga compensation) recurses one level; a compensation is not itself
 // compensable, so the recursion ends after one extra call.
 fn emit_dispatch_spec(exemplar: &Exemplar, spec: &Json, literal_fns: &mut Vec<String>) -> String {
-    let with_spec = spec.get("with_spec").map(Json::each).unwrap_or(&[]);
+    let with_spec = spec.get("with_spec").map_or_default(Json::each);
     let with_pairs: Vec<String> = with_spec
         .iter()
         .map(|pair| {
             let kv = pair.as_array().unwrap_or(&[]);
             let key = kv.first().map(Json::to_s).unwrap_or_default();
             let raw = kv.get(1).map(Json::to_s).unwrap_or_default();
-            format!("({}, {})", naming::ruby_inspect_string(&key), emit_with_value(exemplar, &raw, literal_fns))
+            format!(
+                "({}, {})",
+                naming::ruby_inspect_string(&key),
+                emit_with_value(exemplar, &raw, literal_fns)
+            )
         })
         .collect();
-    let compensates = match spec.get("compensates") {
-        Some(nested) => format!("Some(&{})", emit_dispatch_spec(exemplar, nested, literal_fns)),
-        None => "None".to_string(),
-    };
+    let compensates = spec.get("compensates").map_or_else(
+        || "None".to_string(),
+        |nested| {
+            format!(
+                "Some(&{})",
+                emit_dispatch_spec(exemplar, nested, literal_fns)
+            )
+        },
+    );
     format!(
         "crate::kernel::DispatchSpec {{ command_name: {}, with: &[{}], compensates: {} }}",
         naming::ruby_inspect_string(&spec.get("command_name").map(Json::to_s).unwrap_or_default()),
@@ -243,17 +307,29 @@ fn emit_dispatch_spec(exemplar: &Exemplar, spec: &Json, literal_fns: &mut Vec<St
 fn emit_with_value(exemplar: &Exemplar, raw: &str, literal_fns: &mut Vec<String>) -> String {
     let parsed = with_value_parsed(raw);
     if let Literal::Symbol(name) = &parsed {
-        return format!("crate::kernel::WithValue::Ref({})", naming::ruby_inspect_string(name));
+        return format!(
+            "crate::kernel::WithValue::Ref({})",
+            naming::ruby_inspect_string(name)
+        );
     }
 
     let fn_name = format!("pm_literal_{}", literal_fns.len());
-    literal_fns.push(exemplar.render("with_value_literal_fn", &[("tmpl_literal_fn", fn_name.clone()), ("tmpl_body_placeholder()", json_literal_expr(&parsed))]));
+    literal_fns.push(exemplar.render(
+        "with_value_literal_fn",
+        &[
+            ("tmpl_literal_fn", fn_name.clone()),
+            ("tmpl_body_placeholder()", json_literal_expr(&parsed)),
+        ],
+    ));
     format!("crate::kernel::WithValue::Literal({fn_name})")
 }
 
 fn emit_handler(exemplar: &Exemplar, handler: &Json, literal_fns: &mut Vec<String>) -> String {
-    let dispatches = handler.get("dispatches").map(Json::each).unwrap_or(&[]);
-    let dispatch_strs: Vec<String> = dispatches.iter().map(|d| emit_dispatch_spec(exemplar, d, literal_fns)).collect();
+    let dispatches = handler.get("dispatches").map_or_default(Json::each);
+    let dispatch_strs: Vec<String> = dispatches
+        .iter()
+        .map(|d| emit_dispatch_spec(exemplar, d, literal_fns))
+        .collect();
     format!(
         "crate::kernel::Handler {{ event_type: {}, from_state: {}, to_state: {}, dispatches: &[{}] }}",
         naming::ruby_inspect_string(&handler.get("event_type").map(Json::to_s).unwrap_or_default()),
@@ -268,9 +344,9 @@ pub fn emit_process_manager_table(exemplar: &Exemplar, process_managers: &[Json]
     let pm_exprs: Vec<String> = process_managers
         .iter()
         .map(|pm| {
-            let handlers = pm.get("handlers").map(Json::each).unwrap_or(&[]);
+            let handlers = pm.get("handlers").map_or_default(Json::each);
             let handler_strs: Vec<String> = handlers.iter().map(|h| emit_handler(exemplar, h, &mut literal_fns)).collect();
-            let states = pm.get("states").map(Json::each).unwrap_or(&[]);
+            let states = pm.get("states").map_or_default(Json::each);
             let initial_state = states.first().map(Json::to_s).unwrap_or_default();
             format!(
                 "crate::kernel::ProcessManagerDef {{ name: {}, correlates_by: {}, starts_on: {}, ends_on: {}, initial_state: {}, handlers: &[{}] }}",
@@ -303,12 +379,19 @@ pub fn emit_reference_key_table(exemplar: &Exemplar, chapters: &[(String, Vec<St
             aggregate_names.iter().map(move |name| {
                 let qualified = format!("{domain_name}::{name}");
                 let key = crate::hecks_naming::snake(name);
-                format!("        {} => Some({}),", naming::ruby_inspect_string(&qualified), naming::ruby_inspect_string(&key))
+                format!(
+                    "        {} => Some({}),",
+                    naming::ruby_inspect_string(&qualified),
+                    naming::ruby_inspect_string(&key)
+                )
             })
         })
         .collect();
 
-    exemplar.render("reference_key_table", &[("\"tmpl_qualified\" => Some(\"tmpl_key\"),", arms.join("\n"))])
+    exemplar.render(
+        "reference_key_table",
+        &[("\"tmpl_qualified\" => Some(\"tmpl_key\"),", arms.join("\n"))],
+    )
 }
 
 /// Whether each verb creates the record it addresses; `split_routed_args` in
@@ -318,14 +401,24 @@ pub fn emit_creates_table(exemplar: &Exemplar, aggregates: &[AggregateEntry]) ->
     let mut arms: Vec<String> = Vec::new();
     for a in aggregates {
         for c in &a.commands {
-            arms.push(format!("        {} => {},", naming::ruby_inspect_string(&c.verb), c.creates));
+            arms.push(format!(
+                "        {} => {},",
+                naming::ruby_inspect_string(&c.verb),
+                c.creates
+            ));
         }
         for c in &a.entity_commands {
-            arms.push(format!("        {} => false,", naming::ruby_inspect_string(&c.verb)));
+            arms.push(format!(
+                "        {} => false,",
+                naming::ruby_inspect_string(&c.verb)
+            ));
         }
     }
 
-    exemplar.render("creates_table", &[("\"tmpl_verb\" => true,", arms.join("\n"))])
+    exemplar.render(
+        "creates_table",
+        &[("\"tmpl_verb\" => true,", arms.join("\n"))],
+    )
 }
 
 /// The single-component identity head that `orchestrate.rs` routes by first.
@@ -337,18 +430,34 @@ pub fn emit_identity_head_table(exemplar: &Exemplar, aggregates: &[AggregateEntr
             if a.identified_by.len() != 1 {
                 return None;
             }
-            let head = a.identified_by[0].split('.').next().unwrap_or(&a.identified_by[0]);
+            let head = a.identified_by[0]
+                .split('.')
+                .next()
+                .unwrap_or(&a.identified_by[0]);
             let qualified = format!("{}::{}", a.domain_name, a.name);
-            Some(format!("        {} => Some({}),", naming::ruby_inspect_string(&qualified), naming::ruby_inspect_string(head)))
+            Some(format!(
+                "        {} => Some({}),",
+                naming::ruby_inspect_string(&qualified),
+                naming::ruby_inspect_string(head)
+            ))
         })
         .collect();
 
-    exemplar.render("identity_head_table", &[("\"tmpl_qualified\" => Some(\"tmpl_head\"),", arms.join("\n"))])
+    exemplar.render(
+        "identity_head_table",
+        &[(
+            "\"tmpl_qualified\" => Some(\"tmpl_head\"),",
+            arms.join("\n"),
+        )],
+    )
 }
 
 /// Like `emit_identity_head_table`, for an entity's own identity, keyed by
 /// "Domain::Aggregate.Entity". Two-level-deep entity commands deliberately never resolve here.
-pub fn emit_entity_identity_head_table(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> String {
+pub fn emit_entity_identity_head_table(
+    exemplar: &Exemplar,
+    aggregates: &[AggregateEntry],
+) -> String {
     let arms: Vec<String> = aggregates
         .iter()
         .flat_map(|a| {
@@ -356,30 +465,64 @@ pub fn emit_entity_identity_head_table(exemplar: &Exemplar, aggregates: &[Aggreg
                 if e.identified_by.len() != 1 {
                     return None;
                 }
-                let head = e.identified_by[0].split('.').next().unwrap_or(&e.identified_by[0]);
+                let head = e.identified_by[0]
+                    .split('.')
+                    .next()
+                    .unwrap_or(&e.identified_by[0]);
                 let qualified = format!("{}::{}.{}", a.domain_name, a.name, e.name);
-                Some(format!("        {} => Some({}),", naming::ruby_inspect_string(&qualified), naming::ruby_inspect_string(head)))
+                Some(format!(
+                    "        {} => Some({}),",
+                    naming::ruby_inspect_string(&qualified),
+                    naming::ruby_inspect_string(head)
+                ))
             })
         })
         .collect();
 
-    exemplar.render("entity_identity_head_table", &[("\"tmpl_qualified\" => Some(\"tmpl_head\"),", arms.join("\n"))])
+    exemplar.render(
+        "entity_identity_head_table",
+        &[(
+            "\"tmpl_qualified\" => Some(\"tmpl_head\"),",
+            arms.join("\n"),
+        )],
+    )
 }
 
 pub fn emit_command_attributes_table(exemplar: &Exemplar, aggregates: &[AggregateEntry]) -> String {
     let mut arms: Vec<String> = Vec::new();
     for a in aggregates {
         for c in &a.commands {
-            let names = c.attributes.iter().map(|n| naming::ruby_inspect_string(n)).collect::<Vec<_>>().join(", ");
-            arms.push(format!("        {} => &[{}],", naming::ruby_inspect_string(&c.verb), names));
+            let names = c
+                .attributes
+                .iter()
+                .map(|n| naming::ruby_inspect_string(n))
+                .collect::<Vec<_>>()
+                .join(", ");
+            arms.push(format!(
+                "        {} => &[{}],",
+                naming::ruby_inspect_string(&c.verb),
+                names
+            ));
         }
         for c in &a.entity_commands {
-            let names = c.attributes.iter().map(|n| naming::ruby_inspect_string(n)).collect::<Vec<_>>().join(", ");
-            arms.push(format!("        {} => &[{}],", naming::ruby_inspect_string(&c.verb), names));
+            let names = c
+                .attributes
+                .iter()
+                .map(|n| naming::ruby_inspect_string(n))
+                .collect::<Vec<_>>()
+                .join(", ");
+            arms.push(format!(
+                "        {} => &[{}],",
+                naming::ruby_inspect_string(&c.verb),
+                names
+            ));
         }
     }
 
-    exemplar.render("command_attributes_table", &[("\"tmpl_verb\" => &[\"tmpl_attr\"],", arms.join("\n"))])
+    exemplar.render(
+        "command_attributes_table",
+        &[("\"tmpl_verb\" => &[\"tmpl_attr\"],", arms.join("\n"))],
+    )
 }
 
 // Qualifies the bare "Aggregate.query" `for_each` spelling against the policy's own domain
@@ -389,7 +532,11 @@ fn fan_out_verb_expr(domain_name: &str, policy: &Json) -> String {
     if for_each.is_empty() {
         return "None".to_string();
     }
-    let qualified = if for_each.contains("::") { for_each } else { format!("{domain_name}::{for_each}") };
+    let qualified = if for_each.contains("::") {
+        for_each
+    } else {
+        format!("{domain_name}::{for_each}")
+    };
     format!("Some({})", naming::ruby_inspect_string(&qualified))
 }
 
@@ -403,7 +550,10 @@ fn fan_out_key_expr(policy: &Json, aggregates: &[Json]) -> String {
     let path = for_each.split('.').next().unwrap_or_default().to_string();
     let row_aggregate = path.rsplit("::").next().unwrap_or(&path).to_string();
 
-    let trigger = policy.get("trigger_command").map(Json::to_s).unwrap_or_default();
+    let trigger = policy
+        .get("trigger_command")
+        .map(Json::to_s)
+        .unwrap_or_default();
     let mut parts = trigger.splitn(2, '.');
     let target_aggregate = parts.next().unwrap_or_default().to_string();
     let target_command = parts.next().unwrap_or_default().to_string();
@@ -421,14 +571,19 @@ fn fan_out_key_expr(policy: &Json, aggregates: &[Json]) -> String {
         })
         .and_then(|command| addressing_key_for(&command, &row_aggregate));
 
-    match key {
-        Some(name) => format!("Some({})", naming::ruby_inspect_string(&name)),
-        None => "None".to_string(),
-    }
+    key.map_or_else(
+        || "None".to_string(),
+        |name| format!("Some({})", naming::ruby_inspect_string(&name)),
+    )
 }
 
 fn addressing_key_for(command: &Json, aggregate_name: &str) -> Option<String> {
-    if command.get("references").map(Json::to_s).unwrap_or_default() == aggregate_name {
+    if command
+        .get("references")
+        .map(Json::to_s)
+        .unwrap_or_default()
+        == aggregate_name
+    {
         return Some(crate::hecks_naming::snake(aggregate_name));
     }
 
@@ -471,11 +626,14 @@ mod tests {
 
     // Mirrors the fixtures in `spec/rust_project/reactions_merge_spec.rb`; no real corpus
     // domain exercises this merged-chapter shape.
-    fn policy(name: &str, on_event: &str, trigger_command: &str, target_domain: Option<&str>) -> Json {
-        let target_domain_json = match target_domain {
-            Some(domain) => format!("\"{domain}\""),
-            None => "null".to_string(),
-        };
+    fn policy(
+        name: &str,
+        on_event: &str,
+        trigger_command: &str,
+        target_domain: Option<&str>,
+    ) -> Json {
+        let target_domain_json =
+            target_domain.map_or_else(|| "null".to_string(), |domain| format!("\"{domain}\""));
         Json::parse(&format!(
             "{{\"name\":\"{name}\",\"on_event\":\"{on_event}\",\"trigger_command\":\"{trigger_command}\",\
              \"target_domain\":{target_domain_json},\"for_each\":null,\"with_spec\":[]}}"
@@ -487,12 +645,30 @@ mod tests {
     fn merged_policy_table_carries_the_target_and_a_vendored_chapters_own_same_domain_policy() {
         let orders_policies = vec![policy("OnOrderPlaced", "OrderPlaced", "Invoice.Open", None)];
         let payments_policies = vec![
-            policy("OnPaymentConfirmedByProcessor", "PaymentConfirmedByProcessor", "Payment.Succeed", None),
-            policy("OnPaymentFailed", "PaymentFailed", "Ledger.Reverse", Some("Ledger")),
+            policy(
+                "OnPaymentConfirmedByProcessor",
+                "PaymentConfirmedByProcessor",
+                "Payment.Succeed",
+                None,
+            ),
+            policy(
+                "OnPaymentFailed",
+                "PaymentFailed",
+                "Ledger.Reverse",
+                Some("Ledger"),
+            ),
         ];
         let sources = vec![
-            PolicySource { domain_name: "Orders", policies: &orders_policies, aggregates: &[] },
-            PolicySource { domain_name: "Payments", policies: &payments_policies, aggregates: &[] },
+            PolicySource {
+                domain_name: "Orders",
+                policies: &orders_policies,
+                aggregates: &[],
+            },
+            PolicySource {
+                domain_name: "Payments",
+                policies: &payments_policies,
+                aggregates: &[],
+            },
         ];
 
         let table = emit_merged_policy_table(&Exemplar::load(), &sources);
@@ -510,12 +686,30 @@ mod tests {
     fn merged_cross_domain_policy_table_carries_only_a_vendored_chapters_own_cross_domain_policy() {
         let orders_policies = vec![policy("OnOrderPlaced", "OrderPlaced", "Invoice.Open", None)];
         let payments_policies = vec![
-            policy("OnPaymentConfirmedByProcessor", "PaymentConfirmedByProcessor", "Payment.Succeed", None),
-            policy("OnPaymentFailed", "PaymentFailed", "Ledger.Reverse", Some("Ledger")),
+            policy(
+                "OnPaymentConfirmedByProcessor",
+                "PaymentConfirmedByProcessor",
+                "Payment.Succeed",
+                None,
+            ),
+            policy(
+                "OnPaymentFailed",
+                "PaymentFailed",
+                "Ledger.Reverse",
+                Some("Ledger"),
+            ),
         ];
         let sources = vec![
-            PolicySource { domain_name: "Orders", policies: &orders_policies, aggregates: &[] },
-            PolicySource { domain_name: "Payments", policies: &payments_policies, aggregates: &[] },
+            PolicySource {
+                domain_name: "Orders",
+                policies: &orders_policies,
+                aggregates: &[],
+            },
+            PolicySource {
+                domain_name: "Payments",
+                policies: &payments_policies,
+                aggregates: &[],
+            },
         ];
 
         let table = emit_merged_cross_domain_policy_table(&Exemplar::load(), &sources);