hecks 3.13.0 → 4.0.0

data/rust/codegen/src/prelude.rs

@@ -3,86 +3,151 @@
 
 use crate::exemplar::Exemplar;
 use crate::json::Json;
+use crate::shared::{lifecycle_extra_field, puts_blank, puts_str};
 use crate::{json_codec, types};
 use std::collections::HashMap;
 
-// Mirrors Ruby's `puts`: appends "\n" only when the string does not already end in one.
-fn puts_str(out: &mut String, s: &str) {
-    out.push_str(s);
-    if !s.ends_with('\n') {
-        out.push('\n');
-    }
-}
-
-fn puts_blank(out: &mut String) {
-    out.push('\n');
-}
-
-fn lifecycle_extra_field(node: &Json) -> Vec<(String, String)> {
-    match node.get("lifecycle") {
-        None => vec![],
-        Some(lifecycle) => {
-            let field = lifecycle.get("field").and_then(Json::as_str).unwrap_or("");
-            let ident = crate::naming::rust_ident_field(field);
-            vec![(crate::naming::rust_field(field), format!("crate::kernel::Json::Str(self.{ident}.clone())"))]
-        }
-    }
-}
-
 /// One aggregate's prelude text, or `None` when the aggregate has unsupported attribute
 /// types and no `.rs` file is generated for it.
-pub fn aggregate_prelude(exemplar: &Exemplar, ir: &Json, aggregate: &Json, source_label: &str) -> Option<String> {
-    let value_objects = aggregate.get("value_objects").map(Json::each).unwrap_or(&[]);
-    let value_objects_by_name: HashMap<String, &Json> = value_objects.iter().map(|vo| (vo.get("name").and_then(Json::as_str).unwrap_or("").to_string(), vo)).collect();
+pub fn aggregate_prelude(
+    exemplar: &Exemplar,
+    ir: &Json,
+    aggregate: &Json,
+    source_label: &str,
+) -> Option<String> {
+    let value_objects = aggregate.get("value_objects").map_or_default(Json::each);
+    let value_objects_by_name: HashMap<String, &Json> = value_objects
+        .iter()
+        .map(|vo| {
+            (
+                vo.get("name")
+                    .and_then(Json::as_str)
+                    .unwrap_or("")
+                    .to_string(),
+                vo,
+            )
+        })
+        .collect();
 
     if !types::unsupported_attribute_types(aggregate, &value_objects_by_name).is_empty() {
         return None;
     }
 
-    let aggregates_by_name: HashMap<String, &Json> = ir.get("aggregates").map(Json::each).unwrap_or(&[]).iter().map(|a| (a.get("name").and_then(Json::as_str).unwrap_or("").to_string(), a)).collect();
+    let aggregates_by_name: HashMap<String, &Json> = ir
+        .get("aggregates")
+        .map_or_default(Json::each)
+        .iter()
+        .map(|a| {
+            (
+                a.get("name")
+                    .and_then(Json::as_str)
+                    .unwrap_or("")
+                    .to_string(),
+                a,
+            )
+        })
+        .collect();
 
     let mut out = String::new();
-    puts_str(&mut out, &format!("// GENERATED by hecks project_rust from {source_label}'s canonical IR."));
-    puts_str(&mut out, "// Do not hand-edit — re-run hecks project_rust instead.");
+    puts_str(
+        &mut out,
+        &format!("// GENERATED by hecks project_rust from {source_label}'s canonical IR."),
+    );
+    puts_str(
+        &mut out,
+        "// Do not hand-edit — re-run hecks project_rust instead.",
+    );
     puts_str(&mut out, "#![allow(dead_code, unused_variables)]");
     puts_str(&mut out, "use crate::kernel::Expr;");
     puts_blank(&mut out);
 
     for vo in value_objects {
-        puts_str(&mut out, &types::emit_value_object(exemplar, vo, &value_objects_by_name, &aggregates_by_name));
+        puts_str(
+            &mut out,
+            &types::emit_value_object(exemplar, vo, &value_objects_by_name, &aggregates_by_name),
+        );
         puts_blank(&mut out);
 
-        let closed_set = vo.get("closed_set").map(Json::as_bool).unwrap_or(false);
-        let attrs = vo.get("attributes").map(Json::each).unwrap_or(&[]);
+        let closed_set = vo.get("closed_set").is_some_and(Json::as_bool);
+        let attrs = vo.get("attributes").map_or_default(Json::each);
         if closed_set && attrs.len() == 1 {
             puts_str(&mut out, &json_codec::emit_closed_set_codec(exemplar, vo));
         } else if closed_set {
-            puts_str(&mut out, &json_codec::emit_closed_set_table_codec(exemplar, vo));
+            puts_str(
+                &mut out,
+                &json_codec::emit_closed_set_table_codec(exemplar, vo),
+            );
         } else {
-            let name = crate::naming::rust_ident(vo.get("name").and_then(Json::as_str).unwrap_or(""));
-            puts_str(&mut out, &json_codec::emit_to_json_flat(exemplar, &name, attrs, &value_objects_by_name, false, &[], None));
+            let name =
+                crate::naming::rust_ident(vo.get("name").and_then(Json::as_str).unwrap_or(""));
+            puts_str(
+                &mut out,
+                &json_codec::emit_to_json_flat(exemplar, &name, attrs, false, &[], None),
+            );
             puts_blank(&mut out);
-            puts_str(&mut out, &json_codec::emit_from_json_flat(exemplar, &name, attrs, &value_objects_by_name, None, None, false, false, None));
+            puts_str(
+                &mut out,
+                &json_codec::emit_from_json_flat(
+                    exemplar,
+                    &name,
+                    attrs,
+                    &value_objects_by_name,
+                    None,
+                    None,
+                    false,
+                    false,
+                    None,
+                    None,
+                ),
+            );
         }
         puts_blank(&mut out);
     }
 
-    for entity in aggregate.get("entities").map(Json::each).unwrap_or(&[]) {
-        puts_str(&mut out, &types::emit_entity(exemplar, entity, &value_objects_by_name));
+    for entity in aggregate.get("entities").map_or_default(Json::each) {
+        puts_str(
+            &mut out,
+            &types::emit_entity(exemplar, entity, &value_objects_by_name),
+        );
         puts_blank(&mut out);
 
-        let entity_name = crate::naming::rust_ident(entity.get("name").and_then(Json::as_str).unwrap_or(""));
-        let entity_attrs = entity.get("attributes").map(Json::each).unwrap_or(&[]);
+        let entity_name =
+            crate::naming::rust_ident(entity.get("name").and_then(Json::as_str).unwrap_or(""));
+        let entity_attrs = entity.get("attributes").map_or_default(Json::each);
         let extra = lifecycle_extra_field(entity);
-        puts_str(&mut out, &json_codec::emit_to_json_flat(exemplar, &entity_name, entity_attrs, &value_objects_by_name, false, &extra, None));
+        puts_str(
+            &mut out,
+            &json_codec::emit_to_json_flat(
+                exemplar,
+                &entity_name,
+                entity_attrs,
+                false,
+                &extra,
+                None,
+            ),
+        );
         puts_blank(&mut out);
-        puts_str(&mut out, &json_codec::emit_from_json_state(exemplar, &entity_name, entity_attrs, &value_objects_by_name, false, &extra, None));
+        puts_str(
+            &mut out,
+            &json_codec::emit_from_json_state(
+                exemplar,
+                &entity_name,
+                entity_attrs,
+                &value_objects_by_name,
+                false,
+                &extra,
+                None,
+            ),
+        );
         puts_blank(&mut out);
 
         if json_codec::extract_id_supported(entity) {
             puts_str(&mut out, &json_codec::emit_extract_id(exemplar, entity));
             puts_blank(&mut out);
-            puts_str(&mut out, &json_codec::emit_extract_id_lenient(exemplar, entity));
+            puts_str(
+                &mut out,
+                &json_codec::emit_extract_id_lenient(exemplar, entity),
+            );
             puts_blank(&mut out);
             puts_str(&mut out, &json_codec::emit_extract_wants(exemplar, entity));
             puts_blank(&mut out);
@@ -91,19 +156,44 @@ pub fn aggregate_prelude(exemplar: &Exemplar, ir: &Json, aggregate: &Json, sourc
         }
     }
 
-    puts_str(&mut out, &types::emit_record(exemplar, aggregate, &value_objects_by_name));
+    puts_str(
+        &mut out,
+        &types::emit_record(exemplar, aggregate, &value_objects_by_name),
+    );
     puts_blank(&mut out);
 
-    let record_name = crate::naming::rust_ident(aggregate.get("name").and_then(Json::as_str).unwrap_or(""));
-    let record_attrs = aggregate.get("attributes").map(Json::each).unwrap_or(&[]);
+    let record_name =
+        crate::naming::rust_ident(aggregate.get("name").and_then(Json::as_str).unwrap_or(""));
+    let record_attrs = aggregate.get("attributes").map_or_default(Json::each);
     let extra = lifecycle_extra_field(aggregate);
-    puts_str(&mut out, &json_codec::emit_to_json_flat(exemplar, &record_name, record_attrs, &value_objects_by_name, true, &extra, Some(aggregate)));
+    puts_str(
+        &mut out,
+        &json_codec::emit_to_json_flat(
+            exemplar,
+            &record_name,
+            record_attrs,
+            true,
+            &extra,
+            Some(aggregate),
+        ),
+    );
     puts_blank(&mut out);
-    puts_str(&mut out, &json_codec::emit_from_json_state(exemplar, &record_name, record_attrs, &value_objects_by_name, true, &extra, Some(aggregate)));
+    puts_str(
+        &mut out,
+        &json_codec::emit_from_json_state(
+            exemplar,
+            &record_name,
+            record_attrs,
+            &value_objects_by_name,
+            true,
+            &extra,
+            Some(aggregate),
+        ),
+    );
     puts_blank(&mut out);
     puts_str(
         &mut out,
-        &format!("impl crate::kernel::ToJson for {record_name} {{\n    fn to_json(&self) -> crate::kernel::Json {{\n        {record_name}::to_json(self)\n    }}\n}}\n"),
+        &format!("impl crate::kernel::ToJson for {record_name} {{\n    fn to_json(&self) -> crate::kernel::Json {{\n        Self::to_json(self)\n    }}\n}}\n"),
     );
     puts_blank(&mut out);