fast_cov 0.2.1 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d41bffc0dc2cbd1cf3d92d8296c61318b544f4a53d2709868cecc7ff1013cbb
-  data.tar.gz: 75896a982a456bc9715a1f62895e295ad969afb99069e0781cb21d670ed4a4ae
+  metadata.gz: ba4073b332a0c7f0837d5cf954b9ad98353721e6350c24969541819a42a27c65
+  data.tar.gz: c85de804a17e0f1bd7b21a370e61dbe0d59dc2bb5ce02d84f827c500d6816b5a
 SHA512:
-  metadata.gz: 30a3b33ddca11202bdc7dfd138d847d0cc0d2366ba3915f57a5063e157ee756661da5599bcbd1348d2a9723cd89f6f3ed21acc57da2ea497f3005d4aed70429a
-  data.tar.gz: 3ac7f28ac5e49176cd7e3c8373f8b8fa5a1375fd9a2561d5d348c3081246f24c71a65b275c306a675555235d7e9caeaaaf2df4ccda83508ecc2d4f95a1c1f8cc
+  metadata.gz: f080c26c0a0813a10555885ac162e7662519641501d5d499bebbb1315414ba3469770ac66d95576d6209cc7e9c8b4181fa43c6a729c3d4ccd2c282a1394a86f6
+  data.tar.gz: 0ff5f9c3053015028416a2d5190785542abf1bfe0ce6fe2c0d8dae5ab16e555419f5a8b350980119ebf87065b1166b5f700f6131c582c4df9c36b5eb3a0b5f8e

data/README.md

@@ -121,6 +121,48 @@ cov = FastCov::Coverage.new(
 
 This API is mainly useful for internal use and low-level tests. `CoverageMap` is the intended public orchestration API.
 
+## StaticMap
+
+`FastCov::StaticMap` is a build-time API for static dependency mapping. It parses Ruby files with Prism, resolves literal constant references, and builds a direct dependency graph. Transitive closures are computed lazily on demand.
+
+```ruby
+static_map = FastCov::StaticMap.new(root: Rails.root)
+static_map.build("spec/**/*_spec.rb")
+
+# Direct dependencies for a single file
+static_map.dependencies("/app/spec/models/user_spec.rb")
+# => ["/app/app/models/user.rb"]
+
+# Transitive closure (computed and cached on first call)
+static_map.transitive_dependencies("/app/spec/models/user_spec.rb")
+# => ["/app/app/models/account.rb", "/app/app/models/user.rb"]
+
+# Raw direct graph
+static_map.direct_graph
+# => { "/app/spec/models/user_spec.rb" => ["/app/app/models/user.rb"], ... }
+```
+
+The instance caches constant resolution results, so reusing the same instance across multiple `build` calls is efficient.
+
+#### Options
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `root` | String or Pathname | required | Absolute project root. Only resolved files under this path are included. |
+| `ignored_paths` | String or Array<String> | `[]` | Files or directories to exclude from the graph and recursive traversal. |
+| `*patterns` (on `build`) | String(s) or Array | required | File paths or globs to traverse. Relative paths are expanded against `root`. |
+
+#### How it works
+
+- `build` traverses reachable files and stores a direct dependency graph
+- `dependencies` returns direct dependencies for a file
+- `transitive_dependencies` computes and caches the transitive closure lazily
+- Constant resolution results are cached and reused across `build` calls
+- Resolves each reference from most-specific lexical candidate to least-specific
+- Uses `const_defined?` and `const_source_location` to resolve literal constant references to source files
+
+This is intended for a booted application process. It requires constants to be eager-loaded. It will not see dynamic constant lookups that are not expressed as literal constants in the source.
+
 ## Writing custom trackers
 
 There are two approaches: a minimal custom tracker, or inheriting from `AbstractTracker`.
@@ -167,7 +209,7 @@ class MyTracker < FastCov::AbstractTracker
 
   module MyPatch
     def some_method(...)
-      MyTracker.record(some_file_path)
+      MyTracker.record { some_file_path }
       super
     end
   end

data/ext/fast_cov/fast_cov.c

@@ -140,80 +140,6 @@ static void on_line_event(rb_event_flag_t event, VALUE self_data, VALUE self,
   record_impacted_file(data, filename);
 }
 
-// ---- Utils module methods (FastCov::Utils) ------------------------------
-
-// Utils.path_within?(path, directory) -> true/false
-// Check if path is within directory, correctly handling:
-// - Trailing slashes on directory
-// - Sibling directories with longer names (e.g., /a/b/c vs /a/b/cd)
-static VALUE utils_path_within(VALUE self, VALUE path, VALUE directory) {
-  Check_Type(path, T_STRING);
-  Check_Type(directory, T_STRING);
-
-  // Freeze strings to prevent GC compaction from moving them
-  rb_str_freeze(path);
-  rb_str_freeze(directory);
-
-  bool result = fast_cov_is_within_root(
-      RSTRING_PTR(path), RSTRING_LEN(path),
-      RSTRING_PTR(directory), RSTRING_LEN(directory));
-
-  return result ? Qtrue : Qfalse;
-}
-
-// Utils.relativize_paths(set, root) -> set
-// Mutates set in place: converts absolute paths to relative paths from root.
-// Paths not within root are left unchanged.
-static VALUE utils_relativize_paths(VALUE self, VALUE set, VALUE root) {
-  Check_Type(root, T_STRING);
-
-  // Freeze root to prevent GC from moving it during compaction
-  rb_str_freeze(root);
-
-  const char *root_ptr = RSTRING_PTR(root);
-  long root_len = RSTRING_LEN(root);
-
-  // Normalize: strip trailing slash for offset calculation
-  long effective_root_len = root_len;
-  if (effective_root_len > 0 && root_ptr[effective_root_len - 1] == '/') {
-    effective_root_len--;
-  }
-
-  // Collect paths to transform (can't modify set while iterating)
-  VALUE paths = rb_funcall(set, rb_intern("to_a"), 0);
-  long num_paths = RARRAY_LEN(paths);
-
-  for (long i = 0; i < num_paths; i++) {
-    VALUE abs_path = rb_ary_entry(paths, i);
-    if (!RB_TYPE_P(abs_path, T_STRING)) continue;
-
-    // Freeze to prevent GC moving it
-    rb_str_freeze(abs_path);
-
-    const char *path_ptr = RSTRING_PTR(abs_path);
-    long path_len = RSTRING_LEN(abs_path);
-
-    // Use proper within_root check
-    if (!fast_cov_is_within_root(path_ptr, path_len, root_ptr, root_len)) {
-      continue;
-    }
-
-    // Calculate offset (skip root + separator)
-    long offset = effective_root_len;
-    if (offset < path_len && path_ptr[offset] == '/') offset++;
-
-    // Create relative path
-    VALUE rel_path = rb_str_substr(abs_path, offset, path_len - offset);
-
-    // Delete old path, add new path
-    rb_funcall(set, rb_intern("delete"), 1, abs_path);
-    rb_funcall(set, rb_intern("add"), 1, rel_path);
-  }
-
-  RB_GC_GUARD(paths);
-  return set;
-}
-
 // ---- Ruby instance methods ----------------------------------------------
 
 static VALUE fast_cov_initialize(int argc, VALUE *argv, VALUE self) {
@@ -366,8 +292,4 @@ void Init_fast_cov(void) {
   rb_define_method(cCoverage, "start", fast_cov_start, 0);
   rb_define_method(cCoverage, "stop", fast_cov_stop, 0);
 
-  // FastCov::Utils module (C-defined methods)
-  VALUE mUtils = rb_define_module_under(mFastCov, "Utils");
-  rb_define_module_function(mUtils, "path_within?", utils_path_within, 2);
-  rb_define_module_function(mUtils, "relativize_paths", utils_relativize_paths, 2);
 }

data/lib/fast_cov/coverage_map.rb

@@ -52,11 +52,21 @@ module FastCov
       self
     end
 
-    def start
-      if @started
-        raise "CoverageMap is already started" if block_given?
-        return self
+    def build
+      raise ArgumentError, "build requires a block" unless block_given?
+      raise "CoverageMap is already started" if @started
+
+      start
+      begin
+        yield
+      ensure
+        result = stop
       end
+      result
+    end
+
+    def start
+      return self if @started
 
       begin
         @native_coverage = Coverage.new(
@@ -72,17 +82,7 @@ module FastCov
         raise
       end
 
-      if block_given?
-        result = nil
-        begin
-          yield
-        ensure
-          result = stop
-        end
-        result
-      else
-        self
-      end
+      self
     end
 
     def stop
@@ -142,7 +142,7 @@ module FastCov
     end
 
     def absolute_path?(path)
-      File.absolute_path?(path.to_s)
+      File.absolute_path?(path)
     end
 
     def normalize_path(path)

data/lib/fast_cov/static_map/reference_extractor.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require "prism"
+
+module FastCov
+  class StaticMap
+    module ReferenceExtractor
+      class << self
+        def extract(filename)
+          result = Prism.parse_file(filename)
+          return FastCov::StaticMap::EMPTY_ARRAY unless result.success?
+
+          reference_groups = []
+          seen_groups = {}
+          collect_constants(result.value, reference_groups, seen_groups, [])
+
+          reference_groups.map do |group|
+            group.map { |const_name| -const_name }.freeze
+          end.freeze
+        end
+
+        private
+
+        def collect_constants(node, reference_groups, seen_groups, nesting_prefixes)
+          case node
+          when Prism::ModuleNode
+            module_name = constant_name_for_nesting(node.constant_path)
+            next_prefixes = next_nesting_prefixes(nesting_prefixes, module_name)
+            node.body&.compact_child_nodes&.each do |child|
+              collect_constants(child, reference_groups, seen_groups, next_prefixes)
+            end
+            return
+          when Prism::ClassNode
+            class_name = constant_name_for_nesting(node.constant_path)
+            next_prefixes = next_nesting_prefixes(nesting_prefixes, class_name)
+            add_with_nesting(node.superclass, reference_groups, seen_groups, nesting_prefixes) if node.superclass
+            node.body&.compact_child_nodes&.each do |child|
+              collect_constants(child, reference_groups, seen_groups, next_prefixes)
+            end
+            return
+          when Prism::SingletonClassNode
+            node.body&.compact_child_nodes&.each do |child|
+              collect_constants(child, reference_groups, seen_groups, nesting_prefixes)
+            end
+            return
+          when Prism::ConstantPathNode
+            add_with_nesting(node, reference_groups, seen_groups, nesting_prefixes)
+            return
+          when Prism::ConstantReadNode
+            add_reference_group(
+              expand_with_nesting(node.name.to_s, nesting_prefixes),
+              reference_groups,
+              seen_groups
+            )
+            return
+          end
+
+          node.compact_child_nodes.each do |child|
+            collect_constants(child, reference_groups, seen_groups, nesting_prefixes)
+          end
+        end
+
+        def add_with_nesting(node, reference_groups, seen_groups, nesting_prefixes)
+          candidates = candidates_for_node(node, nesting_prefixes)
+          add_reference_group(candidates, reference_groups, seen_groups)
+        end
+
+        def candidates_for_node(node, nesting_prefixes)
+          case node
+          when Prism::ConstantPathNode
+            path = resolve_constant_path(node)
+            return FastCov::StaticMap::EMPTY_ARRAY unless path
+
+            if path.start_with?("::")
+              [path.delete_prefix("::")]
+            else
+              expand_with_nesting(path, nesting_prefixes)
+            end
+          when Prism::ConstantReadNode
+            expand_with_nesting(node.name.to_s, nesting_prefixes)
+          else
+            FastCov::StaticMap::EMPTY_ARRAY
+          end
+        end
+
+        def add_reference_group(candidates, reference_groups, seen_groups)
+          return if candidates.empty?
+
+          key = candidates.join("\0")
+          return if seen_groups[key]
+
+          seen_groups[key] = true
+          reference_groups << candidates
+        end
+
+        def expand_with_nesting(const_name, nesting_prefixes)
+          candidates = []
+          seen_candidates = {}
+
+          nesting_prefixes.reverse_each do |prefix|
+            add_unique("#{prefix}::#{const_name}", candidates, seen_candidates)
+          end
+
+          add_unique(const_name, candidates, seen_candidates)
+          candidates
+        end
+
+        def next_nesting_prefixes(nesting_prefixes, nested_name)
+          return nesting_prefixes unless nested_name
+
+          if nesting_prefixes.empty?
+            [nested_name]
+          else
+            nesting_prefixes + ["#{nesting_prefixes.last}::#{nested_name}"]
+          end
+        end
+
+        def constant_name_for_nesting(node)
+          case node
+          when Prism::ConstantPathNode
+            resolve_constant_path(node)&.delete_prefix("::")
+          when Prism::ConstantReadNode
+            node.name.to_s
+          end
+        end
+
+        def add_unique(const_name, constants, seen)
+          return if seen[const_name]
+
+          seen[const_name] = true
+          constants << const_name
+        end
+
+        def resolve_constant_path(node)
+          parts = []
+          current = node
+
+          while current.is_a?(Prism::ConstantPathNode)
+            parts.unshift(current.name.to_s)
+            current = current.parent
+          end
+
+          if current.is_a?(Prism::ConstantReadNode)
+            parts.unshift(current.name.to_s)
+          elsif current.nil?
+            return "::#{parts.join("::")}"
+          else
+            return nil
+          end
+
+          parts.join("::")
+        end
+      end
+    end
+  end
+end

data/lib/fast_cov/static_map.rb

@@ -0,0 +1,257 @@
+# frozen_string_literal: true
+
+module FastCov
+  class StaticMap
+    EMPTY_ARRAY = [].freeze
+
+    autoload :ReferenceExtractor, File.expand_path("static_map/reference_extractor", __dir__)
+
+    def initialize(root:, ignored_paths: [], concurrency: Etc.nprocessors)
+      @root = share_path(root)
+      @root_prefix = -"#{@root}/"
+      @ignored_paths = normalize_ignored_paths(ignored_paths)
+      @concurrency = concurrency
+      @resolved_file_by_const = {}
+      @closure_by_file = {}
+      @graph = {}
+    end
+
+    def build(*patterns)
+      input_files = expand_files(patterns.flatten).select { |file| processable_file?(file) }
+
+      queue = input_files.dup
+      processed = {}
+
+      until queue.empty?
+        to_process = queue.reject { |f| processed[f] }
+        break if to_process.empty?
+
+        to_process.each { |f| processed[f] = true }
+        queue.clear
+
+        # Stage 1: Parse files (parallel)
+        parsed = parse_files(to_process)
+
+        # Stage 2: Resolve unique constants (sequential — GVL-bound)
+        resolve_candidates(parsed)
+
+        # Stage 3: Build graph edges, discover new files
+        parsed.each do |file, groups|
+          deps = resolve_dependencies(file, groups)
+          relative_file = relativize(file)
+          @graph[relative_file] = deps.empty? ? EMPTY_ARRAY : deps.map { |d| relativize(d) }.freeze
+
+          deps.each do |dep|
+            queue << dep unless processed[dep]
+          end
+        end
+      end
+
+      input_files.flat_map { |file| dependencies(file) }.uniq
+    end
+
+    def direct_graph
+      @graph
+    end
+
+    def direct_dependencies(file)
+      @graph.fetch(relativize_input(file), EMPTY_ARRAY)
+    end
+
+    def dependencies(file)
+      file = relativize_input(file)
+      resolve_transitive_dependencies(file)
+    end
+
+    private
+
+    attr_reader :closure_by_file, :ignored_paths, :resolved_file_by_const, :root
+
+    def parse_files(files)
+      if @concurrency > 1 && files.size > 1
+        parse_files_parallel(files)
+      else
+        parse_files_sequential(files)
+      end
+    end
+
+    def parse_files_sequential(files)
+      parsed = {}
+      files.each { |f| parsed[f] = ReferenceExtractor.extract(f) }
+      parsed
+    end
+
+    def parse_files_parallel(files)
+      parsed = {}
+      mutex = Mutex.new
+      slice_size = [files.size / @concurrency + 1, 1].max
+
+      files.each_slice(slice_size).map do |slice|
+        Thread.new(slice) do |thread_files|
+          local = {}
+          thread_files.each { |f| local[f] = ReferenceExtractor.extract(f) }
+          mutex.synchronize { parsed.merge!(local) }
+        end
+      end.each(&:join)
+
+      parsed
+    end
+
+    def resolve_candidates(parsed)
+      parsed.each_value do |groups|
+        groups.each do |candidates|
+          candidates.each do |const_name|
+            next if resolved_file_by_const.key?(const_name)
+
+            resolve_constant_file(const_name)
+          end
+        end
+      end
+    end
+
+    def resolve_dependencies(file, groups)
+      deps = {}
+
+      groups.each do |candidates|
+        resolved_file = resolve_reference_group(candidates)
+        next unless resolved_file
+        next if resolved_file == file
+
+        deps[resolved_file] = true
+      end
+
+      deps.empty? ? EMPTY_ARRAY : deps.keys.sort.freeze
+    end
+
+    def resolve_reference_group(candidates)
+      candidates.each do |const_name|
+        file = resolved_file_by_const[const_name]
+        return file if file && include_path?(file)
+      end
+
+      nil
+    end
+
+    def resolve_transitive_dependencies(file)
+      cached = closure_by_file[file]
+      return cached if cached
+
+      visiting = {}
+      stack = [[file, :enter]]
+
+      until stack.empty?
+        current_file, state = stack.pop
+
+        if state == :exit
+          dependencies = {}
+
+          @graph.fetch(current_file, EMPTY_ARRAY).each do |dependency_file|
+            dependencies[dependency_file] = true
+
+            closure_by_file.fetch(dependency_file, EMPTY_ARRAY).each do |transitive_dependency|
+              dependencies[transitive_dependency] = true
+            end
+          end
+
+          dependencies.delete(current_file)
+          closure_by_file[current_file] = dependencies.empty? ? EMPTY_ARRAY : dependencies.keys.sort.freeze
+          visiting.delete(current_file)
+          next
+        end
+
+        next if closure_by_file.key?(current_file)
+        next if visiting[current_file]
+
+        visiting[current_file] = true
+        stack << [current_file, :exit]
+
+        @graph.fetch(current_file, EMPTY_ARRAY).reverse_each do |dependency_file|
+          next if closure_by_file.key?(dependency_file)
+          next if visiting[dependency_file]
+
+          stack << [dependency_file, :enter]
+        end
+      end
+
+      closure_by_file.fetch(file, EMPTY_ARRAY)
+    end
+
+    def resolve_constant_file(const_name)
+      return nil unless constant_defined?(const_name)
+
+      source_location = Object.const_source_location(const_name)
+      file = source_location&.first
+      return nil unless file && File.file?(file)
+
+      resolved_file_by_const[const_name] = share_path(file)
+    rescue StandardError
+      nil
+    end
+
+    def constant_defined?(const_name)
+      current = Object
+
+      const_name.split("::").each do |segment|
+        return false unless current.const_defined?(segment, false)
+
+        current = current.const_get(segment, false)
+      end
+
+      true
+    rescue StandardError
+      false
+    end
+
+    def include_path?(path)
+      return false unless FastCov::Utils.path_within?(path, root)
+
+      ignored_paths.none? { |ignored_path| FastCov::Utils.path_within?(path, ignored_path) }
+    end
+
+    def processable_file?(file)
+      File.file?(file) && include_path?(file)
+    end
+
+    def expand_files(patterns)
+      Array(patterns)
+        .flat_map do |pattern|
+          pattern = pattern.to_s
+          pattern = File.expand_path(pattern, root) unless File.absolute_path?(pattern)
+          Dir.glob(pattern)
+        end
+        .map { |path| share_path(path) }
+        .uniq
+        .sort
+    end
+
+    def normalize_ignored_paths(ignored_paths)
+      Array(ignored_paths)
+        .compact
+        .map { |path| share_path(File.expand_path(path, root)) }
+        .uniq
+        .sort
+        .freeze
+    end
+
+    def relativize(absolute_path)
+      share_string(absolute_path.delete_prefix(@root_prefix))
+    end
+
+    def relativize_input(file)
+      path = file.to_s
+      if File.absolute_path?(path)
+        relativize(path)
+      else
+        share_string(path)
+      end
+    end
+
+    def share_path(path)
+      share_string(File.expand_path(path.to_s))
+    end
+
+    def share_string(string)
+      -string.to_s
+    end
+  end
+end

data/lib/fast_cov/trackers/abstract_tracker.rb

@@ -21,6 +21,10 @@ module FastCov
       @started_thread = nil
     end
 
+    def root
+      @coverage_map.root
+    end
+
     # Public API - called by FastCov framework
 
     def start
@@ -70,12 +74,12 @@ module FastCov
     class << self
       attr_accessor :active
 
-      def record(to: nil)
+      def record(path, to: nil)
         return unless active
-        return unless block_given?
+        return unless path
 
-        path = yield
-        active.record(path, to: to) if path
+        to ||= Utils.resolve_caller(caller_locations(1, 20), active.root)
+        active.record(path, to: to)
       end
 
       def reset

data/lib/fast_cov/trackers/const_get_tracker.rb

@@ -23,9 +23,8 @@ module FastCov
 
     module ConstGetPatch
       def const_get(name, inherit = true)
-        source = caller_locations(1, 1).first&.absolute_path
         result = super
-        FastCov::ConstGetTracker.record(to: source) { const_source_location(name, inherit)&.first }
+        FastCov::ConstGetTracker.record(const_source_location(name, inherit)&.first)
         result
       end
     end

data/lib/fast_cov/trackers/factory_bot_tracker.rb

@@ -42,7 +42,7 @@ module FastCov
           next unless block.is_a?(Proc)
 
           location = block.source_location
-          record { location&.first }
+          record(location&.first)
         end
       end
     end

data/lib/fast_cov/trackers/file_tracker.rb

@@ -4,21 +4,27 @@ require_relative "abstract_tracker"
 
 module FastCov
   # Tracks files read from disk during coverage (JSON, YAML, .rb templates, etc.)
-  # via File.read and File.open.
+  # via File.read, File.open, and YAML load methods.
+  #
+  # YAML methods are patched separately because Bootsnap's compile cache
+  # overrides YAML.load_file/safe_load_file to bypass File.open entirely.
   #
   # Register via: coverage_map.use(FastCov::FileTracker)
   class FileTracker < AbstractTracker
     def install
-      return if File.singleton_class.ancestors.include?(FilePatch)
+      unless File.singleton_class.ancestors.include?(FilePatch)
+        File.singleton_class.prepend(FilePatch)
+      end
 
-      File.singleton_class.prepend(FilePatch)
+      if defined?(::YAML) && !::YAML.singleton_class.ancestors.include?(YamlPatch)
+        ::YAML.singleton_class.prepend(YamlPatch)
+      end
     end
 
     module FilePatch
       def read(name, *args, **kwargs, &block)
-        source = caller_locations(1, 1).first&.absolute_path
         super.tap do
-          FastCov::FileTracker.record(to: source) { File.expand_path(name) }
+          FastCov::FileTracker.record(File.expand_path(name))
         end
       end
 
@@ -26,9 +32,28 @@ module FastCov
         mode = args[0]
         is_read = mode.nil? || (mode.is_a?(String) && mode.start_with?("r")) ||
                   (mode.is_a?(Integer) && (mode & (File::WRONLY | File::RDWR)).zero?)
-        source = caller_locations(1, 1).first&.absolute_path
         super.tap do
-          FastCov::FileTracker.record(to: source) { File.expand_path(name) } if is_read
+          FastCov::FileTracker.record(File.expand_path(name)) if is_read
+        end
+      end
+    end
+
+    module YamlPatch
+      def load_file(path, *args, **kwargs)
+        super.tap do
+          FastCov::FileTracker.record(File.expand_path(path))
+        end
+      end
+
+      def safe_load_file(path, *args, **kwargs)
+        super.tap do
+          FastCov::FileTracker.record(File.expand_path(path))
+        end
+      end
+
+      def unsafe_load_file(path, *args, **kwargs)
+        super.tap do
+          FastCov::FileTracker.record(File.expand_path(path))
         end
       end
     end

data/lib/fast_cov/utils.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module FastCov
+  module Utils
+    # Check if path is within directory, correctly handling:
+    # - Trailing slashes on directory
+    # - Sibling directories with longer names (e.g., /a/b/c vs /a/b/cd)
+    def self.path_within?(path, directory)
+      dir = directory.end_with?("/") ? directory.chop : directory
+      return true if path == dir
+
+      path.start_with?("#{dir}/")
+    end
+
+    # Mutates set in place: converts absolute paths to relative paths from root.
+    # Paths not within root are left unchanged.
+    def self.relativize_paths(set, root)
+      prefix = root.end_with?("/") ? root : "#{root}/"
+
+      set.to_a.each do |abs_path|
+        next unless abs_path.is_a?(String)
+        next unless abs_path.start_with?(prefix) || abs_path == root.chomp("/")
+
+        set.delete(abs_path)
+        set.add(abs_path.delete_prefix(prefix))
+      end
+
+      set
+    end
+
+    # Walk caller locations to find the first frame whose file is within root.
+    # Handles indirect calls (e.g., YAML.load_file -> File.open) where the
+    # immediate caller is a stdlib/gem file outside the project.
+    def self.resolve_caller(locations, root)
+      locations.each do |loc|
+        path = loc.absolute_path
+        next unless path
+
+        return path if path_within?(path, root)
+      end
+      nil
+    end
+  end
+end

data/lib/fast_cov/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FastCov
-  VERSION = "0.2.1"
+  VERSION = "0.3.1"
 end

data/lib/fast_cov.rb

@@ -3,6 +3,7 @@
 require "fast_cov/fast_cov.#{RUBY_VERSION}"
 
 module FastCov
+  autoload :Utils, File.expand_path("fast_cov/utils", __dir__)
   autoload :VERSION, File.expand_path("fast_cov/version", __dir__)
   autoload :ConnectedDependencies, File.expand_path("fast_cov/connected_dependencies", __dir__)
   autoload :CoverageMap, File.expand_path("fast_cov/coverage_map", __dir__)
@@ -10,4 +11,5 @@ module FastCov
   autoload :FileTracker, File.expand_path("fast_cov/trackers/file_tracker", __dir__)
   autoload :FactoryBotTracker, File.expand_path("fast_cov/trackers/factory_bot_tracker", __dir__)
   autoload :ConstGetTracker, File.expand_path("fast_cov/trackers/const_get_tracker", __dir__)
+  autoload :StaticMap, File.expand_path("fast_cov/static_map", __dir__)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fast_cov
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.3.1
 platform: ruby
 authors:
 - Ngan Pham
@@ -85,10 +85,13 @@ files:
 - lib/fast_cov/connected_dependencies.rb
 - lib/fast_cov/coverage_map.rb
 - lib/fast_cov/dev.rb
+- lib/fast_cov/static_map.rb
+- lib/fast_cov/static_map/reference_extractor.rb
 - lib/fast_cov/trackers/abstract_tracker.rb
 - lib/fast_cov/trackers/const_get_tracker.rb
 - lib/fast_cov/trackers/factory_bot_tracker.rb
 - lib/fast_cov/trackers/file_tracker.rb
+- lib/fast_cov/utils.rb
 - lib/fast_cov/version.rb
 homepage: https://github.com/Gusto/fast_cov
 licenses: