mutation_tester 1.2.0

data/lib/mutation_tester/progress_display.rb

@@ -0,0 +1,130 @@
+module MutationTester
+  class ProgressDisplay
+    attr_reader :total, :current, :current_mutation
+
+    def initialize(total, config, output_stream: $stdout.clone)
+      @output_stream = output_stream
+      @total = total
+      @current = 0
+      @current_mutation = nil
+      @config = config
+      @start_time = Time.now
+      @spinner_frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
+      @spinner_index = 0
+      @lock = Mutex.new
+      @spinner_thread = nil
+      @stop_spinner = false
+
+      start_spinner if @config.show_progress
+    end
+
+    def update(mutation, index)
+      @lock.synchronize do
+        @current = index
+        @current_mutation = mutation
+      end
+    end
+
+    def finish
+      @lock.synchronize do
+        @stop_spinner = true
+        if @config.show_progress
+          clear_line
+          elapsed = Time.now - @start_time
+          @output_stream.puts "  #{Rainbow("Completed in #{format_duration(elapsed)}").green}"
+        end
+      end
+      stop_spinner
+    end
+
+    private
+
+    def render(already_locked = false)
+      return unless @config.show_progress
+
+      if already_locked
+        _render_internal
+      else
+        @lock.synchronize { _render_internal }
+      end
+    end
+
+    def _render_internal
+      clear_line
+
+      progress = (@current.to_f / @total * 100).round(1)
+      progress_bar = create_progress_bar(progress)
+      spinner = @spinner_frames[@spinner_index]
+
+      mutation_info = @current_mutation ? " | #{@current_mutation[:type]} | line #{@current_mutation[:line]}" : ''
+
+      line = "#{Rainbow(spinner).magenta} [#{progress_bar}] #{Rainbow(progress.to_s + "%").bright} | " \
+             "#{Rainbow("#{@current}/#{@total}").cyan} mutations processed#{mutation_info}"
+
+      @output_stream.print line
+      @output_stream.flush
+    end
+
+    def create_progress_bar(percentage)
+      width = 20
+      filled = (percentage / 100.0 * width).round
+      empty = width - filled
+
+      Rainbow('█' * filled).green + Rainbow('░' * empty).white
+    end
+
+    def clear_line
+      @output_stream.print "\r"
+      @output_stream.print ' ' * 100
+      @output_stream.print "\r"
+    end
+
+    def format_duration(seconds)
+      if seconds < 60
+        "#{seconds.round(1)}s"
+      elsif seconds < 3600
+        minutes = (seconds / 60).floor
+        secs = (seconds % 60).round
+        "#{minutes}m #{secs}s"
+      else
+        hours = (seconds / 3600).floor
+        minutes = ((seconds % 3600) / 60).floor
+        "#{hours}h #{minutes}m"
+      end
+    end
+
+    def start_spinner
+      return if @spinner_thread
+
+      @stop_spinner = false
+      @spinner_thread = Thread.new do
+        loop do
+          should_stop = @lock.synchronize do
+            if @stop_spinner
+              true
+            else
+              @spinner_index = (@spinner_index + 1) % @spinner_frames.length
+              render(true) if @config.show_progress
+              false
+            end
+          end
+
+          break if should_stop
+
+          sleep 0.1
+        end
+      end
+
+      @spinner_thread.abort_on_exception = false
+    end
+
+    def stop_spinner
+      return unless @spinner_thread
+
+      @stop_spinner = true
+      @spinner_thread.wakeup if @spinner_thread.status == 'sleep'
+      @spinner_thread.join
+      @spinner_thread = nil
+    end
+  end
+end

data/lib/mutation_tester/railtie.rb

@@ -0,0 +1,7 @@
+module MutationTester
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      require_relative 'rake_task'
+    end
+  end
+end

data/lib/mutation_tester/rake_task.rb

@@ -0,0 +1,18 @@
+require 'rake'
+
+module MutationTester
+  RAKE_TASKS_PATH = File.expand_path('../tasks/mutation_tester.rake', __dir__)
+  BENCH_TASKS_PATH = File.expand_path('../tasks/bench.rake', __dir__)
+
+  @rake_tasks_loaded = false
+
+  def self.load_rake_tasks
+    return if @rake_tasks_loaded
+
+    @rake_tasks_loaded = true
+    load RAKE_TASKS_PATH
+    load BENCH_TASKS_PATH if File.exist?(BENCH_TASKS_PATH)
+  end
+end
+
+MutationTester.load_rake_tasks

data/lib/mutation_tester/reporters/base_reporter.rb

@@ -0,0 +1,154 @@
+module MutationTester
+  module Reporters
+    class BaseReporter
+      attr_reader :results, :source_file, :spec_file, :config
+
+      def self.score(results)
+        effective_killed = results.count { |r| %i[killed timeout].include?(status_for(r)) }
+        scored = results.count { |r| %i[killed timeout survived].include?(status_for(r)) }
+        return 0.0 if scored.zero?
+
+        (effective_killed.to_f / scored * 100).round(2)
+      end
+
+      def self.status_for(result)
+        result[:status] || (result[:killed] ? :killed : :survived)
+      end
+
+      def initialize(results, source_file, spec_file, config, interrupted: false)
+        @results = results
+        @source_file = source_file
+        @spec_file = spec_file
+        @config = config
+        @interrupted = interrupted
+      end
+
+      def interrupted?
+        @interrupted
+      end
+
+      def generate
+        raise NotImplementedError, 'Subclasses must implement #generate'
+      end
+
+      protected
+
+      def status_of(result)
+        self.class.status_for(result)
+      end
+
+      def count_with_status(status)
+        @results.count { |r| status_of(r) == status }
+      end
+
+      def killed_count
+        count_with_status(:killed)
+      end
+
+      def survived_count
+        count_with_status(:survived)
+      end
+
+      def timeout_count
+        count_with_status(:timeout)
+      end
+
+      def stillborn_count
+        count_with_status(:stillborn)
+      end
+
+      def error_count
+        count_with_status(:error)
+      end
+
+      def effective_killed_count
+        killed_count + timeout_count
+      end
+
+      def total_count
+        @results.size
+      end
+
+      def mutation_score
+        self.class.score(@results)
+      end
+
+      def quality_rating
+        score = mutation_score
+        if score >= 90 then 'Excellent 🌟'
+        elsif score >= 75 then 'Good 👍'
+        elsif score >= 60 then 'Fair 😐'
+        elsif score >= 40 then 'Poor 😟'
+        else 'Critical ⚠️'
+        end
+      end
+
+      def survived_mutations
+        @results.select { |r| status_of(r) == :survived }
+      end
+
+      DIFF_CONTEXT_LINES = 2
+      DIFF_DETAIL_STATUSES = %i[survived timeout].freeze
+
+      def survivor_groups
+        survived_mutations
+          .group_by { |r| [r[:file_path], r[:line]] }
+          .map { |(file_path, line), mutations| { file_path: file_path, line: line, mutations: mutations } }
+          .sort_by { |group| group[:line].to_i }
+      end
+
+      def diff_lines(mutations)
+        primary = mutations.first
+        context = source_context_for(primary)
+        return diff_without_context(mutations) unless context
+
+        lines, first, last = context
+        hunk = "@@ -#{first},#{last - first + 1} +#{first},#{last - first + mutations.size} @@"
+        (first..last).each_with_object([[:hunk, hunk, nil]]) do |number, out|
+          if number == primary[:line]
+            out << [:removed, lines[number - 1], nil]
+            indent = lines[number - 1][/\A\s*/]
+            mutations.each { |m| out << [:added, indent + replacement_text(m), m] }
+          else
+            out << [:context, lines[number - 1], nil]
+          end
+        end
+      end
+
+      private
+
+      def diff_without_context(mutations)
+        primary = mutations.first
+        removed = primary[:source_line] || primary[:original].to_s
+        [[:removed, removed, nil]] + mutations.map { |m| [:added, replacement_text(m), m] }
+      end
+
+      def replacement_text(mutation)
+        mutation[:mutated_line] || mutation[:mutated].to_s
+      end
+
+      def source_context_for(mutation)
+        line = mutation[:line]
+        return nil unless line.is_a?(Integer) && line >= 1 && mutation[:source_line]
+
+        lines = cached_source_lines(mutation[:file_path] || @source_file)
+        return nil unless lines && lines[line - 1] && lines[line - 1].strip == mutation[:source_line].strip
+
+        first = [line - DIFF_CONTEXT_LINES, 1].max
+        last = [line + DIFF_CONTEXT_LINES, lines.size].min
+        [lines, first, last]
+      end
+
+      def cached_source_lines(path)
+        @cached_source_lines ||= {}
+        return @cached_source_lines[path] if @cached_source_lines.key?(path)
+
+        @cached_source_lines[path] = begin
+          File.read(path).lines.map(&:chomp)
+        rescue StandardError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/mutation_tester/reporters/batch_json_reporter.rb

@@ -0,0 +1,72 @@
+module MutationTester
+  module Reporters
+    class BatchJsonReporter
+      SCHEMA_VERSION = 1
+
+      def initialize(result, config, passed:)
+        @result = result
+        @config = config
+        @passed = passed
+      end
+
+      def render
+        JSON.pretty_generate(envelope)
+      end
+
+      private
+
+      def envelope
+        {
+          schema_version: SCHEMA_VERSION,
+          summary: {
+            files: @result.processed.size + @result.skipped.size,
+            processed: @result.processed.size,
+            skipped: skipped_entries,
+            score: aggregate_score,
+            passed: @passed,
+            interrupted: @result.interrupted?
+          },
+          survivors: survivor_entries,
+          files: file_reports
+        }
+      end
+
+      def skipped_entries
+        @result.skipped.map do |entry|
+          {
+            file: entry.source_file,
+            reason: BatchRunner::SKIP_REASONS.fetch(entry.reason || :no_spec)
+          }
+        end
+      end
+
+      def survivor_entries
+        @result.survivors.map do |survivor|
+          {
+            file: File.expand_path(survivor[:file]),
+            line: survivor[:line],
+            type: survivor[:type],
+            original: survivor[:original],
+            mutated: survivor[:mutated]
+          }
+        end
+      end
+
+      def aggregate_score
+        BaseReporter.score(@result.processed.flat_map { |entry| entry.results || [] })
+      end
+
+      def file_reports
+        @result.processed.map do |entry|
+          JsonReporter.new(
+            entry.results || [],
+            File.expand_path(entry.source_file),
+            File.expand_path(entry.spec_file),
+            @config,
+            interrupted: !!entry.interrupted
+          ).report_data
+        end
+      end
+    end
+  end
+end

data/lib/mutation_tester/reporters/console_reporter.rb

@@ -0,0 +1,130 @@
+module MutationTester
+  module Reporters
+    class ConsoleReporter < BaseReporter
+      def generate
+        puts "\n" + Rainbow('=' * 80).bright
+        puts Rainbow('🧬 MUTATION TESTING REPORT').bright.cyan
+        puts Rainbow('=' * 80).bright
+
+        print_summary
+        print_survived_mutations if survived_count > 0
+
+        puts "\n" + Rainbow('=' * 80).bright
+      end
+
+      private
+
+      def print_summary
+        puts "\n📊 Summary:"
+        puts "  Total Mutations: #{total_count}"
+        puts "  #{Rainbow("Killed: " + killed_count.to_s).green} ✅"
+        puts "  #{Rainbow("Survived: " + survived_count.to_s).red} ❌"
+        puts "  #{Rainbow("Timeout: " + timeout_count.to_s).yellow} ⏱️"
+        puts "  #{Rainbow("Stillborn: " + stillborn_count.to_s).yellow} 🧬"
+        puts "  #{Rainbow("Errors: " + error_count.to_s).yellow} 💥"
+        print_excluded_summary
+        print_selection_summary
+        puts "  Mutation Score: #{Rainbow(mutation_score.to_s + "%").bright}"
+        puts "  Quality: #{quality_rating}"
+        puts "\n  " + progress_bar
+      end
+
+      def print_excluded_summary
+        count = excluded_line_count
+        return unless count.positive?
+
+        puts "  #{Rainbow("Excluded: " + count.to_s + " line(s) (mutation_tester:disable)").blue} 🚫"
+      end
+
+      def print_selection_summary
+        return unless selection_stats_available?
+
+        puts "  #{Rainbow("Selection: #{subset_kill_count} kill(s) by test subset, #{full_kill_count} by full file").cyan} ⚡"
+      end
+
+      def selection_stats_available?
+        return false unless @config.test_selection && FrameworkDetector.detect(@spec_file) == :rspec
+
+        @config.runner != :in_memory || @results.any? { |result| result.key?(:kill_phase) }
+      end
+
+      def subset_kill_count
+        kill_phase_count(:subset)
+      end
+
+      def full_kill_count
+        kill_phase_count(:full)
+      end
+
+      def kill_phase_count(phase)
+        @results.count { |r| r[:kill_phase] == phase }
+      end
+
+      def excluded_line_count
+        MutationTester::Mutator.disabled_lines(File.read(@source_file)).size
+      rescue StandardError
+        0
+      end
+
+      def progress_bar
+        filled = (mutation_score / 5).to_i
+        empty = 20 - filled
+        bar = Rainbow('█' * filled).green + Rainbow('░' * empty).white
+        "[#{bar}] #{mutation_score}%"
+      end
+
+      def print_survived_mutations
+        puts "\n" + Rainbow('⚠️  Survived Mutations (Need Improvement):').yellow
+        puts Rainbow('-' * 80).yellow
+
+        survivor_groups.each { |group| print_survivor_group(group) }
+      end
+
+      def print_survivor_group(group)
+        mutations = group[:mutations]
+        puts "\n  #{format_location(mutations.first)}#{variant_count_suffix(mutations)}"
+        mutations.each do |mutation|
+          puts "    #{Rainbow("##{mutation[:id]}").bright} [#{mutation[:type]}] #{mutation[:description]}"
+        end
+        puts
+        diff_lines(mutations).each do |kind, text, mutation|
+          puts render_diff_line(kind, text, mutation, mutations.size)
+        end
+        puts "  💡 Suggestion: #{suggestion_for(mutations)}"
+      end
+
+      def variant_count_suffix(mutations)
+        mutations.size > 1 ? " (#{mutations.size} variants)" : ''
+      end
+
+      def suggestion_for(mutations)
+        if mutations.size == 1
+          "Add test to verify behavior when #{mutations.first[:description].downcase}"
+        else
+          "Add tests to verify behavior for each of the #{mutations.size} variants above"
+        end
+      end
+
+      def render_diff_line(kind, text, mutation, variant_count)
+        case kind
+        when :hunk then "    #{Rainbow(text).cyan}"
+        when :removed then "    #{Rainbow('-').red} #{text}"
+        when :added then "    #{Rainbow('+').green} #{text}#{variant_marker(mutation, variant_count)}"
+        else "      #{text}"
+        end
+      end
+
+      def variant_marker(mutation, variant_count)
+        variant_count > 1 ? "  #{Rainbow("(##{mutation[:id]})").bright}" : ''
+      end
+
+      def format_location(mutation)
+        if @config.show_file_path
+          "Location: #{Rainbow("#{mutation[:file_path]}:#{mutation[:line]}").cyan}"
+        else
+          "Line: #{Rainbow(mutation[:line].to_s).cyan}"
+        end
+      end
+    end
+  end
+end