rspec-tracer 0.1.0

data/lib/rspec_tracer/rspec_runner.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module RSpecTracer
+  module RSpecRunner
+    def run_specs(_example_groups)
+      actual_count = RSpec.world.example_count
+      filtered_examples, example_groups = RSpecTracer.filter_examples
+
+      RSpec.world.instance_variable_set(:@filtered_examples, filtered_examples)
+      RSpec.world.instance_variable_set(:@example_groups, example_groups)
+
+      current_count = RSpec.world.example_count
+
+      puts
+      puts <<-EXAMPLES.strip.gsub(/\s+/, ' ')
+        RSpec tracer is running #{current_count} examples (actual: #{actual_count},
+        skipped: #{actual_count - current_count})
+      EXAMPLES
+
+      RSpecTracer.running = true
+
+      super(example_groups)
+    end
+  end
+end

data/lib/rspec_tracer/ruby_coverage.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module RSpecTracer
+  module RubyCoverage
+    def result
+      RSpecTracer.coverage_reporter.coverage
+    end
+  end
+end

data/lib/rspec_tracer/runner.rb

@@ -0,0 +1,299 @@
+# frozen_string_literal: true
+
+require_relative 'cache'
+require_relative 'reporter'
+
+module RSpecTracer
+  class Runner
+    EXAMPLE_RUN_REASON = {
+      explicit_run: 'Explicit run',
+      no_cache: 'No cache',
+      failed_example: 'Failed previously',
+      pending_example: 'Pending previously',
+      files_changed: 'Files changed'
+    }.freeze
+
+    attr_reader :cache, :reporter
+
+    def initialize
+      @cache = RSpecTracer::Cache.new
+      @reporter = RSpecTracer::Reporter.new
+      @filtered_examples = {}
+
+      @cache.load_cache_for_run
+      filter_examples_to_run
+    end
+
+    def run_example?(example_id)
+      return true if explicit_run?
+
+      !@cache.all_examples.key?(example_id) || @filtered_examples.key?(example_id)
+    end
+
+    def run_example_reason(example_id)
+      return EXAMPLE_RUN_REASON[:explicit_run] if explicit_run?
+
+      @filtered_examples[example_id] || EXAMPLE_RUN_REASON[:no_cache]
+    end
+
+    def register_example(example)
+      @reporter.register_example(example)
+    end
+
+    def on_example_skipped(example_id)
+      @reporter.on_example_skipped(example_id)
+    end
+
+    def on_example_passed(example_id, execution_result)
+      @reporter.on_example_passed(example_id, execution_result)
+    end
+
+    def on_example_failed(example_id, execution_result)
+      @reporter.on_example_failed(example_id, execution_result)
+    end
+
+    def on_example_pending(example_id, execution_result)
+      @reporter.on_example_pending(example_id, execution_result)
+    end
+
+    def register_deleted_examples
+      @reporter.register_deleted_examples(@cache.all_examples)
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def generate_missed_coverage
+      missed_coverage = Hash.new do |files_coverage, file_path|
+        files_coverage[file_path] = Hash.new do |strength, line_number|
+          strength[line_number] = 0
+        end
+      end
+
+      @cache.cached_examples_coverage.each_pair do |example_id, example_coverage|
+        example_coverage.each_pair do |file_path, line_coverage|
+          next unless @reporter.example_skipped?(example_id)
+
+          file_name = RSpecTracer::SourceFile.file_name(file_path)
+
+          next if @reporter.file_deleted?(file_name)
+
+          line_coverage.each_pair do |line_number, strength|
+            missed_coverage[file_path][line_number] += strength
+          end
+        end
+      end
+
+      missed_coverage
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def register_dependency(examples_coverage)
+      examples_coverage.each_pair do |example_id, example_coverage|
+        register_example_files_dependency(example_id)
+
+        example_coverage.each_key do |file_path|
+          source_file = RSpecTracer::SourceFile.from_path(file_path)
+
+          next if RSpecTracer.filters.any? { |filter| filter.match?(source_file) }
+
+          @reporter.register_source_file(source_file)
+          @reporter.register_dependency(example_id, source_file[:file_name])
+        end
+      end
+
+      @reporter.pending_examples.each do |example_id|
+        register_example_files_dependency(example_id)
+      end
+    end
+
+    def register_untraced_dependency(trace_point_files)
+      untraced_files = generate_untraced_files(trace_point_files)
+
+      untraced_files.each do |file_path|
+        source_file = RSpecTracer::SourceFile.from_path(file_path)
+
+        next if RSpecTracer.filters.any? { |filter| filter.match?(source_file) }
+
+        @reporter.register_source_file(source_file)
+
+        @reporter.all_examples.each_key do |example_id|
+          @reporter.register_dependency(example_id, source_file[:file_name])
+        end
+      end
+    end
+
+    def register_examples_coverage(examples_coverage)
+      @reporter.register_examples_coverage(examples_coverage)
+    end
+
+    def generate_report
+      @reporter.generate_last_run_report
+
+      generate_failed_examples_report
+      generate_pending_examples_report
+
+      %i[all_files all_examples dependency examples_coverage].each do |report_type|
+        send("generate_#{report_type}_report")
+      end
+
+      @reporter.generate_reverse_dependency_report
+      @reporter.write_reports
+    end
+
+    private
+
+    def explicit_run?
+      ENV.fetch('RSPEC_TRACER_NO_SKIP', 'false') == 'true'
+    end
+
+    def filter_examples_to_run
+      add_previously_failed_examples
+      add_previously_pending_examples
+      filter_by_files_changed
+    end
+
+    def add_previously_failed_examples
+      @cache.failed_examples.each do |example_id|
+        @filtered_examples[example_id] = EXAMPLE_RUN_REASON[:failed_example]
+      end
+    end
+
+    def add_previously_pending_examples
+      @cache.pending_examples.each do |example_id|
+        @filtered_examples[example_id] = EXAMPLE_RUN_REASON[:pending_example]
+      end
+    end
+
+    def filter_by_files_changed
+      @cache.dependency.each_pair do |example_id, files|
+        next if @filtered_examples.key?(example_id)
+
+        files.each do |file_name|
+          break if filtered_by_file_changed?(example_id, file_name)
+        end
+      end
+    end
+
+    def filtered_by_file_changed?(example_id, file_name)
+      if @reporter.file_changed?(file_name)
+        @filtered_examples[example_id] = EXAMPLE_RUN_REASON[:files_changed]
+
+        return true
+      end
+
+      source_file = registered_source_file(file_name)
+
+      return false if source_file &&
+        @cache.all_files[file_name][:digest] == source_file[:digest]
+
+      @filtered_examples[example_id] = EXAMPLE_RUN_REASON[:files_changed]
+
+      if source_file.nil?
+        @reporter.on_file_deleted(file_name)
+      else
+        @reporter.on_file_modified(file_name)
+      end
+
+      true
+    end
+
+    def generate_untraced_files(trace_point_files)
+      all_files = @reporter.all_files
+        .each_value
+        .with_object([]) { |source_file, files| files << source_file[:file_path] }
+
+      (trace_point_files | fetch_rspec_required_files) - all_files
+    end
+
+    def fetch_rspec_required_files
+      rspec_root = RSpec::Core::RubyProject.root
+      rspec_path = RSpec.configuration.default_path
+
+      RSpec.configuration.requires.map do |file_name|
+        file_name = "#{file_name}.rb" if File.extname(file_name).empty?
+
+        File.join(rspec_root, rspec_path, file_name)
+      end
+    end
+
+    def register_example_files_dependency(example_id)
+      example = @reporter.all_examples[example_id]
+
+      register_example_file_dependency(example_id, example[:file_name])
+
+      return if example[:rerun_file_name] == example[:file_name]
+
+      register_example_file_dependency(example_id, example[:rerun_file_name])
+    end
+
+    def register_example_file_dependency(example_id, file_name)
+      source_file = registered_source_file(file_name)
+
+      @reporter.register_source_file(source_file)
+      @reporter.register_dependency(example_id, file_name)
+    end
+
+    def registered_source_file(file_name)
+      @reporter.all_files[file_name] || RSpecTracer::SourceFile.from_name(file_name)
+    end
+
+    def generate_all_files_report
+      @cache.all_files.each_pair do |file_name, data|
+        next if @reporter.all_files.key?(file_name) ||
+          @reporter.file_deleted?(file_name)
+
+        @reporter.all_files[file_name] = data
+      end
+    end
+
+    def generate_all_examples_report
+      @cache.all_examples.each_pair do |example_id, data|
+        next if @reporter.all_examples.key?(example_id) ||
+          @reporter.example_deleted?(example_id)
+
+        @reporter.all_examples[example_id] = data
+      end
+    end
+
+    def generate_failed_examples_report
+      @cache.failed_examples.each do |example_id|
+        next if @reporter.example_deleted?(example_id) ||
+          @reporter.all_examples.key?(example_id)
+
+        @reporter.register_failed_example(example_id)
+      end
+    end
+
+    def generate_pending_examples_report
+      @cache.pending_examples.each do |example_id|
+        next if @reporter.example_deleted?(example_id) ||
+          @reporter.all_examples.key?(example_id)
+
+        @reporter.register_pending_example(example_id)
+      end
+    end
+
+    def generate_dependency_report
+      @cache.dependency.each_pair do |example_id, data|
+        next if @reporter.dependency.key?(example_id) ||
+          @reporter.example_deleted?(example_id)
+
+        @reporter.dependency[example_id] = data.reject do |file_name|
+          @reporter.file_deleted?(file_name)
+        end
+      end
+
+      @reporter.dependency.transform_values!(&:to_a)
+    end
+
+    def generate_examples_coverage_report
+      @cache.cached_examples_coverage.each_pair do |example_id, data|
+        next if @reporter.examples_coverage.key?(example_id) ||
+          @reporter.example_deleted?(example_id)
+
+        @reporter.examples_coverage[example_id] = data.reject do |file_name|
+          @reporter.file_deleted?(file_name)
+        end
+      end
+    end
+  end
+end

data/lib/rspec_tracer/source_file.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RSpecTracer
+  module SourceFile
+    PROJECT_ROOT_REGEX = Regexp.new("^#{Regexp.escape(RSpecTracer.root)}").freeze
+
+    module_function
+
+    def from_path(file_path)
+      return unless File.file?(file_path)
+
+      {
+        file_path: file_path,
+        file_name: file_name(file_path),
+        digest: Digest::MD5.hexdigest(File.read(file_path))
+      }
+    end
+
+    def from_name(file_name)
+      from_path(file_path(file_name))
+    end
+
+    def file_name(file_path)
+      file_path.sub(PROJECT_ROOT_REGEX, '')
+    end
+
+    def file_path(file_name)
+      File.expand_path(file_name.sub(%r{^/}, ''), RSpecTracer.root)
+    end
+  end
+end

data/lib/rspec_tracer/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module RSpecTracer
+  VERSION = '0.1.0'
+end

data/lib/rspec_tracer.rb

@@ -0,0 +1,243 @@
+# frozen_string_literal: true
+
+require 'English'
+
+require 'digest/md5'
+require 'docile'
+require 'fileutils'
+require 'forwardable'
+require 'json'
+require 'pry'
+require 'set'
+
+require_relative 'rspec_tracer/configuration'
+RSpecTracer.extend RSpecTracer::Configuration
+
+require_relative 'rspec_tracer/coverage_reporter'
+require_relative 'rspec_tracer/defaults'
+require_relative 'rspec_tracer/example'
+require_relative 'rspec_tracer/html_reporter/reporter'
+require_relative 'rspec_tracer/rspec_reporter'
+require_relative 'rspec_tracer/rspec_runner'
+require_relative 'rspec_tracer/ruby_coverage'
+require_relative 'rspec_tracer/runner'
+require_relative 'rspec_tracer/source_file'
+require_relative 'rspec_tracer/version'
+
+module RSpecTracer
+  class << self
+    attr_accessor :running, :pid
+
+    def start(&block)
+      RSpecTracer.running = false
+      RSpecTracer.pid = Process.pid
+
+      puts 'Started RSpec tracer'
+
+      configure(&block) if block
+
+      initial_setup
+    end
+
+    # rubocop:disable Metrics/AbcSize
+    def filter_examples
+      groups = Set.new
+      to_run = Hash.new { |hash, group| hash[group] = [] }
+
+      RSpec.world.filtered_examples.each_pair do |example_group, examples|
+        examples.each do |example|
+          tracer_example = RSpecTracer::Example.from(example)
+          example_id = tracer_example[:example_id]
+          example.metadata[:rspec_tracer_example_id] = example_id
+
+          if runner.run_example?(example_id)
+            run_reason = runner.run_example_reason(example_id)
+            tracer_example[:run_reason] = run_reason
+            example.metadata[:description] = "#{example.description} (#{run_reason})"
+
+            to_run[example_group] << example
+            groups << example.example_group.parent_groups.last
+
+            runner.register_example(tracer_example)
+          else
+            runner.on_example_skipped(example_id)
+          end
+        end
+      end
+
+      [to_run, groups.to_a]
+    end
+    # rubocop:enable Metrics/AbcSize
+
+    def at_exit_behavior
+      return unless RSpecTracer.pid == Process.pid && RSpecTracer.running
+
+      run_exit_tasks
+    end
+
+    def start_example_trace
+      trace_point.enable if trace_example?
+    end
+
+    def stop_example_trace(success)
+      return unless trace_example?
+
+      trace_point.disable
+
+      unless success
+        @traced_files = Set.new
+
+        return
+      end
+
+      @trace_example = false
+    end
+
+    def runner
+      return @runner if defined?(@runner)
+    end
+
+    def coverage_reporter
+      return @coverage_reporter if defined?(@coverage_reporter)
+    end
+
+    def trace_point
+      return @trace_point if defined?(@trace_point)
+    end
+
+    def traced_files
+      return @traced_files if defined?(@traced_files)
+    end
+
+    def trace_example?
+      defined?(@trace_example) ? @trace_example : false
+    end
+
+    def simplecov?
+      return @simplecov if defined?(@simplecov)
+    end
+
+    private
+
+    def initial_setup
+      unless setup_rspec
+        puts 'Could not find a running RSpec process'
+
+        return
+      end
+
+      setup_coverage
+      setup_trace_point
+
+      @runner = RSpecTracer::Runner.new
+      @coverage_reporter = RSpecTracer::CoverageReporter.new
+    end
+
+    def setup_rspec
+      runners = ObjectSpace.each_object(::RSpec::Core::Runner) do |runner|
+        runner_clazz = runner.singleton_class
+        clazz = RSpecTracer::RSpecRunner
+
+        runner_clazz.prepend(clazz) unless runner_clazz.ancestors.include?(clazz)
+
+        reporter_clazz = runner.configuration.reporter.singleton_class
+        clazz = RSpecTracer::RSpecReporter
+
+        reporter_clazz.prepend(clazz) unless reporter_clazz.ancestors.include?(clazz)
+      end
+
+      runners.positive?
+    end
+
+    def setup_coverage
+      @simplecov = defined?(SimpleCov) && SimpleCov.running
+
+      if simplecov?
+        # rubocop:disable Lint/EmptyBlock
+        SimpleCov.at_exit {}
+        # rubocop:enable Lint/EmptyBlock
+      else
+        require 'coverage'
+
+        ::Coverage.start
+      end
+    end
+
+    def setup_trace_point
+      @trace_example = true
+      @traced_files = Set.new
+
+      @trace_point = TracePoint.new(:call) do |tp|
+        RSpecTracer.traced_files << tp.path if tp.path.start_with?(RSpecTracer.root)
+      end
+    end
+
+    def run_exit_tasks
+      generate_reports
+
+      simplecov? ? run_simplecov_exit_task : run_coverage_exit_task
+    ensure
+      RSpecTracer.running = false
+    end
+
+    def generate_reports
+      puts 'RSpec tracer is generating reports'
+
+      generate_tracer_reports
+      generate_coverage_reports
+      runner.generate_report
+      RSpecTracer::HTMLReporter::Reporter.new.generate_report
+    end
+
+    def generate_tracer_reports
+      runner.register_deleted_examples
+      runner.register_dependency(coverage_reporter.examples_coverage)
+      runner.register_untraced_dependency(@traced_files)
+    end
+
+    def generate_coverage_reports
+      coverage_reporter.generate_final_examples_coverage
+      coverage_reporter.merge_coverage(runner.generate_missed_coverage)
+      runner.register_examples_coverage(coverage_reporter.examples_coverage)
+    end
+
+    def run_simplecov_exit_task
+      coverage_clazz = ::Coverage.singleton_class
+      clazz = RSpecTracer::RubyCoverage
+      coverage_clazz.prepend(clazz) unless coverage_clazz.ancestors.include?(clazz)
+
+      puts 'SimpleCov will now generate coverage report (<3 RSpec tracer)'
+
+      SimpleCov.result.format!
+    end
+
+    def run_coverage_exit_task
+      coverage_reporter.generate_final_coverage
+
+      file_name = File.join(RSpecTracer.coverage_path, 'coverage.json')
+
+      write_coverage_report(file_name)
+      print_coverage_stats(file_name)
+    end
+
+    def write_coverage_report(file_name)
+      report = {
+        RSpecTracer: {
+          coverage: coverage_reporter.coverage,
+          timestamp: Time.now.utc.to_i
+        }
+      }
+
+      File.write(file_name, JSON.pretty_generate(report))
+    end
+
+    def print_coverage_stats(file_name)
+      stat = coverage_reporter.coverage_stat
+
+      puts <<-REPORT.strip.gsub(/\s+/, ' ')
+        Coverage report generated for RSpecTracer to #{file_name}. #{stat[:covered_lines]}
+        / #{stat[:total_lines]} LOC (#{stat[:covered_percent]}%) covered
+      REPORT
+    end
+  end
+end