rigortype 0.4.4 → 0.4.5

data/lib/rigor/sig_gen/writer.rb

@@ -98,7 +98,8 @@ module Rigor
         source_path ||= candidates.first&.path
         unless inside_sig_root?(target)
           return WriteResult.new(source_path: source_path, target_path: target,
-                                 action: :skipped_outside_sig_root)
+                                 action: :skipped_outside_sig_root,
+                                 skipped: candidates.map { |c| [c, :outside_sig_root] })
         end
 
         target.exist? ? update_existing(source_path, target, candidates) : create_new(source_path, target, candidates)
@@ -636,7 +637,8 @@ module Rigor
       end
 
       # Returns a list of `[method_name (Symbol), kind (Symbol)]` pairs for every method-like member in the
-      # declaration ({LayoutIndex.member_keys}). ADR-14 slice 4 recognises the three `attr_*` declaration kinds
+      # declaration ({LayoutIndex.member_keys}); an `alias` declares its new name (#1975). ADR-14 slice 4
+      # recognises the three `attr_*` declaration kinds
       # so a source-side `attr_reader :name` and an RBS-side `attr_reader name: T` are treated as the same member
       # (i.e. user-authored); a `def self?.f` counts as both an instance and a singleton `f` (#1488).
       def collect_member_pairs(decl)
@@ -754,7 +756,7 @@ module Rigor
 
       def find_attr_member(decl, method_name, kind)
         decl.members.find do |m|
-          next false if m.is_a?(RBS::AST::Members::MethodDefinition)
+          next false if m.is_a?(RBS::AST::Members::MethodDefinition) || m.is_a?(RBS::AST::Members::Alias)
 
           LayoutIndex.member_keys(m).include?([method_name, kind])
         end

data/lib/rigor/signature_path_audit.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "rooted_glob"
+
 module Rigor
   # Classifies each configured `signature_paths:` entry by what it actually contributes to
   # the RBS environment, so a caller can warn when a configured path resolves to nothing.
@@ -90,7 +92,7 @@ module Rigor
       return Entry.new(path: path, status: :missing, rbs_file_count: 0) unless File.exist?(path)
       return Entry.new(path: path, status: :not_directory, rbs_file_count: 0) unless File.directory?(path)
 
-      count = Dir.glob(File.join(path, "**", "*.rbs")).size
+      count = RootedGlob.glob(path, "**/*.rbs").size
       Entry.new(path: path, status: count.zero? ? :empty : :ok, rbs_file_count: count)
     end
 
@@ -204,7 +206,7 @@ module Rigor
     private_class_method :listed?
 
     def self.canonical_rbs_files(dir)
-      Dir.glob(File.join(dir, "**", "*.rbs")).filter_map { |file| canonical_path(file) }
+      RootedGlob.glob(dir, "**/*.rbs").filter_map { |file| canonical_path(file) }
     end
     private_class_method :canonical_rbs_files
 

data/lib/rigor/type/constant.rb

@@ -78,7 +78,8 @@ module Rigor
       # `RbsTypeTranslator#translate_literal` already maps the parsed RBS Literal back to `Constant`.
       # Scalar carriers without RBS Literal support (Float, Range, Rational, Complex, Regexp, Pathname)
       # keep their pre-existing widen-to-class-name behaviour because RBS rejects their literal spellings
-      # as syntax errors.
+      # as syntax errors. `Range` is generic (`Range[out E]`), and a bare `Range` fails `rbs validate`, so
+      # it carries the class of its endpoints, or `untyped` when both are nil (#1891).
       def erase_to_rbs
         case value
         when true then "true"
@@ -86,6 +87,7 @@ module Rigor
         when nil then "nil"
         when Integer then value.to_s
         when Symbol, String then value.inspect
+        when Range then "Range[#{range_element_rbs}]"
         else value.class.name
         end
       end
@@ -106,6 +108,13 @@ module Rigor
       def inspect
         "#<Rigor::Type::Constant #{describe(:short)}>"
       end
+
+      private
+
+      def range_element_rbs
+        classes = [value.begin, value.end].compact.map { |endpoint| endpoint.class.name }.uniq.sort
+        classes.empty? ? "untyped" : classes.join(" | ")
+      end
     end
   end
 end

data/lib/rigor/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rigor
-  VERSION = "0.4.4"
+  VERSION = "0.4.5"
 end

data/plugins/rigor-actioncable/lib/rigor/plugin/actioncable/channel_discoverer.rb

@@ -99,7 +99,7 @@ module Rigor
             # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
             next [] unless @io_boundary.directory?(absolute)
 
-            Dir.glob(File.join(absolute, "**", "*.rb"))
+            Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
           end
         end
 

data/plugins/rigor-actionmailer/lib/rigor/plugin/actionmailer/mailer_discoverer.rb

@@ -90,7 +90,7 @@ module Rigor
             # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
             next [] unless @io_boundary.directory?(absolute)
 
-            Dir.glob(File.join(absolute, "**", "*.rb"))
+            Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
           end
         end
 

data/plugins/rigor-actionpack/lib/rigor/plugin/actionpack/controller_discoverer.rb

@@ -58,7 +58,7 @@ module Rigor
             # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
             next [] unless @io_boundary.directory?(absolute)
 
-            Dir.glob(File.join(absolute, "**", "*.rb"))
+            Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
           end
         end
 

data/plugins/rigor-actionpack/lib/rigor/plugin/actionpack/render_locals.rb

@@ -159,13 +159,18 @@ module Rigor
 
           # Project-relative paths, the spelling `#template_units_for_file` is handed and the spelling the
           # compiled cache is keyed by.
+          #
+          # #1803 — listed through the boundary's `#glob`, which records each root's membership: a helper
+          # added under `app/helpers`, or a template under a `view_search_paths:` root the template globs do
+          # not claim, is analysed by nobody, and without the row the run-result caches kept serving the
+          # index built before it appeared.
           def self.source_files(io_boundary, roots, pattern)
             root_prefix = "#{Dir.pwd}#{File::SEPARATOR}"
             roots.flat_map do |root|
               absolute = File.expand_path(root)
               next [] unless io_boundary.directory?(absolute)
 
-              Dir.glob(File.join(absolute, "**", pattern)).map { |path| path.delete_prefix(root_prefix) }
+              io_boundary.glob(absolute, "**/#{pattern}").map { |path| path.delete_prefix(root_prefix) }
             end
           end
 

data/plugins/rigor-actionpack/lib/rigor/plugin/actionpack/view_assigns.rb

@@ -116,7 +116,7 @@ module Rigor
               absolute = File.expand_path(root)
               next [] unless @io_boundary.directory?(absolute)
 
-              Dir.glob(File.join(absolute, "**", "*.rb"))
+              @io_boundary.glob(absolute, "**/*.rb")
             end
           end
 

data/plugins/rigor-active-model-serializers/lib/rigor/plugin/active_model_serializers/serializer_discoverer.rb

@@ -127,7 +127,7 @@ module Rigor
             # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
             next [] unless @io_boundary.directory?(absolute)
 
-            Dir.glob(File.join(absolute, "**", "*.rb"))
+            Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
           end
         end
 

data/plugins/rigor-activejob/lib/rigor/plugin/activejob/effects.rb

@@ -146,11 +146,12 @@ module Rigor
 
         # ADR-45 WD1b (#613) — `config/application.rb` is probed at a fixed path, so its ABSENCE is what
         # shapes "no adapter" on a project that has none yet; the probe goes through the boundary to record
-        # that. The globbed `config/environments/*.rb` entries exist by enumeration and only pick up the
-        # (immediately superseded) presence row.
+        # that. The `config/environments/*.rb` listing goes through `#glob` (#1803), whose row records the
+        # directory's membership; each listed entry only picks up the (immediately superseded) presence row.
         def config_files(io_boundary, root)
           application = File.join(root, CONFIG_PATHS.first)
-          environments = Dir.glob(File.join(root, CONFIG_PATHS.last, "*.rb"))
+          environments_dir = File.join(root, CONFIG_PATHS.last)
+          environments = io_boundary.glob(environments_dir, "*.rb")
           ([application] + environments).select { |path| io_boundary.file?(path) }
         rescue StandardError
           []

data/plugins/rigor-activejob/lib/rigor/plugin/activejob/job_discoverer.rb

@@ -92,7 +92,7 @@ module Rigor
             # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
             next [] unless @io_boundary.directory?(absolute)
 
-            Dir.glob(File.join(absolute, "**", "*.rb"))
+            Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
           end
         end
 

data/plugins/rigor-activerecord/lib/rigor/plugin/activerecord/model_discoverer.rb

@@ -375,7 +375,7 @@ module Rigor
             # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
             next [] unless @io_boundary.directory?(absolute)
 
-            Dir.glob(File.join(absolute, "**", "*.rb"))
+            Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
           end
         end
 

data/plugins/rigor-activestorage/lib/rigor/plugin/activestorage/attachment_discoverer.rb

@@ -69,7 +69,7 @@ module Rigor
             # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
             next [] unless @io_boundary.directory?(absolute)
 
-            Dir.glob(File.join(absolute, "**", "*.rb"))
+            Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
           end
         end
 

data/plugins/rigor-alba/lib/rigor/plugin/alba/resource_discoverer.rb

@@ -65,7 +65,7 @@ module Rigor
             # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
             next [] unless @io_boundary.directory?(absolute)
 
-            Dir.glob(File.join(absolute, "**", "*.rb"))
+            Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
           end
         end
       end

data/plugins/rigor-dry-types/lib/rigor/plugin/dry_types.rb

@@ -109,7 +109,7 @@ module Rigor
       def scannable_paths
         @scannable_paths ||= services.configuration.paths.flat_map do |entry|
           if io_boundary.directory?(entry)
-            Dir.glob(File.join(entry, "**", "*.rb"), sort: true)
+            Dir.glob("**/*.rb", base: entry).map { |path| File.join(entry, path) }
           elsif io_boundary.file?(entry) && entry.end_with?(".rb")
             [entry]
           else

data/plugins/rigor-factorybot/lib/rigor/plugin/factorybot/factory_discoverer.rb

@@ -54,7 +54,7 @@ module Rigor
             if @io_boundary.file?(absolute)
               [absolute]
             elsif @io_boundary.directory?(absolute)
-              Dir.glob(File.join(absolute, "**", "*.rb"))
+              Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
             else
               []
             end

data/plugins/rigor-ffi/lib/rigor/plugin/ffi/discoverer.rb

@@ -11,6 +11,8 @@ module Rigor
       # carried no row at all and was served after any edit, an analysed file's included, until `--no-cache`.
       class Discoverer
         RUBY_GLOB = "**/*.rb"
+        RUBY_FILE = "*.rb"
+        SKIPPED_DIRECTORIES = %w[vendor .git].freeze
 
         def self.discover(root:, io:)
           new(root: root, io: io).discover
@@ -67,20 +69,47 @@ module Rigor
 
         private
 
+        # #1959 — one `:kinds` listing row over the root's top-level entries, then one `:names` `**/*.rb` row per
+        # real directory among them other than `vendor/`. A single `**/*.rb` row over the root re-walked an in-tree
+        # `vendor/bundle` on every warm validation and read stale on every `bundle install`. The listing carries
+        # each entry's kind and not just its name: the walk descends a directory but not a symlinked one (`**` never
+        # followed it), so a file `gen` that becomes a directory `gen/`, or a symlink that becomes a real
+        # directory, changes what it reads while every name stays put.
+        #
+        # The answer is `Dir.glob("**/*.rb")` minus the skipped paths and minus every match that is not a regular
+        # file (#2113), in its order: entry by entry, a top-level name matching `*.rb`, then that directory's
+        # matches. A directory so named is walked, never read. The boundary answers absolute paths; they are spelled
+        # back under `@root` as `Dir.glob` spells them.
         def ruby_files
           return [] unless @root && @io.directory?(@root.to_s)
 
-          boundary_glob.reject { |p| p.include?("/vendor/") || p.include?("/.git/") }
-        end
-
-        # One `:names` `**/*.rb` row over the root, `vendor/` included: a per-entry walk that skipped it recorded
-        # names only, so a top-level entry that changed kind under the same name went unseen. The boundary
-        # answers absolute paths; they are spelled back under `@root` as `Dir.glob` spells them, so the filter
-        # above sees the same strings it always did.
-        def boundary_glob
           root = @root.to_s
           prefix = "#{File.absolute_path(root)}/"
-          @io.glob(root, RUBY_GLOB).map { |path| File.join(root, path.delete_prefix(prefix)) }
+          @io.list_directory_kinds(root).flat_map do |path, kind|
+            name = path.delete_prefix(prefix)
+            own = File.fnmatch?(RUBY_FILE, name) && readable_file?(path, kind) ? [File.join(root, name)] : []
+            next own unless kind == :directory && !SKIPPED_DIRECTORIES.include?(name)
+
+            own + @io.glob(path, RUBY_GLOB).filter_map do |nested|
+              relative = nested.delete_prefix(prefix)
+              File.join(root, relative) if !skipped?(relative) && @io.file?(nested)
+            end
+          end
+        end
+
+        # #2113 — `*.rb` names a directory too, and a fifo, socket or device can carry the name. Only a regular file
+        # is read: `read_file` on a directory raises `EISDIR` and aborts the whole walk, and on a fifo it blocks
+        # until a writer appears. A top-level entry is judged by its `lstat` kind, and a symlink by what it
+        # resolves to; a nested match is judged by `file?` (which follows a symlink as `File.file?` does).
+        def readable_file?(path, kind)
+          kind == :file || (kind == :symlink && @io.file?(path))
+        end
+
+        # #1956 — the skip reads the path relative to the root, a `vendor` or `.git` directory segment at any
+        # depth under it. Matching `/vendor/` in the whole path also dropped every file of a project that itself
+        # lives under some `…/vendor/…` directory, and the catalog came out empty.
+        def skipped?(relative)
+          relative.split("/")[0...-1].intersect?(SKIPPED_DIRECTORIES)
         end
 
         # The glob's rows record which files match; this read's row carries an edit.

data/plugins/rigor-ffi/lib/rigor/plugin/ffi/target_detector.rb

@@ -26,7 +26,7 @@ module Rigor
         def extconf_uses_ffx?(root, io = nil)
           return false if root.nil?
 
-          extconfs = io ? io.glob(root.to_s, EXTCONF_GLOB) : Dir.glob(File.join(root.to_s, EXTCONF_GLOB))
+          extconfs = io ? io.glob(root.to_s, EXTCONF_GLOB) : Dir.glob(EXTCONF_GLOB, base: root.to_s).map { |path| File.join(root.to_s, path) }
           extconfs.any? do |extconf|
             read_text(extconf, io).include?("FFX.create_makefile")
           rescue SystemCallError

data/plugins/rigor-pundit/lib/rigor/plugin/pundit/authorization_scan.rb

@@ -72,7 +72,7 @@ module Rigor
             # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
             next [] unless @io_boundary.directory?(absolute)
 
-            Dir.glob(File.join(absolute, "**", "*.rb"))
+            Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
           end
         end
 

data/plugins/rigor-pundit/lib/rigor/plugin/pundit/policy_discoverer.rb

@@ -60,7 +60,7 @@ module Rigor
             # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
             next [] unless @io_boundary.directory?(absolute)
 
-            Dir.glob(File.join(absolute, "**", "*.rb"))
+            Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
           end
         end
 

data/plugins/rigor-rails-i18n/lib/rigor/plugin/rails_i18n/locale_index.rb

@@ -34,12 +34,17 @@ module Rigor
           end
         end
 
-        attr_reader :entries, :locales
+        attr_reader :entries, :locales, :load_errors
 
         # @param locales — all locale names that contributed at least one key.
-        def initialize(entries, locales:)
+        # @param load_errors — the {LocaleLoader::LoadError}s of the files that did not parse (#1954). They
+        #   ride in the index, not beside it, because the index is the cached producer value: a warm run
+        #   serves it without re-reading a single locale file, so an error kept anywhere else is lost exactly
+        #   when the cache hits.
+        def initialize(entries, locales:, load_errors: [])
           @entries = entries.freeze
           @locales = locales.dup.freeze
+          @load_errors = load_errors.map(&:freeze).freeze
           @by_key = entries.to_h { |e| [e.dotted_key, e] }.freeze
           freeze
         end

data/plugins/rigor-rails-i18n/lib/rigor/plugin/rails_i18n/locale_loader.rb

@@ -15,9 +15,9 @@ module Rigor
       # flattened into dotted keys (`users.welcome`, `errors.messages.blank`, …). For each leaf string,
       # `%{var}` placeholders are extracted via a simple regex.
       #
-      # Files that fail to parse are skipped with a load-error diagnostic surfaced through the plugin's
-      # error channel. Non-Hash YAML roots (e.g. a top-level sequence) are also skipped — the format is
-      # locale-keyed by convention.
+      # Files that fail to parse are skipped and recorded in the returned index's `load_errors`, which the
+      # plugin discloses as a run-scoped load-error row. Non-Hash YAML roots (e.g. a top-level sequence) are
+      # also skipped — the format is locale-keyed by convention.
       class LocaleLoader
         PLACEHOLDER_RE = /%\{(?<name>[^}]+)\}/
 
@@ -66,7 +66,7 @@ module Rigor
               value_kinds: per_key_kinds[dotted_key].freeze
             )
           end
-          LocaleIndex.new(entries, locales: locales.to_a.sort)
+          LocaleIndex.new(entries, locales: locales.to_a.sort, load_errors: @load_errors)
         end
 
         private
@@ -90,7 +90,7 @@ module Rigor
             # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
             next [] unless @io_boundary.directory?(absolute)
 
-            Dir.glob(File.join(absolute, "**", "*.{yml,yaml}"))
+            Dir.glob("**/*.{yml,yaml}", base: absolute).map { |path| File.join(absolute, path) }
           end.sort
         end
 

data/plugins/rigor-rails-i18n/lib/rigor/plugin/rails_i18n.rb

@@ -57,7 +57,11 @@ module Rigor
         target_gems: ["i18n"],
         # Bumped 2026-06-23 — view template lazy-key scanning (`t('.key')` inside ERB / Haml / Slim under
         # `view_search_paths`).
-        version: "0.3.0",
+        # Bumped 2026-10-17 (#1954) — the cached `:locale_index` value now carries the YAML load errors. A
+        # belt-and-braces key change: a released build already drops pre-change entries with the cache ABI
+        # (`Rigor::VERSION`) and a checkout with its engine-source identity, and the read below tolerates
+        # an index without errors either way.
+        version: "0.3.1",
         description: "Validates I18n `t(key)` calls against `config/locales/*.yml`.",
         config_schema: {
           "locale_search_paths" => { kind: :array, default: ["config/locales"] },
@@ -72,17 +76,12 @@ module Rigor
       )
 
       # `watch:` covers every `.yml` / `.yaml` file under the locale search paths so the cache invalidates
-      # when locale files are added, removed, or edited (ADR-60 WD3). `@load_errors` is a producer-side
-      # capture: it is populated only when the block runs (a cache miss / a watched file changed), which is
-      # exactly when a malformed YAML must re-surface.
+      # when locale files are added, removed, or edited (ADR-60 WD3). The YAML load errors travel inside the
+      # returned index (`LocaleIndex#load_errors`), not in an instance variable the block sets (#1954): a
+      # warm producer-cache hit skips the block, so a block-side capture lost the load-error row on every
+      # run whose result was not itself served from the run-result cache.
       producer :locale_index, watch: -> { [[@locale_search_paths, "**/*.yml", "**/*.yaml"]] } do |_params|
-        loader = LocaleLoader.new(
-          io_boundary: io_boundary,
-          search_paths: @locale_search_paths
-        )
-        index = loader.load
-        @load_errors = loader.load_errors
-        index
+        LocaleLoader.new(io_boundary: io_boundary, search_paths: @locale_search_paths).load
       end
 
       # Scans view templates under `view_search_paths` for lazy `t('.key')` / `I18n.translate('.key')`
@@ -102,7 +101,6 @@ module Rigor
         @locale_search_paths = Array(config.fetch("locale_search_paths")).map(&:to_s)
         @view_search_paths = Array(config.fetch("view_search_paths")).map(&:to_s)
         @configured_locales = Array(config.fetch("configured_locales")).map(&:to_s)
-        @load_errors = []
       end
 
       # Returns no rows of its own: every file-level outcome here is run-scoped. The YAML load errors and the
@@ -114,8 +112,11 @@ module Rigor
       # are lazily loaded + memoised by `producer_value`, so the repeat registrations are no-ops.
       def diagnostics_for_file(path:, scope:, root:) # rubocop:disable Lint/UnusedMethodArgument
         index = producer_value(:locale_index)
-        disclose_load_errors unless @load_errors.empty?
-        disclose_locale_runtime_error if index.nil? && producer_error(:locale_index)
+        if index
+          disclose_load_errors(Array(index.load_errors))
+        elsif producer_error(:locale_index)
+          disclose_locale_runtime_error
+        end
         view_diags = producer_value(:view_diagnostics) || []
         if (view_err = producer_error(:view_diagnostics))
           disclose_view_runtime_error(view_err)
@@ -175,7 +176,7 @@ module Rigor
           # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
           next [] unless io_boundary.directory?(absolute)
 
-          Dir.glob(File.join(absolute, "**", "*.{erb,haml,slim}"))
+          Dir.glob("**/*.{erb,haml,slim}", base: absolute).map { |path| File.join(absolute, path) }
         end.sort
       end
 
@@ -209,8 +210,8 @@ module Rigor
       # be pinned to the first analysed Ruby file — once per plugin INSTANCE, so once per fork-pool worker
       # (#1051). They go through the run-scoped channel instead: keyed by the locale path that failed, so a
       # project with two broken YAML files still discloses both, each exactly once, at `.rigor.yml:1:1`.
-      def disclose_load_errors
-        @load_errors.each do |err|
+      def disclose_load_errors(load_errors)
+        load_errors.each do |err|
           disclose_once(
             "locale-parse:#{err.path}",
             message: "rigor-rails-i18n: failed to parse `#{err.path}`: #{err.message}",

data/plugins/rigor-rails-routes/lib/rigor/plugin/rails_routes.rb

@@ -168,7 +168,7 @@ module Rigor
           # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
           next unless io_boundary.directory?(absolute)
 
-          Dir.glob(File.join(absolute, "**", "*.rb")).each(&)
+          Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }.each(&)
         end
       end
 

data/plugins/rigor-sidekiq/lib/rigor/plugin/sidekiq/worker_discoverer.rb

@@ -92,7 +92,7 @@ module Rigor
             # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
             next [] unless @io_boundary.directory?(absolute)
 
-            Dir.glob(File.join(absolute, "**", "*.rb"))
+            Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
           end
         end
 

data/plugins/rigor-sinatra/lib/rigor/plugin/sinatra.rb

@@ -29,7 +29,9 @@ module Rigor
     # ## Reach
     #
     # All nine class-level HTTP verb methods Sinatra exposes: `get`, `post`, `put`, `delete`, `head`,
-    # `options`, `patch`, `link`, `unlink` (`lib/sinatra/base.rb:1531-1553`). Both modular-style subclasses
+    # `options`, `patch`, `link`, `unlink` (`lib/sinatra/base.rb:1531-1553`), plus the `before` / `after`
+    # filters (`add_filter`) and the `error` / `not_found` handlers, whose blocks `compile!` turns into
+    # instance methods through the same `generate_method` (issue #1768). Both modular-style subclasses
     # of `Sinatra::Base` and `Sinatra::Application` (classic top-level style, when used via `class App <
     # Sinatra::Application`) match because the receiver constraint accepts every subclass.
     #
@@ -57,7 +59,7 @@ module Rigor
         block_as_methods: [
           Rigor::Plugin::Macro::BlockAsMethod.new(
             receiver_constraint: "Sinatra::Base",
-            method_names: %i[get post put delete head options patch link unlink]
+            method_names: %i[get post put delete head options patch link unlink before after error not_found]
           )
         ]
       )

data/plugins/rigor-sorbet/lib/rigor/plugin/sorbet.rb

@@ -504,8 +504,8 @@ module Rigor
             # must not vary by machine / run. `Dir.glob` sorts its results by default on Ruby 3.0+, so the fold
             # order is already stable (the slice-1 comment's "filesystem order" caveat predates that default);
             # this walk relies on it rather than re-sorting.
-            Dir.glob(File.join(absolute, "**", "*#{ext}")).each do |path|
-              harvest_file(canonicalize(path), catalog, sigil_by_path, parse_errors_by_path)
+            Dir.glob("**/*#{ext}", base: absolute).each do |relative|
+              harvest_file(canonicalize(File.join(absolute, relative)), catalog, sigil_by_path, parse_errors_by_path)
             end
           end
         elsif io_boundary.file?(absolute) && extensions.any? { |ext| absolute.end_with?(ext) }

data/plugins/rigor-typelizer/lib/rigor/plugin/typelizer/serializer_discoverer.rb

@@ -63,7 +63,7 @@ module Rigor
           @project_paths.flat_map do |entry|
             absolute = File.expand_path(entry)
             if @io_boundary.directory?(absolute)
-              Dir.glob(File.join(absolute, "**", "*.rb"))
+              Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
             elsif absolute.end_with?(".rb") && @io_boundary.file?(absolute)
               [absolute]
             else
@@ -78,7 +78,7 @@ module Rigor
             # ADR-45 WD1b (#613) — boundary-probed: a root that appears later invalidates the warm run.
             next [] unless @io_boundary.directory?(absolute)
 
-            Dir.glob(File.join(absolute, "**", "*.rb"))
+            Dir.glob("**/*.rb", base: absolute).map { |path| File.join(absolute, path) }
           end
         end
       end

data/sig/rigor/plugin/io_boundary.rbs

@@ -4,11 +4,14 @@ class Rigor::Plugin::IoBoundary
   def file?: (untyped) -> bool
   def directory?: (untyped) -> bool
   def list_directory: (untyped) -> Array[String]
+  def list_directory_kinds: (untyped) -> Hash[String, untyped]
   # Records a `:names` glob row (membership only); a caller needing a match's content `read_file`s it. A `..`
   # segment, a brace or a backslash in `pattern` raises `AccessDeniedError`.
   def glob: (untyped root, untyped pattern) -> Array[String]
-  # sig-gen gap: #1156 — the generator pins the empty-summary literal (`count: 0, first_path: nil`); the
-  # record's fields are the running count and the first refused path, nil when nothing was refused.
+  # sig-gen gap: #1154 — the proposal leaves both string fields untyped. `nearest_root` comes from `@policy`, an
+  # ivar assigned from an `initialize` parameter (the #1154 shape); `first_path` comes from `@first_refused_path`,
+  # written from `record_refusal(path)`'s parameter outside `initialize`, a case #1154 as titled does not yet cover.
+  # The record's fields are the running count and the first refused path, nil when nothing was refused.
   def refusal_summary: () -> { count: Integer, first_path: String?, nearest_root: String? }?
   def open_url: (untyped url) -> String
   # Returns a frozen `Rigor::Cache::Descriptor` (no RBS yet -> untyped).

data/sig/rigor/rooted_glob.rbs

@@ -0,0 +1,7 @@
+module Rigor
+  module RootedGlob
+    METACHARACTERS: Regexp
+
+    def self?.glob: (untyped, untyped) -> Array[String]
+  end
+end

data/sig/rigor/scope.rbs

@@ -61,7 +61,7 @@ module Rigor
     def discovered_singleton_def_nodes: () -> Hash[String, Hash[Symbol, untyped]]
     def discovered_def_sources: () -> Hash[String, Hash[Symbol, String]]
     def discovered_singleton_def_sources: () -> Hash[String, Hash[Symbol, String]]
-    def discovered_method_visibilities: () -> Hash[String, Hash[Symbol, Symbol]]
+    def discovered_method_visibilities: () -> Hash[String, Hash[Symbol | [:singleton, Symbol], Symbol]]
     # sig-gen gap: #1148 — sig-gen skips an endless-def reader (untyped return); the row is hand-written.
     def discovered_parameter_envelopes: () -> Hash[String, Hash[untyped, untyped]]
     # sig-gen gap: #1149 — sig-gen skips the `||` fallback reader (untyped return); the row is hand-written.
@@ -128,7 +128,7 @@ module Rigor
       attr_reader discovered_singleton_def_nodes: Hash[String, Hash[Symbol, untyped]]
       attr_reader discovered_def_sources: Hash[String, Hash[Symbol, String]]
       attr_reader discovered_singleton_def_sources: Hash[String, Hash[Symbol, String]]
-      attr_reader discovered_method_visibilities: Hash[String, Hash[Symbol, Symbol]]
+      attr_reader discovered_method_visibilities: Hash[String, Hash[Symbol | [:singleton, Symbol], Symbol]]
       # sig-gen gap: #1150 — `Data.define` members carry no type, as for every other row in this class.
       attr_reader discovered_parameter_envelopes: Hash[String, Hash[untyped, untyped]]
       attr_reader discovered_superclasses: Hash[String, String]
@@ -201,7 +201,7 @@ module Rigor
       # authored: ADR-119 WD1 sibling pairing; no inferred signature exists for it (#1150).
       def sibling_tables: () -> Hash[Symbol, untyped]
 
-      def with: (?declared_types: Hash[untyped, Type::t], ?class_ivars: Hash[String, Hash[Symbol, Type::t]], ?class_cvars: Hash[String, Hash[Symbol, Type::t]], ?program_globals: Hash[Symbol, Type::t], ?program_global_seeds: Hash[Symbol, Type::t], ?discovered_classes: Hash[String, Type::Singleton], ?in_source_constants: Hash[String, Type::t], ?discovered_methods: Hash[String, Hash[Symbol, Symbol]], ?discovered_def_nodes: Hash[String, Hash[Symbol, untyped]], ?discovered_def_nestings: Hash[untyped, Array[String]], ?discovered_singleton_def_nodes: Hash[String, Hash[Symbol, untyped]], ?discovered_def_sources: Hash[String, Hash[Symbol, String]], ?discovered_singleton_def_sources: Hash[String, Hash[Symbol, String]], ?discovered_method_visibilities: Hash[String, Hash[Symbol, Symbol]], ?discovered_parameter_envelopes: Hash[String, Hash[untyped, untyped]], ?discovered_superclasses: Hash[String, String], ?discovered_includes: Hash[String, Array[String]], ?discovered_prepends: Hash[String, Array[String]], ?discovered_extends: Hash[String, Array[String]], ?discovered_class_sources: Hash[String, Set[String]], ?constant_sources: Hash[String, Set[String]], ?constant_writers: Hash[String, Array[String]], ?constant_shadowers: Hash[String, Array[String]], ?published_constant_names: Set[String], ?local_constant_names: Set[String], ?published_constant_alias_names: Set[String], ?published_constant_ivars: Hash[String, Set[Symbol]], ?data_member_layouts: Hash[String, Array[Symbol]], ?struct_member_layouts: Hash[String, { members: Array[Symbol], keyword_init: bool }], ?param_inferred_types: Hash[[String, Symbol, Symbol], Hash[Symbol, Type::t]], ?discovered_deferred_ranges: Hash[String, Array[[Integer, Integer, Symbol?, Symbol?, String?]]], ?discovered_refinements: Hash[String, Hash[Symbol | String, Array[String]]], ?discovered_global_write_census: Set[Array[untyped]], ?run_generation: Object?, ?patched_line_readers: Set[Symbol], ?clears_last_status: bool, ?defines_case_equality: bool, ?implicit_self_evidence: untyped, ?in_effect_refinements: untyped, ?possible_discovered_methods: Hash[String, Hash[Symbol, Symbol]], ?possible_discovered_deferred_ranges: Hash[String, Array[[Integer, Integer, Symbol?, Symbol?, String?]]], ?contested_discovered_def_nodes: Set[Array[untyped]], ?contested_discovered_singleton_def_nodes: Set[Array[untyped]], ?contested_discovered_method_visibilities: Set[Array[untyped]], ?contested_discovered_parameter_envelopes: Set[Array[untyped]]) -> DiscoveryIndex
+      def with: (?declared_types: Hash[untyped, Type::t], ?class_ivars: Hash[String, Hash[Symbol, Type::t]], ?class_cvars: Hash[String, Hash[Symbol, Type::t]], ?program_globals: Hash[Symbol, Type::t], ?program_global_seeds: Hash[Symbol, Type::t], ?discovered_classes: Hash[String, Type::Singleton], ?in_source_constants: Hash[String, Type::t], ?discovered_methods: Hash[String, Hash[Symbol, Symbol]], ?discovered_def_nodes: Hash[String, Hash[Symbol, untyped]], ?discovered_def_nestings: Hash[untyped, Array[String]], ?discovered_singleton_def_nodes: Hash[String, Hash[Symbol, untyped]], ?discovered_def_sources: Hash[String, Hash[Symbol, String]], ?discovered_singleton_def_sources: Hash[String, Hash[Symbol, String]], ?discovered_method_visibilities: Hash[String, Hash[Symbol | [:singleton, Symbol], Symbol]], ?discovered_parameter_envelopes: Hash[String, Hash[untyped, untyped]], ?discovered_superclasses: Hash[String, String], ?discovered_includes: Hash[String, Array[String]], ?discovered_prepends: Hash[String, Array[String]], ?discovered_extends: Hash[String, Array[String]], ?discovered_class_sources: Hash[String, Set[String]], ?constant_sources: Hash[String, Set[String]], ?constant_writers: Hash[String, Array[String]], ?constant_shadowers: Hash[String, Array[String]], ?published_constant_names: Set[String], ?local_constant_names: Set[String], ?published_constant_alias_names: Set[String], ?published_constant_ivars: Hash[String, Set[Symbol]], ?data_member_layouts: Hash[String, Array[Symbol]], ?struct_member_layouts: Hash[String, { members: Array[Symbol], keyword_init: bool }], ?param_inferred_types: Hash[[String, Symbol, Symbol], Hash[Symbol, Type::t]], ?discovered_deferred_ranges: Hash[String, Array[[Integer, Integer, Symbol?, Symbol?, String?]]], ?discovered_refinements: Hash[String, Hash[Symbol | String, Array[String]]], ?discovered_global_write_census: Set[Array[untyped]], ?run_generation: Object?, ?patched_line_readers: Set[Symbol], ?clears_last_status: bool, ?defines_case_equality: bool, ?implicit_self_evidence: untyped, ?in_effect_refinements: untyped, ?possible_discovered_methods: Hash[String, Hash[Symbol, Symbol]], ?possible_discovered_deferred_ranges: Hash[String, Array[[Integer, Integer, Symbol?, Symbol?, String?]]], ?contested_discovered_def_nodes: Set[Array[untyped]], ?contested_discovered_singleton_def_nodes: Set[Array[untyped]], ?contested_discovered_method_visibilities: Set[Array[untyped]], ?contested_discovered_parameter_envelopes: Set[Array[untyped]]) -> DiscoveryIndex
     end
 
     class IndexedKey
@@ -338,6 +338,7 @@ module Rigor
     # Issue #530 — public so the external-gem ancestry probe asks the same question the walk does.
     def known_user_class?: (String | Symbol name) -> bool
     def singleton_def_for: (String | Symbol class_name, String | Symbol method_name) -> ::Prism::DefNode?
+    def module_function_def?: (untyped, untyped) -> (false | true)
     def singleton_def_through_ancestors: (String | Symbol class_name, String | Symbol method_name, ?name_memo: Hash[untyped, untyped]) -> ([::Prism::DefNode, String] | [nil, nil])
     def user_def_site_for: (String | Symbol class_name, String | Symbol method_name) -> String?
     def user_singleton_def_site_for: (String | Symbol class_name, String | Symbol method_name) -> String?