hecks 3.4.2 → 3.6.0

data/lib/hecks/projections/glossary.rb

@@ -7,6 +7,9 @@ require_relative "glossary/sentences"
 require_relative "glossary/mermaid"
 require_relative "glossary/markdown"
 require_relative "glossary/html"
+require_relative "glossary/entries"
+require_relative "glossary/slugs"
+require_relative "glossary/index"
 
 module Hecks
   module Projections
@@ -44,7 +47,7 @@ module Hecks
       # Gathers every term, groups it into sections, assigns headings and
       # slugs, and builds the index links resolve through.
       def document(bluebook, markings = [])
-        sections = sections(bluebook, entries(bluebook, markings))
+        sections = sections(bluebook, Entries.all(bluebook, markings))
         Slugs.assign!(bluebook, sections)
         Document.new(bluebook: bluebook, sections: sections, index: Index.new(sections), markings: markings)
       end
@@ -52,28 +55,37 @@ module Hecks
       # Aggregates first, A to Z by spoken name, then the groups no aggregate homes.
       def sections(bluebook, entries)
         grouped = entries.group_by(&:section)
-        list = bluebook.aggregates.sort_by { |aggregate| Naming.words(aggregate.hecks_name).downcase }.map do |aggregate|
+        aggregate_sections(bluebook, grouped) + group_sections(grouped)
+      end
+
+      def aggregate_sections(bluebook, grouped)
+        bluebook.aggregates.sort_by { |aggregate| Naming.words(aggregate.hecks_name).downcase }.map do |aggregate|
           Section.new(name: aggregate.hecks_name, title: Naming.words(aggregate.hecks_name), aggregate: aggregate,
                       terms: with_headwords(grouped.fetch(aggregate.hecks_name, []), aggregate.hecks_name))
         end
-        [ROLES, READ_MODELS, REACTIONS].each do |name|
+      end
+
+      # The sections no aggregate homes: roles, read models and reactions, when any term belongs.
+      def group_sections(grouped)
+        [ROLES, READ_MODELS, REACTIONS].filter_map do |name|
           held = grouped[name == REACTIONS ? nil : name]
-          list << Section.new(name: name, title: name, terms: with_headwords(held, name)) if held
+          Section.new(name: name, title: name, terms: with_headwords(held, name)) if held
         end
-        list
       end
 
       # A headword is qualified only when it would repeat within its section, never numbered.
       def with_headwords(entries, section_name)
         entries.each { |entry| entry.headword = Naming.words(entry.name) }
-        entries.group_by(&:headword).each_value do |group|
-          next if group.size == 1
-
-          group.each { |entry| entry.headword = qualified(entry, group, section_name) }
-        end
+        entries.group_by(&:headword).each_value { |group| qualify_repeats(group, section_name) }
         entries.sort_by { |entry| [entry.headword.downcase, entry.kind.to_s] }
       end
 
+      def qualify_repeats(group, section_name)
+        return if group.size == 1
+
+        group.each { |entry| entry.headword = qualified(entry, group, section_name) }
+      end
+
       def qualified(entry, group, section_name)
         base = Naming.words(entry.name)
         return "#{base} (the list)" if entry.kind == :query && group.any? { |other| other.kind == :command }
@@ -81,186 +93,6 @@ module Hecks
 
         base
       end
-
-      # Entities carry their own commands and queries, so they are walked one level down.
-      def holders(bluebook)
-        bluebook.aggregates.flat_map { |aggregate| [aggregate, *aggregate.entities] }
-      end
-
-      # Maps every holder name to its owning aggregate's name.
-      def holder_aggregate(bluebook)
-        bluebook.aggregates.each_with_object({}) do |aggregate, map|
-          map[aggregate.hecks_name] = aggregate.hecks_name
-          aggregate.entities.each { |entity| map[entity.hecks_name] = aggregate.hecks_name }
-        end
-      end
-
-      # Maps each emitted event to its `[holder, command]` raisers. An event is never
-      # declared, so its home is the first raiser's aggregate.
-      def event_raisers(bluebook)
-        holders(bluebook).each_with_object(Hash.new { |hash, key| hash[key] = [] }) do |holder, map|
-          holder.commands.each { |command| command.emits.each { |event| map[event] << [holder, command] } }
-        end
-      end
-
-      # The last segment of a dotted name.
-      def bare(qualified) = qualified.to_s.split(".").last
-
-      # Gathers every term the glossary carries, ungrouped and unordered.
-      def entries(bluebook, markings = [])
-        homes   = holder_aggregate(bluebook)
-        raisers = event_raisers(bluebook)
-        home_of = ->(event) { raisers.key?(event) ? homes[raisers[event].first.first.hecks_name] : nil }
-
-        entries = []
-        entries += entity_entries(bluebook)
-        entries += value_object_entries(bluebook, markings)
-        entries += verb_entries(bluebook, homes)
-        entries += event_entries(bluebook, raisers, home_of)
-        entries += policy_entries(bluebook, home_of)
-        entries += saga_entries(bluebook, home_of)
-        entries += role_entries(bluebook)
-        entries += read_model_entries(bluebook)
-        entries
-      end
-
-      def entity_entries(bluebook)
-        bluebook.aggregates.flat_map do |aggregate|
-          aggregate.entities.map do |entity|
-            Entry.new(name: entity.hecks_name, kind: :entity, within: aggregate.hecks_name,
-                      section: aggregate.hecks_name, facts: { entity: entity })
-          end
-        end
-      end
-
-      # Aggregates only; `Bluebook::Entity` deliberately does not answer `value_objects`.
-      def value_object_entries(bluebook, markings = [])
-        bluebook.aggregates.flat_map do |aggregate|
-          marked = Sensitivity.for_aggregate(markings, bluebook.name, aggregate)
-          aggregate.value_objects.map do |value_object|
-            sensitive = Sensitivity.for_value_object(marked, aggregate, value_object)
-            Entry.new(name: value_object.hecks_name, kind: :value_object, within: aggregate.hecks_name,
-                      section: aggregate.hecks_name,
-                      facts: { value_object: value_object, sensitive: sensitive })
-          end
-        end
-      end
-
-      def verb_entries(bluebook, homes)
-        holders(bluebook).flat_map do |holder|
-          commands = holder.commands.map do |command|
-            Entry.new(name: command.hecks_name, kind: :command, within: holder.hecks_name,
-                      section: homes[holder.hecks_name], facts: { command: command, holder: holder })
-          end
-          queries = holder.queries.map do |query|
-            Entry.new(name: query.hecks_name, kind: :query, within: holder.hecks_name,
-                      section: homes[holder.hecks_name], facts: { query: query })
-          end
-          commands + queries
-        end
-      end
-
-      def event_entries(bluebook, raisers, home_of)
-        raisers.map do |event, raised_by|
-          reactions = bluebook.policies.select { |policy| bare(policy.on_event) == event }
-          Entry.new(name: event, kind: :event, section: home_of.call(event),
-                    facts: { event: event, raised_by: raised_by, policies: reactions })
-        end
-      end
-
-      def policy_entries(bluebook, home_of)
-        bluebook.policies.map do |policy|
-          Entry.new(name: policy.name, kind: :policy, section: home_of.call(bare(policy.on_event)),
-                    facts: { policy: policy })
-        end
-      end
-
-      def saga_entries(bluebook, home_of)
-        bluebook.process_managers.map do |saga|
-          shape = saga.to_h
-          Entry.new(name: shape[:name], kind: :saga, section: home_of.call(bare(shape[:starts_on])),
-                    facts: { saga: shape })
-        end
-      end
-
-      # Roles cut across aggregates, so they get their own section.
-      def role_entries(bluebook)
-        by_role = Hash.new { |hash, key| hash[key] = [] }
-        holders(bluebook).each do |holder|
-          holder.commands.select(&:role).each { |command| by_role[command.role] << [holder, command] }
-        end
-        by_role.map do |role, issues|
-          Entry.new(name: role, kind: :role, section: ROLES, facts: { role: role, commands: issues })
-        end
-      end
-
-      # A read model joins heads from more than one aggregate, so it belongs to none.
-      def read_model_entries(bluebook)
-        bluebook.read_models.map do |read_model|
-          Entry.new(name: read_model.name, kind: :read_model, section: READ_MODELS, facts: { read_model: read_model })
-        end
-      end
-
-      # Reproduces GitHub's heading slugs, computed in document order, so links land the
-      # same whether GitHub renders the `.md` or `Html` renders the page.
-      module Slugs
-        module_function
-
-        def github(text) = text.to_s.downcase.gsub(/[^\p{Word}\- ]/, "").tr(" ", "-")
-
-        # Assigns every section's and entry's slug, in document order.
-        def assign!(bluebook, sections)
-          seen = Hash.new(0)
-          take = lambda do |text|
-            base = github(text)
-            seen[base] += 1
-            seen[base] == 1 ? base : "#{base}-#{seen[base] - 1}"
-          end
-          take.call(Markdown.title(bluebook))
-          sections.each do |section|
-            section.slug = take.call(section.title)
-            section.terms.each { |entry| entry.slug = take.call(entry.headword) }
-          end
-        end
-      end
-
-      # Resolves declared references structurally, never by searching prose. An
-      # undeclared target (a cross-domain command) answers nil and renders unlinked.
-      class Index
-        def initialize(sections)
-          @by_key = {}
-          sections.each do |section|
-            @by_key[[:aggregate, section.name]] = section if section.aggregate
-            section.terms.each { |entry| @by_key[key_of(entry)] = entry }
-          end
-        end
-
-        # Commands, queries and value objects can share a bare name across holders, so
-        # their key includes the holder.
-        def key_of(entry)
-          case entry.kind
-          when :command, :query, :value_object then [entry.kind, entry.within, entry.name]
-          else [entry.kind, entry.name]
-          end
-        end
-
-        # Looks up a term or aggregate section by kind and name.
-        #
-        # @return [Entry, Section, nil]
-        def [](kind, name, within: nil)
-          @by_key[within ? [kind, within, name] : [kind, name]]
-        end
-
-        # A Markdown link to a term's heading, or the plain words when undeclared.
-        # `label:` overrides the link text to tell two same-named terms apart.
-        def link(kind, name, within: nil, label: nil)
-          target = self[kind, name, within: within]
-          return label || Naming.words(name) unless target
-
-          text = label || (target.is_a?(Section) ? target.title : target.headword)
-          "[#{text}](##{target.slug})"
-        end
-      end
     end
   end
 end

data/lib/hecks/projections/model.rb

@@ -59,7 +59,7 @@ module Hecks
           # Generated — projected from the language's own #{name} aggregate.
           # Do not edit: the holding half is rendered, and #{host.fetch(:behaviour)}
           # is where anything hand-written belongs.
-          require_relative "behaviour/#{File.basename(host.fetch(:file), '.rb')}"
+          require_relative "behaviour/#{File.basename(host.fetch(:file), ".rb")}"
 
           module Hecks
             module Bluebook
@@ -103,13 +103,15 @@ module Hecks
       #   `Deviations` marks as parent-ref, judge-only, off-the-wire, dynamic-tail,
       #   folded, or unpacked
       def emitted_fields(bluebook, name)
-        bluebook.aggregate(name).attributes.map(&:name)
-                .reject { |f| Deviations.parent_ref?(f) } -
-          Deviations.judge_only(name) -
-          Deviations.off_the_wire(name) -
-          Deviations.dynamic_tail(name) -
-          Deviations.folded(name).values.flatten -
-          Deviations.unpacked(name).keys
+        declared = bluebook.aggregate(name).attributes.map(&:name).reject { |f| Deviations.parent_ref?(f) }
+        declared - omitted_fields(name)
+      end
+
+      # @param name [String] the construct's name
+      # @return [Array<Symbol>] the fields `Deviations` keeps out of `emits_ir`, whatever the reason
+      def omitted_fields(name)
+        Deviations.judge_only(name) + Deviations.off_the_wire(name) + Deviations.dynamic_tail(name) +
+          Deviations.folded(name).values.flatten + Deviations.unpacked(name).keys
       end
 
       # Renders the `attr_reader` line for every emitted field, plus an `attr_accessor`
@@ -118,17 +120,21 @@ module Hecks
       # @param host [Hash{Symbol => Object}] the construct's `HOST` entry
       # @return [String] the rendered reader/accessor lines, one construct's worth
       def readers(host)
-        lines = ["attr_reader #{host.fetch(:readers).map { |r| ":#{r}" }.join(', ')}"]
+        lines = ["attr_reader #{host.fetch(:readers).map { |r| ":#{r}" }.join(", ")}"]
         accessors = host.fetch(:accessors, [])
         return lines.join("\n") if accessors.empty?
 
         # The off-the-wire reason is emitted so the comment survives regeneration.
         reasons = Deviations::OFF_THE_WIRE.fetch(host.fetch(:construct, ""), {})
-        (lines + accessors.map do |a|
-          why = reasons[a]
-          (why ? "\n# #{a.to_s.capitalize}, declared and deliberately off the wire\n# #{wrap(why)}\n" : "") +
-            "attr_accessor :#{a}"
-        end).join("\n")
+        (lines + accessors.map { |a| accessor_line(a, reasons[a]) }).join("\n")
+      end
+
+      # @param accessor [Symbol] a field kept off the wire
+      # @param why [String, nil] the reason it is, when `Deviations` gives one
+      # @return [String] its `attr_accessor`, led by the reason as a comment
+      def accessor_line(accessor, why)
+        note = why ? "\n# #{accessor.to_s.capitalize}, declared and deliberately off the wire\n# #{wrap(why)}\n" : ""
+        "#{note}attr_accessor :#{accessor}"
       end
 
       # Renders the `initialize` that assigns every declared field, coerced as `HOST`

data/lib/hecks/projections/rust_vocabulary/arguments/support.rb

@@ -0,0 +1,33 @@
+module Hecks
+  module Projections
+    module RustVocabulary
+      module Arguments
+        # The free functions every `<Variant>Args::render_args` formats through, as Rust lines.
+        SUPPORT = [
+          "/// Ruby's `#inspect` of a name, as a refusal quotes it: `{:?}` on a",
+          "/// `&str`, the quoting every kernel call site used before",
+          "/// RefusalSiteArgument existed.",
+          "fn quoted(text: &str) -> String {",
+          "    format!(\"{text:?}\")",
+          "}",
+          "",
+          "/// A list argument, written the way its RefusalSiteArgument row says:",
+          "/// sorted first (before quoting), each item quoted, then joined; an",
+          "/// empty list reads `when_empty`.",
+          "fn list(items: &[&str], sorted: bool, inspect: bool, separator: &str, when_empty: &str) -> String {",
+          "    let mut items = items.to_vec();",
+          "    if sorted {",
+          "        items.sort_unstable();",
+          "    }",
+          "    if items.is_empty() {",
+          "        return when_empty.to_string();",
+          "    }",
+          "    let write = |item: &&str| if inspect { quoted(item) } else { item.to_string() };",
+          "    items.iter().map(write).collect::<Vec<_>>().join(separator)",
+          "}",
+          ""
+        ].freeze
+      end
+    end
+  end
+end

data/lib/hecks/projections/rust_vocabulary/arguments.rb

@@ -0,0 +1,171 @@
+require_relative "../../runtime/refusal_wording"
+require_relative "arguments/support"
+
+module Hecks
+  module Projections
+    module RustVocabulary
+      # The typed `<Variant>Args` structs of a refusal-template enum: each site's declared arguments
+      # checked against its template, then written as Rust.
+      module Arguments
+        module_function
+
+        # [refusal, site] => that site's argument rows; refused unless they name exactly the
+        # template's placeholders, in first-appearance order, with known formatting rules.
+        #
+        # @param rows [Array<Hash>] the RefusalTemplate rows
+        # @param argument_rows [Array<Hash>] the RefusalSiteArgument rows
+        # @return [Hash{Array<String> => Array<Hash>}] each site's argument rows
+        # @raise [ArgumentError] when an argument names no template or disagrees with one
+        def site_arguments(rows, argument_rows)
+          grouped = argument_rows.group_by { |row| site_key(row) }
+          orphans = grouped.keys - rows.map { |row| site_key(row) }
+          raise ArgumentError, "RefusalSiteArgument rows name no RefusalTemplate: #{orphans.inspect}" if orphans.any?
+
+          rows.to_h { |row| [site_key(row), site_specs(row, grouped)] }
+        end
+
+        # @param row [Hash] a RefusalTemplate or RefusalSiteArgument row
+        # @return [Array<String>] its refusal and site
+        def site_key(row) = [row.fetch("refusal"), row.fetch("site")]
+
+        # @param row [Hash] a RefusalTemplate row
+        # @param grouped [Hash] the argument rows by site
+        # @return [Array<Hash>] the site's argument rows, once checked against the template
+        # @raise [ArgumentError] when they do not match the template's placeholders
+        def site_specs(row, grouped)
+          key   = site_key(row)
+          specs = grouped.fetch(key, [])
+          wants = row.fetch("template").scan(/\{(\w+)\}/).flatten.uniq
+          names = specs.map { |spec| spec.fetch("argument") }
+          unless names == wants
+            raise ArgumentError, "RefusalSiteArgument for #{key.join("/")} declares #{names.inspect}; " \
+                                 "its template's placeholders are #{wants.inspect}"
+          end
+          specs.each { |spec| check_rule!(key, spec) }
+        end
+
+        # @param key [Array<String>] the site's refusal and site
+        # @param spec [Hash] one argument row
+        # @return [void]
+        # @raise [ArgumentError] when the row's shape, quoting or sorting is unknown
+        def check_rule!(key, spec)
+          where = "#{key.join("/")}.#{spec.fetch("argument")}"
+          unless Runtime::RefusalWording::SHAPES.include?(spec.fetch("shape"))
+            raise ArgumentError, "#{where}: unknown shape #{spec["shape"].inspect}"
+          end
+          unless Runtime::RefusalWording::QUOTINGS.include?(spec.fetch("quoting"))
+            raise ArgumentError, "#{where}: unknown quoting #{spec["quoting"].inspect}"
+          end
+          return if %w[true false].include?(spec.fetch("sorted"))
+
+          raise ArgumentError, "#{where}: sorted must be \"true\" or \"false\""
+        end
+
+        # @param enum [String] the enum's name
+        # @param variants [Array<String>] the variant names
+        # @param rows [Array<Hash>] the RefusalTemplate rows
+        # @param by_site [Hash] the argument rows by site
+        # @return [Array] the support functions and one args struct a variant, as Rust lines
+        def argument_types(enum, variants, rows, by_site)
+          SUPPORT + variants.zip(rows).flat_map do |variant, row|
+            args_struct(enum, variant, row, by_site.fetch(site_key(row)))
+          end
+        end
+
+        # @param enum [String] the enum's name
+        # @param variant [String] the variant's name
+        # @param row [Hash] the variant's RefusalTemplate row
+        # @param specs [Array<Hash>] the variant's argument rows
+        # @return [Array] its `<Variant>Args` struct and `render_args`, as Rust lines
+        def args_struct(enum, variant, row, specs)
+          struct_lines(enum, variant, row, specs) + impl_lines(enum, variant, specs)
+        end
+
+        # @return [Array] the struct holding a variant's arguments, as Rust lines
+        def struct_lines(enum, variant, row, specs)
+          [struct_doc(enum, variant, row),
+           "#[derive(Debug, Clone, Copy)]",
+           "pub struct #{variant}Args<'a> {",
+           struct_fields(specs),
+           "}",
+           ""]
+        end
+
+        # @return [Array] the `render_args` that formats each argument and fills the template
+        def impl_lines(enum, variant, specs)
+          ["impl #{variant}Args<'_> {",
+           "    /// The site's wording, every argument formatted by its declared row.",
+           "    pub fn render_args(&self) -> String {",
+           render_body(enum, variant, specs),
+           "    }",
+           "}",
+           ""]
+        end
+
+        # @return [Array<String>] the formatting `let`s and the `render` call
+        def render_body(enum, variant, specs)
+          locals = specs.filter_map { |spec| formatted_local(spec) }
+          [locals.map { |line| "        #{line}" },
+           "        #{enum}::#{variant}.render(&[",
+           render_pairs(specs),
+           "        ])"]
+        end
+
+        # @return [String] the doc comment above a variant's args struct
+        def struct_doc(enum, variant, row)
+          "/// `#{enum}::#{variant}`'s arguments — `RefusalWording.render_site(" \
+            "#{RustVocabulary.rust_string(row.fetch("refusal"))}, #{RustVocabulary.rust_string(row.fetch("site"))}, ...)`."
+        end
+
+        # @return [Array<String>] a doc line and a field for each argument
+        def struct_fields(specs)
+          specs.flat_map do |spec|
+            type = spec.fetch("shape") == "list" ? "&'a [&'a str]" : "&'a str"
+            ["    /// #{rule_reading(spec)}", "    pub #{rust_field(spec.fetch("argument"))}: #{type},"]
+          end
+        end
+
+        # @return [Array<String>] the `(name, value)` pair each argument adds to `render`
+        def render_pairs(specs)
+          specs.map do |spec|
+            name  = spec.fetch("argument")
+            value = formatted_local(spec) ? "#{local_name(name)}.as_str()" : "self.#{rust_field(name)}"
+            "            (#{RustVocabulary.rust_string(name)}, #{value}),"
+          end
+        end
+
+        # @param spec [Hash] one argument row
+        # @return [String, nil] the `let` that formats it, or nil when it is used as it stands
+        def formatted_local(spec)
+          name  = spec.fetch("argument")
+          field = "self.#{rust_field(name)}"
+          if spec.fetch("shape") == "list"
+            "let #{local_name(name)} = list(#{field}, #{spec.fetch("sorted")}, #{spec.fetch("quoting") == "inspect"}, " \
+              "#{RustVocabulary.rust_string(spec.fetch("separator"))}, " \
+              "#{RustVocabulary.rust_string(spec.fetch("when_empty"))});"
+          elsif spec.fetch("quoting") == "inspect"
+            "let #{local_name(name)} = quoted(#{field});"
+          end
+        end
+
+        # @param spec [Hash] one argument row
+        # @return [String] how the row formats its argument, in words
+        def rule_reading(spec)
+          quoting = spec.fetch("quoting") == "inspect" ? ", quoted" : ""
+          return "scalar#{quoting}" unless spec.fetch("shape") == "list"
+
+          sorted = spec.fetch("sorted") == "true" ? ", sorted" : ""
+          "list#{sorted}#{quoting}, joined #{spec.fetch("separator").inspect}, empty reads #{spec.fetch("when_empty").inspect}"
+        end
+
+        # @param argument [String] an argument's name
+        # @return [String] the Rust local that holds its formatted text
+        def local_name(argument) = "#{argument}_text"
+
+        # @param argument [String] an argument's name
+        # @return [String] the Rust field, raw-escaped when the name is a keyword
+        def rust_field(argument) = RustVocabulary::RUST_KEYWORDS.include?(argument) ? "r##{argument}" : argument
+      end
+    end
+  end
+end

data/lib/hecks/projections/rust_vocabulary/enum_body.rb

@@ -0,0 +1,114 @@
+module Hecks
+  module Projections
+    module RustVocabulary
+      # The `impl` block of one projected enum: its list constant, one accessor a row field,
+      # `from_name`, and the extras a table's kind adds.
+      module EnumBody
+        # The private `render` a refusal-template enum carries, as Rust lines.
+        RENDER_FN = [
+          "    /// `RefusalWording.substitute`: replace every `{key}` marker, in the",
+          "    /// order given. A template is read, never evaluated. Private: call",
+          "    /// sites go through a site's typed `<Variant>Args::render_args`,",
+          "    /// which formats and supplies every declared argument.",
+          "    fn render(&self, values: &[(&str, &str)]) -> String {",
+          "        let mut text = self.template().to_string();",
+          "        for (key, value) in values {",
+          "            text = text.replace(&format!(\"{{{key}}}\"), value);",
+          "        }",
+          "        text",
+          "    }"
+        ].freeze
+
+        module_function
+
+        # @param spec [Hash] the table's entry in `RustVocabulary::TABLES`
+        # @param variants [Array<String>] the variant names, in row order
+        # @param rows [Array<Hash>] the table's rows
+        # @return [Array] the lines of `impl <Enum> { ... }`, nested arrays allowed
+        def impl_lines(spec, variants, rows)
+          enum = spec[:enum]
+          ["impl #{enum} {",
+           constants(enum, variants, spec[:kind]),
+           rows.first.keys.map { |field| accessor(enum, field, variants, rows) },
+           from_name(enum, spec[:kind]),
+           extras(enum, variants, spec[:kind]),
+           "}",
+           ""]
+        end
+
+        # @param enum [String] the enum's name
+        # @param variants [Array<String>] the variant names
+        # @param kind [Symbol] `:order`, `:templates` or `:set`
+        # @return [Array<String>] the `ORDER` or `ALL` constant, as Rust lines
+        def constants(enum, variants, kind)
+          list = variants.map { |variant| "        #{enum}::#{variant}," }
+          if kind == :order
+            ["    /// The declared step order, first to last.",
+             "    pub const ORDER: [#{enum}; #{variants.size}] = [", list, "    ];", ""]
+          else
+            ["    /// Every row, in declared order.",
+             "    pub const ALL: &'static [#{enum}] = &[", list, "    ];", ""]
+          end
+        end
+
+        # @param enum [String] the enum's name
+        # @param field [String] the row field the accessor reads
+        # @param variants [Array<String>] the variant names
+        # @param rows [Array<Hash>] the table's rows
+        # @return [Array] the accessor, as Rust lines
+        def accessor(enum, field, variants, rows)
+          arms = variants.zip(rows).map do |variant, row|
+            "            #{enum}::#{variant} => #{RustVocabulary.rust_string(row.fetch(field))},"
+          end
+          ["    /// The row's declared `#{field}`.",
+           "    pub fn #{RustVocabulary.accessor_name(field)}(&self) -> &'static str {",
+           "        match self {",
+           arms,
+           "        }",
+           "    }",
+           ""]
+        end
+
+        # Built on the enum's own list and name accessor, not a string match, so no wildcard arm.
+        #
+        # @param enum [String] the enum's name
+        # @param kind [Symbol] `:order`, `:templates` or `:set`
+        # @return [Array<String>] `from_name`, as Rust lines
+        def from_name(enum, kind)
+          list  = kind == :order ? "ORDER" : "ALL"
+          field = kind == :templates ? "site" : RustVocabulary.name_field(kind)
+          ["    /// The row whose `#{field}` is `name`, if any.",
+           "    pub fn from_name(name: &str) -> Option<#{enum}> {",
+           "        #{enum}::#{list}.iter().copied().find(|row| row.#{RustVocabulary.accessor_name(field)}() == name)",
+           "    }",
+           ""]
+        end
+
+        # @param enum [String] the enum's name
+        # @param variants [Array<String>] the variant names
+        # @param kind [Symbol] `:order`, `:templates` or `:set`
+        # @return [Array<String>] the methods only this kind of table has, as Rust lines
+        def extras(enum, variants, kind)
+          case kind
+          when :order then position_fn(enum, variants)
+          when :templates then RENDER_FN
+          else []
+          end
+        end
+
+        # @param enum [String] the enum's name
+        # @param variants [Array<String>] the variant names
+        # @return [Array] `position`, as Rust lines
+        def position_fn(enum, variants)
+          arms = variants.each_with_index.map { |variant, index| "            #{enum}::#{variant} => #{index}," }
+          ["    /// This step's index in `ORDER`.",
+           "    pub fn position(&self) -> usize {",
+           "        match self {",
+           arms,
+           "        }",
+           "    }"]
+        end
+      end
+    end
+  end
+end