hecks 5.0.0 → 6.0.0

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

@@ -15,7 +15,7 @@ pub fn not_implemented(file: &str, line: usize, word: &str) -> Diagnostic {
 /// Applies a `.hecksagon` body onto an already-built `ir::Bluebook`, attaching
 /// aggregate-scoped ports to the aggregates the sibling `.bluebook` registered.
 ///
-/// `gem_chapter_names` collects each `attaches "Name"` and
+/// `gem_bluebook_names` collects each `attaches "Name"` and
 /// `vendored_bluebook_names` each `attaches "name", from: :vendor`, in file order, for `hecks-parse resolve`; `ir.json` itself
 /// carries neither.
 ///
@@ -26,7 +26,7 @@ pub fn apply(
     lines: &[SourceLine],
     pos: &mut usize,
     bluebook: &mut ir::Bluebook,
-    gem_chapter_names: &mut Vec<String>,
+    gem_bluebook_names: &mut Vec<String>,
     vendored_bluebook_names: &mut Vec<String>,
     require_matching_aggregate: bool,
 ) -> ParseResult<()> {
@@ -67,6 +67,16 @@ pub fn apply(
                 call.word.as_str(),
                 "port" | "subscribe" | "attaches" | "translates" | "bounded" | "driven_by" | "end"
             ) {
+                if matches!(call.word.as_str(), "capabilities" | "concerns" | "annotate") {
+                    return Err(Diagnostic::new(
+                        file,
+                        line.number,
+                        format!(
+                            "`{}` is not a hecksagon word and nothing reads it; delete the line",
+                            call.word
+                        ),
+                    ));
+                }
                 let instead = match call.word.as_str() {
                     "uses_framework" => Some("attaches \"Name\""),
                     "uses_embryonaut_bluebook" => Some("attaches \"name\", from: :vendor"),
@@ -90,7 +100,7 @@ pub fn apply(
         match super::next_line(file, lines, pos, "Hecksagon")? {
             None => return Ok(()),
             Some(gated) => match gated.row.word {
-                // A bare root port belongs to the chapter, not an aggregate; validated, then
+                // A bare root port belongs to the bluebook, not an aggregate; validated, then
                 // discarded (`IR::Bluebook#to_h` has no `ports:` key).
                 "port" => {
                     let name =
@@ -111,7 +121,7 @@ pub fn apply(
                     bluebook.policies.push(built);
                 }
                 "subscribe" => {}
-                // One word for a chapter the gem carries and for a vendored package; a binding
+                // One word for a bluebook the gem carries and for a vendored package; a binding
                 // fact collected for `resolve`, absent from `ir.json`. Only `from: :vendor`
                 // is admitted as a source, and anything else is refused.
                 "attaches" => {
@@ -123,7 +133,7 @@ pub fn apply(
                         1,
                     )?;
                     match super::named_symbol(&gated.args, "from").as_deref() {
-                        None => gem_chapter_names.push(name),
+                        None => gem_bluebook_names.push(name),
                         Some("vendor") => vendored_bluebook_names.push(name),
                         Some(other) => {
                             return Err(Diagnostic::new(

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

@@ -3,8 +3,8 @@
 
 pub mod adapter;
 pub mod aggregate;
-pub mod chapter;
 pub mod command;
+pub mod declaration;
 pub mod domain_port;
 pub mod entity;
 pub mod file;
@@ -572,6 +572,12 @@ fn rocket_key_name(file: &str, word: &str, key_text: &str, line: usize) -> Parse
     Ok(rest.to_string())
 }
 
+/// A `pairs` row with neither a position nor a name: it admits every named argument the
+/// keyword's specific rows do not.
+fn is_open_pairs_row(row: &ArgumentRow) -> bool {
+    row.kind == "pairs" && row.at.is_empty() && row.named.is_empty()
+}
+
 fn validate_named(
     file: &str,
     word: &str,
@@ -581,6 +587,20 @@ fn validate_named(
     line: usize,
 ) -> ParseResult<()> {
     let candidates: Vec<&&ArgumentRow> = rows.iter().filter(|r| r.named == name).collect();
+    // An open `pairs` row (no position, no name) takes any key the specific rows leave over, as
+    // `provides` does for a capability its package declares; each value is text.
+    if candidates.is_empty() && rows.iter().any(|r| is_open_pairs_row(r)) {
+        let kind = classify_lexical_kind(value);
+        if kind == "text" {
+            return Ok(());
+        }
+        return Err(Diagnostic::new(
+            file,
+            line,
+            format!("'{word}'s '{name}:' ('{value}') reads as {kind}"),
+        )
+        .with_expected(vec!["text".to_string()]));
+    }
     if candidates.is_empty() {
         let expected: Vec<String> = rows
             .iter()
@@ -613,7 +633,7 @@ pub(crate) fn dispatch_stub(
     word: &str,
 ) -> Diagnostic {
     match inner_context {
-        "Bluebook" => chapter::not_implemented(file, line, word),
+        "Bluebook" => declaration::not_implemented(file, line, word),
         "Hecksagon" => hecksagon::not_implemented(file, line, word),
         "Aggregate" => aggregate::not_implemented(file, line, word),
         "Entity" => entity::not_implemented(file, line, word),
@@ -780,6 +800,24 @@ pub(crate) fn positional_symbol(
     })
 }
 
+/// A field name Ruby takes as a symbol or a string: `order_by :position`, `order_by "slug.value"`.
+pub(crate) fn positional_field_name(
+    file: &str,
+    line: usize,
+    word: &str,
+    args: &ArgumentGateResult,
+    at: usize,
+) -> ParseResult<String> {
+    if positional_raw(file, line, word, args, at)?
+        .trim()
+        .starts_with('"')
+    {
+        positional_text(file, line, word, args, at)
+    } else {
+        positional_symbol(file, line, word, args, at)
+    }
+}
+
 /// The name in a source symbol token: `:name` -> `name`, `:"a.b"` -> `a.b`.
 /// Not `ruby_value::read`, which reads rendered wire values rather than source syntax.
 fn symbol_text(raw: &str) -> Option<String> {
@@ -1182,6 +1220,50 @@ pub(crate) fn build_attribute(
     ))
 }
 
+/// Reads `reference_to one_of(A, B), as: :subject` into its tagged-reference shapes (ADR 0127),
+/// refusing a union with no `as:` or fewer than two distinct aggregates, as Ruby does.
+pub(crate) fn one_of_reference(
+    file: &str,
+    line: usize,
+    aggregate: &str,
+    raw: &str,
+    args: &ArgumentGateResult,
+) -> ParseResult<crate::build::references::OneOfReference> {
+    let inner = raw
+        .find('(')
+        .map_or("", |open| &raw[open + 1..raw.len() - 1]);
+    let variants: Vec<String> = ruby_value::split_items(inner)
+        .into_iter()
+        .map(|segment| crate::build::naming::demodulise(segment.trim()))
+        .collect();
+    let listed = variants.join(", ");
+    let Some(as_name) = named_symbol(args, "as") else {
+        return Err(Diagnostic::new(
+            file,
+            line,
+            format!(
+                "{aggregate}'s reference_to one_of({listed}) needs as: — a union has no one name"
+            ),
+        ));
+    };
+    let mut distinct = variants.clone();
+    distinct.sort();
+    distinct.dedup();
+    if variants.len() < 2 || distinct.len() != variants.len() {
+        return Err(Diagnostic::new(
+            file,
+            line,
+            format!("{aggregate}.{as_name}'s one_of names {listed} — a union names two or more distinct aggregates"),
+        ));
+    }
+    Ok(crate::build::references::one_of_reference(
+        aggregate,
+        &variants,
+        &as_name,
+        named_flag(args, "optional"),
+    ))
+}
+
 /// Resolves an attribute's type: a bare constant, `list_of(T)`, or an inline `one_of(...)`.
 ///
 /// `list_of` unwraps to `(inner, true)`. `one_of` synthesizes a closed-set value object named

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

@@ -94,7 +94,7 @@ pub fn parse_body(
 
 /// Every state named by a handler's `from_state` or `to_state`, in first-seen order.
 /// Order matters: `begin_saga` starts a fresh instance in `pm.states.first`.
-fn derived_states(handlers: &[ir::ProcessManagerHandler]) -> Vec<String> {
+pub(crate) fn derived_states(handlers: &[ir::ProcessManagerHandler]) -> Vec<String> {
     let mut states = Vec::new();
     for handler in handlers {
         for state in [&handler.from_state, &handler.to_state] {

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

@@ -1,6 +1,6 @@
-//! The `Query` construct: `where`, `order_by`, `limit` and the open-map option words.
+//! The `Query` construct: `reference_to`, `where`, `order_by`, `limit` and the open-map option words.
 
-use crate::build::{query_derive, query_options};
+use crate::build::{naming, query_derive, query_options, references};
 use crate::diag::{Diagnostic, ParseResult};
 use crate::ir;
 use crate::lex::SourceLine;
@@ -44,6 +44,16 @@ pub fn parse_body(
             "attribute" => query
                 .attributes
                 .push(super::build_attribute(file, line, "attribute", &gated.args)?.0),
+            // A query has no root of its own, so a reference is always a parameter, as in Ruby.
+            "reference_to" => {
+                let target_raw =
+                    super::positional_constant(file, line, "reference_to", &gated.args, 1)?;
+                query.attributes.push(references::reference_attribute(
+                    &naming::demodulise(target_raw),
+                    super::named_symbol(&gated.args, "as").as_deref(),
+                    super::named_flag(&gated.args, "optional"),
+                ));
+            }
             "where" => {
                 query_derive::refuse_on_target(file, line, "where", &gated.args.named)?;
                 query
@@ -52,7 +62,7 @@ pub fn parse_body(
             }
             "order_by" => {
                 // The gate already refuses an undeclared `on:`; only `where` needs a check.
-                let field = super::positional_symbol(file, line, "order_by", &gated.args, 1)?;
+                let field = super::positional_field_name(file, line, "order_by", &gated.args, 1)?;
                 let direction = match gated.args.positional.iter().find(|(idx, _)| *idx == 2) {
                     Some((_, text)) => text.trim().trim_start_matches(':').to_string(),
                     None => "asc".to_string(),

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

@@ -178,7 +178,8 @@ pub fn parse_body(
                 wheres.extend(query_derive::where_clauses(&field_pairs, target.as_deref()));
             }
             "order_by" => {
-                let field = super::positional_symbol(file, last_line, "order_by", &gated.args, 1)?;
+                let field =
+                    super::positional_field_name(file, last_line, "order_by", &gated.args, 1)?;
                 let direction = match gated.args.positional.iter().find(|(idx, _)| *idx == 2) {
                     Some((_, text)) => text.trim().trim_start_matches(':').to_string(),
                     None => "asc".to_string(),