hecks 5.0.0 → 6.0.0

data/lib/hecks/tools/fuzz_sweep/findings.rb

@@ -8,7 +8,8 @@ module Hecks
       # Replays a generated sequence and judges, groups and shrinks what it finds.
       module Findings
         # An exception escaping Replay's per-step isolation is an interpreter defect, not a domain
-        # refusal.
+        # refusal. A sweep on SQLite or Postgres also checks that adapter's projection answers
+        # each rooted read model as the in-process loop does (ADR 0122).
         #
         # @param domain [String] the domain directory
         # @param steps [Array<Hash>] the sequence to replay
@@ -17,7 +18,7 @@ module Hecks
         #   `:crash`) and its message
         def outcome(domain, steps, adapter = :memory)
           history = Hecks::Fuzzing::Replay.call(domain, steps, adapter: adapter)
-          violations = Hecks::Fuzzing::Properties.check(history).reject { |_, result| result == true }
+          violations = property_results(domain, steps, adapter, history).reject { |_, result| result == true }
           return [:clean, nil] if violations.empty?
 
           [:property_violation, violations.map { |name, message| "#{name}: #{message}" }.join("; ")]
@@ -25,6 +26,21 @@ module Hecks
           [:crash, "#{e.class}: #{e.message}"]
         end
 
+        # The standard battery's results, and the projection agreement's when `adapter` has one.
+        #
+        # @param domain [String] the domain directory
+        # @param steps [Array<Hash>] the sequence replayed
+        # @param adapter [Symbol] the persistence it was replayed on
+        # @param history [Hash] the replayed history
+        # @return [Hash{Symbol => true, String}] each property name mapped to its result
+        def property_results(domain, steps, adapter, history)
+          results = Hecks::Fuzzing::Properties.check(history)
+          agreement = Hecks::Fuzzing::ProjectionAgreement
+          return results unless agreement.checks?(adapter)
+
+          results.merge(agreement::PROPERTY => agreement.property(domain, steps, adapter))
+        end
+
         # Groups findings by property name or exception class, stable across shrink candidates.
         #
         # @param message [String, nil] a finding's message

data/lib/hecks/tools/fuzz_sweep/options.rb

@@ -30,11 +30,15 @@ module Hecks
         def apply_option(options, arg, rest)
           if (key = INTEGER_OPTIONS[arg]) then options[key] = Integer(rest.shift)
           elsif arg == "--persist-regressions" then options[:persist] = true
-          elsif arg == "--adapter" then options[:adapter] = rest.shift.to_s.downcase.to_sym
+          elsif arg == "--adapter" then options[:adapter] = adapter_name(rest.shift)
           else options[:domain] = arg
           end
         end
 
+        # @param word [String, nil] the word after `--adapter`
+        # @return [Symbol] the adapter it names, lowercased
+        def adapter_name(word) = word.to_s.downcase.to_sym
+
         # @return [Boolean] whether `adapter` is one a sweep can boot on; warns when it is not
         def adapter_known?(adapter)
           return true if ADAPTERS.include?(adapter)

data/lib/hecks/tools/fuzz_sweep.rb

@@ -85,12 +85,12 @@ module Hecks
         fuzz_in_pool(domains, workers) { |domain| fuzz_in_child(options, domain, root) }
       end
 
-      # Runs in a forked child. A Postgres child gets its own scratch schema, so children can fuzz
-      # one database at once.
+      # Runs in a forked child. A Postgres child fuzzes in its own scratch schema, which
+      # `IsolatedBoot.scratch_schema` names by the child's pid, so children can fuzz one database
+      # at once.
       #
       # @return [Boolean] whether the domain was clean
       def fuzz_in_child(options, domain, root)
-        ENV[Hecks::Fuzzing::IsolatedBoot::FUZZ_SCHEMA_ENV] = "hecks_fuzz_#{Process.pid}" if options[:adapter] == :postgres
         fuzz_with(options, domain, root)
       end
 
@@ -177,13 +177,25 @@ module Hecks
       end
 
       # @return [Array(Symbol, String)] the verdict, replaying a clean run once more to see that it
-      #   repeats; and its message
+      #   repeats, and, for a domain that attaches Bulk, once more each way to see that a bulk run
+      #   matches dispatching its rows by hand, and on a SQL store that one statement matches row by
+      #   row (ADR 0129); and its message
       def verdict_for(domain, generated, adapter)
         verdict, message = outcome(domain, generated, adapter)
         return [verdict, message] unless verdict == :clean
 
         determinism = Hecks::Fuzzing::Properties.replay_is_deterministic(domain, generated, adapter: adapter)
-        determinism == true ? [:clean, nil] : [:nondeterminism, determinism]
+        return [:nondeterminism, determinism] unless determinism == true
+
+        parity = Hecks::Fuzzing::Properties.bulk_runs_match_hand_dispatch(domain, generated, adapter: adapter)
+        return [:bulk_parity, parity] unless parity == true
+
+        set_parity(domain, generated, adapter)
+      end
+
+      def set_parity(domain, generated, adapter)
+        parity = Hecks::Fuzzing::Properties.set_transform_matches_row_by_row(domain, generated, adapter: adapter)
+        parity == true ? [:clean, nil] : [:set_transform_parity, parity]
       end
     end
   end

data/lib/hecks/tools/gate.rb

@@ -1,13 +1,13 @@
 # frozen_string_literal: true
 
 require "open3"
-require "yaml"
+require "hecks/vocabulary"
 require_relative "../tools"
 
 module Hecks
   module Tools
-    # Runs a stage's checks, which `lib/hecks/gate/stages.yml` holds as data, all at once and
-    # reports every one, so a red check does not hide the others.
+    # Runs a stage's checks, which the `GateStage` and `GateCheck` rows of the Vocabulary bluebook
+    # hold as data, all at once and reports every one, so a red check does not hide the others.
     #
     #   hecks gate pre_push                # every check of the stage
     #   hecks gate pre_push only=rubocop   # the named checks
@@ -16,16 +16,38 @@ module Hecks
     # A green stage prints which checks passed; a red one prints each failing check's whole output
     # and what its failure means, and answers status 1.
     module Gate
-      STAGES_FILE = File.expand_path("../gate/stages.yml", __dir__)
       USAGE = "usage: hecks gate <stage> [only=a,b] | hecks gate --list"
 
       module_function
 
+      # @return [Hash{String => Hash}] each stage by name: its `env` and its `checks`, in order,
+      #   each check with its `id`, `title`, `run` words and `blocked`
+      def stages
+        checks = Vocabulary.rows("GateCheck").to_h { |row| [row["name"], check(row)] }
+        Vocabulary.rows("GateStage").to_h do |row|
+          stage = { "env" => env(row["env"]), "checks" => row["checks"].split(",").map { |name| checks.fetch(name) } }
+          [row["name"], stage]
+        end
+      end
+
+      # @param row [Hash{String => String}] a `GateCheck` row
+      # @return [Hash] the check: a script runs as `sh -ec`, otherwise `argv` is the command's words
+      def check(row)
+        run = row["script"].empty? ? row["argv"].split : ["sh", "-ec", row["script"]]
+        row.slice("id", "title", "blocked").merge("run" => run)
+      end
+
+      # @param words [String] `NAME=value` words
+      # @return [Hash{String => String}] the variables a stage sets
+      def env(words)
+        words.split.to_h { |word| word.split("=", 2) }
+      end
+
       # @param argv [Array<String>] a stage name and optionally `only=a,b`, or `--list`
       # @param root [String] the checkout the checks run in
       # @return [Integer] 0 when every check passed, 1 when one failed, 2 on bad usage
       def main(argv, root: Tools::ROOT, **)
-        stages = YAML.load_file(STAGES_FILE, aliases: true)
+        stages = self.stages
         return list(stages) if argv == ["--list"]
 
         name, only = parse(argv)

data/lib/hecks/tools/hoist_local_givens/rewriting.rb

@@ -105,11 +105,12 @@ module Hecks
         # `seg` with each of the candidate's occurrences swapped for a bare reference.
         def bare_references(seg, pattern, candidate)
           seg.gsub(pattern) do
-            indent, predicate_src = Regexp.last_match.captures
+            match = Regexp.last_match
+            indent, predicate_src = match.captures
             if matching_occurrence?(predicate_src, candidate)
               "#{indent}given(#{candidate.description.inspect})\n"
             else
-              Regexp.last_match(0)
+              match[0]
             end
           end
         end

data/lib/hecks/tools/hoist_local_givens.rb

@@ -104,10 +104,8 @@ module Hecks
       # @param registry [Object] the booted bluebooks
       # @return [Hash{String => Array}] each command's rules, by location
       def command_rule_map(registry)
-        Hecks::QueryIR.collect_rules(registry)
-                      .reject { |r| r.location.end_with?(" (declared)") }
-                      .group_by(&:location)
-                      .transform_values { |rules| rules.map { |r| [r.kind, r.description, r.canonical] }.sort }
+        local = Hecks::QueryIR.collect_rules(registry).reject { |r| r.location.end_with?(" (declared)") }
+        local.group_by(&:location).transform_values { |rules| rules.map { |r| [r.kind, r.description, r.canonical] }.sort }
       end
 
       # @param files [Array<String>] one example domain's bluebook files

data/lib/hecks/tools/lanes/prebuilt_workflow.rb

@@ -23,7 +23,7 @@ module Hecks
         def header(row)
           name = row["name"]
           ["name: Publish #{name}", "",
-           "# Generated by hecks project_lanes from the PrebuiltBinary rows of the Vocabulary chapter. Do not hand-edit.",
+           "# Generated by hecks project_lanes from the PrebuiltBinary rows of the Vocabulary bluebook. Do not hand-edit.",
            "#",
            "# Builds #{row["executable"]} from #{row["crate"]} for #{row["target"]} and publishes it as the release",
            "# #{name}-<key>, where the key is a hash of the crate's build inputs. A client that needs the same",

data/lib/hecks/tools/lanes/rows.rb

@@ -5,8 +5,14 @@ require "hecks/vocabulary"
 module Hecks
   module Tools
     module Lanes
-      # The `Lane` rows of the Vocabulary chapter, checked against what the projection can express.
+      # The `Lane` rows of the Vocabulary bluebook, checked against what the projection can express.
       module Rows
+        # Empty, or a trailer key of dash-joined words such as `Release-Approved-By`.
+        TRAILER_KEY = /\A([A-Za-z][A-Za-z0-9]*(-[A-Za-z0-9]+)*)?\z/
+
+        # Empty, or a whole number of hours.
+        WHOLE_HOURS = /\A\d*\z/
+
         module_function
 
         # @return [Array<Hash{String => String}>] the `Lane` rows
@@ -36,10 +42,10 @@ module Hecks
 
         # @return [Boolean] whether `release_trailer` is empty (nothing is released from the lane)
         #   or a git trailer key such as `Release-Approved-By`
-        def trailer?(lane) = lane["release_trailer"].to_s.match?(/\A([A-Za-z][A-Za-z0-9]*(-[A-Za-z0-9]+)*)?\z/)
+        def trailer?(lane) = lane["release_trailer"].to_s.match?(TRAILER_KEY)
 
         # @return [Boolean] whether `alert_after` is empty (never late) or whole hours
-        def hours?(lane) = lane["alert_after"].to_s.match?(/\A\d*\z/)
+        def hours?(lane) = lane["alert_after"].to_s.match?(WHOLE_HOURS)
 
         def follows_problem(lane, names)
           follows = lane["follows"].to_s

data/lib/hecks/tools/lanes/ruleset.rb

@@ -9,7 +9,7 @@ module Hecks
       # The ruleset GitHub is given for a guarded lane.
       #
       # A guarded lane cannot be deleted or rewound, and a `green` lane takes only a commit on
-      # which every `RequiredCheck` of the Vocabulary chapter has already passed. No actor is let
+      # which every `RequiredCheck` of the Vocabulary bluebook has already passed. No actor is let
       # past it: a push of a commit that passed is how a promotion moves the lane, and the GitHub
       # Actions app cannot be named as a bypass actor.
       module Ruleset

data/lib/hecks/tools/lanes/watch_workflow.rb

@@ -11,7 +11,7 @@ module Hecks
         HEADER = <<~YAML.chomp
           name: Watch lanes
 
-          # Generated by hecks project_lanes from the Lane rows of the Vocabulary chapter. Do not hand-edit.
+          # Generated by hecks project_lanes from the Lane rows of the Vocabulary bluebook. Do not hand-edit.
           #
           # Every hour, asks `PromotionRun` whether a lane has stood behind the lane it follows for
           # longer than its Lane row allows (`alert_after`, in hours). The rule is decided there, not

data/lib/hecks/tools/lanes/workflow.rb

@@ -10,7 +10,7 @@ module Hecks
         HEADER = <<~YAML.chomp
           name: Promote
 
-          # Generated by hecks project_lanes from the Lane rows of the Vocabulary chapter. Do not hand-edit.
+          # Generated by hecks project_lanes from the Lane rows of the Vocabulary bluebook. Do not hand-edit.
           #
           # After CI finishes on a push to the lane a lane follows, asks `PromotionRun` to move the
           # lane onto the newest commit of that lane every RequiredCheck passed on. Which commit may

data/lib/hecks/tools/lanes.rb

@@ -6,7 +6,7 @@ require_relative "../hecks/adapters/github_rulesets"
 
 module Hecks
   module Tools
-    # Projects the `Lane` rows of the Vocabulary chapter into what GitHub is told about them: a
+    # Projects the `Lane` rows of the Vocabulary bluebook into what GitHub is told about them: a
     # ruleset for each guarded lane (`.github/rulesets/<lane>.json`), one for the tag such a lane
     # feeds (`.github/rulesets/tag-<tag>.json`), and the workflow that promotes
     # each lane that follows another (`.github/workflows/promote.yml`). The workflow only runs

data/lib/hecks/tools/oidc_manifests.rb

@@ -6,7 +6,7 @@ require_relative "../tools"
 module Hecks
   module Tools
     # Projects each domain's OIDC client and scope manifest (`Hecks::Projections::OIDC`) into an
-    # `oidc.json` beside the domain, or into one `<chapter>.oidc.json` for each chapter of a
+    # `oidc.json` beside the domain, or into one `<bluebook>.oidc.json` for each bluebook of a
     # directory that holds several.
     #
     # A domain that has no bluebook is skipped and one that cannot be projected is reported, so a
@@ -38,15 +38,12 @@ module Hecks
       # @return [Array<String>] the domain directories, relative to `root`, sorted
       def domains(root)
         folder = Hecks::Adapters::Folder.new
-        Dir.glob(File.join(root, "**/*.hecksagon"))
-           .map { |path| folder.domain_root(File.dirname(path)) }
-           .compact
-           .map { |path| path.delete_prefix("#{root}/") }
-           .grep_v(NOT_DOMAINS)
-           .uniq.sort
+        roots = Dir.glob(File.join(root, "**/*.hecksagon")).map { |path| folder.domain_root(File.dirname(path)) }
+        relative = roots.compact.map { |path| path.delete_prefix("#{root}/") }
+        relative.grep_v(NOT_DOMAINS).uniq.sort
       end
 
-      # Projects one manifest for each chapter the directory holds.
+      # Projects one manifest for each bluebook the directory holds.
       #
       # @param root [String] the checkout
       # @param path [String] a domain directory, relative to `root`
@@ -55,20 +52,20 @@ module Hecks
         registry = Hecks.boot(File.join(root, path), install_driving: false).registry
         return warn("  #{path}: no bluebook found — skipped") if registry.bluebooks.empty?
 
-        project_chapters(registry, root, path)
+        project_bluebooks(registry, root, path)
       rescue StandardError => e
-        warn "  #{path}: cannot project — #{e.message.lines.first.strip}"
+        warn "  #{path}: cannot project — #{Hecks::Text.first_line(e.message)}"
       end
 
-      # The chapters a directory declares: those with a `.bluebook` file under it. A chapter it
+      # The bluebooks a directory declares: those with a `.bluebook` file under it. A bluebook it
       # only attaches (Governance, for one) is loaded from elsewhere and has its own directory's
       # manifest.
       #
       # @param registry [Hecks::Runtime::Registry] the booted registry of the directory
       # @param directory [String] the directory that was booted
-      # @return [Array<String>] the chapter names, in load order; the first loaded when none has a
+      # @return [Array<String>] the bluebook names, in load order; the first loaded when none has a
       #   recorded source
-      def chapters_of(registry, directory)
+      def bluebooks_of(registry, directory)
         under = "#{File.expand_path(directory)}/"
         own = registry.bluebooks.keys.select do |name|
           Array(registry.bluebook_sources[name]).any? { |source| File.expand_path(source).start_with?(under) }
@@ -80,8 +77,8 @@ module Hecks
       # @param root [String] the checkout
       # @param path [String] the domain directory, relative to `root`
       # @return [void]
-      def project_chapters(registry, root, path)
-        names = chapters_of(registry, File.join(root, path))
+      def project_bluebooks(registry, root, path)
+        names = bluebooks_of(registry, File.join(root, path))
         names.each do |name|
           file = file_for(names, name)
           write_manifest(registry, name, File.join(root, path, file))
@@ -89,12 +86,12 @@ module Hecks
         end
       end
 
-      # A domain of one chapter keeps `oidc.json`; a directory of several chapters, such as the
+      # A domain of one bluebook keeps `oidc.json`; a directory of several bluebooks, such as the
       # framework members, gets one manifest each, so none of them stands for the others.
       #
-      # @param names [Array<String>] every chapter the directory holds
-      # @param name [String] the chapter the manifest is for
-      # @return [String] the manifest's file name: `oidc.json`, or `<chapter>.oidc.json`
+      # @param names [Array<String>] every bluebook the directory holds
+      # @param name [String] the bluebook the manifest is for
+      # @return [String] the manifest's file name: `oidc.json`, or `<bluebook>.oidc.json`
       def file_for(names, name) = names.one? ? "oidc.json" : "#{Naming.snake(name)}.oidc.json"
 
       # @param registry [Hecks::Runtime::Registry] the booted registry

data/lib/hecks/tools/regeneration_run.rb

@@ -32,6 +32,9 @@ module Hecks
                          "Only pizzas, mod.rs and Cargo.toml are committed; run " \
                          "`hecks regenerate_corpus --confirm` first, then the check."
 
+      # The `hecks project_rust` flag that leaves the `meta/` module as an earlier domain wrote it.
+      SKIP_META = "--skip-meta"
+
       module_function
 
       # Regenerates the corpus, or checks it.
@@ -43,8 +46,8 @@ module Hecks
       def main(argv, root: Tools::ROOT)
         Dir.chdir(root) do
           domains = plan(root)
-          # A check projects into a scratch copy of the crate; the forked children inherit
-          # HECKS_RUST_DIR.
+          # A check projects into a scratch copy of the crate; the forked children inherit the
+          # workspace with the process.
           scratch = argv.include?("--check") && scratch_crate(root)
           run_plan(domains, scratch)
         end
@@ -62,13 +65,12 @@ module Hecks
         FileUtils.rm_rf(scratch) if scratch
       end
 
-      # Points `HECKS_RUST_DIR` at `scratch` while the block runs, then puts it back.
-      def with_rust_dir(scratch)
-        saved = ENV.fetch("HECKS_RUST_DIR", nil)
-        ENV["HECKS_RUST_DIR"] = scratch if scratch
-        yield
-      ensure
-        saved ? ENV["HECKS_RUST_DIR"] = saved : ENV.delete("HECKS_RUST_DIR")
+      # Builds in `scratch` while the block runs; with none, in the workspace already chosen.
+      def with_rust_dir(scratch, &)
+        require "hecks/rust_build"
+        return yield unless scratch
+
+        Hecks::RustBuild.in_workspace(scratch, &)
       end
 
       # `meta` is never in the list: `Hecks::Corpus::RUST_ELSEWHERE` routes it to the check that
@@ -98,7 +100,8 @@ module Hecks
         require "hecks/bluebook/meta_validator"
         require "hecks/rust_build"
         Hecks::Bluebook::MetaValidator.grammar_registry
-        domains.each { |domain| project_rust_in_fork(domain) }
+        # Every domain writes the same `meta/` module, so the first one does and the rest skip it.
+        domains.each_with_index { |domain, index| project_rust_in_fork(domain, skip_meta: index.positive?) }
       end
 
       # Forks so the child inherits the memoized grammar registry instead of rebuilding it. The
@@ -106,12 +109,14 @@ module Hecks
       # process's stdout.
       #
       # @param domain [String] the domain, relative to the checkout
+      # @param skip_meta [Boolean] leave the `meta/` module as an earlier domain wrote it
       # @return [void]
       # @raise [SystemExit] when the child fails
-      def project_rust_in_fork(domain)
+      def project_rust_in_fork(domain, skip_meta: false)
         puts "== hecks project_rust #{domain} =="
         reader, writer = IO.pipe
-        pid = fork { run_child(reader, writer, domain) }
+        argv = skip_meta ? [domain, SKIP_META] : [domain]
+        pid = fork { run_child(reader, writer, argv) }
         writer.close
         $stdout.write(reader.read)
         reader.close
@@ -122,23 +127,23 @@ module Hecks
 
       # @param reader [IO] the parent's end of the pipe, closed here
       # @param writer [IO] the child's end, which becomes its stdout and stderr
-      # @param domain [String] the domain
+      # @param argv [Array<String>] the domain, and any flag for `hecks project_rust`
       # @return [void] never returns: the child leaves without the parent's exit handlers
-      def run_child(reader, writer, domain)
+      def run_child(reader, writer, argv)
         reader.close
         # The real descriptors, not the globals: a caller may have swapped those for a buffer.
         STDOUT.reopen(writer) # rubocop:disable Style/GlobalStdStream
         STDERR.reopen(writer) # rubocop:disable Style/GlobalStdStream
         $stdout = STDOUT
         $stderr = STDERR
-        status = child_status(domain)
+        status = child_status(argv)
         $stdout.flush
         exit!(status)
       end
 
       # @return [Integer] the exit status of `hecks project_rust` for the domain
-      def child_status(domain)
-        Hecks::RustBuild.run("project_rust", [domain], out: STDOUT, err: STDERR) # rubocop:disable Style/GlobalStdStream
+      def child_status(argv)
+        Hecks::RustBuild.run("project_rust", argv, out: STDOUT, err: STDERR) # rubocop:disable Style/GlobalStdStream
       rescue SystemExit => e
         e.status
       rescue StandardError => e

data/lib/hecks/tools/release_only.rb

@@ -11,7 +11,7 @@ module Hecks
     # inherit the base's certification instead of running the suite again.
     #
     # The files a bump edits, and which of their lines it may change, are the `ReleaseFile` rows of
-    # the Vocabulary chapter. A change is a release bump when it touches at least one file, every
+    # the Vocabulary bluebook. A change is a release bump when it touches at least one file, every
     # file it touches is a row, and every line it adds or removes in a file matches that row's
     # `lines` pattern (an empty pattern admits any line). Whether the base is certified is read
     # from the base commit's own check runs: every `RequiredCheck` row that is not marked
@@ -21,6 +21,9 @@ module Hecks
     module ReleaseOnly
       GREEN = %w[success skipped].freeze
 
+      # The `+` or `-` that opens an added or removed line of a diff.
+      CHANGE_MARK = /\A[+-]/
+
       module_function
 
       # @param changes [Hash{String => Array<String>}] each changed path to the lines it adds or
@@ -91,7 +94,7 @@ module Hecks
 
       # @return [Boolean] whether the line is an added or removed line, not a header
       def content_line?(line)
-        line.match?(/\A[+-]/) && !line.start_with?("+++ ", "--- ")
+        line.match?(CHANGE_MARK) && !line.start_with?("+++ ", "--- ")
       end
 
       # @param repository [String] `owner/name`

data/lib/hecks/tools/rust_comment_style/caps_words.rb

@@ -69,17 +69,17 @@ module Hecks
         end
 
         def keep_capitals?(word)
-          bare = word.sub(/'[A-Z]{1,2}\z/, "")
+          bare = word.sub(CommentStyle::SHOUTED_SUFFIX, "")
           return false if CommentStyle::PROPER_NOUNS.key?(bare) || RUST_PROPER_NOUNS.key?(bare)
 
           CommentStyle::ACRONYMS.include?(bare) || RUST_ACRONYMS.include?(bare) ||
-            @constants.include?(bare) || bare.match?(/\A[IVX]+\z/)
+            @constants.include?(bare) || bare.match?(CommentStyle::ROMAN_NUMERAL)
         end
 
         def sentence_start?(comment, masked, offset)
           before = masked[0, offset].sub(MARKER, "")
-          return before.match?(/[.!?]["')\]]*\s+\z/) if before.match?(/[[:alnum:]#{FILLER}]/o)
-          return true if before.match?(/\A\s*(?:[-*•]|─+|\d+[.)])\s+\z/)
+          return before.match?(CommentStyle::SENTENCE_BREAK) if before.match?(/[[:alnum:]#{FILLER}]/o)
+          return true if before.match?(CommentStyle::LIST_MARKER)
 
           after_sentence_end?(comment)
         end
@@ -90,7 +90,7 @@ module Hecks
           return true unless previous&.full_line
 
           body = previous.text.sub(MARKER, "").strip
-          body.empty? || body.match?(/[.!?]["')\]]*\z/)
+          body.empty? || body.match?(CommentStyle::SENTENCE_END)
         end
       end
     end

data/lib/hecks/tools/rust_comment_style/fixing.rb

@@ -75,7 +75,7 @@ module Hecks
           return false if masked[0, offset].sub(MARKER, "").match?(/[[:alnum:]#{FILLER}]/o)
 
           above = comment.full_line ? @by_line[comment.line - 1] : nil
-          !above&.full_line || above.text.match?(%r{\A/{2,3}!?\s*\z})
+          !above&.full_line || above.text.match?(EMPTY_COMMENT)
         end
 
         # Splits one over-long prose comment line in two. Lines with no safe

data/lib/hecks/tools/rust_comment_style/masking.rb

@@ -5,6 +5,9 @@ require_relative "../../tools"
 module Hecks
   module Tools
     module RustCommentStyle
+      # A comment line with nothing after its slashes: a paragraph break.
+      EMPTY_COMMENT = %r{\A/{2,3}!?\s*\z}
+
       # Blanks the spans of a Rust comment that must keep their capitals (code spans, quotes, SQL),
       # and decides which capitalised SQL keywords on a line to leave alone.
       module Masking
@@ -21,7 +24,7 @@ module Hecks
 
         def continues_paragraph?(comment)
           above = @by_line[comment.line - 1]
-          comment.full_line && above&.full_line && !above.text.match?(%r{\A/{2,3}!?\s*\z})
+          comment.full_line && above&.full_line && !above.text.match?(EMPTY_COMMENT)
         end
 
         def mask(comment)
@@ -52,8 +55,8 @@ module Hecks
         def quoted_heading?(span)
           return false unless span.start_with?('"') && !span.match?(CommentStyle::SQL_PHRASES)
 
-          capitals = span.scan(/\b[A-Z]{2,}\b/).size
-          capitals >= 3 || (capitals == 2 && !span.match?(/[a-z]/))
+          capitals = span.scan(CommentStyle::SHOUTED_WORD).size
+          capitals >= 3 || (capitals == 2 && !span.match?(CommentStyle::LOWERCASE))
         end
 
         def sql_keywords(comment, words)
@@ -65,7 +68,7 @@ module Hecks
         end
 
         def sql_classes(words)
-          bare = words.map { |w| w.sub(/'[A-Z]{1,2}\z/, "") } - ["A"]
+          bare = words.map { |w| w.sub(CommentStyle::SHOUTED_SUFFIX, "") } - ["A"]
           [bare, bare.select { |w| CommentStyle::SQL_STRONG.include?(w) }, bare.select { |w| CommentStyle::SQL_WEAK.include?(w) }]
         end
 

data/lib/hecks/tools/rust_comment_style/source_file.rb

@@ -12,6 +12,11 @@ module Hecks
     module RustCommentStyle
       # One parsed `.rs` file and the violations found in it.
       class SourceFile
+        # A `const` or `static` item, capturing its all-caps name.
+        CONSTANT_ITEM = /\b(?:const|static)\s+(?:mut\s+)?([A-Z][A-Z0-9_]*)\b/
+        # A string holding nothing but an all-caps name of three or more characters.
+        QUOTED_CONSTANT = /"([A-Z][A-Z0-9_]{2,})"/
+
         include Masking
         include CapsWords
         include TextChecks
@@ -61,8 +66,8 @@ module Hecks
           code_only = @source.dup
           Tokenizer.comments(@source).each { |c| code_only[c.line - 1] ||= "" }
           names = Set.new
-          code_only.scan(/\b(?:const|static)\s+(?:mut\s+)?([A-Z][A-Z0-9_]*)\b/) { |(n)| names << n }
-          code_only.scan(/"([A-Z][A-Z0-9_]{2,})"/) { |(n)| names << n }
+          code_only.scan(CONSTANT_ITEM) { |(n)| names << n }
+          code_only.scan(QUOTED_CONSTANT) { |(n)| names << n }
           names
         end
       end

data/lib/hecks/tools/rust_comment_style/text_checks.rb

@@ -44,7 +44,7 @@ module Hecks
         end
 
         def history_violations(comment)
-          masked = comment.text.gsub(/`[^`]*`/) { |span| " " * span.length }
+          masked = comment.text.gsub(CommentStyle::CODE_SPAN) { |span| " " * span.length }
           pattern = CommentStyle::HISTORY.find { |candidate| masked.match?(candidate) }
           return [] unless pattern
 

data/lib/hecks/tools/rust_comment_style/tokenizer.rb

@@ -8,6 +8,9 @@ module Hecks
       # Finds Rust source's line comments, distinguishing them from `//` inside
       # code, strings, raw strings, and char literals. Block comments are not recognised.
       class Tokenizer
+        # A Rust char literal: one character or one escape between single quotes.
+        CHAR_LITERAL = /\A'(?:\\.|[^'\\\n]){1}'/
+
         # Lexes `source` for its line comments in one pass.
         def self.comments(source)
           new(source).run
@@ -67,7 +70,7 @@ module Hecks
         end
 
         def consume_quote(pos, col)
-          match = @src[pos..].match(/\A'(?:\\.|[^'\\\n]){1}'/)
+          match = @src[pos..].match(CHAR_LITERAL)
           match ? [pos + match[0].length, col + match[0].length] : [pos + 1, col + 1]
         end