hecks 3.4.2 → 3.6.0

data/lib/hecks/ports/persistence/postgres_dump/connection.rb

@@ -30,13 +30,13 @@ module Hecks
             {
               host: (@uri.host unless @uri.host.to_s.empty?), port: @uri.port,
               user: decode(@uri.user), password: decode(@uri.password),
-              dbname: (database unless database.empty?), sslmode: URI.decode_www_form(@uri.query.to_s).to_h["sslmode"]
+              dbname: (database unless database.empty?), sslmode: query_params["sslmode"]
             }.compact
           end
 
           # Builds the libpq environment variables for a child process.
           def env
-            settings.to_h { |key, value| ["PG#{key.to_s.sub('dbname', 'database').upcase}", value.to_s] }
+            settings.to_h { |key, value| ["PG#{key.to_s.sub("dbname", "database").upcase}", value.to_s] }
           end
 
           # Opens a connection with the `pg` gem; the caller closes it.
@@ -47,6 +47,8 @@ module Hecks
 
           private
 
+          def query_params = URI.decode_www_form(@uri.query.to_s).to_h
+
           def decode(value)
             value && URI.decode_www_form_component(value)
           end

data/lib/hecks/ports/persistence/postgres_dump.rb

@@ -26,10 +26,10 @@ module Hecks
         # Writes a custom-format dump of the schema and proves it restores.
         def call(dest)
           require "pg"
-          raise Error, "schema #{@schema} has no tables in #{@source.database}" if counting(@source) { |db| counts(db) }.empty?
+          raise Error, "schema #{@schema} has no tables in #{@source.database}" if source_counts.empty?
 
           run("pg_dump", @source, "--format=custom", "--no-owner", "--no-privileges", "--schema=#{@schema}", "--file=#{dest}")
-          expected = counting(@source) { |db| counts(db) }
+          expected = source_counts
           verify_restore(dest, expected)
           Result.new(tables: expected)
         rescue PG::Error => e
@@ -38,21 +38,27 @@ module Hecks
 
         private
 
+        def source_counts = counting(@source) { |db| counts(db) }
+
         def verify_restore(dump, expected)
           scratch = "dump_verify_#{Process.pid}_#{SecureRandom.hex(3)}"
           counting(@verify) do |admin|
             admin.exec("CREATE DATABASE #{admin.quote_ident(scratch)}")
             begin
-              target = @verify.with_database(scratch)
-              run("pg_restore", target, "--no-owner", "--no-privileges", "--exit-on-error", "--dbname=#{scratch}", dump)
-              actual = counting(target) { |db| counts(db) }
-              raise Error, mismatch(expected, actual) unless actual == expected
+              restore_and_compare(dump, scratch, expected)
             ensure
               drop(admin, scratch)
             end
           end
         end
 
+        def restore_and_compare(dump, scratch, expected)
+          target = @verify.with_database(scratch)
+          run("pg_restore", target, "--no-owner", "--no-privileges", "--exit-on-error", "--dbname=#{scratch}", dump)
+          actual = counting(target) { |db| counts(db) }
+          raise Error, mismatch(expected, actual) unless actual == expected
+        end
+
         def counting(connection)
           db = connection.connect
           yield db
@@ -72,7 +78,7 @@ module Hecks
         def mismatch(expected, actual)
           differing = (expected.keys | actual.keys).reject { |name| expected[name] == actual[name] }
           detail = differing.map { |name| "#{name} (source #{expected[name].inspect}, restored #{actual[name].inspect})" }
-          "the restored dump disagrees with the source for #{detail.join(', ')}; " \
+          "the restored dump disagrees with the source for #{detail.join(", ")}; " \
             "if the database took writes during the dump, dump it again"
         end
 

data/lib/hecks/ports/persistence/repository_factory.rb

@@ -9,24 +9,48 @@ module Hecks
       module RepositoryFactory
         module_function
 
+        # The keywords `build` accepts; an unknown one raises ArgumentError.
+        BuildOptions = Struct.new(:recover, :settings_verb, keyword_init: true) do
+          def initialize(recover: true, settings_verb: VERB) = super
+        end
+
         # Instantiates the adapter a bind names, guards it, and wraps it as a repository.
-        def build(registry, domain, aggregate, bind, recover: true, settings_verb: VERB)
+        #
+        # @param registry [Runtime::Registry] the booted registry
+        # @param domain [String, Symbol] the domain the aggregate belongs to
+        # @param aggregate [Bluebook::Aggregate] the aggregate to persist
+        # @param bind [Bluebook::Bind] the bind naming the adapter
+        # @param ** [Hash] the options; `recover:` (default true) replays the journal at build time;
+        #   `settings_verb:` (default `VERB`) names the verb whose settings configure the adapter
+        # @return [Persistence::AppendOnly] the repository, recovered unless the adapter is atomic
+        # @raise [ArgumentError] on an unknown option
+        def build(registry, domain, aggregate, bind, **)
+          opts = BuildOptions.new(**)
+          settings = adapter_settings(registry, domain, bind, opts.settings_verb)
+          adapter = registry.adapter_class(bind.adapter).new(aggregate: aggregate, settings: settings, root: registry.root)
+          repository = AppendOnly.new(CodecBoundary.guard!(adapter))
+          # `:atomic_append` (PostgresEra) means `append` already committed the
+          # projected state in the same transaction as the journal row, so a
+          # boot-time replay through `project` has nothing left to fix up.
+          opts.recover && !repository.capabilities.include?(:atomic_append) ? repository.recover! : repository
+        end
+
+        # Checks the bind against the registry and gathers the settings its adapter is built with.
+        #
+        # @param registry [Runtime::Registry] the booted registry
+        # @param domain [String, Symbol] the domain the aggregate belongs to
+        # @param bind [Bluebook::Bind] the bind naming the adapter
+        # @param settings_verb [String] the verb whose settings configure the adapter
+        # @return [Hash] the declared settings plus the domain, resolved era and superseding era
+        def adapter_settings(registry, domain, bind, settings_verb)
           registry.check_verb(bind)
           settings = registry.binding_settings(domain, settings_verb, bind.adapter)
                              .reject { |key, _| key.to_sym == :role }
           registry.check_settings(bind, settings)
           # domain, resolved era and superseding era ride along outside the declared
           # settings: a lineage adapter needs them to journal per domain, per-era.
-          adapter = registry.adapter_class(bind.adapter)
-                            .new(aggregate: aggregate,
-                                 settings:  settings.merge(domain: domain.to_s, era: registry.resolved_eras[domain.to_s],
-                                                           superseded_by: registry.superseded_eras[domain.to_s]),
-                                 root:      registry.root)
-          repository = AppendOnly.new(CodecBoundary.guard!(adapter))
-          # `:atomic_append` (PostgresEra) means `append` already committed the
-          # projected state in the same transaction as the journal row, so a
-          # boot-time replay through `project` has nothing left to fix up.
-          recover && !repository.capabilities.include?(:atomic_append) ? repository.recover! : repository
+          settings.merge(domain: domain.to_s, era: registry.resolved_eras[domain.to_s],
+                         superseded_by: registry.superseded_eras[domain.to_s])
         end
       end
     end

data/lib/hecks/ports/persistence/state_codec.rb

@@ -226,6 +226,16 @@ module Hecks
 
           return true unless value.is_a?(Array)
 
+          list_decoded?(aggregate, attribute, value)
+        end
+
+        # Checks every Hash element of a stored list, the mirror of `decode_field` for a list.
+        #
+        # @param aggregate [Bluebook::Aggregate, Bluebook::Entity] the root construct
+        # @param attribute [Bluebook::Attribute] the list field's declaration
+        # @param value [Array] the stored list
+        # @return [Boolean] true when every Hash element is decoded
+        def list_decoded?(aggregate, attribute, value)
           # The element type resolves once per list, not once per element.
           fields = :unresolved
           value.all? do |element|

data/lib/hecks/ports/persistence.rb

@@ -1,13 +1,4 @@
-module Hecks
-  module Ports
-    module Persistence
-      NAME = "persistence".freeze
-      VERB = "persisted_by".freeze
-      DEFAULT_ADAPTER = "Memory".freeze
-    end
-  end
-end
-
+require_relative "persistence/constants"
 require_relative "persistence/binding_policy"
 require_relative "persistence/plugin"
 require_relative "persistence/repository_factory"

data/lib/hecks/ports/projection.rb

@@ -39,11 +39,11 @@ module Hecks
           @authoritative = authoritative
           @projection = projection
           @policy = policy.to_sym
-          unless VALID_POLICIES.include?(@policy)
-            raise ArgumentError,
-                  "unknown projection catch_up! policy #{@policy.inspect} — expected one of " \
-                  "#{VALID_POLICIES.map(&:inspect).join(' or ')}"
-          end
+          return if VALID_POLICIES.include?(@policy)
+
+          raise ArgumentError,
+                "unknown projection catch_up! policy #{@policy.inspect} — expected one of " \
+                "#{VALID_POLICIES.map(&:inspect).join(" or ")}"
         end
 
         # Appends and projects every authoritative entry the store lacks.
@@ -57,25 +57,15 @@ module Hecks
         def catch_up!
           return refresh! if @policy == :refresh
 
-          compacted_through = @authoritative.respond_to?(:compacted_through) ? @authoritative.compacted_through : 0
+          compacted_through = compacted_through_sequence
           present = @projection.entries
-          if present.length < compacted_through
-            raise Runtime::WiringError,
-                  ":strict catch-up needs journal history the authoritative store has already " \
-                  "compacted (through sequence #{compacted_through}, this projection has only " \
-                  "consumed #{present.length}) — use :refresh instead"
-          end
+          refuse_compacted!(compacted_through, present)
 
           entries = Queue.new(@authoritative).entries
           present_tail = present.drop(compacted_through)
-          unless consistent?(entries, present_tail)
-            raise Runtime::WiringError, "projection history does not match its authoritative history"
-          end
+          refuse_divergence!(entries, present_tail)
 
-          entries.drop(present_tail.length).each do |entry|
-            @projection.append(entry)
-            @projection.project(entry)
-          end
+          entries.drop(present_tail.length).each { |entry| apply(entry) }
           @projection
         end
 
@@ -83,14 +73,37 @@ module Hecks
 
         private
 
+        def compacted_through_sequence
+          @authoritative.respond_to?(:compacted_through) ? @authoritative.compacted_through : 0
+        end
+
+        def refuse_compacted!(compacted_through, present)
+          return unless present.length < compacted_through
+
+          raise Runtime::WiringError,
+                ":strict catch-up needs journal history the authoritative store has already " \
+                "compacted (through sequence #{compacted_through}, this projection has only " \
+                "consumed #{present.length}) — use :refresh instead"
+        end
+
+        def refuse_divergence!(entries, present_tail)
+          return if consistent?(entries, present_tail)
+
+          raise Runtime::WiringError, "projection history does not match its authoritative history"
+        end
+
+        def apply(entry)
+          @projection.append(entry)
+          @projection.project(entry)
+        end
+
         # Resets the store and rebuilds it from the aggregate's own current records — one
         # synthetic save per live record, never a replay of deleted or superseded history.
         def refresh!
           @projection.reset!
           @authoritative.all.each do |instance|
             entry = Persistence::Entry.new(operation: "save", id: instance.id.to_s, state: instance.state.dup)
-            @projection.append(entry)
-            @projection.project(entry)
+            apply(entry)
           end
           @projection
         end

data/lib/hecks/ports/query/in_memory.rb

@@ -23,14 +23,8 @@ module Hecks
         # @param registry [Runtime::Registry, nil] passed to registry-aware comparisons
         # @return [Array<Runtime::Instance, Hash>] the matching records, ordered and paged
         def execute(records, declared, args = {}, registry: nil)
-          matched = records.select do |record|
-            declared.wheres.all? do |clause|
-              holds?(clause, comparable(FieldPath.dig(record, clause.field)), args, registry: registry)
-            end
-          end
-          field   = declared.order_by&.field
-          matched = Ordering.apply(matched, declared.order_by, declared.null_semantics,
-                                   identity: ->(record) { record.id.to_s }) { |record| comparable(FieldPath.dig(record, field)) }
+          matched = filter(records, declared, args, registry)
+          matched = order(matched, declared)
           # Offset before limit, as SQL means `LIMIT n OFFSET m`; the reverse order returns a short
           # or empty page (`limit 10, offset 10` would drop everything).
           matched = matched.drop(resolve(declared.offset.value, args).to_i) if declared.offset
@@ -38,6 +32,20 @@ module Hecks
           matched
         end
 
+        def filter(records, declared, args, registry)
+          records.select do |record|
+            declared.wheres.all? do |clause|
+              holds?(clause, comparable(FieldPath.dig(record, clause.field)), args, registry: registry)
+            end
+          end
+        end
+
+        def order(matched, declared)
+          field = declared.order_by&.field
+          Ordering.apply(matched, declared.order_by, declared.null_semantics,
+                         identity: ->(record) { record.id.to_s }) { |record| comparable(FieldPath.dig(record, field)) }
+        end
+
         def holds?(clause, held, args, registry: nil)
           Comparison.holds?(clause.op, held, comparable(resolve(clause.value, args)), registry: registry)
         end

data/lib/hecks/projection_files/expression_tables.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Hecks
+  module ProjectionFiles
+    # The expression-tables projection: the admitted operators, with the algebra each comparison
+    # declares. Extended onto `ProjectionFiles`.
+    module ExpressionTables
+      # @param root [String] the checkout
+      # @return [Result] `lib/hecks/bluebook/expression/projection.json`
+      # @raise [Refused] if an admitted operator has no declared algebra, or the projection drops an
+      #   operator the language's own guards evaluate through
+      def expression_tables(root)
+        require "hecks"
+        require "hecks/grammar"
+        operators = expression_operators(Grammar.expression)
+        dropped = Grammar.self_bearing_operators.except(*operators.map { |row| row[:symbol] })
+        raise Refused, dropped_message(dropped) unless dropped.empty?
+
+        dispatcher = Grammar.expression
+        text = "#{JSON.pretty_generate(operators: operators, normalisations: Grammar.admitted_normalisations(dispatcher))}\n"
+        Result.new({ File.join(root, "lib/hecks/bluebook/expression/projection.json") => text }, [])
+      end
+
+      # @param dispatcher [Object] the expression dispatcher
+      # @return [Array<Hash>] each admitted operator, with the algebra a comparison declares
+      # @raise [Refused] if a comparison has no declared algebra
+      def expression_operators(dispatcher)
+        algebra = comparison_algebra
+        Grammar.admitted_operators(dispatcher).map { |op| operator_row(op, algebra) }
+      end
+
+      # @return [Hash{String => Hash}] each comparison's declared algebra, by operator symbol
+      def comparison_algebra
+        vocabulary = chapter.aggregates.find { |aggregate| aggregate.name == "Vocabulary" }
+        vocabulary.value_objects.find { |value_object| value_object.hecks_name == "Comparison" }
+                  .members.to_h { |row| [row.to_h.values.first, row.to_h] }
+      end
+
+      # @param operator [Hash] one admitted operator
+      # @param algebra [Hash{String => Hash}] each comparison's declared algebra
+      # @return [Hash] the operator's projected row
+      # @raise [Refused] if a comparison has no declared algebra
+      def operator_row(operator, algebra)
+        row = operator.slice(:symbol, :category, :precedence, :arity)
+        return row unless operator[:category] == "comparison"
+
+        declared = algebra.fetch(operator[:symbol]) do
+          raise Refused, "#{operator[:symbol]} is admitted but Vocabulary::Comparison declares no algebra for it"
+        end
+        row.merge(compares_less_than: declared[:compares_less_than],
+                  compares_equal: declared[:compares_equal], negated: declared[:negated])
+      end
+
+      # @param dropped [Hash{String => Array<String>}] operator to the guards evaluating through it
+      # @return [String] one line for each operator a projection would strand
+      def dropped_message(dropped)
+        dropped.map do |symbol, sites|
+          "#{symbol} is self-bearing — the language's own predicates evaluate through it " \
+            "(#{sites.first(3).join("; ")}) — rewrite those guards before retiring it"
+        end.join("\n")
+      end
+    end
+  end
+end

data/lib/hecks/projection_files/texts.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Hecks
+  module ProjectionFiles
+    # The Rust text of the generated `reserved_names.rs` and `field_hints.rs`. Extended onto
+    # `ProjectionFiles`.
+    module Texts
+      # The whole `reserved_names.rs`, with its constants where `%<consts>s` stands.
+      RESERVED_NAMES = <<~RUST
+        // GENERATED by hecks project_reserved_names from the RustReservedWord and
+        // CargoReservedName vocabularies (lib/hecks/language/bluebook/
+        // vocabulary.bluebook). Do not hand-edit — re-run hecks project_reserved_names.
+
+        %<consts>s
+      RUST
+
+      # The whole `field_hints.rs`, with its statics where `%<consts>s` stands.
+      FIELD_HINTS = <<~RUST
+        // GENERATED by hecks project_field_hints from Vocabulary::FieldHint
+        // (lib/hecks/language/bluebook/vocabulary.bluebook). Do not
+        // hand-edit — re-run hecks project_field_hints instead.
+        //
+        // web.rs's `text_field` matches these in the SAME precedence Ruby's
+        // own `text_field` does: EMAIL_HINT, then URL_HINT, then TEL_HINT —
+        // against `html_type`, first match wins — then, only if `html_type`
+        // stayed "text", TEXTAREA_HINT against `kind`.
+
+        use regex::Regex;
+        use std::sync::LazyLock;
+
+        %<consts>s
+      RUST
+
+      # One hint's `static`.
+      FIELD_HINT = <<~RUST
+        /// %<title>s hint, resolving to `%<resolves_to>s` on a match —
+        /// Vocabulary::FieldHint's own declared pattern, unmodified (the
+        /// same text `Regexp#source` reads off FieldShape's own
+        /// %<name>s, which is built from this same row).
+        /// `(?i)` up front is this crate's spelling
+        /// of Ruby's trailing `/i` — the WHOLE pattern is case-insensitive
+        /// on both sides, never partially.
+        pub static %<name>s: LazyLock<Regex> =
+            LazyLock::new(|| Regex::new(r#"(?i)%<pattern>s"#).expect("declared field-hint pattern must compile"));
+      RUST
+
+      # @param consts [Array<String>] the rendered Rust constants
+      # @return [String] the whole `reserved_names.rs`
+      def reserved_names_text(consts)
+        format(RESERVED_NAMES, consts: consts.join("\n\n"))
+      end
+
+      # @param hints [Array<Hash>] the rows of `Vocabulary::FieldHint`
+      # @return [String] the whole `field_hints.rs`
+      def field_hints_text(hints)
+        format(FIELD_HINTS, consts: hints.map { |hint| field_hint_constant(hint) }.join("\n"))
+      end
+
+      # @param hint [Hash] one `FieldHint` row: its name, pattern and what it resolves to
+      # @return [String] the Rust `static` for it
+      def field_hint_constant(hint)
+        format(FIELD_HINT, title: hint[:name].capitalize, resolves_to: hint[:resolves_to],
+                           name: "#{hint[:name].upcase}_HINT", pattern: hint[:pattern])
+      end
+    end
+  end
+end

data/lib/hecks/projection_files.rb

@@ -3,6 +3,8 @@
 require "fileutils"
 require "json"
 require "tempfile"
+require_relative "projection_files/texts"
+require_relative "projection_files/expression_tables"
 
 module Hecks
   # What each `project_*` generator of the language writes, held as data: absolute path to text.
@@ -38,6 +40,9 @@ module Hecks
     NAMES = %i[model vocabulary rust_vocabulary reserved_names parser_table bootstrap_table
                field_hints expression_tables reference].freeze
 
+    extend Texts
+    extend ExpressionTables
+
     module_function
 
     # Builds one projection without writing anything.
@@ -124,19 +129,24 @@ module Hecks
     # @raise [Refused] if a vocabulary declares no members
     def reserved_names(root)
       require "hecks/vocabulary"
-      consts = RESERVED_TABLES.map do |const, vocabulary|
-        words = Hecks::Vocabulary.fetch(vocabulary)
-        raise Refused, "vocabulary #{vocabulary} declares no members" if words.empty?
-
-        lines = words.map { |word| "    #{word.inspect}," }.join("\n")
-        "/// The `#{vocabulary}` vocabulary, #{words.size} entries.\n" \
-          "pub const #{const}: &[&str] = &[\n#{lines}\n];"
-      end
-      text = reserved_names_text(consts)
+      text = reserved_names_text(RESERVED_TABLES.map { |const, vocabulary| reserved_constant(const, vocabulary) })
       targets = %w[rust/codegen/src/reserved_names.rs rust/build/src/reserved_names.rs]
       Result.new(targets.to_h { |target| [File.join(root, target), text] }, [])
     end
 
+    # @param const [String] the Rust constant's name
+    # @param vocabulary [String] the vocabulary its words come from
+    # @return [String] the Rust `pub const` listing every word
+    # @raise [Refused] if the vocabulary declares no members
+    def reserved_constant(const, vocabulary)
+      words = Hecks::Vocabulary.fetch(vocabulary)
+      raise Refused, "vocabulary #{vocabulary} declares no members" if words.empty?
+
+      lines = words.map { |word| "    #{word.inspect}," }.join("\n")
+      "/// The `#{vocabulary}` vocabulary, #{words.size} entries.\n" \
+        "pub const #{const}: &[&str] = &[\n#{lines}\n];"
+    end
+
     # @param root [String] the checkout
     # @return [Result] the Rust parser's keyword table
     def parser_table(root)
@@ -162,22 +172,6 @@ module Hecks
       Result.new({ File.join(root, "rust/host/src/field_hints.rs") => field_hints_text(hints) }, [])
     end
 
-    # @param root [String] the checkout
-    # @return [Result] `lib/hecks/bluebook/expression/projection.json`
-    # @raise [Refused] if an admitted operator has no declared algebra, or the projection drops an
-    #   operator the language's own guards evaluate through
-    def expression_tables(root)
-      require "hecks"
-      require "hecks/grammar"
-      operators = expression_operators(Grammar.expression)
-      dropped = Grammar.self_bearing_operators.except(*operators.map { |row| row[:symbol] })
-      raise Refused, dropped_message(dropped) unless dropped.empty?
-
-      dispatcher = Grammar.expression
-      text = "#{JSON.pretty_generate(operators: operators, normalisations: Grammar.admitted_normalisations(dispatcher))}\n"
-      Result.new({ File.join(root, "lib/hecks/bluebook/expression/projection.json") => text }, [])
-    end
-
     # The DSL reference pages and the README regions generated from the same declarations.
     #
     # @param root [String] the checkout
@@ -203,83 +197,5 @@ module Hecks
     def chapter
       Bluebook::MetaValidator.grammar_registry.bluebook("Bluebook")
     end
-
-    # @param dispatcher [Object] the expression dispatcher
-    # @return [Array<Hash>] each admitted operator, with the algebra a comparison declares
-    # @raise [Refused] if a comparison has no declared algebra
-    def expression_operators(dispatcher)
-      vocabulary = chapter.aggregates.find { |aggregate| aggregate.name == "Vocabulary" }
-      algebra = vocabulary.value_objects.find { |value_object| value_object.hecks_name == "Comparison" }
-                          .members.to_h { |row| [row.to_h.values.first, row.to_h] }
-      Grammar.admitted_operators(dispatcher).map do |op|
-        row = { symbol: op[:symbol], category: op[:category], precedence: op[:precedence], arity: op[:arity] }
-        next row unless op[:category] == "comparison"
-
-        declared = algebra.fetch(op[:symbol]) do
-          raise Refused, "#{op[:symbol]} is admitted but Vocabulary::Comparison declares no algebra for it"
-        end
-        row.merge(compares_less_than: declared[:compares_less_than],
-                  compares_equal: declared[:compares_equal], negated: declared[:negated])
-      end
-    end
-
-    # @param dropped [Hash{String => Array<String>}] operator to the guards evaluating through it
-    # @return [String] one line for each operator a projection would strand
-    def dropped_message(dropped)
-      dropped.map do |symbol, sites|
-        "#{symbol} is self-bearing — the language's own predicates evaluate through it " \
-          "(#{sites.first(3).join('; ')}) — rewrite those guards before retiring it"
-      end.join("\n")
-    end
-
-    # @param consts [Array<String>] the rendered Rust constants
-    # @return [String] the whole `reserved_names.rs`
-    def reserved_names_text(consts)
-      <<~RUST
-        // GENERATED by hecks project_reserved_names from the RustReservedWord and
-        // CargoReservedName vocabularies (lib/hecks/language/bluebook/
-        // vocabulary.bluebook). Do not hand-edit — re-run hecks project_reserved_names.
-
-        #{consts.join("\n\n")}
-      RUST
-    end
-
-    # @param hints [Array<Hash>] the rows of `Vocabulary::FieldHint`
-    # @return [String] the whole `field_hints.rs`
-    def field_hints_text(hints)
-      consts = hints.map { |hint| field_hint_constant(hint) }.join("\n")
-      <<~RUST
-        // GENERATED by hecks project_field_hints from Vocabulary::FieldHint
-        // (lib/hecks/language/bluebook/vocabulary.bluebook). Do not
-        // hand-edit — re-run hecks project_field_hints instead.
-        //
-        // web.rs's `text_field` matches these in the SAME precedence Ruby's
-        // own `text_field` does: EMAIL_HINT, then URL_HINT, then TEL_HINT —
-        // against `html_type`, first match wins — then, only if `html_type`
-        // stayed "text", TEXTAREA_HINT against `kind`.
-
-        use regex::Regex;
-        use std::sync::LazyLock;
-
-        #{consts}
-      RUST
-    end
-
-    # @param hint [Hash] one `FieldHint` row: its name, pattern and what it resolves to
-    # @return [String] the Rust `static` for it
-    def field_hint_constant(hint)
-      name = "#{hint[:name].upcase}_HINT"
-      <<~RUST
-        /// #{hint[:name].capitalize} hint, resolving to `#{hint[:resolves_to]}` on a match —
-        /// Vocabulary::FieldHint's own declared pattern, unmodified (the
-        /// same text `Regexp#source` reads off FieldShape's own
-        /// #{name}, which is built from this same row).
-        /// `(?i)` up front is this crate's spelling
-        /// of Ruby's trailing `/i` — the WHOLE pattern is case-insensitive
-        /// on both sides, never partially.
-        pub static #{name}: LazyLock<Regex> =
-            LazyLock::new(|| Regex::new(r#"(?i)#{hint[:pattern]}"#).expect("declared field-hint pattern must compile"));
-      RUST
-    end
   end
 end