rspec-tracer 1.2.3 → 2.0.0.pre.2

data/lib/rspec_tracer/reporter.rb

@@ -1,204 +0,0 @@
-# frozen_string_literal: true
-
-module RSpecTracer
-  class Reporter
-    attr_reader :all_examples, :interrupted_examples, :duplicate_examples,
-                :possibly_flaky_examples, :flaky_examples, :pending_examples,
-                :skipped_examples, :failed_examples, :all_files, :modified_files,
-                :deleted_files, :dependency, :examples_coverage
-
-    attr_accessor :reverse_dependency, :last_run
-
-    def initialize
-      initialize_examples
-      initialize_files
-      initialize_dependency
-      initialize_coverage
-    end
-
-    def register_example(example)
-      @all_examples[example[:example_id]] = example
-      @duplicate_examples[example[:example_id]] << example
-    end
-
-    def deregister_duplicate_examples
-      @duplicate_examples.select! { |_, examples| examples.count > 1 }
-
-      return if @duplicate_examples.empty?
-
-      @all_examples.reject! { |example_id, _| @duplicate_examples.key?(example_id) }
-    end
-
-    def on_example_skipped(example_id)
-      @skipped_examples << example_id
-    end
-
-    def on_example_passed(example_id, result)
-      return if @duplicate_examples.key?(example_id)
-
-      @passed_examples << example_id
-      @all_examples[example_id][:execution_result] = formatted_execution_result(result)
-    end
-
-    def on_example_failed(example_id, result)
-      return if @duplicate_examples.key?(example_id)
-
-      @failed_examples << example_id
-      @all_examples[example_id][:execution_result] = formatted_execution_result(result)
-    end
-
-    def on_example_pending(example_id, result)
-      return if @duplicate_examples.key?(example_id)
-
-      @pending_examples << example_id
-      @all_examples[example_id][:execution_result] = formatted_execution_result(result)
-    end
-
-    def register_interrupted_examples
-      @all_examples.each_pair do |example_id, example|
-        next if example.key?(:execution_result)
-
-        @interrupted_examples << example_id
-      end
-
-      return if @interrupted_examples.empty?
-
-      RSpecTracer.logger.info "RSpec tracer is not processing #{@interrupted_examples.count} interrupted examples"
-    end
-
-    def register_deleted_examples(seen_examples)
-      @deleted_examples = seen_examples.keys.to_set - (@skipped_examples | @all_examples.keys)
-      @deleted_examples -= @interrupted_examples
-
-      @deleted_examples.select! do |example_id|
-        example = seen_examples[example_id]
-
-        file_changed?(example[:file_name]) || file_changed?(example[:rerun_file_name])
-      end
-    end
-
-    def register_possibly_flaky_example(example_id)
-      @possibly_flaky_examples << example_id
-    end
-
-    def register_flaky_example(example_id)
-      @flaky_examples << example_id
-    end
-
-    def register_failed_example(example_id)
-      @failed_examples << example_id
-    end
-
-    def register_pending_example(example_id)
-      @pending_examples << example_id
-    end
-
-    def duplicate_example?(example_id)
-      @duplicate_examples.key?(example_id)
-    end
-
-    def example_interrupted?(example_id)
-      @interrupted_examples.include?(example_id)
-    end
-
-    def example_passed?(example_id)
-      @passed_examples.include?(example_id)
-    end
-
-    def example_skipped?(example_id)
-      @skipped_examples.include?(example_id)
-    end
-
-    def example_failed?(example_id)
-      @failed_examples.include?(example_id)
-    end
-
-    def example_pending?(example_id)
-      @pending_examples.include?(example_id)
-    end
-
-    def example_deleted?(example_id)
-      @deleted_examples.include?(example_id)
-    end
-
-    def register_source_file(source_file)
-      @all_files[source_file[:file_name]] = source_file
-    end
-
-    def on_file_deleted(file_name)
-      @deleted_files << file_name
-    end
-
-    def on_file_modified(file_name)
-      @modified_files << file_name
-    end
-
-    def file_deleted?(file_name)
-      @deleted_files.include?(file_name)
-    end
-
-    def file_modified?(file_name)
-      @modified_files.include?(file_name)
-    end
-
-    def file_changed?(file_name)
-      file_deleted?(file_name) || file_modified?(file_name)
-    end
-
-    def register_dependency(example_id, file_name)
-      @dependency[example_id] << file_name
-    end
-
-    def register_examples_coverage(examples_coverage)
-      @examples_coverage = examples_coverage
-    end
-
-    private
-
-    def initialize_examples
-      @all_examples = {}
-      @duplicate_examples = Hash.new { |examples, example_id| examples[example_id] = [] }
-      @interrupted_examples = Set.new
-      @passed_examples = Set.new
-      @possibly_flaky_examples = Set.new
-      @flaky_examples = Set.new
-      @failed_examples = Set.new
-      @skipped_examples = Set.new
-      @pending_examples = Set.new
-      @deleted_examples = Set.new
-    end
-
-    def initialize_files
-      @all_files = {}
-      @modified_files = Set.new
-      @deleted_files = Set.new
-    end
-
-    def initialize_dependency
-      @dependency = Hash.new { |hash, key| hash[key] = Set.new }
-      @reverse_dependency = Hash.new do |examples, file_name|
-        examples[file_name] = {
-          example_count: 0,
-          examples: Hash.new(0)
-        }
-      end
-    end
-
-    def initialize_coverage
-      @examples_coverage = Hash.new do |examples, example_id|
-        examples[example_id] = Hash.new do |files, file_name|
-          files[file_name] = {}
-        end
-      end
-    end
-
-    def formatted_execution_result(result)
-      {
-        started_at: result.started_at.utc,
-        finished_at: result.finished_at.utc,
-        run_time: result.run_time,
-        status: result.status.to_s
-      }
-    end
-  end
-end

data/lib/rspec_tracer/rspec_reporter.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-module RSpecTracer
-  module RSpecReporter
-    def example_started(example)
-      RSpecTracer.coverage_reporter.record_coverage
-      RSpecTracer.start_example_trace
-
-      super
-    end
-
-    def example_finished(example)
-      example_id = example.metadata[:rspec_tracer_example_id]
-      RSpecTracer.stop_example_trace(example_id)
-      RSpecTracer.coverage_reporter.compute_diff(example_id)
-
-      super
-    end
-
-    def example_passed(example)
-      example_id = example.metadata[:rspec_tracer_example_id]
-      RSpecTracer.runner.on_example_passed(example_id, example.execution_result)
-
-      super
-    end
-
-    def example_failed(example)
-      example_id = example.metadata[:rspec_tracer_example_id]
-      RSpecTracer.runner.on_example_failed(example_id, example.execution_result)
-
-      super
-    end
-
-    def example_pending(example)
-      example_id = example.metadata[:rspec_tracer_example_id]
-      RSpecTracer.runner.on_example_pending(example_id, example.execution_result)
-
-      super
-    end
-  end
-end

data/lib/rspec_tracer/rspec_runner.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-module RSpecTracer
-  module RSpecRunner
-    def run_specs(example_groups)
-      actual_count = RSpec.world.example_count
-
-      if _no_examples?(actual_count)
-        super
-
-        return
-      end
-
-      starting = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      filtered_examples, filtered_example_groups = RSpecTracer.filter_examples
-
-      if _duplicate_examples?
-        super([])
-
-        return
-      end
-
-      RSpec.world.instance_variable_set(:@filtered_examples, filtered_examples)
-      RSpec.world.instance_variable_set(:@example_groups, filtered_example_groups)
-
-      current_count = RSpec.world.example_count
-      ending = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      elapsed = RSpecTracer::TimeFormatter.format_time(ending - starting)
-
-      RSpecTracer.logger.info <<-EXAMPLES.strip.gsub(/\s+/, ' ')
-        RSpec tracer is running #{current_count} examples (actual: #{actual_count},
-        skipped: #{actual_count - current_count}) (took #{elapsed})
-      EXAMPLES
-
-      RSpecTracer.running = true
-
-      super(filtered_example_groups)
-    end
-
-    def _no_examples?(actual_count)
-      return false unless actual_count.zero?
-
-      RSpecTracer.running = true
-      RSpecTracer.no_examples = true
-    end
-
-    def _duplicate_examples?
-      return false if RSpecTracer.runner.reporter.duplicate_examples.empty?
-
-      RSpecTracer.report_writer.print_duplicate_examples
-
-      RSpecTracer.running = true
-      RSpecTracer.duplicate_examples = RSpecTracer.fail_on_duplicates
-    end
-  end
-end

data/lib/rspec_tracer/ruby_coverage.rb

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

data/lib/rspec_tracer/runner.rb

@@ -1,278 +0,0 @@
-# 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',
-      interrupted: 'Interrupted previously',
-      flaky_example: 'Flaky example',
-      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 RSpecTracer.run_all_examples
-
-      !@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 RSpecTracer.run_all_examples
-
-      @filtered_examples[example_id] || EXAMPLE_RUN_REASON[:no_cache]
-    end
-
-    def register_example(example)
-      @reporter.register_example(example)
-    end
-
-    def deregister_duplicate_examples
-      @reporter.deregister_duplicate_examples
-    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_interrupted_examples
-      @reporter.register_interrupted_examples
-    end
-
-    def register_deleted_examples
-      @reporter.register_deleted_examples(@cache.all_examples)
-    end
-
-    # rubocop:disable Metrics/PerceivedComplexity
-    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 if @reporter.example_interrupted?(example_id) ||
-            @reporter.duplicate_example?(example_id)
-
-          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 || 0
-          end
-        end
-      end
-
-      missed_coverage
-    end
-    # rubocop:enable Metrics/PerceivedComplexity
-
-    def register_dependency(examples_coverage)
-      filtered_files = Set.new
-
-      examples_coverage.each_pair do |example_id, example_coverage|
-        next if @reporter.example_interrupted?(example_id) ||
-          @reporter.duplicate_example?(example_id)
-
-        register_example_files_dependency(example_id)
-
-        example_coverage.each_key do |file_path|
-          next if filtered_files.include?(file_path)
-
-          filtered_files << file_path unless register_file_dependency(example_id, file_path)
-        end
-      end
-
-      @reporter.pending_examples.each do |example_id|
-        register_example_files_dependency(example_id)
-      end
-    end
-
-    def register_traced_dependency(examples_traced_files)
-      rspec_required_files = fetch_rspec_required_files
-
-      examples_traced_files.each_pair do |example_id, traced_files|
-        required_files = traced_files | rspec_required_files
-
-        required_files.each { |file_path| register_file_dependency(example_id, file_path) }
-      end
-    end
-
-    def register_examples_coverage(examples_coverage)
-      @reporter.register_examples_coverage(examples_coverage)
-    end
-
-    private
-
-    def filter_examples_to_run
-      starting = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      @changed_files = fetch_changed_files
-
-      filter_by_example_status
-      filter_by_files_changed
-
-      ending = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-      elapsed = RSpecTracer::TimeFormatter.format_time(ending - starting)
-
-      RSpecTracer.logger.debug "RSpec tracer processed cache (took #{elapsed})"
-    end
-
-    def filter_by_example_status
-      add_previously_interrupted_examples
-      add_previously_flaky_examples
-      add_previously_failed_examples
-      add_previously_pending_examples
-    end
-
-    def filter_by_files_changed
-      @cache.dependency.each_pair do |example_id, files|
-        next if @filtered_examples.key?(example_id)
-        next unless @changed_files.intersect?(files)
-
-        @filtered_examples[example_id] = EXAMPLE_RUN_REASON[:files_changed]
-      end
-    end
-
-    def add_previously_interrupted_examples
-      @cache.interrupted_examples.each do |example_id|
-        @filtered_examples[example_id] = EXAMPLE_RUN_REASON[:interrupted]
-      end
-    end
-
-    def add_previously_flaky_examples
-      @cache.flaky_examples.each do |example_id|
-        @filtered_examples[example_id] = EXAMPLE_RUN_REASON[:flaky_example]
-
-        next unless @cache.dependency.key?(example_id)
-        next if @changed_files.intersect?(@cache.dependency[example_id])
-
-        @reporter.register_possibly_flaky_example(example_id)
-      end
-    end
-
-    def add_previously_failed_examples
-      @cache.failed_examples.each do |example_id|
-        next if @filtered_examples.key?(example_id)
-
-        @filtered_examples[example_id] = EXAMPLE_RUN_REASON[:failed_example]
-
-        next unless @cache.dependency.key?(example_id)
-        next if @changed_files.intersect?(@cache.dependency[example_id])
-
-        @reporter.register_possibly_flaky_example(example_id)
-      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 fetch_changed_files
-      @cache.all_files.each_value do |cached_file|
-        file_name = cached_file[:file_name]
-        source_file = RSpecTracer::SourceFile.from_name(file_name)
-
-        if source_file.nil?
-          @reporter.on_file_deleted(file_name)
-        elsif cached_file[:digest] != source_file[:digest]
-          @reporter.on_file_modified(file_name)
-        end
-      end
-
-      @reporter.modified_files | @reporter.deleted_files
-    end
-
-    def fetch_rspec_required_files
-      rspec_root = RSpec::Core::RubyProject.root
-      rspec_path = RSpec.configuration.default_path
-
-      RSpec.configuration.requires.each_with_object([]) do |file_name, required_files|
-        file_name = "#{file_name}.rb" if File.extname(file_name).empty?
-        file_path = File.join(rspec_root, rspec_path, file_name)
-
-        required_files << file_path if File.file?(file_path)
-      end
-    end
-
-    def register_example_files_dependency(example_id)
-      return if @reporter.example_interrupted?(example_id) ||
-        @reporter.duplicate_example?(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)
-      return if @reporter.example_interrupted?(example_id) ||
-        @reporter.duplicate_example?(example_id)
-
-      source_file = RSpecTracer::SourceFile.from_name(file_name)
-
-      if source_file.nil?
-        RSpecTracer.logger.debug "Skipping missing source file #{file_name} for example #{example_id}"
-        return
-      end
-
-      @reporter.register_source_file(source_file)
-      @reporter.register_dependency(example_id, file_name)
-    end
-
-    def register_file_dependency(example_id, file_path)
-      return if @reporter.example_interrupted?(example_id) ||
-        @reporter.duplicate_example?(example_id)
-
-      source_file = RSpecTracer::SourceFile.from_path(file_path)
-
-      if source_file.nil?
-        RSpecTracer.logger.debug "Skipping missing source file #{file_path} for example #{example_id}"
-        return false
-      end
-
-      return false if RSpecTracer.filters.any? { |filter| filter.match?(source_file) }
-
-      @reporter.register_source_file(source_file)
-      @reporter.register_dependency(example_id, source_file[:file_name])
-
-      true
-    end
-  end
-end