hecks 3.4.2 → 3.6.0

data/lib/hecks/bluebook/assembly/contracts/sagas.rb

@@ -0,0 +1,109 @@
+module Hecks
+  module Bluebook
+    class Assembly
+      # The contracts for the process manager chain and the syntax records;
+      # `CONTRACTS` merges every group.
+      SAGAS = {
+        "ProcessManager" => Contract.new(
+          holder: ProcessManager, make: :new,
+          fields: {
+            name:          [:name,          :plain],
+            # Must be a Symbol: SagaInterpreter looks it up as a symbol-keyed hash
+            # key. A String silently matches nothing, and the saga never advances.
+            correlates_by: [:correlates_by, :identity],
+            starts_on:     [:starts_on,     :plain],
+            ends_on:       [:ends_on,       :plain],
+            states:        [:states,        :plain]
+          },
+          reads: { states: :names },
+          # `handlers` comes from the judge walking the containment tree
+          # (`Handler.parent == "ProcessManager"`), the same as Aggregate's
+          # own `value_objects` — not from any field this contract reads.
+          derived: { position: :walk, handlers: :children }
+        ),
+
+        # Handler is nested under ProcessManager. `event_type` is its real
+        # identity (a saga answers each event once), so unlike other entities
+        # it has no walk-minted `position` to derive.
+        "Handler"        => Contract.new(
+          holder: ProcessManagerHandler, make: :new,
+          fields: {
+            event_type: [:event_type, :plain],
+            from_state: [:from_state, :plain],
+            to_state:   [:to_state,   :plain]
+          },
+          # `dispatches` comes from the containment walk, like ProcessManager's
+          # own `handlers` above — not from a field this contract reads.
+          derived: { dispatches: :children }
+        ),
+
+        # Dispatch is nested under Handler, two levels deep. `command_name` alone
+        # is not identity — a handler can fan the same command out more than
+        # once, so `position` (walk-minted) disambiguates.
+        "Dispatch"       => Contract.new(
+          holder: DispatchSpec, make: :new,
+          fields: {
+            command_name: [:command_name, :plain],
+            with_spec:    [:with_spec,    :bindings]
+          },
+          rows: { with_spec: :with_spec_rows, compensates_with_spec: :compensates_with_spec_rows },
+          reads: { with_spec: [:from, :with_spec] },
+          # compensates_* fold one IR object (`DispatchSpec#compensates`) into two fields.
+          derived: {
+            position:                 :walk,
+            compensates_command_name: [:folded, :compensates, :command_name],
+            compensates_with_spec:    [:folded, :compensates, :with_spec]
+          }
+        ),
+
+        # Syntax/Keyword/Argument bypass Build/Reconstruction entirely (ADR 0026) —
+        # SyntaxBoot reads them directly. These entries exist only so assembly_spec
+        # can hold them to the same "every field claimed" discipline as the rest.
+        "Syntax"         => Contract.new(
+          holder: nil, make: nil,
+          fields: { name: [:name, :plain] },
+          derived: { keywords: :children, arguments: :children }
+        ),
+
+        "Keyword"        => Contract.new(
+          holder: nil, make: nil,
+          fields: {
+            word:          [:word,          :plain],
+            context:       [:context,       :plain],
+            body:          [:body,          :plain],
+            inner:         [:inner,         :plain],
+            opens:         [:opens,         :plain],
+            fills:         [:fills,         :plain],
+            was:           [:was,           :plain],
+            resolves_via:  [:resolves_via,  :plain],
+            disambiguator: [:disambiguator, :plain],
+            calls:         [:calls,         :plain]
+          },
+          derived: { position: :walk }
+        ),
+
+        "Argument"       => Contract.new(
+          holder: nil, make: nil,
+          fields: {
+            keyword:          [:keyword,          :plain],
+            context:          [:context,          :plain],
+            at:               [:at,               :plain],
+            named:            [:named,            :plain],
+            kind:             [:kind, :plain],
+            required:         [:required,         :plain],
+            fills:            [:fills,            :plain],
+            selects:          [:selects,          :plain],
+            pair_key_fills:   [:pair_key_fills,   :plain],
+            pair_value_fills: [:pair_value_fills, :plain],
+            pairs_shape:      [:pairs_shape,      :plain],
+            variadic:         [:variadic,         :plain],
+            minimum:          [:minimum,          :plain],
+            coerce:           [:coerce,           :plain],
+            blank_message:    [:blank_message,    :plain]
+          },
+          derived: { position: :walk }
+        )
+      }.freeze
+    end
+  end
+end

data/lib/hecks/bluebook/assembly/contracts/structure.rb

@@ -0,0 +1,91 @@
+module Hecks
+  module Bluebook
+    class Assembly
+      # The contracts for the chapter, aggregate, command and value object;
+      # `CONTRACTS` merges every group.
+      STRUCTURE = {
+        "Bluebook"    => Contract.new(
+          holder: Chapter, make: :new,
+          fields: {
+            name:              [:name,           :plain],
+            version:           [:version,        :plain],
+            vision:            [:vision,         :plain],
+            classification:    [:classification, :plain],
+            formerly_known_as: [:formerly_known_as, :plain],
+            namespace:         [:namespace, :plain],
+            attaches_to:       [:attaches_to, :plain],
+            provides:          [:provides, :plain]
+          },
+          rows: { normalisations: :normalisation_table },
+          derived: { normalisations: :elsewhere }
+        ),
+
+        "Aggregate"   => Contract.new(
+          holder: Aggregate, make: :new,
+          fields: {
+            name:             [:name,          :plain],
+            description:      [:description,   :plain],
+            identified_by:    [:identified_by, :plain],
+            attributes:       [:attributes,    [:each, :attribute]],
+            # Aggregate's own precondition, referenced by name from a command (ADR 0025).
+            invariants:       [:invariants,    [:each, :invariant]],
+            preconditions:    [:preconditions, [:each, :given]],
+            # The local half of `projects :name, from: "reference.remote_field"` (ADR 0025).
+            projected_fields: [:projected_fields, [:each, :projected_field]],
+            provenance:       [:provenance, :plain]
+          },
+          rows: { transitions: :transition_rows, value_objects: :value_object_names, identified_by: :identity_rows },
+          reads: { identified_by: [:each, :identity_path], attributes: [:each_with_id, :attribute],
+                   invariants: [:each, :rule], preconditions: [:each, :rule],
+                   projected_fields: [:each, :projected_field] },
+          derived: {
+            position:      :walk,
+            state_field:   [:folded, :lifecycle, :field],
+            state_start:   [:folded, :lifecycle, :default],
+            transitions:   [:folded, :lifecycle, :transitions],
+            value_objects: :children
+          }
+        ),
+
+        "Command"     => Contract.new(
+          holder: Command, make: :declare,
+          fields: {
+            name:       [:name,       :plain],
+            role:       [:role,       :plain],
+            goal:       [:goal,       :plain],
+            references: [:references, :plain],
+            attributes: [:attributes, [:each, :shape_field]],
+            givens:     [:givens,     [:each, :given]],
+            ensures:    [:ensures,    [:each, :given]],
+            needs:      [:needs,      [:each, :need]],
+            mutations:  [:mutations,  [:each, :mutation]],
+            emits:      [:emits,      :plain],
+            # Lifecycle state as a command guard: one state, an array, or nil (ADR 0025).
+            from:       [:from,       :plain],
+            provenance: [:provenance, :plain]
+          },
+          rows: { mutations: :mutation_rows },
+          reads: { attributes: [:each, :shape_field], givens: [:each, :rule], ensures: [:each, :rule],
+                  needs: [:each, :need], mutations: [:call, :mutations], emits: :names, provenance: :provenance,
+                  from: :from },
+          derived: { position: :walk }
+        ),
+
+        "ValueObject" => Contract.new(
+          holder: ValueObject, make: :declare,
+          fields: {
+            name:       [:name,       :plain],
+            attributes: [:attributes, [:each, :shape_field]],
+            invariants: [:invariants, [:each, :invariant]],
+            members:    [:members,    [:each, :member]],
+            closed_set: [:closed_set, :flag]
+          },
+          # The language counts the admitted rows ; the IR keeps a flag and the rows.
+          reads: { attributes: [:each, :shape_field], invariants: [:each, :rule],
+                  closed_set: [:call, :closed_set?], members: [:call, :members_row] },
+          derived: { position: :walk, rows: [:folded, %i[closed_set members], nil] }
+        )
+      }.freeze
+    end
+  end
+end

data/lib/hecks/bluebook/assembly/contracts.rb

@@ -1,3 +1,8 @@
+require_relative "contracts/structure"
+require_relative "contracts/rules"
+require_relative "contracts/sagas"
+require_relative "contracts/read_models"
+
 module Hecks
   module Bluebook
     # Reopened for `CONTRACTS`, the table of each category's own `Contract`;
@@ -9,325 +14,10 @@ module Hecks
       def self.contract(category) = CONTRACTS.fetch(category.to_s)
 
       CONTRACTS = {
-        "Bluebook"       => Contract.new(
-          holder: Chapter, make: :new,
-          fields: {
-            name:              [:name,           :plain],
-            version:           [:version,        :plain],
-            vision:            [:vision,         :plain],
-            classification:    [:classification, :plain],
-            formerly_known_as: [:formerly_known_as, :plain],
-            namespace:         [:namespace, :plain],
-            attaches_to:       [:attaches_to, :plain],
-            provides:          [:provides, :plain]
-          },
-          rows: { normalisations: :normalisation_table },
-          derived: { normalisations: :elsewhere }
-        ),
-
-        "Aggregate"      => Contract.new(
-          holder: Aggregate, make: :new,
-          fields: {
-            name:             [:name,          :plain],
-            description:      [:description,   :plain],
-            identified_by:    [:identified_by, :plain],
-            attributes:       [:attributes,    [:each, :attribute]],
-            # Aggregate's own precondition, referenced by name from a command (ADR 0025).
-            invariants:       [:invariants,    [:each, :invariant]],
-            preconditions:    [:preconditions, [:each, :given]],
-            # The local half of `projects :name, from: "reference.remote_field"` (ADR 0025).
-            projected_fields: [:projected_fields, [:each, :projected_field]],
-            provenance:       [:provenance, :plain]
-          },
-          rows: { transitions: :transition_rows, value_objects: :value_object_names, identified_by: :identity_rows },
-          reads: { identified_by: [:each, :identity_path], attributes: [:each_with_id, :attribute],
-                   invariants: [:each, :rule], preconditions: [:each, :rule],
-                   projected_fields: [:each, :projected_field] },
-          derived: {
-            position:      :walk,
-            state_field:   [:folded, :lifecycle, :field],
-            state_start:   [:folded, :lifecycle, :default],
-            transitions:   [:folded, :lifecycle, :transitions],
-            value_objects: :children
-          }
-        ),
-
-        "Command"        => Contract.new(
-          holder: Command, make: :declare,
-          fields: {
-            name:       [:name,       :plain],
-            role:       [:role,       :plain],
-            goal:       [:goal,       :plain],
-            references: [:references, :plain],
-            attributes: [:attributes, [:each, :shape_field]],
-            givens:     [:givens,     [:each, :given]],
-            ensures:    [:ensures,    [:each, :given]],
-            needs:      [:needs,      [:each, :need]],
-            mutations:  [:mutations,  [:each, :mutation]],
-            emits:      [:emits,      :plain],
-            # Lifecycle state as a command guard: one state, an array, or nil (ADR 0025).
-            from:       [:from,       :plain],
-            provenance: [:provenance, :plain]
-          },
-          rows: { mutations: :mutation_rows },
-          reads: { attributes: [:each, :shape_field], givens: [:each, :rule], ensures: [:each, :rule],
-                  needs: [:each, :need], mutations: [:call, :mutations], emits: :names, provenance: :provenance,
-                  from: :from },
-          derived: { position: :walk }
-        ),
-
-        "ValueObject"    => Contract.new(
-          holder: ValueObject, make: :declare,
-          fields: {
-            name:       [:name,       :plain],
-            attributes: [:attributes, [:each, :shape_field]],
-            invariants: [:invariants, [:each, :invariant]],
-            members:    [:members,    [:each, :member]],
-            closed_set: [:closed_set, :flag]
-          },
-          # The language counts the admitted rows ; the IR keeps a flag and the rows.
-          reads: { attributes: [:each, :shape_field], invariants: [:each, :rule],
-                  closed_set: [:call, :closed_set_of], members: [:call, :members_row] },
-          derived: { position: :walk, rows: [:folded, %i[closed_set members], nil] }
-        ),
-
-        "Query"          => Contract.new(
-          holder: Query, make: :new,
-          fields: {
-            name:           [:name,        :plain],
-            description:    [:description, :plain],
-            attributes:     [:attributes,  [:each, :shape_field]],
-            wheres:         [:wheres,          [:each, :where_clause]],
-            order_by:       [:order_by,        :order_by],
-            limit:          [:limit,           :limit],
-            returns:        [:returns,         :plain],
-            needs:          [:needs,           [:each, :need]],
-            # Held by the language as an open map, so every one of these reads the
-            # same way and a ninth option needs no new field on either side.
-            offset:         [:offset,          [:option, :offset]],
-            cursor:         [:cursor,          [:option, :cursor]],
-            null_semantics: [:null_semantics,  [:option, :null_semantics]],
-            authorization:  [:authorization,   [:option, :authorization]],
-            inspection:     [:inspection,      [:option, :inspection]]
-          },
-          rows: { wheres: :where_rows, options: :option_rows },
-          reads: { attributes: [:each, :shape_field], wheres: [:each, :where_clause],
-                  needs: [:each, :need], order_by: [:call, :order_by], limit: [:call, :limit] },
-          derived: {
-            position:    :walk,
-            order_field: [:folded, :order_by, :field],
-            order_way:   [:folded, :order_by, :direction],
-            options:     [:folded, %i[offset cursor null_semantics authorization inspection], nil]
-          }
-        ),
-
-        "Entity"         => Contract.new(
-          holder: Entity, make: :declare,
-          fields: {
-            name:          [:name,          :plain],
-            description:   [:description,   :plain],
-            # A list of paths, like Aggregate's. Must be Symbols: a String looks
-            # identical here but a symbol-keyed args lookup downstream would find
-            # nothing, silently rejecting a value that was in fact passed.
-            identified_by: [:identified_by, :plain],
-            attributes:    [:attributes,    [:each, :shape_field]],
-            # Same shape as Aggregate's own `preconditions`, one level down (ADR 0028).
-            preconditions: [:preconditions, [:each, :given]],
-            # Same shape as Aggregate's own `invariants`, checked per instance of
-            # this entity rather than the aggregate's flat state.
-            invariants:    [:invariants,    [:each, :invariant]]
-          },
-          rows: { transitions: :transition_rows, identified_by: :identity_rows },
-          reads: { identified_by: [:each, :identity_path], attributes: [:each, :shape_field],
-                   preconditions: [:each, :rule], invariants: [:each, :rule] },
-          derived: {
-            position:    :walk,
-            owner:       :parent,
-            state_field: [:folded, :lifecycle, :field],
-            state_start: [:folded, :lifecycle, :default],
-            transitions: [:folded, :lifecycle, :transitions]
-          }
-        ),
-
-        "Policy"         => Contract.new(
-          holder: Policy, make: :new,
-          fields: {
-            name:               [:name,            :plain],
-            aggregate:          [:aggregate,       :plain],
-            on_event:           [:on_event,        :plain],
-            trigger_command:    [:trigger_command, :plain],
-            target_domain:      [:target_domain,   :plain],
-            expect_undelivered: [:expect_undelivered, :plain],
-            where:              [:where,           :plain],
-            for_each:           [:for_each,        :plain],
-            with_spec:          [:with_spec,       :bindings]
-          },
-          rows: { with_spec: :with_spec_rows },
-          reads: { with_spec: [:from, :with_spec], expect_undelivered: :expect_undelivered? },
-          derived: { position: :walk }
-        ),
-
-        "ProcessManager" => Contract.new(
-          holder: ProcessManager, make: :new,
-          fields: {
-            name:          [:name,          :plain],
-            # Must be a Symbol: SagaInterpreter looks it up as a symbol-keyed hash
-            # key. A String silently matches nothing, and the saga never advances.
-            correlates_by: [:correlates_by, :identity],
-            starts_on:     [:starts_on,     :plain],
-            ends_on:       [:ends_on,       :plain],
-            states:        [:states,        :plain]
-          },
-          reads: { states: :names },
-          # `handlers` comes from the judge walking the containment tree
-          # (`Handler.parent == "ProcessManager"`), the same as Aggregate's
-          # own `value_objects` — not from any field this contract reads.
-          derived: { position: :walk, handlers: :children }
-        ),
-
-        # Handler is nested under ProcessManager. `event_type` is its real
-        # identity (a saga answers each event once), so unlike other entities
-        # it has no walk-minted `position` to derive.
-        "Handler"        => Contract.new(
-          holder: ProcessManagerHandler, make: :new,
-          fields: {
-            event_type: [:event_type, :plain],
-            from_state: [:from_state, :plain],
-            to_state:   [:to_state,   :plain]
-          },
-          # `dispatches` comes from the containment walk, like ProcessManager's
-          # own `handlers` above — not from a field this contract reads.
-          derived: { dispatches: :children }
-        ),
-
-        # Dispatch is nested under Handler, two levels deep. `command_name` alone
-        # is not identity — a handler can fan the same command out more than
-        # once, so `position` (walk-minted) disambiguates.
-        "Dispatch"       => Contract.new(
-          holder: DispatchSpec, make: :new,
-          fields: {
-            command_name: [:command_name, :plain],
-            with_spec:    [:with_spec,    :bindings]
-          },
-          rows: { with_spec: :with_spec_rows, compensates_with_spec: :compensates_with_spec_rows },
-          reads: { with_spec: [:from, :with_spec] },
-          # compensates_* fold one IR object (`DispatchSpec#compensates`) into two fields.
-          derived: {
-            position:                 :walk,
-            compensates_command_name: [:folded, :compensates, :command_name],
-            compensates_with_spec:    [:folded, :compensates, :with_spec]
-          }
-        ),
-
-        # Syntax/Keyword/Argument bypass Build/Reconstruction entirely (ADR 0026) —
-        # SyntaxBoot reads them directly. These entries exist only so assembly_spec
-        # can hold them to the same "every field claimed" discipline as the rest.
-        "Syntax"         => Contract.new(
-          holder: nil, make: nil,
-          fields: { name: [:name, :plain] },
-          derived: { keywords: :children, arguments: :children }
-        ),
-
-        "Keyword"        => Contract.new(
-          holder: nil, make: nil,
-          fields: {
-            word:          [:word,          :plain],
-            context:       [:context,       :plain],
-            body:          [:body,          :plain],
-            inner:         [:inner,         :plain],
-            opens:         [:opens,         :plain],
-            fills:         [:fills,         :plain],
-            was:           [:was,           :plain],
-            resolves_via:  [:resolves_via,  :plain],
-            disambiguator: [:disambiguator, :plain],
-            calls:         [:calls,         :plain]
-          },
-          derived: { position: :walk }
-        ),
-
-        "Argument"       => Contract.new(
-          holder: nil, make: nil,
-          fields: {
-            keyword:          [:keyword,          :plain],
-            context:          [:context,          :plain],
-            at:               [:at,               :plain],
-            named:            [:named,            :plain],
-            kind:             [:kind, :plain],
-            required:         [:required,         :plain],
-            fills:            [:fills,            :plain],
-            selects:          [:selects,          :plain],
-            pair_key_fills:   [:pair_key_fills,   :plain],
-            pair_value_fills: [:pair_value_fills, :plain],
-            pairs_shape:      [:pairs_shape,      :plain],
-            variadic:         [:variadic,         :plain],
-            minimum:          [:minimum,          :plain],
-            coerce:           [:coerce,           :plain],
-            blank_message:    [:blank_message,    :plain]
-          },
-          derived: { position: :walk }
-        ),
-
-        "ReadModel"      => Contract.new(
-          holder: ReadModel, make: :new,
-          fields: {
-            name:             [:name,             :plain],
-            description:      [:description,      :plain],
-            reference_name:   [:reference_name,   :identity],
-            reference_target: [:reference_target, :plain],
-            aggregate_heads:  [:aggregate_heads,  [:each, :head]],
-            group_by:         [:group_by,         [:each, :group_by_field]],
-            # Scalars, not lists: `:plain` is for Build (native to_h value);
-            # the `reads:` entry below is for Reconstruction (stringified row).
-            count:            [:count,            :plain],
-            median_field:     [:median_field,     :plain],
-            sum_field:        [:sum_field,        :plain],
-            avg_field:        [:avg_field,        :plain],
-            min_field:        [:min_field,        :plain],
-            max_field:        [:max_field,        :plain],
-            percentile_field: [:percentile_field, :plain],
-            percentile_at:    [:percentile_at,    :plain],
-            any_field:        [:any_field,        :plain],
-            all_field:        [:all_field,        :plain],
-            # A read model inherits every option an ask has, so it reads them the
-            # same way — see Query.
-            wheres:           [:wheres,           [:each, :where_clause]],
-            order_by:         [:order_by,         :order_by],
-            limit:            [:limit,            :limit],
-            offset:           [:offset,           [:option, :offset]],
-            cursor:           [:cursor,           [:option, :cursor]],
-            null_semantics:   [:null_semantics,   [:option, :null_semantics]],
-            authorization:    [:authorization,    [:option, :authorization]],
-            inspection:       [:inspection,       [:option, :inspection]]
-          },
-          rows: { options: :read_model_option_rows },
-          # `wheres` needs its own reader so an undeclared list defaults to `[]`,
-          # not the generic reader's `nil`; real values arrive via the options
-          # merge in `read_model` below, which overrides this default.
-          reads: { reference_name: :symbol, aggregate_heads: [:each, :head],
-                  group_by: [:each, :group_by_field], wheres: [:each, :where_clause],
-                  # `count` needs boolean coercion (stringified on the wire);
-                  # `median_field` needs none — the default reader already
-                  # matches `to_h`'s String-or-nil.
-                  count: :read_model_count,
-                  # `percentile_at` needs Float coercion; every other reduction field
-                  # is a Symbol-like name the default text reader already matches.
-                  percentile_at: :read_model_percentile_at },
-          derived: {
-            position:   :walk,
-            query_name: [:computed, :query_name],
-            options:    [:folded, %i[offset cursor null_semantics authorization inspection], nil]
-          }
-        ),
-
-        # Member is nested under ValueObject. Its pairs are an open map, so it
-        # holds no `shape` field — only walk-minted `position` and `pairs`
-        # (still one row per entry, still an open map).
-        "Member"         => Contract.new(
-          holder: nil, make: nil,
-          fields: {},
-          rows: { pairs: :pair_rows },
-          derived: { position: :walk, pairs: [:folded, %i[members], nil] }
-        )
+        **STRUCTURE,
+        **RULES,
+        **SAGAS,
+        **READ_MODELS
       }.freeze
     end
   end

data/lib/hecks/bluebook/assembly/marks.rb

@@ -12,20 +12,21 @@ module Hecks
           type = field[:type].to_s
           target = type[/\AReference<(.+)>\z/, 1]
 
-          Attribute.new(
-            name:         field[:name],
-            type:         target ? Reference.new(target) : type,
+          Attribute.new(name: field[:name], type: target ? Reference.new(target) : type, **attribute_options(field))
+        end
+
+        # Every registry bluebook is a round-trip product, so a fact dropped here is a fact
+        # the language cannot state about itself. `admits` is not on `to_h`, but the grammar
+        # registry keeps the assembled graph and downstream projections read the link off it.
+        def attribute_options(field)
+          {
             list:         field[:list] ? true : false,
             default:      field[:default],
-            # Every registry bluebook is a round-trip product, so a fact dropped
-            # here is a fact the language cannot state about itself.
             optional:     field[:optional] ? true : false,
             pattern:      field[:pattern],
-            # Not on `to_h`, but the grammar registry keeps the assembled graph and
-            # downstream projections read the link off it, so it must survive.
             admits:       field[:admits],
             relationship: field[:relationship]
-          )
+          }
         end
 
         # A head's field and a verb's argument are separate verbs sharing one IR class.

data/lib/hecks/bluebook/attribute.rb

@@ -1,4 +1,5 @@
 require_relative "behaviour/attribute"
+require_relative "keyword_fields"
 require_relative "../ir"
 require_relative "../vocabulary"
 require_relative "../naming"
@@ -24,6 +25,12 @@ module Hecks
 
       attr_reader :name, :type, :default, :pattern, :admits, :relationship
 
+      # The optional fields (`list`, `default`, `optional`, `pattern`, `admits`, `relationship`)
+      # and what each holds when the declaration omits it.
+      FIELD_DEFAULTS = {
+        list: false, default: nil, optional: false, pattern: nil, admits: nil, relationship: nil
+      }.freeze
+
       # A Reference is kept as itself; every other type is a name.
       #
       # @param name [Symbol, String] the attribute's name
@@ -35,16 +42,12 @@ module Hecks
       # @param pattern [String, nil] a regex source the value must match (`PatternSubset`)
       # @param admits [String, nil] an aggregate-qualified closed-set name for the value
       # @param relationship [Symbol, nil] the DSL word that minted this attribute, or `nil`
-      def initialize(name:, type:, list: false, default: nil, optional: false, pattern: nil,
-                     admits: nil, relationship: nil)
-        @name     = name.to_sym
-        @type     = spell(type)
-        @list     = list
-        @default  = default
-        @optional = optional
-        @pattern  = pattern
-        @admits   = admits&.to_s
-        @relationship = relationship&.to_s
+      def initialize(name:, type:, **given)
+        KeywordFields.assign(self, KeywordFields.fill(given, FIELD_DEFAULTS))
+        @name         = name.to_sym
+        @type         = spell(type)
+        @admits       = @admits&.to_s
+        @relationship = @relationship&.to_s
       end
 
       # A bare constant in a bluebook is a name, even when Ruby has heard of it.

data/lib/hecks/bluebook/behaviour/aggregate.rb

@@ -90,13 +90,20 @@ module Hecks
           held = @ports_by_name[port.name]
           return attach_port(port) unless held
 
-          operations = held.operations + port.operations.reject { |op| held.operation(op.hecks_name) }
-          answers    = held.answered_queries + port.answered_queries.reject { |a| held.answer_for(a.name) }
-          merged     = Bluebook::DomainPort.new(name: held.name, operations: operations, answered_queries: answers)
+          merged = merge_port(held, port)
           @ports[@ports.index(held)] = merged
           @ports_by_name[merged.name] = merged
         end
 
+        # @param held [Bluebook::DomainPort] the port the aggregate already holds under the name
+        # @param port [Bluebook::DomainPort] the port declared again
+        # @return [Bluebook::DomainPort] `held` with whatever `port` adds to it
+        def merge_port(held, port)
+          operations = held.operations + port.operations.reject { |op| held.operation(op.hecks_name) }
+          answers    = held.answered_queries + port.answered_queries.reject { |a| held.answer_for(a.name) }
+          Bluebook::DomainPort.new(name: held.name, operations: operations, answered_queries: answers)
+        end
+
         # @param port [Bluebook::DomainPort] a port under a name the aggregate does not hold
         # @return [void]
         def attach_port(port)