rigortype 0.1.16 → 0.1.18

data/lib/rigor/cache/rbs_constant_table.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "rbs_descriptor"
+require_relative "rbs_cache_producer"
 
 module Rigor
   module Cache
@@ -15,19 +16,12 @@ module Rigor
     # Cache descriptor shape is shared with every other cache
     # producer that depends on the RBS environment — see
     # {RbsDescriptor.build} for the slot definitions.
-    class RbsConstantTable
+    class RbsConstantTable < RbsCacheProducer
       PRODUCER_ID = "rbs.constant_type_table"
 
       # @param loader [Rigor::Environment::RbsLoader]
       # @param store [Rigor::Cache::Store]
       # @return [Hash{String => Rigor::Type}]
-      def self.fetch(loader:, store:)
-        descriptor = RbsDescriptor.build(loader)
-        store.fetch_or_compute(producer_id: PRODUCER_ID, params: {}, descriptor: descriptor) do
-          compute(loader)
-        end
-      end
-
       def self.compute(loader)
         table = {}
         loader.each_constant_decl do |name, entry|

data/lib/rigor/cache/rbs_environment.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "rbs_descriptor"
+require_relative "rbs_cache_producer"
 require_relative "rbs_environment_marshal_patch"
 
 module Rigor
@@ -26,19 +27,12 @@ module Rigor
     # Cache descriptor shape is shared with every other cache
     # producer that depends on the RBS environment — see
     # {RbsDescriptor.build}.
-    class RbsEnvironment
+    class RbsEnvironment < RbsCacheProducer
       PRODUCER_ID = "rbs.environment"
 
       # @param loader [Rigor::Environment::RbsLoader]
       # @param store [Rigor::Cache::Store]
       # @return [::RBS::Environment]
-      def self.fetch(loader:, store:)
-        descriptor = RbsDescriptor.build(loader)
-        store.fetch_or_compute(producer_id: PRODUCER_ID, params: {}, descriptor: descriptor) do
-          compute(loader)
-        end
-      end
-
       def self.compute(loader)
         Rigor::Environment::RbsLoader.build_env_for(
           libraries: loader.libraries,

data/lib/rigor/cache/rbs_known_class_names.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative "rbs_descriptor"
+require_relative "rbs_cache_producer"
 
 module Rigor
   module Cache
@@ -18,19 +19,12 @@ module Rigor
     # Cache descriptor shape is shared with {RbsConstantTable} via
     # {RbsDescriptor.build}; a single signature change or rbs gem
     # bump invalidates both producers in lockstep.
-    class RbsKnownClassNames
+    class RbsKnownClassNames < RbsCacheProducer
       PRODUCER_ID = "rbs.known_class_names"
 
       # @param loader [Rigor::Environment::RbsLoader]
       # @param store [Rigor::Cache::Store]
       # @return [Set<String>]
-      def self.fetch(loader:, store:)
-        descriptor = RbsDescriptor.build(loader)
-        store.fetch_or_compute(producer_id: PRODUCER_ID, params: {}, descriptor: descriptor) do
-          compute(loader)
-        end
-      end
-
       def self.compute(loader)
         names = Set.new
         loader.each_known_class_name { |name| names << name }

data/lib/rigor/cache/store.rb

@@ -5,6 +5,7 @@ require "fileutils"
 require "json"
 require "monitor"
 require "securerandom"
+require "zlib"
 
 require_relative "descriptor"
 
@@ -17,17 +18,27 @@ module Rigor
     # and nothing else.
     #
     # Read failures (missing file, bad magic, format-version mismatch,
-    # corrupt SHA-256 trailer, unmarshal-able payload) are silently
-    # treated as cache misses; the producer block reruns and the
-    # next write replaces the bad entry. The trailing SHA-256 catches
-    # accidental corruption (partial writes, FS errors); it is **not**
-    # a security boundary, per ADR-2's trusted-gem trust model.
+    # corrupt SHA-256 trailer, un-inflatable or unmarshal-able payload)
+    # are silently treated as cache misses; the producer block reruns
+    # and the next write replaces the bad entry. The trailing SHA-256
+    # catches accidental corruption (partial writes, FS errors); it is
+    # **not** a security boundary, per ADR-2's trusted-gem trust model.
     class Store # rubocop:disable Metrics/ClassLength
+      # On-disk byte-layout version. Bumped on incompatible format
+      # changes (independent of {Descriptor::SCHEMA_VERSION}, which
+      # covers the descriptor schema rather than the byte layout).
+      # v2 (ADR-54 WD2): the value payload is zlib-deflated on write
+      # and inflated on read — Marshal blobs compress to 13–16 % at
+      # an inflate cost an order of magnitude below their
+      # `Marshal.load`. v1 entries fail the header check and read as
+      # silent misses; the `schema_version.txt` marker additionally
+      # carries this version, so the first writable run after a bump
+      # clears the root and reclaims the unreadable bytes.
+      FORMAT_VERSION = 2
+
       # Header literal: 5-byte ASCII magic, 1-byte separator, 1-byte
-      # format version. Bumped on incompatible on-disk format changes
-      # (independent of {Descriptor::SCHEMA_VERSION}, which covers
-      # the descriptor schema rather than the byte layout).
-      HEADER = "RIGOR\x00\x01".b.freeze
+      # format version.
+      HEADER = "RIGOR\x00#{FORMAT_VERSION.chr}".b.freeze
 
       VALID_PRODUCER_ID = /\A[a-z][a-z0-9._-]*\z/
 
@@ -44,9 +55,11 @@ module Rigor
       #   invocations can read from the same cache concurrently
       #   without churning it. See
       #   `docs/design/20260516-editor-mode.md` § "Cache behaviour".
-      def initialize(root:, read_only: false)
+      def initialize(root:, read_only: false, max_bytes: nil)
         @root = root.to_s.dup.freeze
         @read_only = read_only
+        @max_bytes = max_bytes&.then { |n| Integer(n) }
+        @schema_version_ensured = false
         @hits = 0
         @misses = 0
         @writes = 0
@@ -106,6 +119,18 @@ 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
+      # old entries permanently unreadable (header mismatch → miss)
+      # but, alone, would never reclaim their bytes — they can sit
+      # below the eviction cap forever. Folding the format version
+      # into the marker routes the bump through the established
+      # clear-the-root path instead.
+      def self.schema_marker_value
+        "#{Descriptor::SCHEMA_VERSION}.#{FORMAT_VERSION}"
+      end
+
       def self.disk_inventory(root:)
         root_s = root.to_s
         marker = File.join(root_s, "schema_version.txt")
@@ -197,6 +222,81 @@ module Rigor
         value
       end
 
+      # ADR-45 — record-and-validate variant. Unlike {fetch_or_compute},
+      # which keys the entry on its descriptor (so the inputs MUST be
+      # known before running), this keys on `key_descriptor` (the stable
+      # inputs known up front) and stores, alongside the value, a
+      # `dependency_descriptor` of the files the value actually read —
+      # including inputs discovered DURING the computation (e.g. a plugin
+      # reading a file mid-analysis). On the next run the stored
+      # dependencies are re-validated against the filesystem
+      # ({Descriptor#fresh?}); a stale dependency forces a recompute.
+      #
+      # The block MUST return `[value, dependency_descriptor]`. Disk reads
+      # are not in-process-memoised — validation always re-checks the
+      # filesystem — but a single run only looks up once.
+      def fetch_or_validate(producer_id:, key_descriptor:, params: {}, serialize: nil, deserialize: nil)
+        validate_producer_id!(producer_id)
+        ensure_schema_version!
+
+        key = key_descriptor.cache_key_for(producer_id: producer_id, params: params)
+        path = entry_path(producer_id, key)
+        cached = read_entry(path, deserialize: deserialize)
+        if cached && (pair = cached.value).is_a?(Array) && pair.size == 2 &&
+           pair[1].is_a?(Descriptor) && pair[1].fresh?
+          @monitor.synchronize { record(:hits, producer_id) }
+          return pair[0]
+        end
+
+        value, dependency_descriptor = block_given? ? yield : [nil, Descriptor.new]
+        wrote = false
+        unless @read_only
+          # A cache write must never break the run. If the value is not
+          # Marshal-clean (or any disk error occurs) skip caching and
+          # return the freshly-computed value — the next run recomputes.
+          begin
+            write_entry(path, key_descriptor, [value, dependency_descriptor], serialize: serialize)
+            wrote = true
+          rescue StandardError
+            wrote = false
+          end
+        end
+        @monitor.synchronize do
+          record(:misses, producer_id)
+          record(:writes, producer_id) if wrote
+        end
+        value
+      end
+
+      # ADR-6 § "Eviction" — LRU pass over the on-disk cache. No-op when
+      # `max_bytes:` was not configured or the store is read-only.
+      # Walks all `.entry` files, sorts by mtime ascending (oldest = least
+      # recently used), and unlinks from the oldest until the total is at
+      # or below the cap. Touch-on-disk-read ({read_entry}) is the
+      # cross-process LRU signal: every disk hit (not in-process-memo hit)
+      # updates the mtime so recently-read entries survive the eviction pass.
+      # Any FS error is swallowed — eviction must never break a run.
+      def evict!
+        return if @max_bytes.nil? || @read_only
+
+        entries = collect_entry_stats
+        total   = entries.sum { |e| e[:bytes] }
+        return if total <= @max_bytes
+
+        entries.sort_by! { |e| e[:mtime] }
+        entries.each do |entry|
+          break if total <= @max_bytes
+
+          File.unlink(entry[:path])
+          total -= entry[:bytes]
+        rescue StandardError
+          next
+        end
+        nil
+      rescue StandardError
+        nil
+      end
+
       private
 
       Entry = Data.define(:descriptor_bytes, :value)
@@ -238,6 +338,7 @@ module Rigor
         value = safe_load(value_bytes, deserialize)
         return nil if value.equal?(LOAD_FAILED)
 
+        touch_for_lru(path) if @max_bytes
         Entry.new(descriptor_bytes, value)
       end
 
@@ -271,11 +372,15 @@ module Rigor
       LOAD_FAILED = Object.new.freeze
       private_constant :LOAD_FAILED
 
+      # Inflates the stored value payload (ADR-54 WD2), then hands the
+      # raw bytes to the deserialiser. Any failure — corrupt deflate
+      # stream included — reads as a miss.
       def safe_load(bytes, deserialize)
+        raw = Zlib::Inflate.inflate(bytes)
         if deserialize
-          deserialize.call(bytes)
+          deserialize.call(raw)
         else
-          Marshal.load(bytes) # rubocop:disable Security/MarshalLoad
+          Marshal.load(raw) # rubocop:disable Security/MarshalLoad
         end
       rescue StandardError
         LOAD_FAILED
@@ -285,7 +390,7 @@ module Rigor
         FileUtils.mkdir_p(File.dirname(path))
 
         descriptor_bytes = descriptor.to_canonical_bytes
-        value_bytes = serialize_value(value, serialize)
+        value_bytes = Zlib::Deflate.deflate(serialize_value(value, serialize))
 
         body = +"".b
         body << HEADER
@@ -331,10 +436,15 @@ module Rigor
         # never collides with a read under the old). The next
         # writable run will repair the cache.
         return if @read_only
+        # The marker is process-stable; one check per Store is
+        # enough (a benign double-check under a thread race just
+        # repeats idempotent work).
+        return if @schema_version_ensured
 
+        @schema_version_ensured = true
         FileUtils.mkdir_p(@root)
         marker = File.join(@root, "schema_version.txt")
-        current = Descriptor::SCHEMA_VERSION.to_s
+        current = self.class.schema_marker_value
 
         if File.file?(marker)
           on_disk = File.read(marker).strip
@@ -370,6 +480,27 @@ module Rigor
         end
       end
 
+      # Updates both atime and mtime of `path` to the current time — the
+      # cross-process LRU signal used by {evict!}. Best-effort: any FS
+      # error (read-only mount, deleted file) is silently ignored.
+      def touch_for_lru(path)
+        now = Time.now
+        File.utime(now, now, path)
+      rescue StandardError
+        nil
+      end
+
+      # Returns an array of `{ path:, mtime:, bytes: }` hashes for every
+      # `.entry` file under the cache root, skipping unreadable entries.
+      def collect_entry_stats
+        Dir.glob(File.join(@root, "**", "*.entry")).filter_map do |path|
+          stat = File.stat(path)
+          { path: path, mtime: stat.mtime, bytes: stat.size }
+        rescue StandardError
+          nil
+        end
+      end
+
       def read_varint(bytes, offset)
         result = 0
         shift = 0

data/lib/rigor/cli/annotate_command.rb

@@ -9,6 +9,7 @@ require_relative "../scope"
 require_relative "../inference/def_return_typer"
 require_relative "../inference/scope_indexer"
 require_relative "prism_colorizer"
+require_relative "command"
 
 module Rigor
   class CLI
@@ -25,19 +26,13 @@ module Rigor
     # since the appended text is always a comment — and printed to
     # stdout with IRB-style syntax highlighting via
     # {PrismColorizer}.
-    class AnnotateCommand
+    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/
 
-      def initialize(argv:, out:, err:)
-        @argv = argv
-        @out = out
-        @err = err
-      end
-
       # @return [Integer] CLI exit status.
       def run
         options = parse_options

data/lib/rigor/cli/baseline_command.rb

@@ -6,6 +6,7 @@ require_relative "../analysis/baseline"
 require_relative "../analysis/runner"
 require_relative "../cache/store"
 require_relative "../configuration"
+require_relative "command"
 
 module Rigor
   class CLI
@@ -20,18 +21,12 @@ module Rigor
     #   rigor baseline dump
     #   rigor baseline drift
     #   rigor baseline prune
-    class BaselineCommand # rubocop:disable Metrics/ClassLength
+    class BaselineCommand < Command # rubocop:disable Metrics/ClassLength
       EXIT_USAGE = 64
       DEFAULT_BASELINE_PATH = ".rigor-baseline.yml"
 
       SUBCOMMANDS = %w[generate regenerate dump drift prune].freeze
 
-      def initialize(argv:, out: $stdout, err: $stderr)
-        @argv = argv
-        @out = out
-        @err = err
-      end
-
       def run
         subcommand = @argv.shift
         case subcommand