hecks 6.0.0 → 7.0.0

data/rust/parser/src/keywords.rs

@@ -86,6 +86,30 @@ pub static KEYWORDS: &[KeywordRow] = &[
         resolves_via: "",
         disambiguator: "",
     },
+    KeywordRow {
+        word: "formerly_known_as",
+        context: "Aggregate",
+        body: "none",
+        inner: "",
+        opens: "",
+        fills: "formerly_known_as",
+        status: "admitted",
+        was: "",
+        resolves_via: "",
+        disambiguator: "",
+    },
+    KeywordRow {
+        word: "created_by",
+        context: "Aggregate",
+        body: "none",
+        inner: "",
+        opens: "",
+        fills: "created_by",
+        status: "admitted",
+        was: "",
+        resolves_via: "",
+        disambiguator: "",
+    },
     KeywordRow {
         word: "identified_by",
         context: "Aggregate",
@@ -482,6 +506,18 @@ pub static KEYWORDS: &[KeywordRow] = &[
         resolves_via: "",
         disambiguator: "",
     },
+    KeywordRow {
+        word: "domain_module",
+        context: "Bluebook",
+        body: "keywords",
+        inner: "Bluebook",
+        opens: "Bluebook",
+        fills: "",
+        status: "admitted",
+        was: "",
+        resolves_via: "",
+        disambiguator: "",
+    },
     KeywordRow {
         word: "role",
         context: "Command",
@@ -506,6 +542,18 @@ pub static KEYWORDS: &[KeywordRow] = &[
         resolves_via: "",
         disambiguator: "",
     },
+    KeywordRow {
+        word: "audience",
+        context: "Command",
+        body: "none",
+        inner: "",
+        opens: "",
+        fills: "audience",
+        status: "admitted",
+        was: "",
+        resolves_via: "",
+        disambiguator: "",
+    },
     KeywordRow {
         word: "provenance",
         context: "Command",
@@ -530,6 +578,18 @@ pub static KEYWORDS: &[KeywordRow] = &[
         resolves_via: "",
         disambiguator: "",
     },
+    KeywordRow {
+        word: "mints_era",
+        context: "Command",
+        body: "none",
+        inner: "",
+        opens: "",
+        fills: "mints_era",
+        status: "admitted",
+        was: "",
+        resolves_via: "",
+        disambiguator: "",
+    },
     KeywordRow {
         word: "reference_to",
         context: "Command",
@@ -908,7 +968,7 @@ pub static KEYWORDS: &[KeywordRow] = &[
         body: "none",
         inner: "",
         opens: "",
-        fills: "correlates_by",
+        fills: "",
         status: "admitted",
         was: "",
         resolves_via: "",
@@ -938,6 +998,18 @@ pub static KEYWORDS: &[KeywordRow] = &[
         resolves_via: "",
         disambiguator: "",
     },
+    KeywordRow {
+        word: "resumes",
+        context: "ProcessManager",
+        body: "none",
+        inner: "",
+        opens: "",
+        fills: "",
+        status: "admitted",
+        was: "",
+        resolves_via: "",
+        disambiguator: "",
+    },
     KeywordRow {
         word: "transition",
         context: "ProcessManager",
@@ -1682,6 +1754,18 @@ pub static KEYWORDS: &[KeywordRow] = &[
         resolves_via: "",
         disambiguator: "",
     },
+    KeywordRow {
+        word: "handles",
+        context: "PortOperation",
+        body: "none",
+        inner: "",
+        opens: "",
+        fills: "handles",
+        status: "admitted",
+        was: "",
+        resolves_via: "",
+        disambiguator: "",
+    },
     KeywordRow {
         word: "port",
         context: "File",
@@ -1862,6 +1946,18 @@ pub static KEYWORDS: &[KeywordRow] = &[
         resolves_via: "",
         disambiguator: "",
     },
+    KeywordRow {
+        word: "split",
+        context: "TranslationAggregate",
+        body: "none",
+        inner: "",
+        opens: "",
+        fills: "splits",
+        status: "admitted",
+        was: "",
+        resolves_via: "",
+        disambiguator: "",
+    },
     KeywordRow {
         word: "move",
         context: "TranslationAggregate",
@@ -2137,6 +2233,38 @@ pub static ARGUMENTS: &[ArgumentRow] = &[
         variadic: "",
         minimum: "",
     },
+    ArgumentRow {
+        keyword: "formerly_known_as",
+        context: "Aggregate",
+        at: "1",
+        named: "",
+        kind: "text",
+        required: "true",
+        fills: "formerly_known_as",
+        selects: "",
+        pair_key_fills: "",
+        pair_value_fills: "",
+        pairs_shape: "",
+        status: "admitted",
+        variadic: "",
+        minimum: "",
+    },
+    ArgumentRow {
+        keyword: "created_by",
+        context: "Aggregate",
+        at: "1",
+        named: "",
+        kind: "text",
+        required: "true",
+        fills: "created_by",
+        selects: "",
+        pair_key_fills: "",
+        pair_value_fills: "",
+        pairs_shape: "",
+        status: "admitted",
+        variadic: "",
+        minimum: "",
+    },
     ArgumentRow {
         keyword: "identified_by",
         context: "Aggregate",
@@ -3257,6 +3385,38 @@ pub static ARGUMENTS: &[ArgumentRow] = &[
         variadic: "",
         minimum: "",
     },
+    ArgumentRow {
+        keyword: "aggregate",
+        context: "Bluebook",
+        at: "",
+        named: "kind",
+        kind: "text",
+        required: "false",
+        fills: "kind",
+        selects: "",
+        pair_key_fills: "",
+        pair_value_fills: "",
+        pairs_shape: "",
+        status: "admitted",
+        variadic: "",
+        minimum: "",
+    },
+    ArgumentRow {
+        keyword: "domain_module",
+        context: "Bluebook",
+        at: "1",
+        named: "",
+        kind: "text",
+        required: "true",
+        fills: "name",
+        selects: "",
+        pair_key_fills: "",
+        pair_value_fills: "",
+        pairs_shape: "",
+        status: "admitted",
+        variadic: "",
+        minimum: "",
+    },
     ArgumentRow {
         keyword: "role",
         context: "Command",
@@ -3289,6 +3449,22 @@ pub static ARGUMENTS: &[ArgumentRow] = &[
         variadic: "",
         minimum: "",
     },
+    ArgumentRow {
+        keyword: "audience",
+        context: "Command",
+        at: "1",
+        named: "",
+        kind: "symbol",
+        required: "true",
+        fills: "audience",
+        selects: "",
+        pair_key_fills: "",
+        pair_value_fills: "",
+        pairs_shape: "",
+        status: "admitted",
+        variadic: "true",
+        minimum: "",
+    },
     ArgumentRow {
         keyword: "provenance",
         context: "Command",
@@ -4649,6 +4825,22 @@ pub static ARGUMENTS: &[ArgumentRow] = &[
         variadic: "",
         minimum: "",
     },
+    ArgumentRow {
+        keyword: "correlates_by",
+        context: "ProcessManager",
+        at: "1",
+        named: "",
+        kind: "constant",
+        required: "true",
+        fills: "correlates_by",
+        selects: "",
+        pair_key_fills: "",
+        pair_value_fills: "",
+        pairs_shape: "",
+        status: "admitted",
+        variadic: "",
+        minimum: "",
+    },
     ArgumentRow {
         keyword: "starts_on",
         context: "ProcessManager",
@@ -4713,6 +4905,22 @@ pub static ARGUMENTS: &[ArgumentRow] = &[
         variadic: "",
         minimum: "",
     },
+    ArgumentRow {
+        keyword: "resumes",
+        context: "ProcessManager",
+        at: "1",
+        named: "",
+        kind: "text",
+        required: "true",
+        fills: "resumes",
+        selects: "",
+        pair_key_fills: "",
+        pair_value_fills: "",
+        pairs_shape: "",
+        status: "admitted",
+        variadic: "",
+        minimum: "",
+    },
     ArgumentRow {
         keyword: "transition",
         context: "ProcessManager",
@@ -6345,6 +6553,38 @@ pub static ARGUMENTS: &[ArgumentRow] = &[
         variadic: "",
         minimum: "",
     },
+    ArgumentRow {
+        keyword: "handles",
+        context: "PortOperation",
+        at: "1",
+        named: "",
+        kind: "text",
+        required: "true",
+        fills: "command",
+        selects: "",
+        pair_key_fills: "",
+        pair_value_fills: "",
+        pairs_shape: "",
+        status: "admitted",
+        variadic: "",
+        minimum: "",
+    },
+    ArgumentRow {
+        keyword: "handles",
+        context: "PortOperation",
+        at: "",
+        named: "value",
+        kind: "text",
+        required: "true",
+        fills: "value",
+        selects: "",
+        pair_key_fills: "",
+        pair_value_fills: "",
+        pairs_shape: "",
+        status: "admitted",
+        variadic: "",
+        minimum: "",
+    },
     ArgumentRow {
         keyword: "port",
         context: "File",
@@ -6665,6 +6905,54 @@ pub static ARGUMENTS: &[ArgumentRow] = &[
         variadic: "",
         minimum: "",
     },
+    ArgumentRow {
+        keyword: "split",
+        context: "TranslationAggregate",
+        at: "",
+        named: "into",
+        kind: "text",
+        required: "true",
+        fills: "into",
+        selects: "",
+        pair_key_fills: "",
+        pair_value_fills: "",
+        pairs_shape: "",
+        status: "admitted",
+        variadic: "",
+        minimum: "",
+    },
+    ArgumentRow {
+        keyword: "split",
+        context: "TranslationAggregate",
+        at: "",
+        named: "keyed_by",
+        kind: "text",
+        required: "true",
+        fills: "keyed_by",
+        selects: "",
+        pair_key_fills: "",
+        pair_value_fills: "",
+        pairs_shape: "",
+        status: "admitted",
+        variadic: "",
+        minimum: "",
+    },
+    ArgumentRow {
+        keyword: "split",
+        context: "TranslationAggregate",
+        at: "",
+        named: "fields",
+        kind: "text",
+        required: "true",
+        fills: "fields",
+        selects: "",
+        pair_key_fills: "",
+        pair_value_fills: "",
+        pairs_shape: "",
+        status: "admitted",
+        variadic: "",
+        minimum: "",
+    },
     ArgumentRow {
         keyword: "move",
         context: "TranslationAggregate",

data/rust/parser/src/main.rs

@@ -379,11 +379,13 @@ const COVERED_PAIRS: &[(&str, &str)] = &[
     ("lifecycle", "Entity"),
     ("role", "Command"),
     ("goal", "Command"),
+    ("audience", "Command"),
     ("reference_to", "Command"),
     ("given", "Command"),
     ("ensures", "Command"),
     ("needs", "Command"),
     ("idempotent", "Command"),
+    ("mints_era", "Command"),
     ("sets", "Command"),
     ("corrects", "Command"),
     ("delegates_to", "Command"),

data/rust/parser/src/parse/aggregate.rs

@@ -194,6 +194,15 @@ pub fn parse_body(
                     1,
                 )?);
             }
+            "created_by" => {
+                aggregate.created_by = Some(super::positional_text(
+                    file,
+                    line,
+                    "created_by",
+                    &gated.args,
+                    1,
+                )?);
+            }
             // Origin, not identity: captured raw, like a literal Hash default.
             "provenance" => {
                 let raw = super::named_raw(&gated.args, "from")
@@ -203,7 +212,7 @@ pub fn parse_body(
             "acknowledges" => {
                 aggregate.acknowledgements.push(ir::Acknowledgement {
                     finding: super::positional_symbol(file, line, "acknowledges", &gated.args, 1)?,
-                    subject: super::named_symbol(&gated.args, "of").unwrap_or_default(),
+                    subject: super::named_symbol(&gated.args, "of"),
                     reason: super::positional_text(file, line, "acknowledges", &gated.args, 2)?,
                 });
             }

data/rust/parser/src/parse/audience.rs

@@ -0,0 +1,65 @@
+//! The `audience` word of a command: who a launcher lists it for (ADR 0163). Mirrors
+//! `Hecks::Bluebook::DSL::CommandBuilder#audience_impl`.
+
+use crate::diag::{Diagnostic, ParseResult};
+use crate::parse::ArgumentGateResult;
+
+/// The audiences a command may be listed for; mirrors `CommandBuilder::AUDIENCES`.
+const AUDIENCES: &[&str] = &["person", "agent", "ci", "record"];
+
+/// Reads one `audience :a, :b` line into `audience`.
+///
+/// Refuses a second declaration, an empty one, a name that is not an audience and a name given
+/// twice, as the Ruby builder does.
+pub fn declare(
+    file: &str,
+    line: usize,
+    owner: &str,
+    args: &ArgumentGateResult,
+    audience: &mut Vec<String>,
+) -> ParseResult<()> {
+    if !audience.is_empty() {
+        return Err(Diagnostic::new(
+            file,
+            line,
+            format!("{owner} declares its audience twice"),
+        ));
+    }
+    let mut names = Vec::new();
+    for at in 1..=args.positional.len() {
+        names.push(super::positional_symbol(file, line, "audience", args, at)?);
+    }
+    refuse(file, line, owner, &names)?;
+    *audience = names;
+    Ok(())
+}
+
+/// Refuses the names that are not a list of distinct audiences.
+fn refuse(file: &str, line: usize, owner: &str, names: &[String]) -> ParseResult<()> {
+    let problem = match unknown(names) {
+        _ if names.is_empty() => Some(format!("{owner} names no audience")),
+        unknown if !unknown.is_empty() => Some(format!(
+            "{owner} names {} as an audience; the audiences are {}",
+            unknown.join(", "),
+            AUDIENCES.join(", ")
+        )),
+        _ if twice(names) => Some(format!("{owner} names an audience twice")),
+        _ => None,
+    };
+    problem.map_or(Ok(()), |text| Err(Diagnostic::new(file, line, text)))
+}
+
+fn unknown(names: &[String]) -> Vec<&str> {
+    names
+        .iter()
+        .map(String::as_str)
+        .filter(|name| !AUDIENCES.contains(name))
+        .collect()
+}
+
+fn twice(names: &[String]) -> bool {
+    let mut distinct = names.to_vec();
+    distinct.sort();
+    distinct.dedup();
+    distinct.len() != names.len()
+}

data/rust/parser/src/parse/command.rs

@@ -270,6 +270,20 @@ pub fn parse_body(
                 super::needs::declare(file, line, &command.name, &gated.args, &mut command.needs)?;
             }
             "idempotent" => command.idempotent = true,
+            "mints_era" => {
+                command.mints_era =
+                    super::positional_literal_text(file, line, "mints_era", &gated.args, 1)?
+                        == "true";
+            }
+            "audience" => {
+                super::audience::declare(
+                    file,
+                    line,
+                    &command.name,
+                    &gated.args,
+                    &mut command.audience,
+                )?;
+            }
             "provenance" => {
                 let raw = super::named_raw(&gated.args, "from")
                     .ok_or_else(|| Diagnostic::new(file, line, "'provenance' requires a from:"))?;

data/rust/parser/src/parse/declaration.rs

@@ -120,6 +120,7 @@ pub fn parse_bluebook(
                     &mut bluebook_entity_named_givens,
                     &mut pending_bluebook_entity_givens,
                     &mut pending_entity_command_givens,
+                    false,
                 )?;
             }
             "Hecksagon" => hecksagon_files.push(entry),
@@ -146,6 +147,9 @@ pub fn parse_bluebook(
     bluebook.policies = aggregate_policies;
     bluebook.policies.extend(bluebook_policies);
 
+    // A bare `correlates_by Message` resolves to an aggregate's identity once the aggregates exist.
+    crate::build::correlation_keys::resolve_bare(&files[0].0, &mut bluebook)?;
+
     // Reference-hop query tails resolve only once the whole aggregate graph exists.
     crate::build::query_inference::apply(&files[0].0, &mut bluebook)?;
 
@@ -414,13 +418,38 @@ fn parse_body_into(
     bluebook_entity_named_givens: &mut Vec<(String, ir::Given)>,
     pending_bluebook_entity_givens: &mut Vec<(usize, entity::PendingBluebookEntityGiven)>,
     pending_entity_command_givens: &mut Vec<(usize, entity::PendingEntityCommandGiven)>,
+    in_module: bool,
 ) -> ParseResult<()> {
     // The given pool spans the whole bluebook, not one file: a later concept file may reference
     // a named given an earlier one declared. Entries are (owner aggregate name, `Given`).
     while let Some(gated) = super::next_line(file, lines, pos, "Bluebook")? {
         let line = gated.line.number;
+        refuse_inside_module(file, line, gated.row.word, in_module)?;
 
         match gated.row.word {
+            "domain_module" => {
+                let module_name =
+                    super::positional_text(file, line, "domain_module", &gated.args, 1)?;
+                let first = bluebook.aggregates.len();
+                let outer_vision = bluebook.vision.take();
+                parse_body_into(
+                    file,
+                    lines,
+                    pos,
+                    bluebook,
+                    aggregate_policies,
+                    bluebook_policies,
+                    bluebook_named_givens,
+                    pending_bluebook_givens,
+                    pending_command_givens,
+                    bluebook_entity_named_givens,
+                    pending_bluebook_entity_givens,
+                    pending_entity_command_givens,
+                    true,
+                )?;
+                let vision = std::mem::replace(&mut bluebook.vision, outer_vision);
+                group_in_module(bluebook, file, line, &module_name, first, vision)?;
+            }
             "vision" => {
                 bluebook.vision = Some(super::positional_text(
                     file,
@@ -545,3 +574,71 @@ fn parse_body_into(
 
     Ok(())
 }
+
+/// The words that describe the whole bluebook, which a `domain_module` block refuses, and
+/// `domain_module` itself, since modules do not nest.
+fn refuse_inside_module(file: &str, line: usize, word: &str, in_module: bool) -> ParseResult<()> {
+    let wide = matches!(
+        word,
+        "namespace"
+            | "formerly_known_as"
+            | "attaches_to"
+            | "provides"
+            | "core"
+            | "supporting"
+            | "generic"
+    );
+    if in_module && wide {
+        return Err(Diagnostic::new(
+            file,
+            line,
+            format!("{word} describes the whole bluebook, so it cannot sit inside a domain_module"),
+        ));
+    }
+    if in_module && word == "domain_module" {
+        return Err(Diagnostic::new(
+            file,
+            line,
+            "modules do not nest".to_string(),
+        ));
+    }
+    Ok(())
+}
+
+/// Records the aggregates a `domain_module` block declared (from `first` on) as its module's
+/// rows, and gives every row of the module the vision it names, as the Ruby builder does for a
+/// module an earlier file opened.
+fn group_in_module(
+    bluebook: &mut ir::Bluebook,
+    file: &str,
+    line: usize,
+    name: &str,
+    first: usize,
+    vision: Option<String>,
+) -> ParseResult<()> {
+    let held_rows = bluebook.modules.iter().any(|row| row.name == name);
+    if bluebook.aggregates.len() == first && !held_rows {
+        return Err(Diagnostic::new(
+            file,
+            line,
+            format!("domain_module {name:?} holds no aggregate"),
+        ));
+    }
+    let held = bluebook
+        .modules
+        .iter()
+        .find(|row| row.name == name)
+        .map(|row| row.vision.clone());
+    let vision = vision.or(held).unwrap_or_default();
+    for aggregate in &bluebook.aggregates[first..] {
+        bluebook.modules.push(ir::ModuleRow {
+            name: name.to_string(),
+            vision: vision.clone(),
+            aggregate: aggregate.name.clone(),
+        });
+    }
+    for row in bluebook.modules.iter_mut().filter(|row| row.name == name) {
+        row.vision.clone_from(&vision);
+    }
+    Ok(())
+}

data/rust/parser/src/parse/domain_port.rs

@@ -69,6 +69,7 @@ fn parse_operation_body(
         answers: None,
         refuses: None,
         to,
+        handles: Vec::new(),
     };
 
     loop {
@@ -107,6 +108,11 @@ fn parse_operation_body(
                     1,
                 )?);
             }
+            "handles" => {
+                let command = super::positional_text(file, line, "handles", &gated.args, 1)?;
+                let value = super::named_text(&gated.args, "value").unwrap_or_default();
+                operation.handles.push(ir::CommandValue { command, value });
+            }
             "reference_to" => {
                 let target_raw =
                     super::positional_constant(file, line, "reference_to", &gated.args, 1)?;

data/rust/parser/src/parse/mod.rs

@@ -3,6 +3,7 @@
 
 pub mod adapter;
 pub mod aggregate;
+pub mod audience;
 pub mod command;
 pub mod declaration;
 pub mod domain_port;