hecks 2.9.0 → 3.0.0

data/rust/src/kernel/vocab/aggregate_dispatch_order.rs

@@ -0,0 +1,118 @@
+// GENERATED by hecks project_rust_vocabulary (Hecks::Projections::RustVocabulary,
+// lib/hecks/projections/rust_vocabulary.rb) from Vocabulary::AggregateDispatchOrder
+// (lib/hecks/language/bluebook/vocabulary.bluebook).
+// Do not hand-edit — re-run hecks project_rust_vocabulary instead.
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum AggregateStep {
+    DecodeArguments,
+    RefuseUnknownArguments,
+    RefuseAbsentArguments,
+    NormalizeArgs,
+    RefuseRoleMismatch,
+    ResolveReferences,
+    Hydrate,
+    EnforceGivens,
+    AdmissibleTransition,
+    AssignCreationAttributes,
+    ApplyMutations,
+    AdvanceLifecycle,
+    DelegateToEntity,
+    EnforceEnsures,
+    EnforceInvariants,
+    Save,
+    Emit,
+}
+
+impl AggregateStep {
+    /// The declared step order, first to last.
+    pub const ORDER: [AggregateStep; 17] = [
+        AggregateStep::DecodeArguments,
+        AggregateStep::RefuseUnknownArguments,
+        AggregateStep::RefuseAbsentArguments,
+        AggregateStep::NormalizeArgs,
+        AggregateStep::RefuseRoleMismatch,
+        AggregateStep::ResolveReferences,
+        AggregateStep::Hydrate,
+        AggregateStep::EnforceGivens,
+        AggregateStep::AdmissibleTransition,
+        AggregateStep::AssignCreationAttributes,
+        AggregateStep::ApplyMutations,
+        AggregateStep::AdvanceLifecycle,
+        AggregateStep::DelegateToEntity,
+        AggregateStep::EnforceEnsures,
+        AggregateStep::EnforceInvariants,
+        AggregateStep::Save,
+        AggregateStep::Emit,
+    ];
+
+    /// The row's declared `step`.
+    pub fn step(&self) -> &'static str {
+        match self {
+            AggregateStep::DecodeArguments => "decode_arguments",
+            AggregateStep::RefuseUnknownArguments => "refuse_unknown_arguments",
+            AggregateStep::RefuseAbsentArguments => "refuse_absent_arguments",
+            AggregateStep::NormalizeArgs => "normalize_args",
+            AggregateStep::RefuseRoleMismatch => "refuse_role_mismatch",
+            AggregateStep::ResolveReferences => "resolve_references",
+            AggregateStep::Hydrate => "hydrate",
+            AggregateStep::EnforceGivens => "enforce_givens",
+            AggregateStep::AdmissibleTransition => "admissible_transition",
+            AggregateStep::AssignCreationAttributes => "assign_creation_attributes",
+            AggregateStep::ApplyMutations => "apply_mutations",
+            AggregateStep::AdvanceLifecycle => "advance_lifecycle",
+            AggregateStep::DelegateToEntity => "delegate_to_entity",
+            AggregateStep::EnforceEnsures => "enforce_ensures",
+            AggregateStep::EnforceInvariants => "enforce_invariants",
+            AggregateStep::Save => "save",
+            AggregateStep::Emit => "emit",
+        }
+    }
+
+    /// The row whose `step` is `name`, if any.
+    pub fn from_name(name: &str) -> Option<AggregateStep> {
+        AggregateStep::ORDER.iter().copied().find(|row| row.step() == name)
+    }
+
+    /// This step's index in `ORDER`.
+    pub fn position(&self) -> usize {
+        match self {
+            AggregateStep::DecodeArguments => 0,
+            AggregateStep::RefuseUnknownArguments => 1,
+            AggregateStep::RefuseAbsentArguments => 2,
+            AggregateStep::NormalizeArgs => 3,
+            AggregateStep::RefuseRoleMismatch => 4,
+            AggregateStep::ResolveReferences => 5,
+            AggregateStep::Hydrate => 6,
+            AggregateStep::EnforceGivens => 7,
+            AggregateStep::AdmissibleTransition => 8,
+            AggregateStep::AssignCreationAttributes => 9,
+            AggregateStep::ApplyMutations => 10,
+            AggregateStep::AdvanceLifecycle => 11,
+            AggregateStep::DelegateToEntity => 12,
+            AggregateStep::EnforceEnsures => 13,
+            AggregateStep::EnforceInvariants => 14,
+            AggregateStep::Save => 15,
+            AggregateStep::Emit => 16,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn every_row_is_found_by_its_own_name() {
+        for row in AggregateStep::ORDER.iter() {
+            assert_eq!(AggregateStep::from_name(row.step()), Some(*row));
+        }
+    }
+
+    #[test]
+    fn position_is_the_index_in_order() {
+        for (index, step) in AggregateStep::ORDER.iter().enumerate() {
+            assert_eq!(step.position(), index);
+        }
+    }
+}

data/rust/src/kernel/vocab/entity_dispatch_order.rs

@@ -0,0 +1,114 @@
+// GENERATED by hecks project_rust_vocabulary (Hecks::Projections::RustVocabulary,
+// lib/hecks/projections/rust_vocabulary.rb) from Vocabulary::EntityDispatchOrder
+// (lib/hecks/language/bluebook/vocabulary.bluebook).
+// Do not hand-edit — re-run hecks project_rust_vocabulary instead.
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum EntityStep {
+    DecodeArguments,
+    RefuseUnknownArguments,
+    RefuseAbsentArguments,
+    NormalizeArgs,
+    RefuseRoleMismatch,
+    ResolveReferences,
+    HydrateParent,
+    LocateElement,
+    EnforceGivens,
+    AdmissibleTransition,
+    ApplyMutations,
+    AdvanceLifecycle,
+    EnforceEnsures,
+    EnforceInvariants,
+    Save,
+    Emit,
+}
+
+impl EntityStep {
+    /// The declared step order, first to last.
+    pub const ORDER: [EntityStep; 16] = [
+        EntityStep::DecodeArguments,
+        EntityStep::RefuseUnknownArguments,
+        EntityStep::RefuseAbsentArguments,
+        EntityStep::NormalizeArgs,
+        EntityStep::RefuseRoleMismatch,
+        EntityStep::ResolveReferences,
+        EntityStep::HydrateParent,
+        EntityStep::LocateElement,
+        EntityStep::EnforceGivens,
+        EntityStep::AdmissibleTransition,
+        EntityStep::ApplyMutations,
+        EntityStep::AdvanceLifecycle,
+        EntityStep::EnforceEnsures,
+        EntityStep::EnforceInvariants,
+        EntityStep::Save,
+        EntityStep::Emit,
+    ];
+
+    /// The row's declared `step`.
+    pub fn step(&self) -> &'static str {
+        match self {
+            EntityStep::DecodeArguments => "decode_arguments",
+            EntityStep::RefuseUnknownArguments => "refuse_unknown_arguments",
+            EntityStep::RefuseAbsentArguments => "refuse_absent_arguments",
+            EntityStep::NormalizeArgs => "normalize_args",
+            EntityStep::RefuseRoleMismatch => "refuse_role_mismatch",
+            EntityStep::ResolveReferences => "resolve_references",
+            EntityStep::HydrateParent => "hydrate_parent",
+            EntityStep::LocateElement => "locate_element",
+            EntityStep::EnforceGivens => "enforce_givens",
+            EntityStep::AdmissibleTransition => "admissible_transition",
+            EntityStep::ApplyMutations => "apply_mutations",
+            EntityStep::AdvanceLifecycle => "advance_lifecycle",
+            EntityStep::EnforceEnsures => "enforce_ensures",
+            EntityStep::EnforceInvariants => "enforce_invariants",
+            EntityStep::Save => "save",
+            EntityStep::Emit => "emit",
+        }
+    }
+
+    /// The row whose `step` is `name`, if any.
+    pub fn from_name(name: &str) -> Option<EntityStep> {
+        EntityStep::ORDER.iter().copied().find(|row| row.step() == name)
+    }
+
+    /// This step's index in `ORDER`.
+    pub fn position(&self) -> usize {
+        match self {
+            EntityStep::DecodeArguments => 0,
+            EntityStep::RefuseUnknownArguments => 1,
+            EntityStep::RefuseAbsentArguments => 2,
+            EntityStep::NormalizeArgs => 3,
+            EntityStep::RefuseRoleMismatch => 4,
+            EntityStep::ResolveReferences => 5,
+            EntityStep::HydrateParent => 6,
+            EntityStep::LocateElement => 7,
+            EntityStep::EnforceGivens => 8,
+            EntityStep::AdmissibleTransition => 9,
+            EntityStep::ApplyMutations => 10,
+            EntityStep::AdvanceLifecycle => 11,
+            EntityStep::EnforceEnsures => 12,
+            EntityStep::EnforceInvariants => 13,
+            EntityStep::Save => 14,
+            EntityStep::Emit => 15,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn every_row_is_found_by_its_own_name() {
+        for row in EntityStep::ORDER.iter() {
+            assert_eq!(EntityStep::from_name(row.step()), Some(*row));
+        }
+    }
+
+    #[test]
+    fn position_is_the_index_in_order() {
+        for (index, step) in EntityStep::ORDER.iter().enumerate() {
+            assert_eq!(step.position(), index);
+        }
+    }
+}

data/rust/src/kernel/vocab/field_hint.rs

@@ -0,0 +1,70 @@
+// GENERATED by hecks project_rust_vocabulary (Hecks::Projections::RustVocabulary,
+// lib/hecks/projections/rust_vocabulary.rb) from Vocabulary::FieldHint
+// (lib/hecks/language/bluebook/vocabulary.bluebook).
+// Do not hand-edit — re-run hecks project_rust_vocabulary instead.
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum FieldHint {
+    Email,
+    Url,
+    Tel,
+    Textarea,
+}
+
+impl FieldHint {
+    /// Every row, in declared order.
+    pub const ALL: &'static [FieldHint] = &[
+        FieldHint::Email,
+        FieldHint::Url,
+        FieldHint::Tel,
+        FieldHint::Textarea,
+    ];
+
+    /// The row's declared `name`.
+    pub fn name(&self) -> &'static str {
+        match self {
+            FieldHint::Email => "email",
+            FieldHint::Url => "url",
+            FieldHint::Tel => "tel",
+            FieldHint::Textarea => "textarea",
+        }
+    }
+
+    /// The row's declared `pattern`.
+    pub fn pattern(&self) -> &'static str {
+        match self {
+            FieldHint::Email => "email",
+            FieldHint::Url => "\\b(url|uri|website|link)\\b",
+            FieldHint::Tel => "phone|\\btel(ephone)?\\b",
+            FieldHint::Textarea => "\\b(text|body|note|notes|description|message|comment)\\b",
+        }
+    }
+
+    /// The row's declared `resolves_to`.
+    pub fn resolves_to(&self) -> &'static str {
+        match self {
+            FieldHint::Email => "html_type",
+            FieldHint::Url => "html_type",
+            FieldHint::Tel => "html_type",
+            FieldHint::Textarea => "kind",
+        }
+    }
+
+    /// The row whose `name` is `name`, if any.
+    pub fn from_name(name: &str) -> Option<FieldHint> {
+        FieldHint::ALL.iter().copied().find(|row| row.name() == name)
+    }
+
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn every_row_is_found_by_its_own_name() {
+        for row in FieldHint::ALL.iter() {
+            assert_eq!(FieldHint::from_name(row.name()), Some(*row));
+        }
+    }
+}

data/rust/src/kernel/vocab/mod.rs

@@ -0,0 +1,20 @@
+// GENERATED by hecks project_rust_vocabulary (Hecks::Projections::RustVocabulary,
+// lib/hecks/projections/rust_vocabulary.rb) from the Vocabulary
+// aggregate (lib/hecks/language/bluebook/vocabulary.bluebook).
+// Do not hand-edit — re-run hecks project_rust_vocabulary instead.
+//
+// One module per projected table. Every enum below is matched
+// exhaustively by its own accessors — no wildcard arm — so a row the
+// language gains fails to compile until it is handled.
+
+pub mod refusal_template;
+pub mod query_comparator;
+pub mod field_hint;
+pub mod aggregate_dispatch_order;
+pub mod entity_dispatch_order;
+
+pub use refusal_template::RefusalSite;
+pub use query_comparator::QueryComparator;
+pub use field_hint::FieldHint;
+pub use aggregate_dispatch_order::AggregateStep;
+pub use entity_dispatch_order::EntityStep;

data/rust/src/kernel/vocab/query_comparator.rs

@@ -0,0 +1,65 @@
+// GENERATED by hecks project_rust_vocabulary (Hecks::Projections::RustVocabulary,
+// lib/hecks/projections/rust_vocabulary.rb) from Vocabulary::QueryComparator
+// (lib/hecks/language/bluebook/vocabulary.bluebook).
+// Do not hand-edit — re-run hecks project_rust_vocabulary instead.
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum QueryComparator {
+    Eq,
+    Ne,
+    Gt,
+    Gte,
+    Lt,
+    Lte,
+    In,
+    Contains,
+    NoneInState,
+}
+
+impl QueryComparator {
+    /// Every row, in declared order.
+    pub const ALL: &'static [QueryComparator] = &[
+        QueryComparator::Eq,
+        QueryComparator::Ne,
+        QueryComparator::Gt,
+        QueryComparator::Gte,
+        QueryComparator::Lt,
+        QueryComparator::Lte,
+        QueryComparator::In,
+        QueryComparator::Contains,
+        QueryComparator::NoneInState,
+    ];
+
+    /// The row's declared `name`.
+    pub fn name(&self) -> &'static str {
+        match self {
+            QueryComparator::Eq => "eq",
+            QueryComparator::Ne => "ne",
+            QueryComparator::Gt => "gt",
+            QueryComparator::Gte => "gte",
+            QueryComparator::Lt => "lt",
+            QueryComparator::Lte => "lte",
+            QueryComparator::In => "in",
+            QueryComparator::Contains => "contains",
+            QueryComparator::NoneInState => "none_in_state",
+        }
+    }
+
+    /// The row whose `name` is `name`, if any.
+    pub fn from_name(name: &str) -> Option<QueryComparator> {
+        QueryComparator::ALL.iter().copied().find(|row| row.name() == name)
+    }
+
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn every_row_is_found_by_its_own_name() {
+        for row in QueryComparator::ALL.iter() {
+            assert_eq!(QueryComparator::from_name(row.name()), Some(*row));
+        }
+    }
+}