hecks 3.13.0 → 4.0.0

data/lib/hecks/fuzzing/isolated_boot/worlds.rb

@@ -74,12 +74,9 @@ module Hecks
 
         def hecksagon_names_in(path) = File.read(path).scan(HECKSAGON_NAME).flatten
 
-        # Deletes every `translations/*.bluebook` in the copy. A compute/rekey translation
-        # edge refuses to boot under any non-lineage-capable adapter (only `PostgresEra`
-        # answers `lineage_capable? == true`), so every other mode strips it here rather
-        # than tripping that refusal. Safe to drop: an ephemeral, zero-history boot never
-        # has a pre-existing era-1 row to translate — the edge only matters at mint time,
-        # against a real database, never here.
+        # Deletes every `translations/*.bluebook` in the copy. Safe to drop: an ephemeral,
+        # zero-history boot never has a pre-existing era-1 row to translate; the edge only
+        # matters at mint time, against a real database, never here.
         def strip_translations!(copy)
           Dir.glob(File.join(copy, "**", "translations", "*.bluebook")).each { |path| File.delete(path) }
         end

data/lib/hecks/fuzzing/replay/filters.rb

@@ -1,4 +1,4 @@
-require_relative "../../query_specification/common/comparators"
+require_relative "../../vocabulary"
 require_relative "../../query_specification/common/where_clause"
 require_relative "../../query_specification/field_path"
 require_relative "../../ports/query/in_memory"
@@ -9,10 +9,6 @@ module Hecks
       # Answers the ad hoc `{aggregate:, field:, op:, value:}` filter steps that bypass the
       # declared query DSL.
       module Filters
-        # Mirrors QuerySpecification::Common::COMPARATORS, not the Rust
-        # kernel's own comparator enum, which is missing `none_in_state` and has drifted.
-        FILTER_COMPARATORS = Hecks::QuerySpecification::Common::COMPARATORS.map(&:to_s).freeze
-
         # Answers one ad hoc filter step, the mirror image of kernel/cli.rs's own
         # `run_filter`, calling the same production `Ports::Query::InMemory` rather than
         # re-deriving comparator behavior by hand. Sorted by id ascending regardless,
@@ -31,7 +27,7 @@ module Hecks
 
         # A malformed ad-hoc ask is a fault (C8.3), not a bare RuntimeError.
         def check_comparator!(comparator)
-          return if FILTER_COMPARATORS.include?(comparator)
+          return if Hecks::Vocabulary.fetch("QueryComparator").include?(comparator)
 
           raise Bluebook::Expression::EvaluationError, "unknown query comparator #{comparator.inspect}"
         end

data/lib/hecks/gate/stages.yml

@@ -84,6 +84,20 @@ pre_push:
       title: comment blocks, no run of comment lines past ADR 0075's cap
       run: [bundle, exec, exe/hecks, style_run.check_comments, "paths=lib,spec,examples", only=long_block, --wait]
       blocked: a comment block ran past the cap; shorten it.
+    - &check_rust_fmt
+      id: rust_fmt
+      title: rustfmt, every Rust crate laid out as `cargo fmt` would
+      run:
+        - sh
+        - -ec
+        - |
+          # The main crate's generated modules are not committed, so cargo fmt would stop at a
+          # missing file on a fresh checkout; its hand-written entry points are named instead.
+          rustfmt --check --edition 2021 rust/src/main.rs rust/src/kernel/mod.rs rust/tests/*.rs
+          for crate in parser codegen lsp host web build; do
+            cargo fmt --check --manifest-path "rust/$crate/Cargo.toml"
+          done
+      blocked: a Rust file is not laid out as rustfmt has it; run `cargo fmt` in its crate (rust/src/exemplar is exempt, it is text templates). Generated Rust is laid out by its generators, so fix the generator, not the output.
 
 # The checks a push of only unguarded lanes (`main`) runs in place of pre_push. The slow suite is
 # skipped there; the style checks are not, since an offense that lands on `main` is a red CI run,
@@ -140,6 +154,17 @@ ci:
     - *check_comment_style
     - *check_comment_blocks
     - *check_codegen_drift
+    - *check_rust_fmt
+    - id: rust_clippy
+      title: clippy, every Rust crate with its warnings as errors
+      run:
+        - sh
+        - -ec
+        - |
+          for crate in . parser codegen lsp host web build; do
+            cargo clippy --all-targets --manifest-path "rust/$crate/Cargo.toml" -- -D warnings
+          done
+      blocked: clippy found a warning in a Rust crate, under the strict `[lints.clippy]` table of its Cargo.toml. The main crate needs rust/src/generated, so run `hecks regenerate_corpus --confirm` first on a fresh checkout. Fix the code, or allow a lint at the one site with a line saying why; a warning in generated Rust is fixed in its generator.
     - id: lint_deploy_recipes
       title: generated deploy recipes, a command with no checked exit status or no echo
       run: [bundle, exec, exe/hecks, deploy, makefile_check.lint, --wait]

data/lib/hecks/grammar/evolve/seeds.rb

@@ -157,15 +157,9 @@ module Hecks
         # First `end` after the opener is the block's own — member rows sit bare (ADR 0025).
         def keyword_blocks(source) = seed_blocks(source, "KeywordSeed")
 
-        # The first KeywordSeed block's source text.
-        def keyword_block(source) = seed_block(source, "KeywordSeed", required: true)
-
         # ArgumentSeed blocks; see keyword_blocks for why the first bare end
         # after the opener is already the block's own.
         def argument_blocks(source) = seed_blocks(source, "ArgumentSeed")
-
-        # The first ArgumentSeed block's source text.
-        def argument_block(source) = seed_block(source, "ArgumentSeed", required: true)
       end
     end
   end

data/lib/hecks/grammar/evolve.rb

@@ -96,9 +96,6 @@ module Hecks
         end
       end
 
-      # Narrow compatibility entry point for single-file callers; syntax_paths is normal.
-      def syntax_path = syntax_paths.first
-
       # Resolves the file(s) a call should search or write.
       def paths_for(path) = path ? Array(path) : syntax_paths
 

data/lib/hecks/grammar/translation.bluebook

@@ -23,7 +23,7 @@ Hecks.bluebook "Translation" do
     # "retired" is the edge-level declaration (TranslationBuilder#retired).
     value_object "Kind" do
       attribute :value, String,
-                one_of: ["rename", "move", "convert", "drop", "retype", "retired", "compute", "rekey",
+                one_of: ["rename", "move", "convert", "drop", "retype", "retired", "derive", "rekey_to",
                          "backfill", "unresolved"]
     end
 

data/lib/hecks/hecks/adapters/codebase/composing.rb

@@ -0,0 +1,56 @@
+require_relative "corpus_tasks"
+
+module Hecks
+  module Adapters
+    module Codebase
+      # What Codebase's `CorpusRun` asks of the working tree to open the Composer: serve its editor
+      # over one domain directory, on the loopback address only, until the server is stopped.
+      #
+      # The server hook is the one `CorpusTasks` has, so a spec replaces both servers the same way.
+      module Composing
+        # Every operation this family carries out.
+        OPERATIONS = %w[compose].freeze
+
+        # The port the editor listens on when none is named.
+        DEFAULT_PORT = 4570
+
+        # The directory the editor opens when none is named, relative to the checkout.
+        DEFAULT_WORKSPACE = "examples/pizzas/bluebook".freeze
+
+        # The only address the editor binds: it carries no authentication.
+        HOST = "127.0.0.1".freeze
+
+        module_function
+
+        # Opens the editor.
+        #
+        # @param operation [String] `compose`
+        # @param held [Hash] the `CorpusRun` record's fields: `port`, `domains` (the directory)
+        # @param tree [Tree] the working tree, already known to be a hecks checkout
+        # @param shell [#capture, nil] unused
+        # @return [String] a note that the server stopped
+        def call(operation, held, tree, shell: nil)
+          _ = [operation, shell]
+          require "hecks/composer/web"
+          fields = held.transform_values { |value| value.is_a?(Hash) ? value[:value] : value }
+          workspace = File.expand_path(fields[:domains] || DEFAULT_WORKSPACE, tree.root)
+          port = fields[:port] || DEFAULT_PORT
+          warn "composer over #{workspace} on http://#{HOST}:#{port}/composer - no authentication, " \
+               "no CSRF protection, no caller identity; do not expose beyond localhost"
+          app = Composer::Web.app(workspace: workspace)
+          (CorpusTasks.web_server || method(:serve)).call(app: app, port: port, host: HOST)
+          "composed on port #{port}, now stopped"
+        end
+
+        # @param app [#call] the Rack app
+        # @param port [Integer] the port
+        # @param host [String] the address to bind
+        # @return [void]
+        def serve(app:, port:, host:)
+          require "rackup"
+          Rackup::Server.start(app: app, Host: host, Port: port, server: "webrick")
+        end
+      end
+    end
+  end
+end

data/lib/hecks/hecks/adapters/codebase/source_tree.rb

@@ -11,6 +11,7 @@ require_relative "inspection"
 require_relative "codemods"
 require_relative "test_suite"
 require_relative "corpus_tasks"
+require_relative "composing"
 require_relative "publishing"
 require_relative "promotion"
 require_relative "../git"
@@ -183,7 +184,8 @@ module Hecks
       # The task families, each carrying out the operations it lists.
       FAMILIES = [Codebase::Language, Codebase::KernelTables, Codebase::Conformance, Codebase::Regeneration,
                   Codebase::Gate, Codebase::Style, Codebase::Inspection, Codebase::Codemods, Codebase::TestSuite,
-                  Codebase::CorpusTasks, Codebase::Publishing, Codebase::Promotion].freeze
+                  Codebase::CorpusTasks, Codebase::Composing, Codebase::Publishing,
+                  Codebase::Promotion].freeze
       private_constant :FAMILIES
 
       # The facts of a promotion or a watch, naming the operation so policies can tell them apart.

data/lib/hecks/hecks/adapters/journal_store/changes.rb

@@ -117,32 +117,6 @@ module Hecks
         def apply_compaction(held, kind)
           Compaction.new(plain(held[:domain]), aggregates: names(held[:aggregates]), kind: kind).apply!.join("\n")
         end
-
-        # Writes `translations/<edge>.approval`; the host reads it at its next boot.
-        def apply_approve_translation(held)
-          domain = HeldDomain.open(plain(held[:domain]))
-          finding = domain.reading { |lineage| audited_edge(domain, lineage) }
-          document = approval_document(domain, finding, held)
-          path = Translation::ApprovalFile.write!(domain.directory, finding.edge, document)
-          "approval of edge #{document["edge"]} written to #{path} (digest #{document["edge_digest"][0, 12]}…, " \
-            "by #{document["approved_by"]}). Commit it with the edge; the host applies it at its next boot."
-        end
-
-        def approval_document(domain, finding, held)
-          Translation::ApprovalFile.build(
-            edge: finding.edge, approved_by: Git.new.identity(chdir: domain.directory),
-            approved_at: Time.now.utc.iso8601, rehearsal: rehearsal_block(held)
-          )
-        end
-
-        def audited_edge(domain, lineage)
-          eras = domain.held_eras(lineage)
-          finding = eras.empty? ? nil : EdgeAudit.call(domain, lineage, eras)
-          raise Runtime::WiringError, "#{domain.bluebook.name} has no edge to approve" unless finding
-          raise Runtime::WiringError, "#{finding.report}\nAUDIT REFUSED." unless finding.ok
-
-          finding
-        end
       end
     end
   end

data/lib/hecks/hecks/adapters/journal_store/examination.rb

@@ -15,15 +15,14 @@ module Hecks
       module Examination
         # What every fact is until an examination finds otherwise.
         NEUTRAL = {
-          capable: false, held: 0, forks: 0, contested: 0, edges: 0, bound: 0, candidates: 0,
-          audited: false, rehearsal_needed: false, rehearsal_recorded: false,
+          capable: false, held: 0, forks: 0, contested: 0, bound: 0, candidates: 0,
           drifted: false, loadable: false, shape_kept: false
         }.freeze
 
         # Examines the domain a change was asked for.
         #
         # @param held [Hash] the `Era` record: `operation`, `domain`, and whichever of `winners`,
-        #   `era`, `aggregates` and the rehearsal fields the request carried
+        #   `era` and `aggregates` the request carried
         # @return [Hash{Symbol => Hash}] every fact, as `{ value: x }`, and the request's own
         #   `operation`, which the reactions to the examination read
         # @raise [Runtime::NotFound] if the domain cannot be loaded or has no such era
@@ -90,26 +89,6 @@ module Hecks
           { candidates: compaction.candidates.size, bound: compaction.bound.size }
         end
 
-        def examine_approve_translation(held)
-          domain = HeldDomain.open(plain(held[:domain]))
-          return {} unless domain.capable?
-
-          domain.reading do |lineage|
-            eras = domain.held_eras(lineage)
-            finding = eras.empty? ? nil : EdgeAudit.call(domain, lineage, eras)
-            next { capable: true, held: eras.size } unless finding
-
-            { capable: true, held: eras.size, edges: finding.leaving, audited: finding.ok }.merge(rehearsal_facts(finding, held))
-          end
-        end
-
-        def rehearsal_facts(finding, held)
-          {
-            rehearsal_needed:   Translation::ApprovalFile.needs_rehearsal?(finding.edge),
-            rehearsal_recorded: Translation::ApprovalFile.rehearsed?(rehearsal_block(held))
-          }
-        end
-
         # How many eras, before the latest, do not have exactly one edge leading to the next.
         def forks_in(domain, eras)
           eras.each_cons(2).count do |from, to|

data/lib/hecks/hecks/adapters/journal_store/readings.rb

@@ -18,6 +18,8 @@ module Hecks
       # a domain that holds no era answers that it holds none, and only `hold_first` holds one.
       # What a reading refuses is a `Runtime::NotFound`, the refusal a launcher words as an answer.
       module Readings
+        AUDIT_PASSED = "AUDIT PASSED \u2014 review the samples above; intent is yours to approve."
+
         include Scaffolding
         include Attestation
 
@@ -112,17 +114,7 @@ module Hecks
           return "#{held.bluebook.name} stands at era 1 — no edge to audit." unless finding
           raise Runtime::NotFound, "#{finding.report}\nAUDIT REFUSED." unless finding.ok
 
-          [finding.report, audit_verdict(finding.edge, path)].join("\n")
-        end
-
-        def audit_verdict(edge, path)
-          if Translation::ApprovalFile.needs_rehearsal?(edge)
-            "AUDIT PASSED — this edge carries a compute or rekey rule, and the samples above are its ONLY " \
-              "verification. If they show what you intended, rehearse it against a snapshot and run " \
-              "`hecks approve_translation #{path} --confirm` with the rehearsal; the mint refuses until then."
-          else
-            "AUDIT PASSED — review the samples above; intent is yours to approve."
-          end
+          [finding.report, AUDIT_PASSED].join("\n")
         end
       end
     end

data/lib/hecks/hecks/adapters/journal_store.rb

@@ -42,17 +42,6 @@ module Hecks
         end
       end
 
-      # The rehearsal a compute or rekey edge is approved on, as the block the file carries. A
-      # rehearsal that names no host version ran on this one, so it records this release.
-      def rehearsal_block(held)
-        block = { "snapshot" => plain(held[:snapshot]), "host_version" => plain(held[:host_version]),
-                  "result" => plain(held[:rehearsal]), "at" => plain(held[:rehearsed_at]) }.compact
-        return nil if block.empty?
-
-        block["host_version"] ||= Hecks::VERSION
-        block
-      end
-
       # The era as stored, digest unchecked: a text that drifted is what re-attesting is for.
       def raw_era(domain, lineage, ordinal)
         present = lineage.db.exec("SELECT to_regclass('hecks_eras') AS present")[0]["present"]

data/lib/hecks/hecks/adapters/rehearsal/inquiry.rb

@@ -45,7 +45,7 @@ module Hecks
           refusals, after = edge ? @store.audit(@subject, edge) : [[], {}]
           rust = RustAudit.call(@subject, after)
           report = AuditReport.new(minting: minting, edge: edge, states: after, ruby: refusals, rust: rust)
-          answer(edge, report, (refusals + rust.violations).uniq, limits(edge, rust, report))
+          answer(edge, report, (refusals + rust.violations).uniq, limits(rust, report))
         end
 
         private
@@ -82,7 +82,7 @@ module Hecks
         def copy_facts = census.facts.merge(copy_empty: flag(copy_empty?))
 
         def edge_facts(edge)
-          { minting: plain(minting), edge_present: flag(!edge.nil?), edge_approved: flag(approved?(edge)) }
+          { minting: plain(minting), edge_present: flag(!edge.nil?) }
         end
 
         def eras = @eras ||= @store.eras(@subject)
@@ -97,16 +97,9 @@ module Hecks
           before == @subject.label ? "none" : "next"
         end
 
-        def approved?(edge)
-          return false unless edge
-
-          !Translation::ApprovalFile.needs_rehearsal?(edge) ||
-            !Translation::ApprovalFile.applicable(@subject.directory, edge).nil?
-        end
-
-        def limits(edge, rust, report)
+        def limits(rust, report)
           engine = rust.ran ? [] : [ENGINE_LIMIT]
-          engine + report.limits + ALWAYS + @store.limits(edge) + [journal_limit] + attached_limits +
+          engine + report.limits + ALWAYS + [journal_limit] + attached_limits +
             (@subject.held.capable? ? [] : [binding_note])
         end
 

data/lib/hecks/hecks/adapters/rehearsal/memory_store.rb

@@ -65,15 +65,6 @@ module Hecks
           [refusals, after]
         end
 
-        # @param edge [Bluebook::Translation] the edge
-        # @return [Array<Hash>] what memory cannot apply, as report limits
-        def limits(edge)
-          return [] unless edge && Translation::ApprovalFile.needs_rehearsal?(edge)
-
-          [{ what: "the edge's compute and rekey rules",
-             why:  "they are SQL, which only a postgres copy runs; memory leaves those fields as stored" }]
-        end
-
         private
 
         def records(name) = @document.dig("records", name.to_s) || {}

data/lib/hecks/hecks/adapters/rehearsal/postgres_reading.rb

@@ -42,10 +42,6 @@ module Hecks
           end
         end
 
-        # @param _edge [Bluebook::Translation] unused
-        # @return [Array<Hash>] none: a postgres copy runs the compiled rules itself
-        def limits(_edge) = []
-
         private
 
         def schema_candidates(subject)

data/lib/hecks/hecks/codebase.behaviors

@@ -170,6 +170,12 @@ Hecks.behaviors "Codebase" do
     expect refused: "a port is 1 to 65535"
   end
 
+  test "Compose refuses a port that is not one" do
+    tests "Compose", on: "CorpusRun"
+    input port: { value: 70_000 }, run: { value: "compose" }
+    expect refused: "a port is 1 to 65535"
+  end
+
   test "ServeQueryIrMcp refuses a run that is not named" do
     tests "ServeQueryIrMcp", on: "CorpusRun"
     input run: { value: "" }