rigortype 0.1.18 → 0.2.0

data/lib/rigor/cache/descriptor.rb

@@ -13,8 +13,8 @@ module Rigor
     # ([`Rigor::Cache::Store`](store.rb), v0.0.8 slice 2) consumes
     # descriptors but does not extend them.
     #
-    # The descriptor has four slots (`files`, `gems`, `plugins`,
-    # `configs`); every slot is an array of typed entries; an empty
+    # The descriptor has six slots (`files`, `gems`, `plugins`,
+    # `configs`, `dependencies`, `globs`); every slot is an array of typed entries; an empty
     # array means "no dependency in this slot". Composition unions
     # by key per slot; conflicts on the comparison fields raise
     # {Conflict}.
@@ -32,7 +32,12 @@ module Rigor
       # references but never declares, so the marshalled RBS env
       # cached by an older Rigor (which would leave those signatures
       # inert) MUST be rebuilt for the synthesis to take effect.
-      SCHEMA_VERSION = 3
+      # v4: ADR-60 WD3 added the `globs` slot ({GlobEntry}) for the
+      # record-and-validate plugin-producer cache; the new slot
+      # changes `#to_canonical_hash` (and is Marshal-dumped inside
+      # `fetch_or_validate` entry pairs), so entries written by an
+      # older Rigor must read as misses.
+      SCHEMA_VERSION = 4
 
       # Per-slot entry value objects. Constructors validate enums /
       # required fields and freeze the resulting struct so no caller
@@ -160,6 +165,62 @@ module Rigor
         end
       end
 
+      # ADR-60 WD3 — one glob's-worth of watched files, digested as a
+      # single value so the entry covers content change, addition,
+      # AND removal in one row: the digest is the SHA-256 over the
+      # sorted `"<path>\0<sha256-of-content>\n"` rows of every file
+      # matching `File.join(root, pattern)`. A new file adds a row, a
+      # deleted file drops one, an edit changes one — all three move
+      # the digest. {Descriptor#fresh?} re-runs the same computation
+      # and compares.
+      class GlobEntry
+        include Rigor::ValueSemantics
+
+        attr_reader :root, :pattern, :value
+
+        value_fields :root, :pattern, :value
+
+        def initialize(root:, pattern:, value:)
+          @root = root.to_s.dup.freeze
+          @pattern = pattern.to_s.dup.freeze
+          @value = value.to_s.dup.freeze
+          freeze
+        end
+
+        # Builds the entry for the glob's CURRENT filesystem state.
+        def self.compute(root:, pattern:)
+          new(root: root, pattern: pattern, value: digest_for(root: root, pattern: pattern))
+        end
+
+        # The digest the entry's `value` carries. Per-file read
+        # failures (a file vanishing between the glob and the
+        # digest) are treated as the file being absent — same
+        # race posture as {Descriptor#file_entry_fresh?}.
+        def self.digest_for(root:, pattern:)
+          # Dir.glob returns sorted entries by default (sort: true),
+          # so the row order — and therefore the digest — is stable.
+          rows = Dir.glob(File.join(root, pattern)).filter_map do |path|
+            next nil unless File.file?(path)
+
+            "#{path}\0#{Digest::SHA256.file(path).hexdigest}\n"
+          rescue StandardError
+            nil
+          end
+          Digest::SHA256.hexdigest(rows.join)
+        end
+
+        # Composition key — {.compose} unions per (root, pattern)
+        # slot; two contributions for the same slot must agree on
+        # the digest or {Conflict} is raised.
+        def slot_key
+          "#{root}\0#{pattern}"
+        end
+
+        def to_h
+          { "root" => root, "pattern" => pattern, "value" => value }
+        end
+      end
+
       # Raised when {.compose} encounters incompatible entries
       # under the same key (file digest mismatch, gem-locked
       # disagreement, …). Callers handle the exception by
@@ -167,14 +228,15 @@ module Rigor
       # contribution silently.
       class Conflict < StandardError; end
 
-      attr_reader :files, :gems, :plugins, :configs, :dependencies
+      attr_reader :files, :gems, :plugins, :configs, :dependencies, :globs
 
-      def initialize(files: [], gems: [], plugins: [], configs: [], dependencies: [])
+      def initialize(files: [], gems: [], plugins: [], configs: [], dependencies: [], globs: [])
         @files = files.dup.freeze
         @gems = gems.dup.freeze
         @plugins = plugins.dup.freeze
         @configs = configs.dup.freeze
         @dependencies = dependencies.dup.freeze
+        @globs = globs.dup.freeze
         freeze
       end
 
@@ -185,11 +247,15 @@ module Rigor
       # `files` are checked — non-file inputs (config / gems / version)
       # belong in the cache *key*, not the validated dependency set — so
       # a descriptor carrying any non-file slot is never considered fresh
-      # (it was built wrong for this use).
+      # (it was built wrong for this use). ADR-60 WD3 adds `globs`
+      # alongside `files` as a re-validatable slot: a {GlobEntry} is
+      # fresh when re-globbing + re-digesting reproduces its recorded
+      # value.
       def fresh?
         return false unless gems.empty? && plugins.empty? && configs.empty? && dependencies.empty?
 
-        files.all? { |entry| file_entry_fresh?(entry) }
+        files.all? { |entry| file_entry_fresh?(entry) } &&
+          globs.all? { |entry| glob_entry_fresh?(entry) }
       end
 
       # File-comparator strictness ordering. `:digest` is strictest
@@ -212,7 +278,9 @@ module Rigor
         plugins = compose_by_key(descriptors.flat_map(&:plugins), :id)
         configs = compose_by_key(descriptors.flat_map(&:configs), :key)
         dependencies = compose_by_key(descriptors.flat_map(&:dependencies), :gem_name)
-        new(files: files, gems: gems, plugins: plugins, configs: configs, dependencies: dependencies)
+        globs = compose_by_key(descriptors.flat_map(&:globs), :slot_key)
+        new(files: files, gems: gems, plugins: plugins, configs: configs,
+            dependencies: dependencies, globs: globs)
       end
 
       # @param producer_id [String]
@@ -241,6 +309,7 @@ module Rigor
           "dependencies" => sort_entries(dependencies, "gem_name").map(&:to_h),
           "files" => sort_entries(files, "path").map(&:to_h),
           "gems" => sort_entries(gems, "name").map(&:to_h),
+          "globs" => globs.sort_by { |e| [e.root, e.pattern] }.map(&:to_h),
           "plugins" => sort_entries(plugins, "id").map(&:to_h)
         }
       end
@@ -291,6 +360,15 @@ module Rigor
         false
       end
 
+      # ADR-60 WD3 — re-runs the entry's glob + digest and compares
+      # against the recorded value. Any failure reads as stale
+      # (recompute), never a crash.
+      def glob_entry_fresh?(entry)
+        GlobEntry.digest_for(root: entry.root, pattern: entry.pattern) == entry.value
+      rescue StandardError
+        false
+      end
+
       def sort_entries(entries, key)
         entries.sort_by { |e| e.to_h.fetch(key).to_s }
       end

data/lib/rigor/cache/rbs_descriptor.rb

@@ -29,7 +29,8 @@ module Rigor
 
       def self.file_entries(loader)
         roots = loader.signature_paths +
-                Rigor::Environment::RbsLoader.vendored_gem_sig_paths
+                Rigor::Environment::RbsLoader.vendored_gem_sig_paths +
+                Rigor::Environment::RbsLoader.core_overlay_sig_paths
         roots.flat_map do |root|
           next [] unless root.directory?
 

data/lib/rigor/cache/store.rb

@@ -13,9 +13,10 @@ module Rigor
   module Cache
     # Filesystem-backed cache store. Schema, layout, file format,
     # atomicity, and locking are fixed by [ADR-6](../../../docs/adr/6-cache-persistence-backend.md);
-    # callers see the [`Rigor::Cache::Descriptor`](descriptor.rb)
-    # value object plus this class' `#fetch_or_compute` entry point
-    # and nothing else.
+    # callers use `#fetch_or_compute` (producer-keyed),
+    # `#fetch_or_validate` (record-and-validate for discovered-dep
+    # caches, ADR-45), `#stats`, `#evict!`, and `.disk_inventory`,
+    # plus the [`Rigor::Cache::Descriptor`](descriptor.rb) value object.
     #
     # Read failures (missing file, bad magic, format-version mismatch,
     # corrupt SHA-256 trailer, un-inflatable or unmarshal-able payload)
@@ -119,6 +120,7 @@ module Rigor
       #   When the root does not exist or has no schema-version
       #   marker, `schema_version` is nil and the producer list is
       #   empty.
+      #
       # The `schema_version.txt` marker content. Covers BOTH
       # invalidation axes: the descriptor schema and the on-disk byte
       # layout ({FORMAT_VERSION}, ADR-54). A format bump leaves the

data/lib/rigor/cli/annotate_command.rb

@@ -1,13 +1,17 @@
 # frozen_string_literal: true
 
+require "English"
+require "json"
 require "optionparser"
 require "prism"
 
 require_relative "../configuration"
+require_relative "options"
 require_relative "../environment"
 require_relative "../scope"
 require_relative "../inference/def_return_typer"
 require_relative "../inference/scope_indexer"
+require_relative "../inference/statement_evaluator"
 require_relative "prism_colorizer"
 require_relative "command"
 
@@ -20,18 +24,33 @@ module Rigor
     # (so `1; 2; 3` reports `3`), or, for a line that no statement
     # closes, the widest expression ending there (so the `if nil`
     # header reports its condition). It infers that expression's
-    # type and appends a `#=> dump_type: <type>` comment.
+    # type and appends a `#=> <type>` comment (the xmpfilter /
+    # seeing_is_believing convention).
     #
     # The annotated source is re-parsed with Prism — a sanity gate,
     # since the appended text is always a comment — and printed to
-    # stdout with IRB-style syntax highlighting via
+    # stdout. When colour is enabled and `bat`
+    # (https://github.com/sharkdp/bat) is on PATH it is used for
+    # highlighting; otherwise IRB-style highlighting via
     # {PrismColorizer}.
     class AnnotateCommand < Command
       USAGE = "Usage: rigor annotate [options] FILE"
 
-      # Appended ` #=> dump_type: <type>` suffix. Matched and
-      # stripped before re-annotating so re-running is idempotent.
-      ANNOTATION_PATTERN = /\s*#=>\s*dump_type:.*\z/
+      # Trailing `#=> …` annotation comment. Matched and stripped
+      # before re-annotating so re-running is idempotent — this
+      # follows xmpfilter's convention of owning the `#=>` marker,
+      # and also absorbs the older `#=> dump_type: <type>` spelling
+      # (idempotency across re-runs). The leading `\s` requirement
+      # keeps a `#=>` inside a string literal (no preceding
+      # whitespace ambiguity aside) from matching mid-expression.
+      ANNOTATION_PATTERN = /\s+#=>(?:\s.*)?\z/
+
+      # Arguments for highlighting through `bat`: the annotated
+      # text arrives on stdin, so the language must be explicit;
+      # `--style=plain` drops the grid/header chrome so the output
+      # matches the PrismColorizer fallback line-for-line; paging
+      # stays off because the CLI may itself sit in a pipeline.
+      BAT_ARGS = %w[--language=ruby --style=plain --paging=never --color=always].freeze
 
       # @return [Integer] CLI exit status.
       def run
@@ -54,15 +73,23 @@ module Rigor
       def parse_options
         # Default: colour a tty, unless `NO_COLOR` opts out. An
         # explicit `--color` / `--no-color` overrides both.
-        options = { config: nil, color: @out.tty? && !no_color_env? }
+        options = { config: nil, color: @out.tty? && !no_color_env?, bat: nil, format: :text }
 
         parser = OptionParser.new do |opts|
           opts.banner = USAGE
-          opts.on("--config=PATH", "Path to the Rigor configuration file") { |value| options[:config] = value }
+          Options.add_config(opts, options)
+          opts.on("--format=FORMAT", %w[text json],
+                  "Output format: text (default) or json (a { line => type } map)") do |value|
+            options[:format] = value.to_sym
+          end
           opts.on("--[no-]color",
                   "Force or disable ANSI colour (default: auto-detect a tty; honours NO_COLOR)") do |value|
             options[:color] = value
           end
+          opts.on("--[no-]bat",
+                  "Force or disable highlighting through bat (default: when colour is on and bat is found)") do |value|
+            options[:bat] = value
+          end
         end
         parser.parse!(@argv)
 
@@ -91,15 +118,35 @@ module Rigor
         parse_result = Prism.parse(source, filepath: file, version: configuration.target_ruby)
         return 1 if parse_errors?(parse_result, file)
 
+        # `converged_loop_recording` re-records fixpoint-tracked loop
+        # bodies from their converged (post-writeback) bindings, so a
+        # loop-body line annotates the joined widened type (`Integer`)
+        # rather than a stale first-iterations constant (`1 | 2`).
         scope_index = Inference::ScopeIndexer.index(
-          parse_result.value, default_scope: base_scope(configuration)
+          parse_result.value, default_scope: base_scope(configuration),
+                              converged_loop_recording: true
         )
         line_types = LineTypeCollector.new(scope_index).collect(parse_result.value)
 
-        @out.puts(render(annotate(source, line_types), color: options.fetch(:color)))
+        case options.fetch(:format)
+        when :json
+          emit_json(line_types)
+        else
+          @out.puts(render(annotate(source, line_types), color: options.fetch(:color), bat: options.fetch(:bat)))
+        end
         0
       end
 
+      # `--format json` — emit the { line_number => type } map directly, the
+      # same data the text renderer consumes, so clients (the playground,
+      # editors) get structured annotations without reparsing the `#=> <type>`
+      # comment grammar. Values are the short type descriptions the text form
+      # also shows; keys are 1-based line numbers as strings (JSON object keys).
+      def emit_json(line_types)
+        annotations = line_types.keys.sort.to_h { |line| [line.to_s, line_types[line].describe(:short)] }
+        @out.puts(JSON.generate({ "annotations" => annotations }))
+      end
+
       def base_scope(configuration)
         Scope.empty(
           environment: Environment.for_project(
@@ -118,8 +165,8 @@ module Rigor
         true
       end
 
-      # Appends ` #=> dump_type: <type>` to every line a type was
-      # inferred for, aligning the comment column.
+      # Appends ` #=> <type>` to every line a type was inferred
+      # for, aligning the comment column.
       def annotate(source, line_types)
         lines = source.lines
         column = annotation_column(lines, line_types)
@@ -130,7 +177,7 @@ module Rigor
           code = line.chomp.sub(ANNOTATION_PATTERN, "")
           next "#{code}#{eol}" if type.nil?
 
-          "#{code.ljust(column)}  #=> dump_type: #{type.describe(:short)}#{eol}"
+          "#{code.ljust(column)}  #=> #{type.describe(:short)}#{eol}"
         end.join
       end
 
@@ -143,11 +190,46 @@ module Rigor
         widths.max || 0
       end
 
-      def render(annotated, color:)
+      def render(annotated, color:, bat: nil)
         return annotated unless color
         return annotated unless Prism.parse(annotated).success?
 
-        PrismColorizer.colorize(annotated)
+        rendered = render_with_bat(annotated, forced: bat) unless bat == false
+        rendered || PrismColorizer.colorize(annotated)
+      end
+
+      # Pipes the annotated source through `bat` and returns its
+      # highlighted output, or nil when bat is unavailable or
+      # fails (broken install, killed mid-write) — the caller
+      # falls back to {PrismColorizer}. An explicit `--bat` with
+      # no bat on PATH warns instead of failing silently.
+      def render_with_bat(annotated, forced: nil)
+        executable = bat_executable
+        if executable.nil?
+          @err.puts("annotate: --bat requested but no `bat` executable found on PATH") if forced
+          return nil
+        end
+
+        output = IO.popen([executable, *BAT_ARGS], "r+") do |io|
+          io.write(annotated)
+          io.close_write
+          io.read
+        end
+        return nil unless $CHILD_STATUS&.success?
+
+        output.empty? ? nil : output
+      rescue SystemCallError, IOError
+        nil
+      end
+
+      def bat_executable
+        ENV.fetch("PATH", "").split(File::PATH_SEPARATOR).each do |dir|
+          next if dir.empty?
+
+          candidate = File.join(dir, "bat")
+          return candidate if File.file?(candidate) && File.executable?(candidate)
+        end
+        nil
       end
     end
 
@@ -203,11 +285,30 @@ module Rigor
         widest_per_line(program).each do |line, node|
           next if by_line.key?(line)
 
-          type = type_of(node)
+          type = node.is_a?(Prism::BlockParametersNode) ? block_params_type(node) : type_of(node)
           by_line[line] = type unless type.nil?
         end
       end
 
+      # A `do |i|` header line's widest node is its BlockParametersNode —
+      # not an expression, so evaluating it would only echo the
+      # `Dynamic[top]` fallback. Annotate the line with the parameters'
+      # inferred bindings instead (the single param's type, or a tuple
+      # for multi-param blocks); decline (nil) when any param has no
+      # plain name or no recorded binding, leaving the line bare.
+      def block_params_type(params_node)
+        inner = params_node.parameters
+        return nil if inner.nil? || inner.requireds.empty?
+
+        scope = @scope_index[params_node]
+        types = inner.requireds.map do |param|
+          return nil unless param.respond_to?(:name)
+
+          scope.local(param.name) or return nil
+        end
+        types.size == 1 ? types.first : Type::Combinator.tuple_of(*types)
+      end
+
       def widest_per_line(program)
         widest = {}
         walk(program) do |node|
@@ -231,8 +332,13 @@ module Rigor
         node.compact_child_nodes.each { |child| walk(child, &block) }
       end
 
+      # Types the node through the flow evaluator (not the bare
+      # expression typer) under its recorded entry scope, so flow-only
+      # forms type as the engine sees them — `i += 1` dispatches `+` on
+      # `i`'s binding (`Integer`, post-fixpoint) instead of echoing the
+      # RHS literal's `1`.
       def type_of(node)
-        @scope_index[node].type_of(node)
+        Inference::StatementEvaluator.new(scope: @scope_index[node]).evaluate(node).first
       rescue StandardError
         nil
       end

data/lib/rigor/cli/baseline_command.rb

@@ -3,6 +3,7 @@
 require "optparse"
 
 require_relative "../analysis/baseline"
+require_relative "options"
 require_relative "../analysis/runner"
 require_relative "../cache/store"
 require_relative "../configuration"
@@ -106,7 +107,7 @@ module Rigor
         }
         parser = OptionParser.new do |opts|
           opts.banner = "Usage: rigor baseline #{subcommand} [options]"
-          opts.on("--config=PATH", "Path to the Rigor configuration file") { |v| options[:config] = v }
+          Options.add_config(opts, options)
           opts.on("--output=PATH", "Write baseline to PATH (default: #{DEFAULT_BASELINE_PATH})") do |v|
             options[:output] = v
           end
@@ -270,7 +271,7 @@ module Rigor
         }
         parser = OptionParser.new do |opts|
           opts.banner = "Usage: rigor baseline drift [options]"
-          opts.on("--config=PATH", "Path to the Rigor configuration file") { |v| options[:config] = v }
+          Options.add_config(opts, options)
           opts.on("--baseline=PATH", "Path to the baseline file (default: #{DEFAULT_BASELINE_PATH})") do |v|
             options[:baseline] = v
           end
@@ -344,7 +345,7 @@ module Rigor
         }
         parser = OptionParser.new do |opts|
           opts.banner = "Usage: rigor baseline prune [options]"
-          opts.on("--config=PATH", "Path to the Rigor configuration file") { |v| options[:config] = v }
+          Options.add_config(opts, options)
           opts.on("--baseline=PATH", "Path to the baseline file (default: #{DEFAULT_BASELINE_PATH})") do |v|
             options[:baseline] = v
           end