fast_cov 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19e4e4403a0d37409a7c3c71ab93499a288f7868d68756d7e906dfd8c8033ec3
-  data.tar.gz: 8b1984d267cade376fea5c949f98d031d586b11ebf2e17096d749957a1d99af7
+  metadata.gz: 3ce0e302b02e7989034b39bd84cc69e7563378edb3ec31d10491899a4da74bac
+  data.tar.gz: 7273c905846579200383b0409d91ae8ea8066102e1c91d50af5a4c601e03f06e
 SHA512:
-  metadata.gz: 7f1329d14f6e96f054db4e36b24addd60db315f63029b3be39d295667079b41fca240fb36fbdf6bc3cc7f5e80851e4db23557370b34728fb1b49e11cfb17d1a3
-  data.tar.gz: 41af227e9377d3ac3277f658405561ca7d1ec4ae86c9a1306029fdc34dc7e315a63504f9503305d110d3efaac4503b6e90bcbe0d3f8d864e929322fff38b9a2f
+  metadata.gz: 149d759f1b8005b69741319655c2366b8ff3f0422b8c978418942e50f67a0b81b6077e7810c0a70aad56bf80fe130f2fc7b4003f55dc28ac0780d3ce2b847dcb
+  data.tar.gz: 6b8a1e08762f8fdcc4d2488f9c49348c38f5701499fd96550fdb4362cf64089ca76e55ecbfb6d50523cb190e15ed588b4162e873b3419b238d3a1680a6f97016

data/README.md

@@ -51,8 +51,8 @@ Call `FastCov.configure` before using `start`/`stop`. The block yields a `Config
 
 ```ruby
 FastCov.configure do |config|
-  config.root = Rails.root.to_s
-  config.ignored_path = Rails.root.join("vendor").to_s
+  config.root = Rails.root
+  config.ignored_path = Rails.root.join("vendor")
   config.threads = true
 
   config.use FastCov::CoverageTracker
@@ -94,7 +94,7 @@ FastCov.reset                  # Clear configuration and trackers.
 ```ruby
 # spec/support/fast_cov.rb
 FastCov.configure do |config|
-  config.root = Rails.root.to_s
+  config.root = Rails.root
   config.use FastCov::CoverageTracker
   config.use FastCov::FileTracker
 end
@@ -133,7 +133,7 @@ config.use FastCov::CoverageTracker
 
 **Allocation tracing** (`allocations: true`) -- hooks `RUBY_INTERNAL_EVENT_NEWOBJ` to capture `T_OBJECT` and `T_STRUCT` allocations. At stop time, walks each instantiated class's ancestor chain and resolves every ancestor to its source file. This catches empty models, structs, and Data objects that line events alone would miss.
 
-**Constant reference resolution** (`constant_references: true`) -- at stop time, parses tracked files with Prism and walks the AST for `ConstantPathNode` and `ConstantReadNode` to extract constant references, then resolves each constant to its defining file via `Object.const_source_location`. Resolution is transitive (up to 10 rounds) and cached with MD5 digests for invalidation.
+**Constant reference resolution** (`constant_references: true`) -- at stop time, parses tracked files with Prism and walks the AST for `ConstantPathNode` and `ConstantReadNode` to extract constant references, then resolves each constant to its defining file via `Object.const_source_location`. Resolution is transitive (up to 10 rounds) and cached by filename for the lifetime of the process.
 
 #### Disabling expensive features
 
@@ -189,6 +189,34 @@ config.use FastCov::FactoryBotTracker
 
 Prepends a module on `FactoryBot.factories.singleton_class` to intercept the `find` method (called by `create`, `build`, etc.). When a factory is used, the tracker walks its declaration blocks and extracts `source_location` from each proc to find the factory definition file.
 
+### ConstGetTracker
+
+Tracks constants looked up dynamically via `Module#const_get`. This catches dynamic constant lookups that static analysis (Prism) would miss.
+
+```ruby
+config.use FastCov::ConstGetTracker
+```
+
+#### What it catches
+
+- `Object.const_get("Foo::Bar")`
+- Rails' `"UserMailer".constantize` (uses `const_get` under the hood)
+- Any metaprogramming that looks up constants by string name
+
+**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 of literal constant references.
+
+#### Options
+
+| Option | Type | Default | Description |
+|---|---|---|---|
+| `root` | String | `config.root` | Override the root path for this tracker. |
+| `ignored_path` | String | `config.ignored_path` | Override the ignored path for this tracker. |
+| `threads` | Boolean | `config.threads` | Override the threading mode for this tracker. |
+
+#### How it works
+
+Prepends a module on `Module` to intercept `const_get` calls. When a constant is looked up, the tracker calls `const_source_location` to find where the constant was defined and records that file.
+
 ## Writing custom trackers
 
 There are two approaches to writing custom trackers: from scratch (minimal interface) or inheriting from `AbstractTracker` (batteries included).
@@ -295,7 +323,7 @@ Results from all trackers are merged, with later trackers overwriting earlier on
 
 ## Cache
 
-FastCov caches constant reference resolution results in memory so files only need parsing once per process. The cache is process-level, content-addressed (MD5 digests), and populated automatically during `stop`.
+FastCov caches constant reference resolution results in memory so files only need parsing once per process. The cache is process-level, keyed by filename, and populated automatically during `stop`.
 
 ```ruby
 FastCov::Cache.data      # the raw cache hash

data/lib/fast_cov/configuration.rb

@@ -1,27 +1,71 @@
 # frozen_string_literal: true
 
+require "pathname"
+
 module FastCov
   class Configuration
-    attr_accessor :root, :ignored_path, :threads
+    class ConfigurationError < StandardError; end
+
+    attr_accessor :threads
+    attr_reader :root, :ignored_path
 
     def initialize
       @root = Dir.pwd
       @ignored_path = nil
       @threads = true
-      @trackers = []
+      @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)
-      @trackers << {klass: tracker_class, options: options}
+      @tracker_definitions << {klass: tracker_class, options: options}
     end
 
-    def trackers
-      @trackers
+    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/singleton.rb

@@ -0,0 +1,44 @@
+# 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/abstract_tracker.rb

@@ -43,8 +43,8 @@ module FastCov
 
     def record(abs_path)
       return if !@threads && Thread.current != @started_thread
-      return unless abs_path.start_with?(@root)
-      return if @ignored_path && abs_path.start_with?(@ignored_path)
+      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)
     end
 
@@ -61,8 +61,19 @@ module FastCov
     class << self
       attr_accessor :active
 
-      def record(abs_path)
-        @active&.record(abs_path)
+      # 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)
+        return unless active
+
+        path = abs_path || (yield if block_given?)
+        active.record(path) if path
       end
 
       def reset

data/lib/fast_cov/trackers/const_get_tracker.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require_relative "abstract_tracker"
+
+module FastCov
+  # Tracks constants looked up dynamically via Module#const_get.
+  #
+  # This catches dynamic constant lookups that static analysis misses:
+  # - Object.const_get("Foo::Bar")
+  # - Rails' "UserMailer".constantize (uses const_get under the hood)
+  # - Any metaprogramming that looks up constants by string name
+  #
+  # 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)
+  class ConstGetTracker < AbstractTracker
+    def install
+      Module.prepend(ConstGetPatch)
+    end
+
+    module ConstGetPatch
+      def const_get(name, inherit = true)
+        result = super
+        FastCov::ConstGetTracker.record do
+          location = self.const_source_location(name, inherit) rescue nil
+          location&.first
+        end
+        result
+      end
+    end
+  end
+end

data/lib/fast_cov/trackers/factory_bot_tracker.rb

@@ -30,7 +30,7 @@ module FastCov
 
     class << self
       def record_factory_files(factory)
-        return unless @active
+        return unless active
 
         definition = factory.definition
         declarations = definition.instance_variable_get(:@declarations)
@@ -43,8 +43,7 @@ module FastCov
           location = block.source_location
           next unless location
 
-          file_path = location[0]
-          @active.record(file_path)
+          record(location[0])
         end
       end
     end

data/lib/fast_cov/trackers/file_tracker.rb

@@ -15,33 +15,14 @@ module FastCov
 
     module FilePatch
       def read(name, *args, **kwargs, &block)
-        FastCov::FileTracker.record_for_active(name)
-        super
+        super.tap { FastCov::FileTracker.record { File.expand_path(name) } }
       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?)
-        FastCov::FileTracker.record_for_active(name) if is_read
-        super
-      end
-    end
-
-    class << self
-      def record_for_active(path)
-        return unless @active
-
-        path_str = path.to_s
-        return if path_str.empty?
-
-        abs_path = begin
-          File.expand_path(path_str)
-        rescue ArgumentError, TypeError
-          return
-        end
-
-        @active.record(abs_path)
+        super.tap { FastCov::FileTracker.record { File.expand_path(name) } if is_read }
       end
     end
   end

data/lib/fast_cov/version.rb

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

data/lib/fast_cov.rb

@@ -1,62 +1,16 @@
 # frozen_string_literal: true
 
-require_relative "fast_cov/version"
 require "fast_cov/fast_cov.#{RUBY_VERSION}"
-require_relative "fast_cov/configuration"
-require_relative "fast_cov/trackers/abstract_tracker"
-require_relative "fast_cov/trackers/coverage_tracker"
-require_relative "fast_cov/trackers/file_tracker"
-require_relative "fast_cov/trackers/factory_bot_tracker"
 
 module FastCov
-  class << self
-    def configured?
-      !@trackers.nil? && !@trackers.empty?
-    end
-
-    def configure
-      @configuration = Configuration.new
-      yield(@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
-
-    private
-
-    def install_trackers
-      @trackers = @configuration.trackers.map do |entry|
-        tracker = entry[:klass].new(@configuration, **entry[:options])
-        tracker.install if tracker.respond_to?(:install)
-        tracker
-      end
-    end
-  end
+  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
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fast_cov
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Ngan Pham
@@ -85,7 +85,9 @@ files:
 - lib/fast_cov/configuration.rb
 - lib/fast_cov/constant_extractor.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