fast_cov 0.1.6 → 0.2.0

data/lib/fast_cov/connected_dependencies.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module FastCov
+  class ConnectedDependencies
+    def initialize
+      @connections = {}
+      @mutex = Mutex.new
+    end
+
+    def connect(from:, to:)
+      @mutex.synchronize do
+        (@connections[from] ||= {})[to] = true
+      end
+    end
+
+    def expand(paths)
+      raise ArgumentError, "paths must be a Set" unless paths.is_a?(Set)
+
+      pending_paths = paths.to_a
+
+      until pending_paths.empty?
+        path = pending_paths.pop
+
+        connections = @connections[path]
+        next unless connections
+
+        connections.each_key do |dependency|
+          next unless paths.add?(dependency)
+
+          pending_paths << dependency
+        end
+      end
+
+      paths
+    end
+  end
+end

data/lib/fast_cov/coverage_map.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+require "pathname"
+
+module FastCov
+  class CoverageMap
+    class ConfigurationError < StandardError; end
+
+    attr_accessor :threads
+    attr_reader :ignored_paths
+    attr_reader :root
+    attr_reader :connected_dependencies
+
+    def initialize
+      @root = Dir.pwd
+      @threads = true
+      @ignored_paths = []
+      @connected_dependencies = ConnectedDependencies.new
+      @trackers = []
+      @native_coverage = nil
+      @started = false
+    end
+
+    def root=(value)
+      return @root = nil if value.nil?
+
+      path = value.to_s
+      unless absolute_path?(path)
+        raise ConfigurationError, "root must be an absolute path, got: #{path.inspect}"
+      end
+
+      @root = path
+    end
+
+    def ignored_paths=(value)
+      @ignored_paths =
+        case value
+        when nil
+          []
+        when Array
+          value.dup
+        else
+          [value]
+        end
+    end
+
+    def use(tracker_class, **options)
+      raise "CoverageMap is already started" if @started
+      raise ArgumentError, "#{tracker_class} is already registered" if @trackers.any? { |tracker| tracker.is_a?(tracker_class) }
+
+      tracker = tracker_class.new(self, **options)
+      tracker.install if tracker.respond_to?(:install)
+      @trackers << tracker
+      self
+    end
+
+    def start
+      if @started
+        raise "CoverageMap is already started" if block_given?
+        return self
+      end
+
+      begin
+        @native_coverage = Coverage.new(
+          root: normalized_root,
+          ignored_paths: normalized_ignored_paths,
+          threads: @threads != false
+        )
+        @native_coverage.start
+        @trackers.each(&:start)
+        @started = true
+      rescue StandardError
+        cleanup_failed_start
+        raise
+      end
+
+      if block_given?
+        result = nil
+        begin
+          yield
+        ensure
+          result = stop
+        end
+        result
+      else
+        self
+      end
+    end
+
+    def stop
+      return Set.new unless @started
+
+      result = Set.new(@native_coverage.stop.each_key)
+      @trackers.reverse_each { |tracker| result.merge(tracker.stop) }
+      @connected_dependencies.expand(result)
+      Utils.relativize_paths(result, normalized_root)
+    ensure
+      @native_coverage = nil
+      @started = false
+    end
+
+    def include_path?(path)
+      return false unless path
+      return false unless Utils.path_within?(path, normalized_root)
+      return true if @ignored_paths.empty?
+
+      normalized_ignored_paths.none? { |ignored_path| Utils.path_within?(path, ignored_path) }
+    end
+
+    def connect(from:, to:)
+      source = normalize_path(from)
+      target = normalize_path(to)
+      return unless include_path?(source)
+      return unless include_path?(target)
+      return if source == target
+
+      @connected_dependencies.connect(from: source, to: target)
+    end
+
+    private
+
+    def normalized_root
+      path = @root&.to_s
+      raise ConfigurationError, "root is required" if path.nil? || path.empty?
+      raise ConfigurationError, "root must be an absolute path, got: #{path.inspect}" unless absolute_path?(path)
+
+      path
+    end
+
+    def normalized_ignored_paths
+      root = normalized_root
+
+      @ignored_paths.map do |value|
+        path = value.to_s
+        path = File.join(root, path) unless absolute_path?(path)
+
+        unless Utils.path_within?(path, root)
+          raise ConfigurationError,
+            "ignored_paths must be inside root (#{root.inspect}), got: #{path.inspect}"
+        end
+
+        path
+      end
+    end
+
+    def absolute_path?(path)
+      Pathname.new(path).absolute?
+    end
+
+    def normalize_path(path)
+      return if path.nil?
+
+      File.expand_path(path.to_s)
+    end
+
+    def cleanup_failed_start
+      @trackers.reverse_each do |tracker|
+        begin
+          tracker.stop
+        rescue StandardError
+          nil
+        end
+      end
+
+      begin
+        @native_coverage&.stop
+      rescue StandardError
+        nil
+      end
+
+      @native_coverage = nil
+      @started = false
+    end
+  end
+end

data/lib/fast_cov/trackers/abstract_tracker.rb

@@ -4,8 +4,8 @@ module FastCov
   # Base class for trackers that record file paths during coverage.
   #
   # Provides common functionality:
-  # - Path filtering (root, ignored_path)
-  # - Thread-aware recording (threads option)
+  # - Path filtering (root, ignored_paths)
+  # - Thread-aware recording (CoverageMap#threads)
   # - File collection and lifecycle management
   #
   # Descendants override hooks: on_start, on_stop, on_record
@@ -15,10 +15,8 @@ module FastCov
   # - threads: true  -> record from ALL threads (global tracking)
   # - threads: false -> only record from the thread that called start
   class AbstractTracker
-    def initialize(config, **options)
-      @root = options.fetch(:root, config.root)
-      @ignored_path = options.fetch(:ignored_path, config.ignored_path)
-      @threads = options.fetch(:threads, config.threads)
+    def initialize(coverage_map, **_options)
+      @coverage_map = coverage_map
       @files = nil
       @started_thread = nil
     end
@@ -27,7 +25,7 @@ module FastCov
 
     def start
       @files = Set.new
-      @started_thread = Thread.current unless @threads
+      @started_thread = Thread.current unless @coverage_map.threads
       self.class.active = self
       on_start
     end
@@ -41,11 +39,14 @@ module FastCov
       result
     end
 
-    def record(abs_path)
-      return if !@threads && Thread.current != @started_thread
-      return unless Utils.path_within?(abs_path, @root)
-      return if @ignored_path && Utils.path_within?(abs_path, @ignored_path)
-      @files.add(abs_path) if on_record(abs_path)
+    def record(abs_path, to: nil)
+      return if !@coverage_map.threads && Thread.current != @started_thread
+
+      path = normalize_path(abs_path)
+      return unless @coverage_map.include_path?(path)
+
+      @coverage_map.connect(from: to, to: path) if to
+      @files.add(path) if on_record(path)
     end
 
     # Hooks for descendants - override as needed
@@ -54,26 +55,27 @@ module FastCov
     def on_start; end
     def on_stop; end
 
-    def on_record(abs_path)
+    def on_record(path)
       true
     end
 
+    private
+
+    def normalize_path(path)
+      return if path.nil?
+
+      File.expand_path(path.to_s)
+    end
+
     class << self
       attr_accessor :active
 
-      # Record a file path. Accepts a path directly or a block that returns the path.
-      # If block given, it's only executed when tracker is active (avoids expensive work).
-      # Nil values are ignored.
-      #
-      #   record("/path/to/file.rb")           # direct path
-      #   record { expensive_lookup }          # lazy evaluation
-      #   record("/path") { fallback }         # path takes precedence
-      #
-      def record(abs_path = nil)
+      def record(to: nil)
         return unless active
+        return unless block_given?
 
-        path = abs_path || (yield if block_given?)
-        active.record(path) if path
+        path = yield
+        active.record(path, to: to) if path
       end
 
       def reset

data/lib/fast_cov/trackers/const_get_tracker.rb

@@ -12,22 +12,20 @@ module FastCov
   #
   # Note: This does NOT catch direct constant references like `Foo::Bar` in source
   # code - those compile to opt_getconstant_path bytecode and bypass const_get.
-  # Use CoverageTracker with constant_references: true for static analysis.
   #
-  # Register via: config.use FastCov::ConstGetTracker
-  # Options: root, ignored_path, threads (all default from config)
+  # Register via: coverage_map.use(FastCov::ConstGetTracker)
   class ConstGetTracker < AbstractTracker
     def install
+      return if Module.ancestors.include?(ConstGetPatch)
+
       Module.prepend(ConstGetPatch)
     end
 
     module ConstGetPatch
       def const_get(name, inherit = true)
+        source = caller_locations(1, 1).first&.absolute_path
         result = super
-        FastCov::ConstGetTracker.record do
-          location = self.const_source_location(name, inherit) rescue nil
-          location&.first
-        end
+        FastCov::ConstGetTracker.record(to: source) { const_source_location(name, inherit)&.first }
         result
       end
     end

data/lib/fast_cov/trackers/factory_bot_tracker.rb

@@ -9,14 +9,15 @@ module FastCov
   # This tracker intercepts FactoryBot.factories.find (called by create/build)
   # to record the source file where each factory was defined.
   #
-  # Register via: config.use FastCov::FactoryBotTracker
-  # Options: root, ignored_path, threads (all default from config)
+  # Register via: coverage_map.use(FastCov::FactoryBotTracker)
   class FactoryBotTracker < AbstractTracker
     def install
       unless defined?(::FactoryBot)
         raise LoadError, "FactoryBotTracker requires the factory_bot gem to be installed"
       end
 
+      return if ::FactoryBot.factories.singleton_class.ancestors.include?(RegistryPatch)
+
       ::FactoryBot.factories.singleton_class.prepend(RegistryPatch)
     end
 
@@ -41,9 +42,7 @@ module FastCov
           next unless block.is_a?(Proc)
 
           location = block.source_location
-          next unless location
-
-          record(location[0])
+          record { location&.first }
         end
       end
     end

data/lib/fast_cov/trackers/file_tracker.rb

@@ -6,23 +6,30 @@ module FastCov
   # Tracks files read from disk during coverage (JSON, YAML, .rb templates, etc.)
   # via File.read and File.open.
   #
-  # Register via: config.use FastCov::FileTracker
-  # Options: root, ignored_path, threads (all default from config)
+  # Register via: coverage_map.use(FastCov::FileTracker)
   class FileTracker < AbstractTracker
     def install
+      return if File.singleton_class.ancestors.include?(FilePatch)
+
       File.singleton_class.prepend(FilePatch)
     end
 
     module FilePatch
       def read(name, *args, **kwargs, &block)
-        super.tap { FastCov::FileTracker.record { File.expand_path(name) } }
+        source = caller_locations(1, 1).first&.absolute_path
+        super.tap do
+          FastCov::FileTracker.record(to: source) { File.expand_path(name) }
+        end
       end
 
       def open(name, *args, **kwargs, &block)
         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?)
-        super.tap { FastCov::FileTracker.record { File.expand_path(name) } if is_read }
+        source = caller_locations(1, 1).first&.absolute_path
+        super.tap do
+          FastCov::FileTracker.record(to: source) { File.expand_path(name) } if is_read
+        end
       end
     end
   end

data/lib/fast_cov/version.rb

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

data/lib/fast_cov.rb

@@ -3,14 +3,11 @@
 require "fast_cov/fast_cov.#{RUBY_VERSION}"
 
 module FastCov
-  autoload :VERSION,           "fast_cov/version"
-  autoload :Configuration,      "fast_cov/configuration"
-  autoload :Singleton,         "fast_cov/singleton"
-  autoload :AbstractTracker,   "fast_cov/trackers/abstract_tracker"
-  autoload :CoverageTracker,   "fast_cov/trackers/coverage_tracker"
-  autoload :FileTracker,       "fast_cov/trackers/file_tracker"
-  autoload :FactoryBotTracker, "fast_cov/trackers/factory_bot_tracker"
-  autoload :ConstGetTracker,   "fast_cov/trackers/const_get_tracker"
-
-  extend Singleton
+  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__)
+  autoload :AbstractTracker, File.expand_path("fast_cov/trackers/abstract_tracker", __dir__)
+  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__)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fast_cov
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.2.0
 platform: ruby
 authors:
 - Ngan Pham
@@ -9,20 +9,6 @@ bindir: bin
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
-- !ruby/object:Gem::Dependency
-  name: prism
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -96,13 +82,11 @@ files:
 - lib/fast_cov/benchmark/runner.rb
 - lib/fast_cov/benchmark/scenarios.rb
 - lib/fast_cov/compiler.rb
-- lib/fast_cov/configuration.rb
-- lib/fast_cov/constant_extractor.rb
+- lib/fast_cov/connected_dependencies.rb
+- lib/fast_cov/coverage_map.rb
 - lib/fast_cov/dev.rb
-- lib/fast_cov/singleton.rb
 - lib/fast_cov/trackers/abstract_tracker.rb
 - lib/fast_cov/trackers/const_get_tracker.rb
-- lib/fast_cov/trackers/coverage_tracker.rb
 - lib/fast_cov/trackers/factory_bot_tracker.rb
 - lib/fast_cov/trackers/file_tracker.rb
 - lib/fast_cov/version.rb

data/lib/fast_cov/configuration.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require "pathname"
-
-module FastCov
-  class Configuration
-    class ConfigurationError < StandardError; end
-
-    attr_accessor :threads
-    attr_reader :root, :ignored_path
-
-    def initialize
-      @root = Dir.pwd
-      @ignored_path = nil
-      @threads = true
-      @tracker_definitions = []
-    end
-
-    def root=(value)
-      return @root = nil if value.nil?
-
-      path = value.to_s
-      unless absolute_path?(path)
-        raise ConfigurationError, "root must be an absolute path, got: #{path.inspect}"
-      end
-      @root = path
-    end
-
-    def ignored_path=(value)
-      return @ignored_path = nil if value.nil?
-
-      path = value.to_s
-
-      # Expand relative paths against root
-      unless absolute_path?(path)
-        path = File.join(@root, path)
-      end
-
-      # Validate ignored_path is inside root
-      unless path.start_with?(@root)
-        raise ConfigurationError,
-          "ignored_path must be inside root (#{@root.inspect}), got: #{path.inspect}"
-      end
-
-      @ignored_path = path
-    end
-
-    def use(tracker_class, **options)
-      @tracker_definitions << {klass: tracker_class, options: options}
-    end
-
-    def install_trackers
-      @tracker_definitions.map do |entry|
-        tracker = entry[:klass].new(self, **entry[:options])
-        tracker.install if tracker.respond_to?(:install)
-        tracker
-      end
-    end
-
-    def reset
-      initialize
-      self
-    end
-
-    private
-
-    def absolute_path?(path)
-      Pathname.new(path).absolute?
-    end
-  end
-end

data/lib/fast_cov/constant_extractor.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require "prism"
-
-module FastCov
-  module ConstantExtractor
-    def self.extract(filename)
-      result = Prism.parse_file(filename)
-      constants = []
-      collect_constants(result.value, constants)
-      constants
-    end
-
-    class << self
-      private
-
-      def collect_constants(node, constants)
-        case node
-        when Prism::ConstantPathNode
-          path = resolve_constant_path(node)
-          if path
-            constants << path
-            return
-          end
-          # Dynamic parent (e.g., expr::Foo) — fall through to walk children
-        when Prism::ConstantReadNode
-          constants << node.name.to_s
-          return
-        end
-
-        node.compact_child_nodes.each { |child| collect_constants(child, constants) }
-      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 nil
-        end
-
-        parts.join("::")
-      end
-    end
-  end
-end

data/lib/fast_cov/singleton.rb

@@ -1,44 +0,0 @@
-# frozen_string_literal: true
-
-module FastCov
-  module Singleton
-    def configured?
-      !@trackers.nil? && !@trackers.empty?
-    end
-
-    def configure
-      @configuration = Configuration.new
-      yield(@configuration)
-      @trackers = @configuration.install_trackers
-      self
-    end
-
-    def start(&block)
-      raise "FastCov.configure must be called before start" unless configured?
-      @trackers.each(&:start)
-      if block
-        result = nil
-        begin
-          yield
-        ensure
-          result = stop
-        end
-        result
-      else
-        self
-      end
-    end
-
-    def stop
-      raise "FastCov.configure must be called before stop" unless configured?
-      result = Set.new
-      @trackers.each { |t| result.merge(t.stop) }
-      Utils.relativize_paths(result, @configuration.root)
-    end
-
-    def reset
-      @trackers = nil
-      @configuration = nil
-    end
-  end
-end

data/lib/fast_cov/trackers/coverage_tracker.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module FastCov
-  # Wraps the FastCov::Coverage C extension as a tracker plugin.
-  # Handles line coverage, allocation tracing, and constant resolution.
-  #
-  # Register via: config.use FastCov::CoverageTracker
-  # Options: root, ignored_path, threads, constant_references, allocations
-  class CoverageTracker
-    def initialize(config, **options)
-      @coverage = Coverage.new(
-        root: options.fetch(:root, config.root),
-        ignored_path: options.fetch(:ignored_path, config.ignored_path),
-        threads: options.fetch(:threads, config.threads),
-        constant_references: options.fetch(:constant_references, true),
-        allocations: options.fetch(:allocations, true)
-      )
-    end
-
-    def start
-      @coverage.start
-    end
-
-    def stop
-      Set.new(@coverage.stop.each_key)
-    end
-  end
-end