fast_cov 0.1.0

data/ext/fast_cov/fast_cov_utils.c

@@ -0,0 +1,104 @@
+#include "fast_cov.h"
+#include <ruby.h>
+#include <string.h>
+
+// Check if path is within root directory.
+// Handles trailing slashes on root and ensures we don't match
+// /a/b/c against /a/b/cd (sibling directory with longer name).
+bool fast_cov_is_within_root(const char *path, long path_len,
+                             const char *root, long root_len) {
+  // Normalize: strip trailing slash from root for comparison
+  long effective_root_len = root_len;
+  if (effective_root_len > 0 && root[effective_root_len - 1] == '/') {
+    effective_root_len--;
+  }
+
+  // Path must be at least as long as root
+  if (path_len < effective_root_len) {
+    return false;
+  }
+
+  // Check prefix match
+  if (strncmp(path, root, effective_root_len) != 0) {
+    return false;
+  }
+
+  // Path is exactly root (rare but valid)
+  if (path_len == effective_root_len) {
+    return true;
+  }
+
+  // Path must have '/' immediately after root prefix
+  // This prevents /a/b/c from matching /a/b/cd
+  return path[effective_root_len] == '/';
+}
+
+bool fast_cov_is_path_included(const char *path, const char *root_path,
+                               long root_path_len, const char *ignored_path,
+                               long ignored_path_len) {
+  long path_len = (long)strlen(path);
+
+  if (!fast_cov_is_within_root(path, path_len, root_path, root_path_len)) {
+    return false;
+  }
+  if (ignored_path_len > 0 &&
+      fast_cov_is_within_root(path, path_len, ignored_path, ignored_path_len)) {
+    return false;
+  }
+  return true;
+}
+
+char *fast_cov_ruby_strndup(const char *str, size_t size) {
+  char *dup = xmalloc(size + 1);
+  memcpy(dup, str, size);
+  dup[size] = '\0';
+  return dup;
+}
+
+VALUE fast_cov_rescue_nil(VALUE (*fn)(VALUE), VALUE arg) {
+  int exception_state;
+  VALUE result = rb_protect(fn, arg, &exception_state);
+  if (exception_state != 0) {
+    rb_set_errinfo(Qnil);
+    return Qnil;
+  }
+  return result;
+}
+
+VALUE fast_cov_get_const_source_location(VALUE const_name_str) {
+  return rb_funcall(rb_cObject, rb_intern("const_source_location"), 1,
+                    const_name_str);
+}
+
+VALUE fast_cov_safely_get_const_source_location(VALUE const_name_str) {
+  return fast_cov_rescue_nil(fast_cov_get_const_source_location,
+                             const_name_str);
+}
+
+VALUE fast_cov_resolve_const_to_file(VALUE const_name_str) {
+  // Check cache first
+  VALUE const_locations_hash =
+      rb_hash_lookup(fast_cov_cache_hash, ID2SYM(rb_intern("const_locations")));
+  VALUE cached = rb_hash_lookup(const_locations_hash, const_name_str);
+  if (cached != Qnil) {
+    return cached;
+  }
+
+  // Cache miss - resolve via Object.const_source_location
+  VALUE source_location =
+      fast_cov_safely_get_const_source_location(const_name_str);
+  if (NIL_P(source_location) || !RB_TYPE_P(source_location, T_ARRAY) ||
+      RARRAY_LEN(source_location) == 0) {
+    return Qnil;
+  }
+
+  VALUE filename = RARRAY_AREF(source_location, 0);
+  if (NIL_P(filename) || !RB_TYPE_P(filename, T_STRING)) {
+    return Qnil;
+  }
+
+  // Cache the result
+  rb_hash_aset(const_locations_hash, const_name_str, filename);
+
+  return filename;
+}

data/lib/fast_cov/benchmark/runner.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "json"
+require "fileutils"
+
+module FastCov
+  module Benchmark
+    class Runner
+      DEFAULT_ITERATIONS = 1000
+      DEFAULT_SAMPLES = 5
+      WARMUP_ITERATIONS = 20
+
+      attr_reader :iterations, :samples, :baseline_path
+
+      def initialize(iterations: DEFAULT_ITERATIONS, samples: DEFAULT_SAMPLES, baseline_path: nil)
+        @iterations = iterations
+        @samples = samples
+        @baseline_path = baseline_path || default_baseline_path
+        @scenarios = []
+      end
+
+      def scenario(name, &block)
+        @scenarios << { name: name, block: block }
+      end
+
+      def run(save_baseline: false)
+        baseline = load_baseline unless save_baseline
+        results = run_scenarios
+
+        print_results(results, baseline)
+
+        if save_baseline
+          save_baseline_to_disk(results)
+        elsif baseline
+          puts "Baseline: #{@baseline_path} (saved #{baseline["saved_at"]})"
+        else
+          puts "No baseline found. Run with --baseline to save one."
+        end
+      end
+
+      private
+
+      def run_scenarios
+        results = {}
+
+        @scenarios.each do |scenario|
+          measurement = measure(scenario[:block])
+          results[scenario[:name]] = measurement
+        end
+
+        results
+      end
+
+      def measure(block)
+        # Warmup: let JIT, caches, and memory settle
+        WARMUP_ITERATIONS.times { block.call }
+
+        # Collect multiple samples, take the median to filter outliers
+        elapsed_samples = Array.new(@samples) do
+          GC.start
+          GC.compact
+
+          start = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          @iterations.times { block.call }
+          Process.clock_gettime(Process::CLOCK_MONOTONIC) - start
+        end
+
+        median_elapsed = median(elapsed_samples)
+
+        {
+          "avg_ms" => (median_elapsed / @iterations) * 1000.0,
+          "ips" => @iterations / median_elapsed
+        }
+      end
+
+      def median(values)
+        sorted = values.sort
+        mid = sorted.length / 2
+        if sorted.length.odd?
+          sorted[mid]
+        else
+          (sorted[mid - 1] + sorted[mid]) / 2.0
+        end
+      end
+
+      def print_results(results, baseline)
+        has_baseline = baseline && baseline["results"]
+
+        puts "FastCov Benchmark Suite"
+        puts "Ruby #{RUBY_VERSION}, #{RUBY_PLATFORM}"
+        puts "#{@iterations} iterations x #{@samples} samples (median)"
+        puts "=" * 72
+        puts
+
+        header = format("  %-38s %10s %12s", "", "avg (ms)", "ips")
+        header += format(" %14s", "vs baseline") if has_baseline
+        puts header
+        puts "-" * header.length
+
+        results.each do |name, result|
+          line = format("  %-38s %10.3f %12.1f", name, result["avg_ms"], result["ips"])
+
+          if has_baseline && (base = baseline["results"][name])
+            base_avg = base["avg_ms"]
+            if base_avg > 0
+              delta_pct = ((result["avg_ms"] - base_avg) / base_avg) * 100.0
+              sign = delta_pct >= 0 ? "+" : ""
+              line += format(" %13s", "#{sign}#{"%.1f" % delta_pct}%")
+            end
+          end
+
+          puts line
+        end
+
+        puts
+      end
+
+      def load_baseline
+        return nil unless File.exist?(@baseline_path)
+
+        JSON.parse(File.read(@baseline_path))
+      rescue JSON::ParserError
+        nil
+      end
+
+      def save_baseline_to_disk(results)
+        FileUtils.mkdir_p(File.dirname(@baseline_path))
+
+        payload = {
+          "saved_at" => Time.now.strftime("%Y-%m-%d %H:%M:%S"),
+          "ruby_version" => RUBY_VERSION,
+          "platform" => RUBY_PLATFORM,
+          "iterations" => @iterations,
+          "samples" => @samples,
+          "results" => results
+        }
+
+        File.write(@baseline_path, JSON.pretty_generate(payload))
+        puts "Baseline saved to #{@baseline_path}"
+      end
+
+      def default_baseline_path
+        File.expand_path("tmp/benchmark_baseline.json", Dir.pwd)
+      end
+    end
+  end
+end

data/lib/fast_cov/benchmark/scenarios.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module FastCov
+  module Benchmark
+    module Scenarios
+      def self.register(runner, fixtures_dir:)
+        root_calculator = File.join(fixtures_dir, "calculator")
+        root_app = File.join(fixtures_dir, "app")
+        root_all = fixtures_dir
+        ignored_path = File.join(fixtures_dir, "vendor")
+
+        calculator = Calculator.new
+
+        runner.scenario("Line coverage (small)") do
+          cov = FastCov::Coverage.new(root: root_calculator)
+          cov.start
+          calculator.add(1, 2)
+          calculator.subtract(3, 1)
+          cov.stop
+        end
+
+        runner.scenario("Line coverage (many files)") do
+          cov = FastCov::Coverage.new(root: root_all)
+          cov.start
+          calculator.add(1, 2)
+          calculator.subtract(3, 1)
+          calculator.multiply(2, 3)
+          calculator.divide(6, 2)
+          ConstantReader.new.operations
+          MyModel.new
+          User.new("test", "test@test.com")
+          DynamicModel.new.some_method
+          cov.stop
+        end
+
+        runner.scenario("Line coverage (single-threaded)") do
+          cov = FastCov::Coverage.new(root: root_calculator, threads: false)
+          cov.start
+          calculator.add(1, 2)
+          calculator.subtract(3, 1)
+          cov.stop
+        end
+
+        runner.scenario("Line coverage (with ignored_path)") do
+          cov = FastCov::Coverage.new(root: root_all, ignored_path: ignored_path)
+          cov.start
+          calculator.add(1, 2)
+          calculator.subtract(3, 1)
+          cov.stop
+        end
+
+        runner.scenario("Allocation tracing") do
+          cov = FastCov::Coverage.new(root: root_app, allocations: true)
+          cov.start
+          MyModel.new
+          User.new("test", "test@test.com")
+          DynamicModel.new
+          cov.stop
+        end
+
+        runner.scenario("Constant resolution (cold cache)") do
+          FastCov::Cache.clear
+          cov = FastCov::Coverage.new(root: root_calculator)
+          cov.start
+          ConstantReader.new.operations
+          calculator.add(1, 2)
+          cov.stop
+        end
+
+        runner.scenario("Constant resolution (warm cache)") do
+          warm = FastCov::Coverage.new(root: root_calculator)
+          warm.start
+          ConstantReader.new.operations
+          warm.stop
+
+          cov = FastCov::Coverage.new(root: root_calculator)
+          cov.start
+          ConstantReader.new.operations
+          calculator.add(1, 2)
+          cov.stop
+        end
+
+        runner.scenario("Rapid start/stop (100x)") do
+          cov = FastCov::Coverage.new(root: root_calculator)
+          100.times do
+            cov.start
+            calculator.add(1, 2)
+            cov.stop
+          end
+        end
+
+        runner.scenario("Multi-threaded coverage") do
+          cov = FastCov::Coverage.new(root: root_calculator)
+          cov.start
+          t = Thread.new { calculator.add(1, 2) }
+          calculator.multiply(2, 3)
+          t.join
+          cov.stop
+        end
+      end
+    end
+  end
+end

data/lib/fast_cov/compiler.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "rbconfig"
+require "digest/md5"
+
+module FastCov
+  module Compiler
+    EXT_DIR = File.expand_path("../../ext/fast_cov", __dir__)
+    LIB_DIR = File.expand_path("../fast_cov", __dir__)
+
+    def self.compile!
+      Dir.chdir(EXT_DIR) do
+        system(RbConfig.ruby, "extconf.rb") || raise("FastCov: extconf.rb failed")
+        system("make") || raise("FastCov: make failed")
+        system("make install sitearchdir=#{LIB_DIR} sitelibdir=#{LIB_DIR}") || raise("FastCov: make install failed")
+      end
+
+      write_digest
+    end
+
+    def self.stale?
+      return true unless extension_exists?
+
+      stored = read_digest
+      return true unless stored
+
+      stored != source_digest
+    end
+
+    def self.extension_exists?
+      ext_name = "fast_cov.#{RUBY_VERSION}_#{RUBY_PLATFORM}"
+      Dir.glob(File.join(LIB_DIR, "#{ext_name}.{bundle,so}")).any?
+    end
+
+    def self.source_digest
+      files = Dir.glob(File.join(EXT_DIR, "*.{c,h,rb}")).sort
+      combined = files.map { |f| Digest::MD5.file(f).hexdigest }.join
+      Digest::MD5.hexdigest(combined)
+    end
+
+    def self.digest_path
+      File.join(LIB_DIR, ".source_digest.#{RUBY_VERSION}_#{RUBY_PLATFORM}")
+    end
+
+    def self.write_digest
+      File.write(digest_path, source_digest)
+    end
+
+    def self.read_digest
+      File.read(digest_path).strip
+    rescue Errno::ENOENT
+      nil
+    end
+  end
+end

data/lib/fast_cov/configuration.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module FastCov
+  class Configuration
+    attr_accessor :root, :ignored_path, :threads
+
+    def initialize
+      @root = Dir.pwd
+      @ignored_path = nil
+      @threads = true
+      @trackers = []
+    end
+
+    def use(tracker_class, **options)
+      @trackers << {klass: tracker_class, options: options}
+    end
+
+    def trackers
+      @trackers
+    end
+
+    def reset
+      initialize
+      self
+    end
+  end
+end

data/lib/fast_cov/constant_extractor.rb

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Auto-compile entrypoint for local development with path: Gemfile references.
+#
+# Usage in a consuming project's Gemfile:
+#   gem "fast_cov", path: "../fast_cov", require: "fast_cov/dev"
+#
+# Compiles the C extension if:
+#   - It hasn't been compiled for this Ruby version yet
+#   - The C source files have changed since the last compilation
+
+require_relative "compiler"
+
+if FastCov::Compiler.stale?
+  $stdout.puts "[FastCov] Compiling extension for Ruby #{RUBY_VERSION} (#{RUBY_PLATFORM})..."
+  FastCov::Compiler.compile!
+  $stdout.puts "[FastCov] Compilation complete."
+else
+  $stdout.puts "[FastCov] Extension up to date for Ruby #{RUBY_VERSION} (#{RUBY_PLATFORM})"
+end
+
+require_relative "../fast_cov"

data/lib/fast_cov/trackers/abstract_tracker.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+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)
+  # - File collection and lifecycle management
+  #
+  # Descendants override hooks: on_start, on_stop, on_record
+  # Or implement start, stop, record directly without inheriting.
+  #
+  # Threading behavior:
+  # - 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)
+      @files = nil
+      @started_thread = nil
+    end
+
+    # Public API - called by FastCov framework
+
+    def start
+      @files = Set.new
+      @started_thread = Thread.current unless @threads
+      self.class.active = self
+      on_start
+    end
+
+    def stop
+      self.class.active = nil
+      @started_thread = nil
+      on_stop
+      result = @files
+      @files = nil
+      result
+    end
+
+    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)
+      @files.add(abs_path) if on_record(abs_path)
+    end
+
+    # Hooks for descendants - override as needed
+
+    def install; end
+    def on_start; end
+    def on_stop; end
+
+    def on_record(abs_path)
+      true
+    end
+
+    class << self
+      attr_accessor :active
+
+      def record(abs_path)
+        @active&.record(abs_path)
+      end
+
+      def reset
+        @active = nil
+      end
+    end
+  end
+end

data/lib/fast_cov/trackers/coverage_tracker.rb

@@ -0,0 +1,28 @@
+# 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

data/lib/fast_cov/trackers/factory_bot_tracker.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require_relative "abstract_tracker"
+
+module FastCov
+  # Tracks FactoryBot factory definition files when factories are used.
+  #
+  # Factory files are typically loaded at boot time, before coverage starts.
+  # 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)
+  class FactoryBotTracker < AbstractTracker
+    def install
+      unless defined?(::FactoryBot)
+        raise LoadError, "FactoryBotTracker requires the factory_bot gem to be installed"
+      end
+
+      ::FactoryBot.factories.singleton_class.prepend(RegistryPatch)
+    end
+
+    module RegistryPatch
+      def find(name)
+        factory = super
+        FastCov::FactoryBotTracker.record_factory_files(factory)
+        factory
+      end
+    end
+
+    class << self
+      def record_factory_files(factory)
+        return unless @active
+
+        definition = factory.definition
+        declarations = definition.instance_variable_get(:@declarations)
+        return unless declarations
+
+        declarations.each do |decl|
+          block = decl.instance_variable_get(:@block)
+          next unless block.is_a?(Proc)
+
+          location = block.source_location
+          next unless location
+
+          file_path = location[0]
+          @active.record(file_path)
+        end
+      end
+    end
+  end
+end