hecks 1.0.2 → 1.1.0

data/lib/hecks/projector/narrate_projector.rb

@@ -72,7 +72,11 @@ module Hecks
         parts << identity_sentence(aggregate)
 
         refs = aggregate.attributes.select(&:reference?)
-        parts << "Each one is linked to #{to_sentence_list(refs.map { |r| "#{a_or_an(r.type.target_name)} #{r.type.target_name}" })}." unless refs.empty?
+        unless refs.empty?
+          parts << "Each one is linked to #{to_sentence_list(refs.map do |r|
+            "#{a_or_an(r.type.target_name)} #{r.type.target_name}"
+          end)}."
+        end
 
         parts << lifecycle_narrative(aggregate)
         parts << verbs_narrative(aggregate, depth + 1)
@@ -124,35 +128,84 @@ module Hecks
         "#{header}\n\n#{body}"
       end
 
+      # ONE PARAGRAPH, BUILT FROM INDEPENDENT SENTENCES — each sentence
+      # below states one unrelated fact about `command` (its goal, who
+      # issues it, whether it creates the holder, what it takes, what it
+      # references, what gates it, what it guarantees, what it emits), in
+      # the fixed order a reader expects them; nothing after the first
+      # sentence depends on anything before it. Same nil-or-string +
+      # `compact.join` shape `aggregate_narrative`/`entity_narrative`
+      # already use above for the identical reason.
       def command_paragraph(command, holder)
-        # THE GOAL, VERBATIM — same rule `DocsProjector` holds to: quoted
-        # exactly as declared, not recased to fit mid-sentence, because the
-        # promise this whole projector makes is that a sentence here is a
-        # sentence the chapter actually wrote.
-        sentences = ["**#{command.hecks_name}**#{command.goal ? " — #{command.goal}." : '.'}"]
-        sentences << "Issued by #{a_or_an(command.role)} #{command.role}." if command.role
-        # `acts_on.nil?`, NOT `creates?` — `creates?` answers true for every
-        # verb an ENTITY declares (it never references itself; see
-        # `Command#acts_on`'s own comment), so reading it directly here would
-        # tell an SME that `LedgerEntry.Amend` brings a new ledger entry into
-        # being, which is exactly backwards.
-        sentences << "This is how a new #{holder.hecks_name} comes into being." if command.acts_on.nil?
+        [
+          command_headline_sentence(command),
+          command_role_sentence(command),
+          command_creation_sentence(command, holder),
+          command_arguments_sentence(command),
+          command_references_sentence(command),
+          command_conditions_sentence(command, holder),
+          command_guarantees_sentence(command),
+          command_emits_sentence(command)
+        ].compact.join(" ")
+      end
+
+      # THE GOAL, VERBATIM — same rule `DocsProjector` holds to: quoted
+      # exactly as declared, not recased to fit mid-sentence, because the
+      # promise this whole projector makes is that a sentence here is a
+      # sentence the chapter actually wrote.
+      def command_headline_sentence(command)
+        "**#{command.hecks_name}**#{command.goal ? " — #{command.goal}." : '.'}"
+      end
+
+      def command_role_sentence(command)
+        return nil unless command.role
+
+        "Issued by #{a_or_an(command.role)} #{command.role}."
+      end
+
+      # `acts_on.nil?`, NOT `creates?` — `creates?` answers true for every
+      # verb an ENTITY declares (it never references itself; see
+      # `Command#acts_on`'s own comment), so reading it directly here would
+      # tell an SME that `LedgerEntry.Amend` brings a new ledger entry into
+      # being, which is exactly backwards.
+      def command_creation_sentence(command, holder)
+        return nil unless command.acts_on.nil?
+
+        "This is how a new #{holder.hecks_name} comes into being."
+      end
 
+      def command_arguments_sentence(command)
         arguments = command.attributes.reject(&:reference?)
-        sentences << "It takes #{to_sentence_list(arguments.map { |a| Forms::Humanize.label(a.name.to_s).downcase })}." unless arguments.empty?
+        return nil if arguments.empty?
 
+        "It takes #{to_sentence_list(arguments.map { |a| Forms::Humanize.label(a.name.to_s).downcase })}."
+      end
+
+      def command_references_sentence(command)
         refs = command.attributes.select(&:reference?)
-        sentences << "It's aimed at one existing #{to_sentence_list(refs.map { |r| r.type.target_name })}, by id." unless refs.empty?
+        return nil if refs.empty?
 
+        "It's aimed at one existing #{to_sentence_list(refs.map { |r| r.type.target_name })}, by id."
+      end
+
+      def command_conditions_sentence(command, holder)
         conditions = conditions_of(command, holder)
-        sentences << "It only goes through if #{conditions.join('; ')}." unless conditions.empty?
+        return nil if conditions.empty?
 
+        "It only goes through if #{conditions.join('; ')}."
+      end
+
+      def command_guarantees_sentence(command)
         guarantees = command.ensures.map(&:description)
-        sentences << "When it succeeds: #{guarantees.join('; ')}." unless guarantees.empty?
+        return nil if guarantees.empty?
+
+        "When it succeeds: #{guarantees.join('; ')}."
+      end
 
-        sentences << "It records `#{command.emits.join('`, `')}` as a fact." unless command.emits.empty?
+      def command_emits_sentence(command)
+        return nil if command.emits.empty?
 
-        sentences.join(" ")
+        "It records `#{command.emits.join('`, `')}` as a fact."
       end
 
       # EVERY REQUIRED CONDITION, STATED AS SOMETHING THAT MUST BE TRUE —
@@ -166,10 +219,14 @@ module Hecks
 
         lifecycle = holder.lifecycle
         if lifecycle
-          froms = lifecycle.transitions.filter_map { |name, transition|
+          froms = lifecycle.transitions.filter_map do |name, transition|
             Array(transition.from) if name.to_s == command.hecks_name
-          }.flatten.uniq
-          conditions << "its `#{lifecycle.field}` is currently #{to_sentence_list(froms.map { |f| "`#{f}`" }, conj: 'or')}" unless froms.empty?
+          end.flatten.uniq
+          unless froms.empty?
+            conditions << "its `#{lifecycle.field}` is currently #{to_sentence_list(froms.map do |f|
+              "`#{f}`"
+            end, conj: 'or')}"
+          end
         end
 
         conditions + command.givens.map(&:description)
@@ -200,8 +257,8 @@ module Hecks
         "#{header}\n\n#{lines.join("\n")}"
       end
 
-      def op_words(op)
-        { eq: "is", lt: "under", lte: "at most", gt: "over", gte: "at least" }[op.to_s.to_sym] || op.to_s
+      def op_words(comparator)
+        { eq: "is", lt: "under", lte: "at most", gt: "over", gte: "at least" }[comparator.to_s.to_sym] || comparator.to_s
       end
 
       # ── what happens on its own ───────────────────────────────────────
@@ -212,7 +269,8 @@ module Hecks
         parts = [DocsProjector.h(depth, "Reactions")]
         bluebook.policies.each do |policy|
           elsewhere = policy.target_domain ? " in #{policy.target_domain}" : ""
-          parts << "Whenever `#{policy.on_event}` happens, `#{policy.trigger_command}` fires on its own#{elsewhere} — nobody has to ask for it."
+          parts << "Whenever `#{policy.on_event}` happens, `#{policy.trigger_command}` fires on its own#{elsewhere} — " \
+                   "nobody has to ask for it."
         end
 
         bluebook.process_managers.each do |saga|

data/lib/hecks/projector.rb

@@ -70,9 +70,9 @@ module Hecks
     # any construct that emits IR, and `admits!` is what decides whether
     # THIS target can actually take the one handed over.
     def call(name, bluebook:, options: {})
-      projector = registry.fetch(name.to_sym) {
+      projector = registry.fetch(name.to_sym) do
         raise UnknownProjector, "no projector registered for #{name.inspect} — registered: #{registered.sort.inspect}"
-      }
+      end
       admits!(name, projector, bluebook)
       projector.call(bluebook: bluebook, options: options)
     end

data/lib/hecks/query_ir.rb

@@ -1,4 +1,3 @@
-require "set"
 require_relative "bluebook"
 require_relative "codemod"
 require_relative "projections/model"
@@ -49,9 +48,9 @@ module Hecks
     # makes, reusing its own Deviations data so this can never silently
     # drift from what that gate actually checks.
     def construct_diff(name)
-      klass = CONSTRUCTS.fetch(name) {
+      klass = CONSTRUCTS.fetch(name) do
         raise ArgumentError, "no such construct #{name.inspect} — known: #{CONSTRUCTS.keys.join(', ')}"
-      }
+      end
       declared = meta_declared(name)
       emitted  = klass.ir_spec.keys
 
@@ -101,33 +100,9 @@ module Hecks
       rules = []
       chapters = chapter_name ? [registry.bluebook(chapter_name)] : registry.bluebooks.values
 
-      walk_construct = lambda do |construct, path|
-        (construct.respond_to?(:preconditions) ? construct.preconditions : []).each do |rule|
-          rules << Rule.new(kind: "given", description: rule.description, canonical: rule.canonical,
-                            location: "#{path} (declared)")
-        end
-        (construct.respond_to?(:invariants) ? construct.invariants : []).each do |rule|
-          rules << Rule.new(kind: "invariant", description: rule.description, canonical: rule.canonical,
-                            location: "#{path} (declared)")
-        end
-        construct.commands.each do |command|
-          command.givens.each do |rule|
-            rules << Rule.new(kind: "given", description: rule.description, canonical: rule.canonical,
-                              location: "#{path}.#{command.hecks_name}")
-          end
-          command.ensures.each do |rule|
-            rules << Rule.new(kind: "ensures", description: rule.description, canonical: rule.canonical,
-                              location: "#{path}.#{command.hecks_name}")
-          end
-        end
-        construct.entities.each { |piece|
-          walk_construct.call(piece, "#{path}.#{piece.hecks_name}")
-        } if construct.respond_to?(:entities)
-      end
-
       chapters.each do |chapter|
         chapter.aggregates.each do |aggregate|
-          walk_construct.call(aggregate, aggregate.hecks_name)
+          walk_construct_rules(aggregate, aggregate.hecks_name, rules)
           aggregate.value_objects.each do |vo|
             vo.invariants.each do |rule|
               rules << Rule.new(kind: "invariant", description: rule.description, canonical: rule.canonical,
@@ -139,6 +114,39 @@ module Hecks
       rules
     end
 
+    # THE RECURSIVE WALK `collect_rules` drives — pulled out of that method
+    # (pure extraction, identical traversal and Rule shapes) as its own
+    # named, self-recursive method rather than a lambda closing over the
+    # same locals. `rules` is the one piece of state every call shares —
+    # threaded as a parameter and mutated in place, the same accumulator
+    # role the lambda's own closure played.
+    def walk_construct_rules(construct, path, rules)
+      (construct.respond_to?(:preconditions) ? construct.preconditions : []).each do |rule|
+        rules << Rule.new(kind: "given", description: rule.description, canonical: rule.canonical,
+                          location: "#{path} (declared)")
+      end
+      (construct.respond_to?(:invariants) ? construct.invariants : []).each do |rule|
+        rules << Rule.new(kind: "invariant", description: rule.description, canonical: rule.canonical,
+                          location: "#{path} (declared)")
+      end
+      construct.commands.each do |command|
+        command.givens.each do |rule|
+          rules << Rule.new(kind: "given", description: rule.description, canonical: rule.canonical,
+                            location: "#{path}.#{command.hecks_name}")
+        end
+        command.ensures.each do |rule|
+          rules << Rule.new(kind: "ensures", description: rule.description, canonical: rule.canonical,
+                            location: "#{path}.#{command.hecks_name}")
+        end
+      end
+      return unless construct.respond_to?(:entities)
+
+      construct.entities.each do |piece|
+        walk_construct_rules(piece, "#{path}.#{piece.hecks_name}", rules)
+      end
+    end
+    private_class_method :walk_construct_rules
+
     # A rule's OWNER — the construct path a "(declared)" location names
     # directly, or (for a command-level `.givens`/`.ensures` entry) the
     # path with its trailing `.CommandName` segment stripped. Two rules
@@ -196,10 +204,10 @@ module Hecks
       all_rules.group_by { |r| [r.kind, r.description, r.canonical] }
                .map { |key, rules| [key, rules, declaration_count(rules)] }
                .select { |_, _, count| count > 1 }
-               .map { |(kind, description, canonical), rules, _|
+               .map do |(kind, description, canonical), rules, _|
         { kind: kind, description: description, canonical: canonical,
       locations: rules.map(&:location) }
-      }
+      end
     end
 
     # `given` ONLY (not `invariant`/`ensures`) also covers CROSS-ENTITY
@@ -254,9 +262,9 @@ module Hecks
     # resolved chapter-wide reference.
     def declaration_count(rules)
       declared = rules.select { |r| r.location.end_with?(" (declared)") }
-      declared_owners = declared.map { |r| owner_of(r.location) }.to_set
+      declared_owners = declared.to_set { |r| owner_of(r.location) }
       declared_given_roots = declared.select { |r| r.kind == "given" }
-                                     .map { |r| owner_of(r.location).split(".").first }.to_set
+                                     .to_set { |r| owner_of(r.location).split(".").first }
 
       standalone = rules.reject do |r|
         owner = owner_of(r.location)
@@ -282,8 +290,14 @@ module Hecks
         if diff[:missing_from_ruby].empty? && diff[:unaccounted_in_ruby].empty?
           lines << "  clean — every declared field is emitted (or a named deviation), nothing emitted is undeclared"
         else
-          lines << "  MISSING FROM RUBY (declared, not emitted, not a named deviation): #{diff[:missing_from_ruby].join(', ')}" unless diff[:missing_from_ruby].empty?
-          lines << "  UNACCOUNTED IN RUBY (emitted, not declared, not a named deviation): #{diff[:unaccounted_in_ruby].join(', ')}" unless diff[:unaccounted_in_ruby].empty?
+          unless diff[:missing_from_ruby].empty?
+            lines << "  MISSING FROM RUBY (declared, not emitted, not a named deviation): " \
+                     "#{diff[:missing_from_ruby].join(', ')}"
+          end
+          unless diff[:unaccounted_in_ruby].empty?
+            lines << "  UNACCOUNTED IN RUBY (emitted, not declared, not a named deviation): " \
+                     "#{diff[:unaccounted_in_ruby].join(', ')}"
+          end
         end
         lines.join("\n")
       end.join("\n\n")
@@ -358,6 +372,10 @@ module Hecks
     # was never supposed to have this touchpoint at all.
     def reconstruction_reads?(name, field)
       method_name = RECONSTRUCTION_METHODS[name]
+      # rubocop:disable-next Style/ReturnNilInPredicateMethodDefinition -- nil vs
+      # false is a deliberate distinction here: nil means "not applicable" (no
+      # hand-typed method to check), false means "applicable, and it fails" —
+      # see the spec's own "not-applicable (nil), not false" example.
       return nil unless method_name
 
       file, start_line = Hecks::Bluebook::MetaValidator::Reconstruction.instance_method(method_name).source_location
@@ -365,7 +383,9 @@ module Hecks
       def_line = lines[start_line - 1]
       indent = def_line[/\A\s*/]
 
-      body = lines[start_line..].take_while { |line| line.strip.empty? || line[/\A\s*/].size > indent.size || !line.lstrip.start_with?("def ") }
+      body = lines[start_line..].take_while do |line|
+        line.strip.empty? || line[/\A\s*/].size > indent.size || !line.lstrip.start_with?("def ")
+      end
       body.join.include?("#{field}:")
     end
     private_class_method :reconstruction_reads?
@@ -385,7 +405,11 @@ module Hecks
     def format_impact_preview(preview)
       lines = ["== #{preview[:name]}##{preview[:field]} =="]
       preview[:touchpoints].each do |t|
-        mark = t[:present].nil? ? "n/a" : (t[:present] ? "yes" : "NOT YET")
+        mark = if t[:present].nil?
+                 "n/a"
+               else
+                 (t[:present] ? "yes" : "NOT YET")
+               end
         lines << "  [#{mark.rjust(7)}] #{t[:touchpoint]}"
       end
       done = preview[:touchpoints].count { |t| t[:present] == true }

data/lib/hecks/query_specification/common/authorization_spec.rb

@@ -2,7 +2,7 @@ module Hecks
   module QuerySpecification
     module Common
       AuthorizationSpec = Struct.new(:policy, :tenant, keyword_init: true) do
-        def to_h = { policy: policy.to_s, tenant: tenant && tenant.to_s }
+        def to_h = { policy: policy.to_s, tenant: tenant&.to_s }
       end
     end
   end

data/lib/hecks/query_specification/common/comparators.rb

@@ -2,6 +2,10 @@ require_relative "../../literal"
 require_relative "../../vocabulary"
 
 module Hecks
+  # Reopened (see query_specification.rb for the namespace's own
+  # summary) to add Common::COMPARATORS — the vendored comparator
+  # vocabulary — and .render_value, the wire-rendering entry point
+  # shared by every literal-bearing spec struct.
   module QuerySpecification
     module Common
       # `none_in_state`, vendored addition not (yet) upstream hecks

data/lib/hecks/query_specification/common/comparison.rb

@@ -44,7 +44,7 @@ module Hecks
           value = value.to_h if value.is_a?(Runtime::Value)
           return value unless value.is_a?(Hash)
 
-          numerics = value.values.select { |field| field.is_a?(Numeric) }
+          numerics = value.values.grep(Numeric)
           return numerics.first if numerics.size == 1
           return value.values.first if value.size == 1
 
@@ -63,6 +63,13 @@ module Hecks
 
         NUMERIC_TYPES = %w[Integer Float Numeric].freeze
 
+        # A `case` over a closed, declared set (Vocabulary::QueryComparator,
+        # held equal to this list by spec/vocabulary_table_spec — see the
+        # `else` branch's own comment) is the whole point of THE ONE
+        # COMPARATOR TABLE this file's header describes: one place naming
+        # every comparator, not one method per comparator scattered across
+        # a module.
+        # rubocop:disable-next Metrics/CyclomaticComplexity
         def holds?(operation, held, want, registry: nil)
           # A NULL SATISFIES NO COMPARISON — NullPolicy.unmatchable? owns
           # the rule and the reasoning, including why `none_in_state` is

data/lib/hecks/query_specification/common/dsl.rb

@@ -11,6 +11,11 @@ require_relative "where_clause"
 module Hecks
   module QuerySpecification
     module Common
+      # Shared builder-instance methods for the `where`/`order_by`/
+      # `limit`/`offset`/`cursor`/`authorize`/`nulls`/`inspect_query`
+      # bluebook DSL words, mixed into both QueryBuilder and
+      # ReadModelBuilder so the two specification kinds parse the same
+      # clauses identically rather than each carrying its own copy.
       module DSL
         # RENAMED FROM `where`/`order_by`/`limit`/`offset`/`authorize`
         # (all below) — item #13's full metaprogrammed dispatch (slice

data/lib/hecks/query_specification/common/null_policy.rb

@@ -1,6 +1,12 @@
 module Hecks
   module QuerySpecification
     module Common
+      # Null-handling shared between the in-memory and SQL query
+      # engines: stable null-aware ordering (#order, #sql_order) and
+      # which comparators a null value can never satisfy (#unmatchable?,
+      # #sql_predicate) — kept in one place because Memory, Postgres and
+      # SQLite each default nulls differently and must be made to agree
+      # explicitly rather than leaking their own native behavior.
       module NullPolicy
         module_function
 
@@ -82,8 +88,6 @@ module Hecks
             ["#{expression} IS NULL", []]
           elsif value.nil? && operation.to_s == "ne"
             ["#{expression} IS NOT NULL", []]
-          else
-            nil
           end
         end
       end

data/lib/hecks/query_specification/common/options.rb

@@ -3,6 +3,12 @@ require_relative "null_semantics"
 module Hecks
   module QuerySpecification
     module Common
+      # The attribute set every query-shaped construct shares — wheres,
+      # ordering, paging, cursor, authorization, null semantics,
+      # inspection mode — plus `options_to_h`/`extra_options_to_h` for
+      # serializing it. Both Bluebook::Query and
+      # QuerySpecification::ReadModel::Specification subclass this
+      # rather than each declaring the same fields twice.
       class Options
         attr_reader :wheres, :order_by, :limit, :offset, :cursor,
                     :authorization, :null_semantics, :inspection
@@ -10,8 +16,14 @@ module Hecks
         def initialize(wheres: [], order_by: nil, limit: nil, offset: nil, cursor: nil,
                        authorization: nil,
                        inspection: nil, null_semantics: NullSemantics.default)
-          @wheres, @order_by, @limit, @offset, @cursor = wheres, order_by, limit, offset, cursor
-          @authorization, @null_semantics, @inspection = authorization, null_semantics, inspection
+          @wheres = wheres
+          @order_by = order_by
+          @limit = limit
+          @offset = offset
+          @cursor = cursor
+          @authorization = authorization
+          @null_semantics = null_semantics
+          @inspection = inspection
         end
 
         def options_to_h
@@ -21,10 +33,10 @@ module Hecks
         end
 
         def extra_options_to_h
-          options_to_h.reject { |key, value|
+          options_to_h.reject do |key, value|
             value.nil? || value == [] || (key == :null_semantics && value == { mode: "native" })
-          }
-                      .reject { |key, _| %i[wheres order_by limit].include?(key) }
+          end
+                      .except(:wheres, :order_by, :limit)
         end
       end
     end

data/lib/hecks/query_specification/field_path.rb

@@ -85,8 +85,8 @@ module Hecks
       # or a value object carrying at least one numeric member. A dotted
       # path must land on a numeric primitive itself — the convention does
       # not reach through a named path, it IS the absence of one.
-      def numeric?(attribute, segments, &value_object)
-        leaf = leaf_attribute(attribute, segments, &value_object)
+      def numeric?(attribute, segments, &)
+        leaf = leaf_attribute(attribute, segments, &)
         return false if leaf.nil? || leaf.list? || leaf.reference?
         return true if NUMERIC_PRIMITIVES.include?(leaf.type.to_s)
         return false unless segments.empty?
@@ -98,8 +98,8 @@ module Hecks
       # A dotted path must end on a SCALAR member — landing on a value
       # object would hand SQL a JSON object where the reference
       # interpreter unwraps a hash, and the two would answer differently.
-      def scalar_leaf?(attribute, segments, &value_object)
-        leaf = leaf_attribute(attribute, segments, &value_object)
+      def scalar_leaf?(attribute, segments, &)
+        leaf = leaf_attribute(attribute, segments, &)
         !leaf.nil? && !leaf.list? && !leaf.reference? && SCALAR_PRIMITIVES.include?(leaf.type.to_s)
       end
     end

data/lib/hecks/query_specification/read_model/specification.rb

@@ -3,11 +3,14 @@ require_relative "../common/options"
 module Hecks
   module QuerySpecification
     module ReadModel
+      # The read-model-specific specification: Common::Options' shared
+      # query attributes plus `joins`, the one thing a read model
+      # declares that a plain Query does not.
       class Specification < Common::Options
         attr_reader :joins
 
-        def initialize(joins: [], **options)
-          super(**options)
+        def initialize(joins: [], **)
+          super(**)
           @joins = joins
         end
 

data/lib/hecks/router/namespace_installer.rb

@@ -7,12 +7,19 @@ module Hecks
     # resolution stays in Router; this object only adapts it to constants and
     # method calls.
     class NamespaceInstaller
+      # Returned by the `.options(version:)` method installed on each
+      # namespace module — forwards any command/query verb called on it
+      # to the router, pinned to this specific FQN version rather than
+      # the router's default resolution.
       class OptionsProxy
         def initialize(router:, realm:, domain:, aggregate:, options:)
           unknown = options.keys - [:version]
           raise ArgumentError, "unknown router options: #{unknown.join(', ')}" unless unknown.empty?
 
-          @router, @realm, @domain, @aggregate = router, realm, domain, aggregate
+          @router = router
+          @realm = realm
+          @domain = domain
+          @aggregate = aggregate
           @version = options[:version]&.to_s
         end
 
@@ -103,12 +110,12 @@ module Hecks
 
         target.define_singleton_method(:find) do |id|
           found = dispatcher.registry.repository(domain, ir).find(id)
-          found && Facade::Handle.new(dispatcher: dispatcher, domain: domain, ir: ir, instance: found)
+          found && Facade::Handle.new(dispatcher: dispatcher, domain: domain, aggregate: ir, instance: found)
         end
 
         target.define_singleton_method(:all) do
           dispatcher.registry.repository(domain, ir).all.map do |instance|
-            Facade::Handle.new(dispatcher: dispatcher, domain: domain, ir: ir, instance: instance)
+            Facade::Handle.new(dispatcher: dispatcher, domain: domain, aggregate: ir, instance: instance)
           end
         end
       end
@@ -118,16 +125,17 @@ module Hecks
         current_entries.reject { |entry| entry.fqn.aggregate.nil? }
                        .group_by { |entry| [entry.fqn.aggregate, entry.fqn.verb] }
                        .each do |(aggregate, verb), candidates|
-          shortcut_target(aggregate).define_singleton_method(verb) { |**args|
+          shortcut_target(aggregate).define_singleton_method(verb) do |**args|
             installer.send(:dispatch_short, candidates, **args)
-          }
+          end
         end
       end
 
       def dispatch_short(candidates, **args)
         if candidates.length > 1
           shown = candidates.map { |entry| entry.fqn.to_s }.sort.join(", ")
-          aggregate, verb = candidates.first.fqn.aggregate, candidates.first.fqn.verb
+          aggregate = candidates.first.fqn.aggregate
+          verb = candidates.first.fqn.verb
           raise AmbiguousShortRoute, "#{aggregate}.#{verb} is ambiguous — choose one of: #{shown}"
         end
 
@@ -137,8 +145,10 @@ module Hecks
 
       def shortcut_target(aggregate)
         constant = Object.const_get(aggregate, false) if Object.const_defined?(aggregate, false)
-        raise NameError,
-              "cannot install Bluebook shortcut #{aggregate}: it is not a module" if constant && !constant.is_a?(Module)
+        if constant && !constant.is_a?(Module)
+          raise NameError,
+                "cannot install Bluebook shortcut #{aggregate}: it is not a module"
+        end
 
         constant || Object.const_set(aggregate, Module.new)
       end
@@ -146,8 +156,10 @@ module Hecks
       def namespace_for(realm, domain, aggregate)
         [realm, domain, aggregate].compact.reduce(Object) do |parent, name|
           constant = parent.const_get(name, false) if parent.const_defined?(name, false)
-          raise NameError,
-                "cannot install Bluebook route under #{parent}::#{name}: it is not a module" if constant && !constant.is_a?(Module)
+          if constant && !constant.is_a?(Module)
+            raise NameError,
+                  "cannot install Bluebook route under #{parent}::#{name}: it is not a module"
+          end
 
           constant || parent.const_set(name, Module.new)
         end