mutator_rails 0.1.8

data/lib/mutator_rails/mutation_log.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module MutatorRails
+  class MutationLog
+    include Adamantium::Flat
+    include Concord.new(:target_log)
+
+    HEADER = (['log',
+               'kills',
+               'alive',
+               'total',
+               'pct killed',
+               'mutations per sec',
+               'runtime'].join("\t") + "\n").freeze
+
+    def initialize(*)
+      super
+
+      @content = File.read(target_log)
+    end
+
+    def to_s
+      return '' unless complete?
+
+      [link, kills, alive, total, pct, mutations_per_sec, runtime].join("\t")
+    rescue
+      ''
+    end
+
+    def complete?
+      /^Subjects: / === content
+    end
+
+    def details
+      [klass, kills, alive, total, pct, mutations_per_sec, runtime, failure, j1]
+    rescue
+      []
+    end
+
+    def pct
+      return 100 unless total.positive?
+
+      ((100.0 * kills.to_f) / total).round(3)
+    end
+
+    def alive
+      content.match(/Alive:.+?(\d+)$/)[1].to_i rescue 0
+    end
+
+    def j1
+      content.match(/Jobs:.+?(\d+)$/)[1].to_i.eql(1) rescue false
+    end
+
+    def link
+      "=HYPERLINK(\"#{relative_path}\",\"#{klass}\")"
+    end
+
+    private
+
+    attr_reader :content
+
+    def relative_path
+      absolute_file_path.relative_path_from(csv_file)
+    end
+
+    def csv_file
+      Pathname(File.dirname(Pathname(csv))).realpath
+    end
+
+    def csv
+      MutatorRails::Config.configuration.analysis_csv
+    end
+
+    def klass
+      k = content.match(/match_expressions: \[(.+?)\]>$/)
+      k ? k[1] : ''
+    end
+
+    def failure
+      /Failures:/ === content
+    end
+
+    def absolute_file_path
+      Pathname(target_log).realpath
+    end
+
+    def kills
+      content.match(/Kills:.+?(\d+)$/)[1] rescue 0
+    end
+
+    def mutations_per_sec
+      return 0 unless runtime.positive?
+
+      (total.to_f / runtime).round(3)
+    end
+
+
+    def runtime
+      content.match(/Runtime:\s+?(.+)s/).captures.first.to_f
+    rescue
+      0.0
+    end
+
+    def total
+      alive.to_i + kills.to_i
+    end
+
+    def <=>(other)
+      [pct, -alive, link] <=> [other.pct, -other.alive, other.link]
+    end
+  end
+end

data/lib/mutator_rails/railtie.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'mutator_rails'
+require 'rails'
+
+module MutatorRails
+  class Railtie < Rails::Railtie
+    railtie_name :mutator_rails
+
+    rake_tasks do
+      load 'tasks/mutator/mutator.rake'
+      load 'tasks/mutator/analyze.rake'
+      load 'tasks/mutator/statistics.rake'
+      load 'tasks/mutator/cleanup.rake'
+      load 'tasks/mutator/mutate_files.rake'
+    end
+  end
+end

data/lib/mutator_rails/single_mutate.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module MutatorRails
+  class SingleMutate
+    include Concord.new(:guide, :file)
+
+    def call
+      parms = BASIC_PARMS.dup
+      parms << preface(path.basename) + base
+
+      parms << '1> ' + log.to_s
+      log_dir
+
+      cmd = first_run(parms)
+      rerun(cmd)
+    end
+
+    def log
+      if File.exist?(old_log)
+        # repair - this is one time only
+        guide.update(full_log, code_md5, spec_md5)
+        File.rename(old_log, full_log)
+      end
+      
+      full_log
+    end
+
+    def full_log
+      log_location.to_s + '.log'
+    end
+
+    def old_log
+      "#{log_location}_#{code_md5}_#{spec_md5}_#{MUTANT_VERSION}.log"
+    end
+
+    def log_location
+      path.sub(APP_BASE, logroot).sub('.rb', '')
+    end
+
+    def log_dir
+      log_location.dirname.tap do |dir|
+        FileUtils.mkdir_p(dir)
+      end
+    end
+
+    def spec_md5
+      Digest::MD5.file(spec_file).hexdigest
+    end
+
+    def base
+      path.basename.to_s.sub(path.extname, '').camelize
+    end
+
+    def code_md5
+      Digest::MD5.file(path).hexdigest
+    end
+
+    def path
+      Pathname.new(file)
+    end
+
+    def rerun(cmd)
+      return unless File.exist?(log)
+
+      content = File.read(log)
+      return unless /Failures:/ === content
+
+      FileUtils.cp(log, '/tmp')
+      cmd2 = cmd.sub('--use', '-j1 --use')
+      puts log
+      puts "[#{Time.current.iso8601}] #{cmd2}"
+      `#{cmd2}` unless ENV['RACK_ENV'].eql?('test')
+    end
+
+    def first_run(parms)
+      cmd = spec_opt + COMMAND + parms.join(' ')
+
+      if changed? || !complete?(log) || failed?(log)
+        puts "[#{Time.current.iso8601}] #{cmd}"
+        `#{cmd}` unless ENV['RACK_ENV'].eql?('test')
+        guide.update(log, code_md5, spec_md5)
+      end
+
+      cmd
+    end
+
+    def spec_opt
+      "SPEC_OPTS=\"--pattern #{spec_file}\" "
+    end
+
+    def spec_file
+      file.sub(APP_BASE, 'spec/').sub('.rb', '_spec.rb')
+    end
+
+    def complete?(log)
+      content = File.read(log)
+      /^Subjects: / === content
+    end
+
+    def failed?(log)
+      content = File.read(log)
+      /Failures:/ === content
+    end
+
+    def log_correct?
+      guide.current?(log, code_md5, spec_md5)
+    end
+
+    def preface(base)
+      rest = file.sub(APP_BASE, '').sub(/(lib)\//, '').sub(base.to_s, '')
+      return '' if rest == ''
+
+      content = File.read(spec_file)
+      d       = content.match(/RSpec.describe\s+([^ ,]+)/)
+      cs      = d[1].split('::')
+      cs.pop
+      f = cs.join('::')
+      f += '::' if f.present?
+      f
+    end
+
+    private
+    
+    def changed?
+      !log_correct?
+    end
+
+    def logroot
+      MutatorRails::Config.configuration.logroot
+    end
+  end
+end

data/lib/mutator_rails/statistics.rb

@@ -0,0 +1,192 @@
+# frozen_string_literal: true
+
+require 'mutator_rails/mutation_log'
+
+module MutatorRails
+  class Statistics
+    include Procto.call
+
+    def call
+      @content = ListMaker.new.make_list.map(&:details)
+
+      @stats = []
+      total_mutations
+      fully_mutated
+      failures
+      fallback_to_j1
+      top_10_alive
+      top_10_longest
+      top_10_total_mutations
+
+      puts " ... storing #{stats_file}"
+      puts text
+      File.write(stats_file, text)
+    end
+
+    private
+
+    def fully_mutated
+      stats << ''
+      stats << "#{full_mutations} module(s) were fully mutated (#{fully_pct.round(1)}%)"
+    end
+
+    def failures
+      header = false
+      content.each do |detail|
+        failure = detail[7]
+        if failure
+          unless header
+            failure_header
+            header = true
+          end
+          stats << detail[0]
+        end
+      end
+    end
+
+    def failure_header
+      stats << ''
+      stats << "The following modules remain with failures (check log):"
+    end
+
+    def fallback_to_j1
+      header = false
+      content.each do |detail|
+        failure = detail[8]
+        if failure
+          unless header
+            j1_header
+            header = true
+          end
+          stats << detail[0]
+        end
+      end
+    end
+
+    def j1_header
+      stats << ''
+      stats << "The following modules fell back to non-parallel(-j1):"
+    end
+
+    def top_10_alive
+      stats << ''
+      stats << "The following modules had most alive mutations (top 10):"
+      content.sort_by { |d| -d[2].to_i }.take(10).each do |detail|
+        alive = detail[2]
+        if alive.positive?
+          stats << " . #{detail[0]} (#{alive})"
+        end
+      end
+    end
+
+    def top_10_longest
+      stats << ''
+      stats << "The following modules had longest mutation time (top 10):"
+      content.sort_by { |d| -d[6].to_i }.take(10).each do |detail|
+        time = detail[6]
+        if time&.positive?
+          stats << " . #{detail[0]} (#{humanize(time.to_i)})"
+        end
+      end
+    end
+
+    def top_10_total_mutations
+      stats << ''
+      stats << "The following modules had largest mutation count (top 10):"
+      content.sort_by { |d| -d[3].to_i }.take(10).each do |detail|
+        cnt = detail[3]
+        if cnt&.positive?
+          stats << " . #{detail[0]} (#{cnt})"
+        end
+      end
+    end
+
+    def text
+      stats.join("\n")
+    end
+
+    def total_mutations
+      stats << ''
+      stats << "#{content.size} module(s) were mutated in #{total_mutation_time}"
+      stats << "for a total of #{tot_mutations} mutations tested @ #{per_sec.round(2)}/sec average"
+      stats << "which left #{total_alive} mutations alive (#{alive_pct.round(1)}%)"
+      stats << "and #{total_kills} killed (#{killed_pct.round(1)}%)"
+    end
+
+    def full_mutations
+      tot = 0
+      content.each do |detail|
+        alive = detail[2]
+        tot   += 1 if alive&.zero?
+      end
+      tot
+    end
+
+    def fully_pct
+      100.0 * full_mutations / content.size
+    end
+
+    def total_alive
+      tot = 0
+      content.each do |detail|
+        alive = detail[2]
+        tot   += alive.to_i
+      end
+      tot
+    end
+
+    def total_mutation_time
+      humanize(total_seconds.to_i)
+    end
+
+    def total_seconds
+      tot = 0.0
+      content.each do |detail|
+        runtime = detail[6]
+        tot     += runtime if runtime
+      end
+      tot
+    end
+
+    def per_sec
+      tot_mutations.to_f / total_seconds
+    end
+
+    def humanize(secs)
+      [[60, :seconds], [60, :minutes], [24, :hours], [1000, :days]].map { |count, name|
+        if secs > 0
+          secs, n = secs.divmod(count)
+          "#{n.to_i} #{n.to_i.eql?(1) ? name.to_s.chop : name}"
+        end
+      }.compact.reverse.join(' ')
+    end
+
+
+    def tot_mutations
+      tot = 0
+      content.each do |detail|
+        total = detail[3]
+        tot   += total.to_i
+      end
+      tot
+    end
+
+    def total_kills
+      tot_mutations - total_alive
+    end
+
+    def alive_pct
+      100.0 * total_alive / tot_mutations
+    end
+
+    def killed_pct
+      100.0 * total_kills / tot_mutations
+    end
+
+    def stats_file
+      MutatorRails::Config.configuration.statistics
+    end
+
+    attr_reader :stats, :content
+  end
+end