rigortype 0.4.1 → 0.4.3

data/lib/rigor/analysis/incremental_run_slot/write_guard.rb

@@ -4,6 +4,7 @@ require "fileutils"
 require "securerandom"
 
 require_relative "../incremental_run_slot"
+require_relative "../dependency_source_inference/gem_resolver"
 require_relative "../../cache/file_digest"
 require_relative "../../cache/incremental_snapshot"
 
@@ -61,7 +62,9 @@ module Rigor
         # signature file under the configured or auto-detected `sig/` roots, or a `pre_eval:` file, changed in
         # between would leave the snapshot the run restores keyed by one tree
         # and the run reading another. From the stamp on, the lockfiles are the guard's to watch ({#admits?}), which
-        # is also what lets the slot's key, whose only file inputs they are, be computed when the run ends.
+        # is also what lets the slot's key, whose only file inputs they are, be computed when the run ends. The
+        # opted-in gems' resolved versions, the key's one input that is neither a file nor the configuration (issue
+        # #1814), are read at the mark and watched the same way.
         #
         # The mark also records which of the paths an existence row can name are present: the lockfiles, the
         # analysis roots, the `pre_eval:` entries and the signature roots.
@@ -78,10 +81,22 @@ module Rigor
           presence = (lockfiles + named.map { |path| File.absolute_path(path.to_s) }).to_h do |path|
             [path, File.exist?(path)]
           end
+          rows = dependency_rows(configuration)
+          return nil if rows.nil?
+
           new(started_ns: started_ns, device: device, lockfiles: lockfiles, presence: presence,
-              stamp_dir: stamp_dir(cache_root))
+              stamp_dir: stamp_dir(cache_root), configuration: configuration, dependency_rows: rows)
         end
 
+        # Issue #1814 — the opted-in gems' `(name, version, mode)` rows as the key carries them; nil when they cannot
+        # be resolved, which takes no mark (the key could not be computed either).
+        def self.dependency_rows(configuration)
+          DependencySourceInference::GemResolver.dependency_entries(configuration.dependencies)
+        rescue StandardError
+          nil
+        end
+        private_class_method :dependency_rows
+
         # The mark: the change time and device of the first stamp whose change time is later than that of a
         # stamp taken before it, on the same device; nil when none is written within {TICK_WAIT_LIMIT}.
         def self.stamp(cache_root)
@@ -143,17 +158,21 @@ module Rigor
         end
         private_class_method :lockfile_paths
 
-        def initialize(started_ns:, device:, lockfiles:, presence: {}, stamp_dir: nil)
+        def initialize(started_ns:, device:, lockfiles:, presence: {}, stamp_dir: nil, configuration: nil,
+                       dependency_rows: [])
           @stamp_dir = stamp_dir
           @started_ns = started_ns
           @device = device
           @lockfiles = lockfiles
           @presence = presence
+          @configuration = configuration
+          @dependency_rows = dependency_rows
         end
 
         # True when nothing the guard watches moved since the mark:
         #
-        # - no lockfile the key or the fingerprint digests was written, created or removed;
+        # - no lockfile the key or the fingerprint digests was written, created or removed, and no opted-in gem
+        #   resolves to another version than at the mark (issue #1814);
         # - no file `rows` or `pinned` names changed. A content row's file changed if its change time moved. An
         #   existence row asks only whether its path is there, so a path the mark recorded changed if it came or
         #   went, and an editor's lock file created and removed beside it, which moves its directory's change
@@ -174,7 +193,7 @@ module Rigor
         # @param rows — a {Cache::Descriptor} of the rows the key does not pin
         # @param pinned — a {Cache::Descriptor} of the rows it does
         def admits?(rows, pinned: Cache::Descriptor.new)
-          !clock_stepped_back? && @lockfiles.none? { |path| lockfile_changed?(path) } &&
+          !clock_stepped_back? && @lockfiles.none? { |path| lockfile_changed?(path) } && dependency_rows_unchanged? &&
             files_unchanged?(rows.files, strict: true) && globs_unchanged?(rows.globs, strict: true) &&
             files_unchanged?(pinned.files, strict: false) && globs_unchanged?(pinned.globs, strict: false)
         rescue StandardError
@@ -196,6 +215,12 @@ module Rigor
 
         private
 
+        # Issue #1814 — the opted-in gems resolve to the versions they did at the mark. A guard built without a
+        # configuration (the specs' bare constructor) watches none.
+        def dependency_rows_unchanged?
+          @configuration.nil? || self.class.send(:dependency_rows, @configuration) == @dependency_rows
+        end
+
         # One more stamp: a change time earlier than the mark means the clock stepped back since it was taken, so
         # a save since then may carry a change time the guard reads as before it. A stamp that cannot be written,
         # or lands on another device, cannot vouch for the clock either.

data/lib/rigor/analysis/incremental_run_slot.rb

@@ -42,8 +42,8 @@ module Rigor
     # plugin's identity and the engine's (key slots), so a project whose plugins claim template globs is served
     # too. The ADR-87 probe misses on one: the plain slot's key carries the `template-units` slot.
     #
-    # `explain:` is always false: the session's runners never set it (#1533), and the CLI declines the probe under
-    # `--explain`.
+    # `explain:` is always false: the session writes no slot for an `--explain` run (#1533), and the CLI declines
+    # the probe under `--explain`.
     module IncrementalRunSlot
       module_function
 
@@ -84,7 +84,9 @@ module Rigor
         return nil if base.nil?
 
         roots = RunCacheKey.config_entry("incremental.roots", normalize_roots(target.roots).sort.join("\n"))
-        Cache::Descriptor.new(gems: base.gems, configs: base.configs + [roots])
+        # Issue #1814 — the opted-in gems' `(name, version, mode)` rows travel with the key, as they do in the plain
+        # probe's: the gem's walked source reaches every file's answer and no analysed file records it.
+        Cache::Descriptor.new(gems: base.gems, dependencies: base.dependencies, configs: base.configs + [roots])
       end
 
       # The roots as absolute paths, which the KEY holds sorted: `lib`, `./lib` and `lib/` are one root there. A
@@ -113,7 +115,7 @@ module Rigor
       def serve(configuration:, cache_root:, paths:)
         return nil if configuration.effects_enabled?
 
-        files = PathExpansion.ruby_files(paths, configuration.exclude_patterns)
+        files = PathExpansion.ruby_files(paths, configuration.exclude_patterns, base: configuration.exclude_base)
         slot_key = key(configuration: configuration, target: Target.new(files: files, roots: paths))
         return nil if slot_key.nil?
 

data/lib/rigor/analysis/incremental_session.rb

@@ -38,7 +38,7 @@ module Rigor
       # gate) can report what was re-analyzed versus served from cache. `added` / `removed` carry the
       # structural delta so {#run_incremental} (ADR-87 WD3) can recognise a zero-change recheck and skip the
       # unconditional snapshot rewrite.
-      Recheck = Data.define(:diagnostics, :changed, :added, :removed, :affected, :reused) do
+      Recheck = Data.define(:diagnostics, :changed, :added, :removed, :affected, :reused, :templates) do
         # A recheck that changed, added, and removed nothing — the session state is byte-equivalent to the
         # snapshot that was restored, so persisting it again would only rewrite identical bytes.
         def no_change?
@@ -68,9 +68,14 @@ module Rigor
       #   `--verify-incremental` gate use) keeps the sequential recording path bit-for-bit unchanged. The fork
       #   pool records each worker's cross-file reads and marshals them back (PoolCoordinator), so the
       #   dependency graph a pooled recheck rebuilds equals the sequential one.
-      def initialize(configuration:, paths: nil, environment: nil, cache_store: nil, plugin_requirer: nil,
-                     workers: 0, buffer: nil)
+      def initialize(configuration:, paths: nil, environment: nil, cache_store: nil, plugin_requirer: nil, # rubocop:disable Metrics/ParameterLists,Metrics/AbcSize,Metrics/MethodLength
+                     workers: 0, buffer: nil, explain: false, on_file_indexed: nil)
         @configuration = configuration
+        # ADR-113 WD2 — `rigor lens`: {#force_targets=} names files a {#recheck} analyses whether or not they changed,
+        # in this process, so `on_file_indexed` (see {Runner}) sees their seeded index. Neither moves a diagnostic:
+        # a forced file re-analyses under the same seeds its cached rows were computed with.
+        @force_targets = Set.new
+        @on_file_indexed = on_file_indexed
         @paths = paths
         # Editor mode option B (#146) — the in-flight buffer, threaded into every internal Runner so the
         # pre-passes and the closure re-analysis read the editor's bytes at the logical path. A session
@@ -81,6 +86,7 @@ module Rigor
         @cache_store = cache_store
         @plugin_requirer = plugin_requirer
         @workers = workers
+        @explain = explain # #1533: threaded into every Runner; keys the snapshot, and no slot is written
         # ADR-85 WD2 — per-file discovery seed bundles keyed by logical path. A cold baseline builds them; a
         # warm recheck folds them (re-walking only changed files) and refreshes the set. Ride the snapshot.
         @seed_bundles = {}
@@ -122,12 +128,31 @@ module Rigor
         # banner + `--cache-stats`) reads after `#run_incremental`. `@last_runner` is the analysis runner the
         # post-hoc fingerprint reads from; `@plugin_fact_reusable` is the computed decision object.
         @plugin_fact_digest = nil
-        @opaque_plugin_ids = [].freeze
+        @opaque_reasons = {}.freeze
+        @fact_store_unreadable = false
         @fact_surface_invalidated = false
         @last_runner = nil
         @plugin_fact_reusable = nil
       end
 
+      # ADR-113 WD2 — the paths (as {#project_files} spells them) every later {#recheck} analyses in this process.
+      def force_targets=(paths)
+        @force_targets = paths.to_set
+      end
+
+      # The project files a run of this session analyses, as the runner expands the configured paths.
+      def project_files
+        current_files
+      end
+
+      # The per-file discovery bundles of the last run, keyed by path (ADR-85 WD2).
+      attr_reader :seed_bundles
+
+      # The project files `path`'s analysis read from at the last run that analysed it (ADR-46 slice 1).
+      def dependency_sources(path)
+        @sources.fetch(path, Set.new)
+      end
+
       # The project files analyzed at the last baseline / recheck — the set a verify pass partitions and the
       # merge subtracts the affected closure from.
       def analyzed_files
@@ -206,13 +231,13 @@ module Rigor
         fresh_params = fresh_param_table(current, changed, added, removed)
         param_files, param_pairs = param_seed_invalidation(fresh_params)
         affected = affected_closure(changed, added, removed, param_files, param_pairs)
-        analyze_set = affected & current
-        reused = (current & previous) - affected.to_a
+        forced, analyze_set = forced_analyze_set(affected, current)
+        reused = (current & previous) - analyze_set.to_a
         # The freshly collected table is handed to the runner so the run seeds from the SAME table the diff
         # was decided on (and the collector runs once per recheck, not twice). The reused files' cached rows
         # go in too, so the runner lists them in the full run's file order (#1524).
         runner = build_runner(analyze_only: analyze_set, record_dependencies: true,
-                              param_inferred_types: fresh_params,
+                              param_inferred_types: fresh_params, **forced_target_options(forced),
                               restored_run_level_rows: @run_level_rows,
                               served_per_file_diagnostics: @cache.slice(*reused))
         merged = run_runner(runner).diagnostics
@@ -220,7 +245,8 @@ module Rigor
         absorb(runner, current, analyze_set, removed)
         @param_table = fresh_params
         Recheck.new(diagnostics: merged, changed: changed.to_set, added: added.to_set,
-                    removed: removed.to_set, affected: affected, reused: reused.to_set)
+                    removed: removed.to_set, affected: affected, reused: reused.to_set,
+                    templates: runner.template_unit_paths.size)
       end
 
       # Editor mode option B (#146) — a whole-project recheck with the editor's buffer substituted for one
@@ -480,6 +506,7 @@ module Rigor
       # to. Every soundness gate below — the fingerprint, the ADR-88 fact surface — is unchanged, so the
       # decision to reuse is made identically whether or not the result is saved.
       def run_incremental(snapshot:, fingerprint:, persist: true)
+        @last_recheck = nil # #1526 — set only by a warm recheck, see {#last_recheck}
         # ADR-87 WD1 — install the per-run digest table + recording instant + strict flag for the whole
         # invocation so change-detection's stat-then-digest freshness (`#pack_digest` / `#stat_fresh?`) honours
         # `cache.validation: digest` (and `RIGOR_STRICT_VALIDATION`, which the env-only path already sees) and
@@ -508,7 +535,7 @@ module Rigor
             adopt_plugin_fact_fingerprint
             fact_reusable = @plugin_fact_reusable.reusable_against?(restored.plugin_fact_digest)
             if fact_reusable && effects_reusable && !source_rbs_unverified?(result)
-              diagnostics = result.diagnostics
+              diagnostics = keep_recheck(result)
               warm = true
               # ADR-87 WD3 — a warm recheck that changed nothing leaves the session state byte-equivalent to the
               # snapshot it restored, so skip the unconditional rewrite (209ms + 2 MB on gitlab per null recheck).
@@ -539,9 +566,36 @@ module Rigor
 
       # ADR-88 WD1 — reporting hooks the CLI reads after {#run_incremental}. `fact_surface_invalidated?` is true
       # when a valid snapshot was dropped for a fact-surface reason (a plugin sig/catalog edit, or an opaque
-      # plugin) rather than a cold miss. `opaque_plugin_ids` names the contributing-but-surfaceless plugins that
-      # force a full run every invocation.
-      attr_reader :opaque_plugin_ids
+      # plugin) rather than a cold miss. `opaque_reasons` maps each plugin that forces a full run every invocation
+      # to its {PluginFactFingerprint::OpaqueReason}.
+      attr_reader :opaque_reasons
+
+      # #1526 — the {Recheck} of the last {#run_incremental}, or nil unless that run answered warm. A baseline
+      # (cold, or a re-baseline after a fact-surface, effects or source-RBS reason) has no recheck to report.
+      # The diagnostics are not kept: a long-lived session (the LSP) would otherwise retain every merged list.
+      attr_reader :last_recheck
+
+      # Records the warm recheck's sets for {#last_recheck} and hands back its diagnostics.
+      def keep_recheck(result)
+        @last_recheck = result.with(diagnostics: [])
+        result.diagnostics
+      end
+      private :keep_recheck
+
+      # The opaque plugin ids, sorted (the keys of {#opaque_reasons}).
+      def opaque_plugin_ids
+        @opaque_reasons.keys
+      end
+
+      # True when the fact store could not be read, so no single plugin is named (see {PluginFactFingerprint::Result}).
+      def fact_store_unreadable?
+        @fact_store_unreadable
+      end
+
+      # True when the fact surface forces a full run: some plugin is opaque, or the fact store is unreadable.
+      def opaque_fact_surface?
+        !@opaque_reasons.empty? || @fact_store_unreadable
+      end
 
       def fact_surface_invalidated?
         @fact_surface_invalidated
@@ -566,7 +620,8 @@ module Rigor
         registry = prepared_plugin_registry
         fact = compute_plugin_fact_fingerprint(registry)
         @plugin_fact_digest = fact.digest
-        @opaque_plugin_ids = fact.opaque_plugin_ids
+        @opaque_reasons = fact.opaque_reasons
+        @fact_store_unreadable = fact.fact_store_unreadable
         @plugin_fact_reusable = fact
         @seed_bundles = source_rbs_gate.verify(registry, @seed_bundles)
       end
@@ -596,10 +651,10 @@ module Rigor
 
       # ADR-88 WD1 — the plugin fact-surface fingerprint for this invocation. For a SEQUENTIAL run it is read
       # post-hoc from the analysis runner's already-prepared registry (no second `#prepare`, producers already
-      # validated during analysis). A POOLED run's main process skips `#prepare`, so its registry carries no
-      # published facts — there it falls back to the always-sequential probe. Both paths compute the identical
-      # digest for a given fact surface, so the reuse decision is worker-count-independent (the parity spec
-      # asserts this).
+      # validated during analysis). A POOLED run's main process does not run `#prepare` on it (its workers do),
+      # so its registry carries no published facts — there it falls back to the always-sequential probe. Both
+      # paths compute the identical digest for a given fact surface, so the reuse decision is worker-count-independent
+      # (the parity spec asserts this).
       def compute_plugin_fact_fingerprint(registry = prepared_plugin_registry)
         PluginFactFingerprint.from_registry(registry)
       end
@@ -710,7 +765,8 @@ module Rigor
         return nil if fingerprint.nil? || @cache_store.nil? || @cache_store.read_only? || !@buffer.nil?
         # Known before the run: none of these can be written afterwards, so the stamp and the recomputed
         # fingerprint would be spent for nothing.
-        return nil unless @workers.zero? && !@configuration.effects_enabled?
+        # `WriteGuard.start` would also refuse (it recomputes the fingerprint without `explain:`); say so here.
+        return nil unless @workers.zero? && !@configuration.effects_enabled? && !@explain
 
         IncrementalRunSlot::WriteGuard.start(
           configuration: @configuration, roots: @paths || @configuration.paths, cache_root: @cache_store.root,
@@ -724,7 +780,7 @@ module Rigor
       # cold, not the warm run the probe stands in for.
       def run_slot_writable?
         !@cache_store.nil? && !@cache_store.read_only? && @buffer.nil? && @workers.zero? &&
-          !@configuration.effects_enabled? && @opaque_plugin_ids.empty? && !@last_runner.nil?
+          !@configuration.effects_enabled? && !@explain && !opaque_fact_surface? && !@last_runner.nil?
       end
 
       def start_chain(rows)
@@ -1090,12 +1146,24 @@ module Rigor
           changed + removed, @constant_decls, new_constant_decls
         )
         keys = appeared_methods.map { |symbol| negative_key_for(symbol) }
-        keys.concat(moved_classes.map { |klass| "class:#{klass.split('::').last}" })
+        keys.concat(class_move_keys(moved_classes))
         keys.concat(moved_constants.map { |name| "constant:#{name.split('::').last}" })
         Incremental.negative_closure(keys, @negative_dependents) | refinement_affected(changed + removed, summary) |
           global_write_reporters
       end
 
+      # The negative keys a class-declaration diff fires: `class:<last segment>` for a class name, and (issue #1820)
+      # `subclass_of:<last segment of the superclass>` for a `[class, superclass]` pair appearing or vanishing. Any
+      # class declaration moving may move the set of classes whose superclass the tables do not know, which
+      # `subclass_of:*` stands for.
+      def class_move_keys(moved)
+        names, edges = moved.partition { |entry| entry.is_a?(String) }
+        keys = names.map { |klass| "class:#{klass.split('::').last}" }
+        keys.concat(edges.map { |(_child, parent)| "subclass_of:#{parent.split('::').last}" })
+        keys << "subclass_of:*" unless moved.empty?
+        keys
+      end
+
       # Issue #1120 — the consumers whose `call.undefined-method` answer read the refinement table for a method
       # name whose refinements moved in this edit. The before-state is each file's seed bundle (the per-file
       # table the last run recorded), the after-state the scan's per-file tables. A refine body is not a class's
@@ -1115,9 +1183,10 @@ module Rigor
         return {} if index.nil?
 
         result = Hash.new { |hash, key| hash[key] = Set.new }
-        index[:class_sources].each do |class_name, files|
-          files.each { |file| result[file] << class_name }
+        [index[:class_sources], index[:singleton_class_sources] || {}].each do |sources|
+          sources.each { |class_name, files| files.each { |file| result[file] << class_name } }
         end
+        Incremental.add_superclass_edges(result, index[:class_sources], index[:superclasses])
         result.transform_values(&:freeze).freeze
       end
 
@@ -1256,10 +1325,21 @@ module Rigor
         Runner.new(
           configuration: @configuration, cache_store: @cache_store, environment: @environment,
           plugin_requirer: @plugin_requirer, seed_bundles: @seed_bundles, collect_seed_bundles: true,
-          workers: @workers, buffer: @buffer, **
+          workers: @workers, buffer: @buffer, explain: @explain, on_file_indexed: @on_file_indexed, **
         )
       end
 
+      # The forced targets present in `current`, and the recheck's analyse set with them joined to the closure.
+      def forced_analyze_set(affected, current)
+        forced = @force_targets & current.to_set
+        [forced, (affected | forced) & current]
+      end
+
+      # A recheck that forces targets analyses in this process, so the index callback reaches them.
+      def forced_target_options(forced)
+        forced.empty? ? {} : { workers: 0 }
+      end
+
       # Run the runner over the session's explicit paths (or, when none were given, the configuration's
       # `paths:` via `Runner#run`'s default).
       def run_runner(runner)

data/lib/rigor/analysis/path_expansion.rb

@@ -14,10 +14,10 @@ module Rigor
       module_function
 
       # The `.rb` files an ordinary (non-buffer) check over `paths` would analyze.
-      def ruby_files(paths, exclude_patterns)
+      def ruby_files(paths, exclude_patterns, base: Dir.pwd)
         Array(paths).flat_map do |path|
           if File.directory?(path)
-            directory_files(path, exclude_patterns)
+            directory_files(path, exclude_patterns, base: base)
           elsif File.file?(path) && path.end_with?(".rb")
             [path]
           else
@@ -26,16 +26,72 @@ module Rigor
         end
       end
 
-      def directory_files(dir, exclude_patterns)
-        reject_excluded(Dir.glob(File.join(dir, RUBY_GLOB)), exclude_patterns)
+      def directory_files(dir, exclude_patterns, base: Dir.pwd)
+        reject_excluded(Dir.glob(File.join(dir, RUBY_GLOB)), exclude_patterns, base: base)
       end
 
       # `exclude_patterns` are matched with `File.fnmatch?` WITHOUT `FNM_PATHNAME`, so `**`/`*` span separators
       # (the patterns behave like substring globs) — the exact semantics the Runner's directory glob applies.
-      def reject_excluded(file_list, exclude_patterns)
+      #
+      # #1576 — a RELATIVE pattern (a leading `./` is ignored) is matched against the file's path relative to
+      # `base` (the config file's directory, or the working directory with no config), so the same file is
+      # excluded whether `paths:` (absolute) or an argument (relative) named it.
+      #
+      # Two spellings are tried. The LOGICAL one (the path as given, against the logical base) counts only when
+      # the file lies inside the base; it is what lets a symlinked `lib` match `lib/gen/**`. The REALPATH one
+      # (realpath of the file against realpath of the base) is the only one used for a file outside the base, and
+      # it also catches a base or file spelled through a different symlink root (macOS `/tmp` vs `/private/tmp`).
+      # Neither shows a directory name above the base: a file outside it comes out as `../…`, so `**/tmp/**`
+      # cannot exclude a project merely located under a `tmp/`, while `**/vendor/bundle/**` still reaches
+      # `../other/vendor/bundle/x.rb`. The pattern is also tried against `/<relative>`, because without
+      # `FNM_PATHNAME` the unanchored `**/tmp/**` needs a leading `/` to match a top-level `tmp/x.rb` (and `*`
+      # never matches a leading `.`, as in `../other`). A pattern starting with `.` therefore also matches files
+      # outside the base. An ABSOLUTE pattern is matched only against the absolute path (logical, then real).
+      def reject_excluded(file_list, exclude_patterns, base: Dir.pwd)
         return file_list if exclude_patterns.empty?
 
-        file_list.reject { |path| exclude_patterns.any? { |pattern| File.fnmatch?(pattern, path) } }
+        absolute_patterns, relative_patterns = exclude_patterns.partition { |pattern| pattern.start_with?("/") }
+        relative_patterns = relative_patterns.map { |pattern| pattern.sub(%r{\A(?:\./+)+}, "") }
+        logical_base = File.absolute_path(base)
+        context = { cwd: Dir.pwd, base: logical_base, real_base: real_directory(logical_base), real_dirs: {} }
+        file_list.reject { |path| excluded?(path, absolute_patterns, relative_patterns, context) }
+      end
+
+      def excluded?(path, absolute_patterns, relative_patterns, context)
+        logical = File.absolute_path(path, context.fetch(:cwd))
+        base = context.fetch(:base)
+        inside = logical.start_with?("#{base}/")
+        return true if inside && matches_relative?(relative_patterns, logical.byteslice((base.bytesize + 1)..))
+        return true if absolute_patterns.any? { |pattern| File.fnmatch?(pattern, logical) }
+
+        real = real_file(logical, context.fetch(:real_dirs))
+        return false if real == logical && inside && context.fetch(:real_base) == base
+
+        matches_relative?(relative_patterns, relative_path(real, context.fetch(:real_base))) ||
+          (real != logical && absolute_patterns.any? { |pattern| File.fnmatch?(pattern, real) })
+      end
+
+      def relative_path(absolute, base)
+        return absolute.byteslice((base.bytesize + 1)..) if absolute.start_with?("#{base}/")
+
+        Pathname.new(absolute).relative_path_from(Pathname.new(base)).to_s
+      end
+
+      def matches_relative?(patterns, relative)
+        candidates = [relative, "/#{relative}"]
+        patterns.any? { |pattern| candidates.any? { |candidate| File.fnmatch?(pattern, candidate) } }
+      end
+
+      def real_directory(dir)
+        File.realpath(dir)
+      rescue SystemCallError
+        File.absolute_path(dir)
+      end
+
+      def real_file(absolute, real_dirs)
+        dir = File.dirname(absolute)
+        real_dir = real_dirs[dir] ||= real_directory(dir)
+        File.join(real_dir, File.basename(absolute))
       end
     end
   end