hecks 5.0.0 → 7.0.0

data/rust/codegen/src/json_codec.rs

@@ -84,6 +84,78 @@ pub fn scalar_json_accessor(scalar_type: &str) -> &'static str {
     }
 }
 
+/// The refusal for a reference argument offered as anything but an id string, worded as Ruby's
+/// `Value.refuse_object_reference` (`reference_wrong_shape`): an object is "an object", any other
+/// value is described as it arrived. `known_by` is the target's `" (X is known by heads)"` tail.
+/// `" (Target is known by heads)"` for a single reference attribute whose target aggregate is
+/// known, `""` for one whose target lives in another domain (Ruby words that refusal too, with
+/// no tail), or `None` when `attr` is no reference or no aggregates were given.
+fn reference_known_by(
+    attr: &Json,
+    aggregates_by_name: Option<&HashMap<String, &Json>>,
+) -> Option<String> {
+    let target_name = naming::reference_target(crate::attr::type_name(attr))?;
+    let Some(target) = aggregates_by_name?.get(target_name) else {
+        return Some(String::new());
+    };
+    let mut heads: Vec<String> = Vec::new();
+    for path in target.get("identified_by").map_or_default(Json::each) {
+        let head = path.to_s().split('.').next().unwrap_or("").to_string();
+        if !heads.contains(&head) {
+            heads.push(head);
+        }
+    }
+    let known = if heads.is_empty() {
+        String::new()
+    } else {
+        format!(" ({target_name} is known by {})", heads.join(", "))
+    };
+    Some(known)
+}
+
+pub fn reference_shape_error(command: &str, key: &str, known_by: &str, value_var: &str) -> String {
+    format!(
+        "crate::kernel::Refusal::TypeMismatch(crate::kernel::refusal_wording::TypeMismatchReferenceWrongShapeArgs {{ command: {}, attribute: {}, offered: &(if matches!({value_var}, crate::kernel::Json::Object(_)) {{ \"an object\".to_string() }} else {{ {value_var}.describe() }}), known_by: {} }}.render_args())",
+        naming::ruby_inspect_string(command),
+        naming::ruby_inspect_string(key),
+        naming::ruby_inspect_string(known_by),
+    )
+}
+
+/// A required reference argument read as its id string; see `reference_shape_error`.
+pub fn reference_from_json_expr(
+    command: &str,
+    key: &str,
+    known_by: &str,
+    default: Option<&Json>,
+) -> String {
+    let error = reference_shape_error(command, key, known_by, "x");
+    if let Some(default) = default {
+        let default_rhs = naming::literal_rhs(default);
+        return format!(
+            "match v.get({}) {{ Some(x) => x.as_str().map(ToString::to_string).ok_or_else(|| {error})?, None => {default_rhs} }}",
+            naming::ruby_inspect_string(key),
+        );
+    }
+    format!(
+        "{{ let x = {}; x.as_str().map(ToString::to_string).ok_or_else(|| {error})? }}",
+        required_field_expr(command, key, "String"),
+    )
+}
+
+/// An already-fetched optional reference argument read as its id string.
+pub fn reference_from_json_value_expr(
+    command: &str,
+    key: &str,
+    known_by: &str,
+    value_expr: &str,
+) -> String {
+    format!(
+        "{value_expr}.as_str().map(ToString::to_string).ok_or_else(|| {})?",
+        reference_shape_error(command, key, known_by, value_expr)
+    )
+}
+
 pub fn scalar_from_json_expr(
     struct_name: &str,
     key: &str,
@@ -302,13 +374,18 @@ pub fn command_argument_allowlist(
 }
 
 /// `ArgumentGate#refuse_absent_arguments`, generated: every declared non-optional name the JSON
-/// omits, sorted, refuses as `AbsentArgument` before any field is built.
+/// omits, sorted, refuses as `AbsentArgument` before any field is built. An argument with a
+/// `default:` is not required: Ruby fills the default for an omitted one (`fill_defaults`).
 ///
 /// Goes through the site's `<Variant>Args` struct, so leaving an argument out does not compile.
-fn emit_absent_argument_check(command_name: &str, attributes: &[Json]) -> String {
+///
+/// `collect` is for the gate function a dry run reads: with a collector bound it keeps one
+/// refusal per absent name and goes on, for the stage to end; without one it raises, as inline
+/// code does.
+fn emit_absent_argument_check(command_name: &str, attributes: &[Json], collect: bool) -> String {
     let mut required: Vec<String> = attributes
         .iter()
-        .filter(|a| !crate::attr::optional(a))
+        .filter(|a| !crate::attr::optional(a) && crate::attr::default(a).is_none())
         .map(|a| naming::rust_field(crate::attr::name(a)))
         .collect();
     required.sort();
@@ -319,11 +396,24 @@ fn emit_absent_argument_check(command_name: &str, attributes: &[Json]) -> String
         .iter()
         .map(|a| crate::attr::name(a).to_string())
         .collect();
+    let refusal = |names: &str| {
+        format!(
+            "crate::kernel::Refusal::AbsentArgument(crate::kernel::refusal_wording::AbsentArgumentAbsentArgsArgs {{\n        command: {},\n        absent: {names},\n        declared: &[{}],\n    }}.render_args())",
+            naming::ruby_inspect_string(command_name),
+            declared.iter().map(|k| naming::ruby_inspect_string(k)).collect::<Vec<_>>().join(", "),
+        )
+    };
+    let outcome = if collect {
+        format!(
+            "crate::kernel::collecting::refuse_each(&absent, |names| {})?;",
+            refusal("names")
+        )
+    } else {
+        format!("return Err({});", refusal("&absent"))
+    };
     format!(
-        "let required: &[&str] = &[{}];\nlet absent: Vec<&str> = required.iter().copied().filter(|key| v.get(key).is_none()).collect();\nif !absent.is_empty() {{\n    return Err(crate::kernel::Refusal::AbsentArgument(crate::kernel::refusal_wording::AbsentArgumentAbsentArgsArgs {{\n        command: {},\n        absent: &absent,\n        declared: &[{}],\n    }}.render_args()));\n}}\n",
+        "let required: &[&str] = &[{}];\nlet absent: Vec<&str> = required.iter().copied().filter(|key| v.get(key).is_none()).collect();\nif !absent.is_empty() {{\n    {outcome}\n}}\n",
         required.iter().map(|k| naming::ruby_inspect_string(k)).collect::<Vec<_>>().join(", "),
-        naming::ruby_inspect_string(command_name),
-        declared.iter().map(|k| naming::ruby_inspect_string(k)).collect::<Vec<_>>().join(", "),
     )
 }
 
@@ -333,12 +423,26 @@ fn emit_unknown_argument_check(
     command_name: &str,
     known_keys: &[String],
     declared_names: &[String],
+    collect: bool,
 ) -> String {
+    let refusal = |names: &str| {
+        format!(
+            "crate::kernel::Refusal::UnknownArgument(crate::kernel::refusal_wording::UnknownArgumentUnknownArgsArgs {{\n        command: {},\n        unknown: {names},\n        declared: &[{}],\n    }}.render_args())",
+            naming::ruby_inspect_string(command_name),
+            declared_names.iter().map(|k| naming::ruby_inspect_string(k)).collect::<Vec<_>>().join(", "),
+        )
+    };
+    let outcome = if collect {
+        format!(
+            "crate::kernel::collecting::refuse_each(&unknown, |names| {})?;",
+            refusal("names")
+        )
+    } else {
+        format!("return Err({});", refusal("&unknown"))
+    };
     format!(
-        "let unknown = v.unknown_keys(&[{}]);\nif !unknown.is_empty() {{\n    let unknown: Vec<&str> = unknown.iter().map(String::as_str).collect();\n    return Err(crate::kernel::Refusal::UnknownArgument(crate::kernel::refusal_wording::UnknownArgumentUnknownArgsArgs {{\n        command: {},\n        unknown: &unknown,\n        declared: &[{}],\n    }}.render_args()));\n}}\n",
+        "let unknown = v.unknown_keys(&[{}]);\nif !unknown.is_empty() {{\n    let unknown: Vec<&str> = unknown.iter().map(String::as_str).collect();\n    {outcome}\n}}\n",
         known_keys.iter().map(|k| naming::ruby_inspect_string(k)).collect::<Vec<_>>().join(", "),
-        naming::ruby_inspect_string(command_name),
-        declared_names.iter().map(|k| naming::ruby_inspect_string(k)).collect::<Vec<_>>().join(", "),
     )
 }
 
@@ -352,6 +456,7 @@ pub fn unknown_and_absent_argument_checks(
     attributes: &[Json],
     unknown_argument_allowlist: Option<&[String]>,
     absent_argument_check: bool,
+    collect: bool,
 ) -> String {
     let mut check = match unknown_argument_allowlist {
         Some(allowlist) => {
@@ -368,12 +473,16 @@ pub fn unknown_and_absent_argument_checks(
                 .iter()
                 .map(|a| crate::attr::name(a).to_string())
                 .collect();
-            emit_unknown_argument_check(command_name, &known_keys, &declared_names)
+            emit_unknown_argument_check(command_name, &known_keys, &declared_names, collect)
         }
         None => String::new(),
     };
     if absent_argument_check {
-        check.push_str(&emit_absent_argument_check(command_name, attributes));
+        check.push_str(&emit_absent_argument_check(
+            command_name,
+            attributes,
+            collect,
+        ));
     }
     check
 }
@@ -392,10 +501,11 @@ pub fn emit_argument_gates(
             attributes,
             unknown_argument_allowlist,
             false,
+            true,
         ),
         None => String::new(),
     };
-    let absent = emit_absent_argument_check(command_name, attributes);
+    let absent = emit_absent_argument_check(command_name, attributes, true);
 
     format!(
         "impl {struct_name} {{\n{}\n\n{}\n\n{}\n}}\n",
@@ -455,7 +565,14 @@ pub fn emit_from_json_flat(
             let list = crate::attr::list(attr);
             let optional = crate::attr::optional(attr);
 
-            let rhs = if list && optional {
+            let known_by = reference_known_by(attr, aggregates_by_name);
+            let rhs = if let (false, Some(known_by)) = (list, known_by.as_deref()) {
+                if optional {
+                    format!("match v.get({}) {{ Some(crate::kernel::Json::Null) | None => None, Some(x) => Some({}) }}", naming::ruby_inspect_string(&key), reference_from_json_value_expr(command_name, &key, known_by, "x"))
+                } else {
+                    reference_from_json_expr(command_name, &key, known_by, crate::attr::default(attr))
+                }
+            } else if list && optional {
                 let mapper = list_element_from_json_mapper(error_name, &key, attr, value_objects_by_name);
                 let array_error = json_type_error(error_name, &key, "an array");
                 format!(
@@ -478,6 +595,11 @@ pub fn emit_from_json_flat(
                 format!("match v.get({}) {{ Some(crate::kernel::Json::Null) | None => None, Some(x) => Some({}) }}", naming::ruby_inspect_string(&key), composite_from_json_expr(attr, value_objects_by_name, "x"))
             } else if let Some(scalar) = scalar {
                 scalar_from_json_expr(scalar_error_name, &key, scalar, crate::attr::default(attr))
+            } else if let Some(default_rhs) = crate::attr::default(attr).and_then(|_| crate::bridging::creation_default_rhs(attr, value_objects_by_name)) {
+                // A composite argument the caller leaves out takes its declared default, as Ruby's
+                // `fill_defaults` gives it. A null the caller sends is a value, not an omission:
+                // it builds the composite from its own fields, as a required composite does.
+                format!("match v.get({}) {{ None => {default_rhs}, Some(x) => {} }}", naming::ruby_inspect_string(&key), composite_from_json_expr(attr, value_objects_by_name, "x"))
             } else if absent_argument_check {
                 // The argument entry point only; see `required_composite_argument_expr`.
                 required_composite_argument_expr(error_name, &key, attr, value_objects_by_name)
@@ -510,6 +632,7 @@ pub fn emit_from_json_flat(
         attributes,
         unknown_argument_allowlist,
         absent_argument_check,
+        false,
     );
 
     let shorthand_fields = if interleave_checks {
@@ -1014,17 +1137,19 @@ pub fn extract_id_supported(aggregate: &Json) -> bool {
 }
 
 pub fn emit_extract_id(exemplar: &Exemplar, aggregate: &Json) -> String {
-    emit_extract_id_shaped(exemplar, aggregate, "extract_id", "to_id_component")
+    emit_extract_id_shaped(exemplar, aggregate, "extract_id", "to_id_component", true)
 }
 
 /// `extract_id` minted as `extract_id_lenient` on `to_id_component_lenient`; entity addressing
-/// only, never a root aggregate's hydrate.
+/// only, never a root aggregate's hydrate. It reads the entity's declared identity alone, as
+/// Ruby's `EntityElement` does: no `id` or reference-key fallback.
 pub fn emit_extract_id_lenient(exemplar: &Exemplar, entity: &Json) -> String {
     emit_extract_id_shaped(
         exemplar,
         entity,
         "extract_id_lenient",
         "to_id_component_lenient",
+        false,
     )
 }
 
@@ -1033,6 +1158,7 @@ fn emit_extract_id_shaped(
     aggregate: &Json,
     method_name: &str,
     coercion: &str,
+    routing_fallbacks: bool,
 ) -> String {
     let name = naming::rust_ident(aggregate.get("name").and_then(Json::as_str).unwrap_or(""));
     let identified_by: Vec<String> = aggregate
@@ -1071,27 +1197,43 @@ fn emit_extract_id_shaped(
     };
 
     let mut tried = identified_by.clone();
-    tried.push("id".to_string());
-    tried.push(reference_key.clone());
+    if routing_fallbacks {
+        tried.push("id".to_string());
+        tried.push(reference_key.clone());
+    }
     let tried = tried.join(", ");
+    let template = if routing_fallbacks {
+        "extract_id"
+    } else {
+        "extract_id_exact"
+    };
 
+    // The exact shape has no reference-key slot, and its type is its own struct.
+    let type_marker = if routing_fallbacks {
+        "TmplExtractIdType"
+    } else {
+        "TmplExtractExactType"
+    };
+    let mut subs: Vec<(&str, String)> = vec![
+        (type_marker, name.clone()),
+        ("tmpl_extract_id_name", method_name.to_string()),
+    ];
+    if routing_fallbacks {
+        subs.push(("tmpl_id_coercion", coercion.to_string()));
+        subs.push((
+            "\"tmpl_reference_key\"",
+            naming::ruby_inspect_string(&reference_key),
+        ));
+    }
+    subs.push(("tmpl_tier1_join_placeholder()", tier1_join));
+    subs.push((
+        "\"tmpl_error_text\"",
+        naming::ruby_inspect_string(&format!("{name}: no identity found (tried {tried})")),
+    ));
     exemplar.compose(
-        "extract_id",
-        &[
-            ("TmplExtractIdType", name.clone()),
-            ("tmpl_extract_id_name", method_name.to_string()),
-            ("tmpl_id_coercion", coercion.to_string()),
-            (
-                "\"tmpl_reference_key\"",
-                naming::ruby_inspect_string(&reference_key),
-            ),
-            ("tmpl_tier1_join_placeholder()", tier1_join),
-            (
-                "\"tmpl_error_text\"",
-                naming::ruby_inspect_string(&format!("{name}: no identity found (tried {tried})")),
-            ),
-        ],
-        "extract_id:TIER1_LINE",
+        template,
+        &subs,
+        &format!("{template}:TIER1_LINE"),
         &tier1_subs,
         "\n",
     )
@@ -1173,3 +1315,58 @@ pub fn emit_self_identity(exemplar: &Exemplar, entity: &Json) -> String {
         ],
     )
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn argument(name: &str, default: Json) -> Json {
+        Json::Object(vec![
+            ("name".to_string(), Json::String(name.to_string())),
+            ("type".to_string(), Json::String("Integer".to_string())),
+            ("optional".to_string(), Json::Bool(false)),
+            ("default".to_string(), default),
+        ])
+    }
+
+    #[test]
+    fn absent_gate_requires_each_argument_without_a_default_and_no_defaulted_one() {
+        let attributes = vec![
+            argument("key", Json::Null),
+            argument("grace", Json::Number("0".to_string())),
+        ];
+        let gate = emit_absent_argument_check("Reap", &attributes, false);
+        assert!(
+            gate.contains("let required: &[&str] = &[\"key\"];"),
+            "{gate}"
+        );
+    }
+
+    #[test]
+    fn a_reference_to_another_domain_is_worded_as_a_reference_with_no_tail() {
+        let attr = Json::Object(vec![
+            ("name".to_string(), Json::String("parcel".to_string())),
+            (
+                "type".to_string(),
+                Json::String("Reference<Parcel>".to_string()),
+            ),
+        ]);
+        let in_this_domain = HashMap::new();
+        assert_eq!(
+            reference_known_by(&attr, Some(&in_this_domain)),
+            Some(String::new())
+        );
+        assert_eq!(reference_known_by(&attr, None), None);
+    }
+
+    #[test]
+    fn a_reference_argument_refuses_in_the_reference_wrong_shape_wording() {
+        let error = reference_shape_error("Open", "parcel", " (Parcel is known by code)", "x");
+        assert!(
+            error.contains("TypeMismatchReferenceWrongShapeArgs"),
+            "{error}"
+        );
+        assert!(error.contains("\"an object\""), "{error}");
+        assert!(error.contains("\" (Parcel is known by code)\""), "{error}");
+    }
+}

data/rust/codegen/src/main.rs

@@ -23,6 +23,7 @@ mod literal;
 mod manifest;
 mod mutations;
 mod naming;
+mod one_of_references;
 mod optional_pass;
 mod ports;
 mod prelude;
@@ -98,7 +99,7 @@ fn run_prelude(args: &[String]) -> Result<(), String> {
     Ok(())
 }
 
-/// `hecks-codegen domain <ir.json> <source_label> <mod_name> <out_dir>` — writes one chapter's
+/// `hecks-codegen domain <ir.json> <source_label> <mod_name> <out_dir>` — writes one bluebook's
 /// `<aggregate>.rs`, `registry.rs`, `mod.rs`, `manifest.json` and its `ir.json`/`metadata.rs`
 /// sidecars into `out_dir`.
 fn run_domain(args: &[String]) -> Result<(), String> {
@@ -115,7 +116,7 @@ fn run_domain(args: &[String]) -> Result<(), String> {
     Ok(())
 }
 
-/// Reads one chapter's IR and prepares it for generation: marks the fields an `append` binds to an
+/// Reads one bluebook's IR and prepares it for generation: marks the fields an `append` binds to an
 /// optional argument. What it generates from and what it writes to `ir.json` are this same IR.
 fn read_ir(path: &str) -> Result<Json, String> {
     let text = std::fs::read_to_string(path).map_err(|e| format!("reading {path}: {e}"))?;
@@ -124,8 +125,8 @@ fn read_ir(path: &str) -> Result<Json, String> {
     Ok(ir)
 }
 
-/// Writes one chapter's files into `out_dir` and returns the `GeneratedDomain`, so `run_full`
-/// can union the registry, query and read-model definitions across chapters.
+/// Writes one bluebook's files into `out_dir` and returns the `GeneratedDomain`, so `run_full`
+/// can union the registry, query and read-model definitions across bluebooks.
 fn write_domain(
     ex: &exemplar::Exemplar,
     ir: &Json,
@@ -180,14 +181,14 @@ fn write_domain(
 }
 
 /// `hecks-codegen full <out_root> <target_mod_name> <target_source_label> <target_ir.json>
-/// [<chapter_mod_name> <chapter_source_label> <chapter_ir.json>]...`
+/// [<bluebook_mod_name> <bluebook_source_label> <bluebook_ir.json>]...`
 ///
-/// Writes the target chapter's directory, each attached chapter's own directory, and the
-/// target's `merged.rs`: one `Store`/`dispatch_by_name` table spanning every chapter given.
+/// Writes the target bluebook's directory, each attached bluebook's own directory, and the
+/// target's `merged.rs`: one `Store`/`dispatch_by_name` table spanning every bluebook given.
 fn run_full(args: &[String]) -> Result<(), String> {
     if args.len() < 4 || !(args.len() - 4).is_multiple_of(3) {
         return Err(
-            "usage: hecks-codegen full <out_root> <target_mod_name> <target_source_label> <target_ir.json> [<chapter_mod_name> <chapter_source_label> <chapter_ir.json>]..."
+            "usage: hecks-codegen full <out_root> <target_mod_name> <target_source_label> <target_ir.json> [<bluebook_mod_name> <bluebook_source_label> <bluebook_ir.json>]..."
                 .to_string(),
         );
     }
@@ -215,7 +216,7 @@ fn run_full(args: &[String]) -> Result<(), String> {
         &target_out_dir,
     )?;
 
-    // Target first, then each attached chapter in command-line order.
+    // Target first, then each attached bluebook in command-line order.
     let mut reference_key_pairs: Vec<(String, Vec<String>)> = vec![(
         target_domain_name.clone(),
         target_gen
@@ -233,57 +234,57 @@ fn run_full(args: &[String]) -> Result<(), String> {
         .map_or_default(Json::each)
         .to_vec();
 
-    // Policies and process managers merge across chapters; `chapter_irs` keeps each parsed
-    // chapter alive so `policy_sources` can borrow from it.
-    let mut chapter_irs: Vec<Json> = Vec::new();
-    let mut chapter_domain_names: Vec<String> = Vec::new();
+    // Policies and process managers merge across bluebooks; `bluebook_irs` keeps each parsed
+    // bluebook alive so `policy_sources` can borrow from it.
+    let mut bluebook_irs: Vec<Json> = Vec::new();
+    let mut bluebook_domain_names: Vec<String> = Vec::new();
 
     let mut i = 4;
     while i < args.len() {
-        let chapter_mod_name = &args[i];
-        let chapter_source_label = &args[i + 1];
-        let chapter_ir_path = &args[i + 2];
+        let bluebook_mod_name = &args[i];
+        let bluebook_source_label = &args[i + 1];
+        let bluebook_ir_path = &args[i + 2];
         i += 3;
 
-        let chapter_ir = read_ir(chapter_ir_path)?;
-        let chapter_domain_name = chapter_ir
+        let bluebook_ir = read_ir(bluebook_ir_path)?;
+        let bluebook_domain_name = bluebook_ir
             .get("name")
             .and_then(Json::as_str)
             .unwrap_or("")
             .to_string();
 
-        let chapter_out_dir = format!("{out_root}/{chapter_mod_name}");
-        let chapter_gen = write_domain(
+        let bluebook_out_dir = format!("{out_root}/{bluebook_mod_name}");
+        let bluebook_gen = write_domain(
             &ex,
-            &chapter_ir,
-            chapter_source_label,
-            chapter_mod_name,
-            &chapter_out_dir,
+            &bluebook_ir,
+            bluebook_source_label,
+            bluebook_mod_name,
+            &bluebook_out_dir,
         )?;
 
         reference_key_pairs.push((
-            chapter_domain_name.clone(),
-            chapter_gen
+            bluebook_domain_name.clone(),
+            bluebook_gen
                 .registry_aggregates
                 .iter()
                 .map(|a| a.name.clone())
                 .collect(),
         ));
-        merged_aggregates.extend(chapter_gen.registry_aggregates);
-        merged_queries.extend(chapter_gen.query_defs);
-        merged_read_models.extend(chapter_gen.read_model_defs);
+        merged_aggregates.extend(bluebook_gen.registry_aggregates);
+        merged_queries.extend(bluebook_gen.query_defs);
+        merged_read_models.extend(bluebook_gen.read_model_defs);
         merged_process_managers.extend(
-            chapter_ir
+            bluebook_ir
                 .get("process_managers")
                 .map_or_default(Json::each)
                 .to_vec(),
         );
 
-        chapter_domain_names.push(chapter_domain_name);
-        chapter_irs.push(chapter_ir);
+        bluebook_domain_names.push(bluebook_domain_name);
+        bluebook_irs.push(bluebook_ir);
     }
 
-    // One entry per chapter, so its policies qualify against its own domain and aggregates.
+    // One entry per bluebook, so its policies qualify against its own domain and aggregates.
     let policies: Vec<Json> = target_ir
         .get("policies")
         .map_or_default(Json::each)
@@ -298,7 +299,7 @@ fn run_full(args: &[String]) -> Result<(), String> {
         policies: &policies,
         aggregates: &policy_aggregates,
     }];
-    for (name, ir) in chapter_domain_names.iter().zip(chapter_irs.iter()) {
+    for (name, ir) in bluebook_domain_names.iter().zip(bluebook_irs.iter()) {
         policy_sources.push(reactions::PolicySource {
             domain_name: name,
             policies: ir.get("policies").map_or_default(Json::each),

data/rust/codegen/src/manifest.rs

@@ -16,7 +16,7 @@ struct Entry {
     reason: Option<String>,
 }
 
-/// The ordered list of generate/skip decisions made for one chapter.
+/// The ordered list of generate/skip decisions made for one bluebook.
 #[derive(Default)]
 pub struct Manifest {
     entries: Vec<Entry>,

data/rust/codegen/src/naming.rs

@@ -76,17 +76,17 @@ pub fn dispatch_fn_name(cmd: &str) -> String {
 /// `hecks project_reserved_names` — the same tables `naming.rb` reads.
 pub use crate::reserved_names::{CARGO_RESERVED_DOMAIN_NAMES, RUST_KEYWORDS};
 
-/// The modules every generated chapter declares itself, beside its aggregates' modules: the
+/// The modules every generated bluebook declares itself, beside its aggregates' modules: the
 /// sidecar `metadata`, the `registry` table, and the `merged` router. An aggregate whose
 /// downcased name is one of these would declare the module twice and overwrite the file.
-pub const CHAPTER_OWNED_MODULES: &[&str] = &["metadata", "registry", "merged"];
+pub const BLUEBOOK_OWNED_MODULES: &[&str] = &["metadata", "registry", "merged"];
 
 /// The module (and file stem) one aggregate's generated Rust lives in: its downcased name, or
-/// `<name>_aggregate` when that name is one the chapter declares itself. A downcased name never
+/// `<name>_aggregate` when that name is one the bluebook declares itself. A downcased name never
 /// holds an underscore, so the suffixed form cannot meet another aggregate's module.
 pub fn aggregate_module(name: &str) -> String {
     let module = name.to_lowercase();
-    if CHAPTER_OWNED_MODULES.contains(&module.as_str()) {
+    if BLUEBOOK_OWNED_MODULES.contains(&module.as_str()) {
         format!("{module}_aggregate")
     } else {
         module
@@ -388,7 +388,7 @@ mod tests {
     }
 
     #[test]
-    fn an_aggregate_named_for_a_chapter_module_gets_a_suffixed_module() {
+    fn an_aggregate_named_for_a_bluebook_module_gets_a_suffixed_module() {
         assert_eq!(aggregate_module("Metadata"), "metadata_aggregate");
         assert_eq!(aggregate_module("Registry"), "registry_aggregate");
         assert_eq!(aggregate_module("Merged"), "merged_aggregate");