rigortype 0.3.1 → 0.3.3

data/lib/rigor/cli/show_bleedingedge_command.rb

@@ -13,8 +13,9 @@ module Rigor
     #
     # Prints the bleeding-edge overlay — the Rigor-maintained set of the next major's queued changes
     # ({Rigor::BleedingEdge}) — as an explicit list, and reports which of them the project's `bleeding_edge:`
-    # configuration adopts. The overlay is empty in this release, so the command currently reports an empty set; it
-    # becomes the inspection surface ADR-50 describes once a feature is queued.
+    # configuration adopts. Each feature is rendered with its kind: a `severity` feature prints the rule → severity
+    # diff it imposes, and a `behaviour` feature has no such diff to print, so its summary carries the whole
+    # explanation. Ids that have already graduated to default-on (ADR-50 § WD7) are listed after the overlay.
     #
     # Read-only: it loads `.rigor.yml` to resolve the active selection but runs no analysis.
     class ShowBleedingedgeCommand < Command
@@ -62,7 +63,8 @@ module Rigor
                     "overlay" => BleedingEdge.features.map(&:to_h),
                     "selector" => configuration.to_h.fetch("bleeding_edge"),
                     "active" => BleedingEdge.active_features(selector).map(&:id),
-                    "unknown_selected" => BleedingEdge.unknown_selected_ids(selector)
+                    "unknown_selected" => BleedingEdge.unknown_selected_ids(selector),
+                    "graduated" => BleedingEdge::GRADUATED
                   ))
       end
 
@@ -74,6 +76,7 @@ module Rigor
         else
           render_overlay
         end
+        render_graduated
         @out.puts("")
         render_selection(configuration)
       end
@@ -88,7 +91,7 @@ module Rigor
         @out.puts("#{BleedingEdge.features.length} feature(s) queued for the next major:")
         @out.puts("")
         BleedingEdge.features.each do |feature|
-          @out.puts("  #{feature.id}")
+          @out.puts("  #{feature.id} [#{feature.kind}]")
           @out.puts("    #{feature.summary}")
           feature.severity_overrides.each do |rule, severity|
             @out.puts("    severity: #{rule} → :#{severity}")
@@ -96,6 +99,16 @@ module Rigor
         end
       end
 
+      # ADR-50 § WD7 — only printed when something has graduated, so a release with an empty list reads exactly
+      # as it did before graduation existed.
+      def render_graduated
+        return if BleedingEdge::GRADUATED.empty?
+
+        @out.puts("")
+        @out.puts("Graduated — on by default, no longer selectable:")
+        BleedingEdge::GRADUATED.each { |id| @out.puts("  #{id}") }
+      end
+
       def render_selection(configuration)
         selector = configuration.bleeding_edge
         active = BleedingEdge.active_features(selector).map(&:id)

data/lib/rigor/cli/sig_gen_command.rb

@@ -97,10 +97,11 @@ module Rigor
         results = writer.write_all(candidates)
 
         SigGen::Renderer.new(out: @out).render_write(results: results, format: options.fetch(:format))
-        # An assembled file that does not parse is refused rather than written. The user asked for a write and
-        # did not get one, so the command must not report success — a green `sig-gen --write` in CI would
-        # otherwise mean nothing.
-        results.any? { |result| result.action == :skipped_invalid_rbs } ? 1 : 0
+        # A refused write (an assembled file that does not parse, or an existing target that is not valid
+        # UTF-8) means the user asked for a write and did not get one, so the command must not report
+        # success — a green `sig-gen --write` in CI would otherwise mean nothing.
+        refusals = %i[skipped_invalid_rbs skipped_invalid_encoding]
+        results.any? { |result| refusals.include?(result.action) } ? 1 : 0
       end
 
       # Slice 3 — collect call-site argument observations when `--params=observed` is set. When `--observe=PATH` is not

data/lib/rigor/configuration.rb

@@ -61,7 +61,9 @@ module Rigor
       # seed, so an undeclared `def` / `initialize` / setter parameter is typed to the union of its resolved
       # call-site argument types (precision-additive only — the in-body negative rules decline on the inferred
       # lower bound, WD6b). `false` (the default, resolved off by every severity profile) keeps the table empty
-      # and the run byte-identical to today. Mutually exclusive with `--incremental` (WD6c).
+      # and the run byte-identical to today. Composes with `--incremental` (the WD6c mutual exclusion is
+      # lifted): the incremental session recomputes the table each run and diffs it against its snapshot,
+      # re-checking any callee whose seeds moved.
       "parameter_inference" => false,
       "cache" => {
         "path" => ".rigor/cache",
@@ -94,8 +96,9 @@ module Rigor
       # ADR-50 § WD2 — bleeding-edge overlay opt-in. Selects which of the *next major's* queued changes
       # ({Rigor::BleedingEdge}) this project adopts early. Orthogonal to `severity_profile:`. Accepts `false`
       # (default — adopt none), `true` (adopt the whole overlay), a list of feature ids (adopt only those),
-      # or `{ all: true, except: [ids] }` (adopt all but the named). The overlay is empty today, so every
-      # form is currently a no-op; it becomes live when the first discipline is queued for a major.
+      # or `{ all: true, except: [ids] }` (adopt all but the named). A queued change is either a severity
+      # promotion (composed by {SeverityProfile.resolve}) or a behaviour switch (read at its call site
+      # through {#bleeding_edge_active?}); `bleeding_edge:` selects both kinds the same way.
       "bleeding_edge" => false,
       "dependencies" => {
         "source_inference" => [],
@@ -437,6 +440,7 @@ module Rigor
         data.fetch("bleeding_edge", DEFAULTS.fetch("bleeding_edge"))
       )
       @bleeding_edge_severity_overrides = BleedingEdge.severity_overrides_for(@bleeding_edge)
+      @bleeding_edge_active_ids = BleedingEdge.active_ids_for(@bleeding_edge)
       @dependencies = Dependencies.from_h(
         data.fetch("dependencies", DEFAULTS.fetch("dependencies"))
       )
@@ -515,6 +519,39 @@ module Rigor
       }
     end
 
+    # ADR-50 § WD2 — whether the bleeding-edge feature `id` is in force for this run.
+    #
+    # This is how a **behaviour** feature reaches its call site: a severity feature composes itself into
+    # `bleeding_edge_severity_overrides` and needs no engine code, but a queued change to a measurement, an
+    # algorithm, or a default has to be asked about where it happens. Answering from `Configuration` keeps
+    # the selection logic in one place and puts nothing but the id — already ADR-50 WD1 contract vocabulary
+    # — into engine code.
+    #
+    # Two deliberate asymmetries with the `bleeding_edge:` config key:
+    #
+    # - An id in {BleedingEdge::GRADUATED} answers `true` unconditionally. Graduation (§ WD7) turns a
+    #   feature on for everyone, so a gate that outlives it keeps the graduated behaviour rather than
+    #   silently reverting, and the call-site cleanup can land whenever it is convenient.
+    # - An id that is in neither {BleedingEdge::FEATURES} nor {BleedingEdge::GRADUATED} **raises**. An
+    #   unknown id in a *config file* stays inert on purpose (it may come from a newer gem — see
+    #   {#coerce_bleeding_edge}), but an id here is written by a Rigor contributor against the registry in
+    #   the same checkout: a typo is a bug, and reading it as `false` would ship the feature permanently off
+    #   with no signal.
+    #
+    # @param id [String] a feature id from {BleedingEdge::FEATURES} or {BleedingEdge::GRADUATED}.
+    # @return [Boolean]
+    # @raise [ArgumentError] if `id` names no known feature.
+    def bleeding_edge_active?(id)
+      return true if BleedingEdge.graduated?(id)
+      unless BleedingEdge.known_id?(id)
+        raise ArgumentError,
+              "unknown bleeding-edge feature id #{id.inspect}; known ids: " \
+              "#{(BleedingEdge.feature_ids + BleedingEdge::GRADUATED).inspect}"
+      end
+
+      @bleeding_edge_active_ids.include?(id)
+    end
+
     # ADR-50 § WD2 — returns a sibling Configuration whose bleeding-edge selection (and the derived
     # `bleeding_edge_severity_overrides` the two {SeverityProfile.resolve} sites consult) is replaced by
     # `value`, leaving every other field shared with the receiver. `value` takes the same forms as the
@@ -524,16 +561,18 @@ module Rigor
     #
     # The CLI's `--bleeding-edge[=ids]` / `--no-bleeding-edge` flag uses this to override the configured
     # selection for a single run (the same CLI-over-config precedence `--workers` and `--no-cache` follow).
-    # It is a frozen `dup` with the two bleeding-edge ivars re-set: `dup` returns an unfrozen shallow copy
-    # (every other ivar is the receiver's deeply-frozen value, safe to share read-only), the two replacements
+    # It is a frozen `dup` with the bleeding-edge ivars re-set: `dup` returns an unfrozen shallow copy
+    # (every other ivar is the receiver's deeply-frozen value, safe to share read-only), the replacements
     # are themselves deeply frozen, and the re-`freeze` keeps the result `Ractor.shareable?` for the worker
-    # path.
+    # path. **Every ivar `#initialize` derives from `@bleeding_edge` has to be re-derived here** — the
+    # selector, the severity map, and the active-id set the {#bleeding_edge_active?} predicate reads.
     def with_bleeding_edge(value)
       selector = coerce_bleeding_edge(value)
       copy = dup
       copy.instance_variable_set(:@bleeding_edge, selector)
       copy.instance_variable_set(:@bleeding_edge_severity_overrides,
                                  BleedingEdge.severity_overrides_for(selector))
+      copy.instance_variable_set(:@bleeding_edge_active_ids, BleedingEdge.active_ids_for(selector))
       copy.freeze
     end
 

data/lib/rigor/environment/bundle_sig_discovery.rb

@@ -42,7 +42,8 @@ module Rigor
         "strscan",
         "prism", "rbs",
         # data/vendored_gem_sigs/
-        "pg", "mysql2", "nokogiri", "bcrypt", "redis", "idn-ruby"
+        "pg", "mysql2", "nokogiri", "bcrypt", "redis", "idn-ruby", "racc",
+        "bundler", "rubygems"
       ].freeze
 
       # @param bundle_path [String, Pathname, nil] explicit path to the bundler install root. When `nil`,

data/lib/rigor/environment/rbs_coverage_report.rb

@@ -32,7 +32,7 @@ module Rigor
       # hard-coding is acceptable; a directory walk at every call would add stat-cost to no benefit.)
       VENDORED_GEM_NAMES = Set[
         "ast", "bcrypt", "bundler", "cgi", "did_you_mean",
-        "idn-ruby", "mysql2", "nokogiri", "pg", "prism", "redis", "rubygems"
+        "idn-ruby", "mysql2", "nokogiri", "pg", "prism", "racc", "redis", "rubygems"
       ].freeze
 
       # @param locked_gems [Hash{String => LockfileResolver::LockedGem}] The lockfile-resolved gem set. Empty