heckle 1.0.0 → 1.1.0

data/History.txt

@@ -1,3 +1,19 @@
+== 1.1.0 / 2006-12-19
+
+* 12 major enhancements:
+  * Able to roll back original method after processing.
+  * Can mutate numeric literals.
+  * Can mutate strings.
+  * Can mutate a node at a time.
+  * Can mutate if/unless
+  * Decoupled from Test::Unit
+  * Cleaner output
+  * Can mutate true and false.
+  * Can mutate while and until.
+  * Can mutate regexes, ranges, symbols
+  * Can run against entire classes
+  * Command line options!
+  
 == 1.0.0 / 2006-10-22
 
 * 1 major enhancement

data/Manifest.txt

@@ -4,5 +4,12 @@ README.txt
 Rakefile
 bin/heckle
 lib/heckle.rb
+lib/heckle/base.rb
+lib/heckle/reporter.rb
+lib/test_unit_heckler.rb
+sample/Rakefile
+sample/changes.log
+sample/lib/heckled.rb
+sample/test/test_heckled.rb
+test/fixtures/heckled.rb
 test/test_heckle.rb
-

data/README.txt

@@ -1,14 +1,14 @@
 heckle
-    by Ryan Davis
     http://www.rubyforge.org/projects/seattlerb
+    by Ryan Davis and Kevin Clark
 
 == DESCRIPTION:
-  
+
 Unit Testing Sadism. More description coming soon. I'm punting to get
 this launched ASAP.
 
 == FEATURES/PROBLEMS:
-  
+
 * needs some love. haha.
 
 == SYNOPSYS:
@@ -27,7 +27,7 @@ this launched ASAP.
 
 (The MIT License)
 
-Copyright (c) 2006 FIX
+Copyright (c) 2006 Ryan Davis and Kevin Clark
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/Rakefile

@@ -1,5 +1,7 @@
 # -*- ruby -*-
 
+$: << 'lib'
+
 require 'rubygems'
 require 'hoe'
 require './lib/heckle.rb'
@@ -7,9 +9,11 @@ require './lib/heckle.rb'
 Hoe.new('heckle', Heckle::VERSION) do |p|
   p.rubyforge_name = 'seattlerb'
   p.summary = 'Unit Test Sadism'
-  p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  p.description = p.paragraphs_of('README.txt', 2).join("\n\n")
   p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
   p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+
+  p.extra_deps << ['ruby2ruby', '>= 1.1.0']
 end
 
 # vim: syntax=Ruby

data/bin/heckle

@@ -1,15 +1,37 @@
-#!/usr/local/bin/ruby -w
+#!/usr/local/bin/ruby
 
-$: << 'lib'
-require 'heckle'
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+require 'test_unit_heckler'
+require 'optparse'
+
+opts = OptionParser.new do |opts|
+  opts.banner = "Usage: #{File.basename($0)} class_name [method_name]"
+  opts.on( "-v", "--verbose", "Loudly explain heckle run" ) do |opt|
+    TestUnitHeckler.debug = true
+  end
+  
+  opts.on( "-t", "--tests TEST_PATTERN", 
+           "Location of tests (glob)" ) do |pattern|
+    TestUnitHeckler.test_pattern = pattern
+  end
+  
+  opts.on( "-h", "--help", "Show this message") do |opt|
+    puts opts
+  end
+end
+
+opts.parse!
 
-file = ARGV.shift
 impl = ARGV.shift
 meth = ARGV.shift
 
-unless file and impl and meth then
-  abort "usage: #{File.basename($0)} file.rb impl_class_name impl_method_name"
+unless impl then
+  puts opts
+  exit 1
 end
 
-heckle = Heckle.new(file, impl, meth)
-heckle.validate
+if meth
+  TestUnitHeckler.new(impl, meth).validate
+else
+  TestUnitHeckler.validate(impl)
+end

data/lib/heckle.rb

@@ -1,89 +1,6 @@
 require 'rubygems'
 require 'parse_tree'
 require 'ruby2ruby'
-require 'test/unit/autorunner'
-
-class String
-  def to_class
-    split(/::/).inject(Object) { |klass, name| klass.const_get(name) }
-  end
-end
-
-class Heckle < SexpProcessor
-  VERSION = '1.0.0'
-
-  attr_accessor :file, :klass_name, :method_name, :klass, :method
-  def initialize(file=nil, klass_name=nil, method_name=nil)
-    super()
-
-    @file, @klass_name, @method_name = file, klass_name, method_name.intern
-    @klass = @method = nil
-
-    self.strict = false
-    self.auto_shift_type = true
-    self.expected = Array
-  end
-
-  def validate
-    puts "Validating #{file}"
-
-    load file
-    if Test::Unit::AutoRunner.run then
-      puts "Tests passed -- heckling"
-      
-      process(ParseTree.translate(klass_name.to_class, method_name))
-
-      if Test::Unit::AutoRunner.run then
-        puts
-        abort "*** Tests passed again after heckling, your tests are incomplete"
-      else
-        puts "Tests failed -- this is good"
-      end
-    else
-      puts "Tests failed... fix and run heckle again"
-    end
-  end
-
-  ############################################################
-
-  def process_defn(exp)
-    self.method = exp.shift
-    result = [:defn, method]
-    
-    result << process(exp.shift) until exp.empty?
-
-    heckle(result) if should_heckle?
-
-    return result
-  end
-
-  def process_if(exp)
-    cond = process(exp.shift)
-    t = process(exp.shift)
-    f = process(exp.shift)
-
-    if should_heckle? then
-      [:if, cond, f, t]
-    else
-      [:if, cond, t, f]
-    end
-  end
-
-  def should_heckle?
-    method == method_name
-  end
-
-  def heckle(exp)
-    puts "Heckling #{klass_name}##{method_name}"
-
-    r2r = RubyToRuby.new
-    src = r2r.process(exp)
-
-    puts
-    puts "Replacing #{klass}##{method_name} with:"
-    puts src
-    puts
-
-    klass_name.to_class.class_eval(src)
-  end
-end
+require 'logger'
+require 'heckle/reporter'
+require 'heckle/base'

data/lib/heckle/base.rb

@@ -0,0 +1,349 @@
+class String
+  def to_class
+    split(/::/).inject(Object) { |klass, name| klass.const_get(name) }
+  end
+end
+
+module Heckle
+  VERSION = '1.1.0'
+
+  class Base < SexpProcessor
+    MUTATABLE_NODES = [:if, :lit, :str, :true, :false, :while, :until]
+
+    attr_accessor :klass_name, :method_name, :klass, :method, :mutatees, :original_tree,
+                  :mutation_count, :node_count, :failures, :count
+
+    @@debug = false;
+
+    def self.debug=(value)
+      @@debug = value
+    end
+
+    def initialize(klass_name=nil, method_name=nil, reporter = Reporter.new)
+      super()
+
+      @klass_name, @method_name = klass_name, method_name.intern
+      @klass = @method = nil
+      @reporter = reporter
+
+      self.strict = false
+      self.auto_shift_type = true
+      self.expected = Array
+
+      @mutatees = Hash.new
+      @mutation_count = Hash.new
+      @node_count = Hash.new
+      @count = 0
+
+      MUTATABLE_NODES.each {|type| @mutatees[type] = [] }
+
+      @failures = []
+
+      @mutated = false
+
+      grab_mutatees
+
+      @original_tree = current_tree.deep_clone
+      @original_mutatees = mutatees.deep_clone
+    end
+
+    ############################################################
+    ### Overwrite test_pass? for your own Heckle runner.
+    def tests_pass?
+      raise NotImplementedError
+    end
+
+    def run_tests
+      if tests_pass? then
+        record_passing_mutation
+      else
+        @reporter.report_test_failures
+      end
+    end
+
+    ############################################################
+    ### Running the script
+
+    def validate
+      if mutations_left == 0
+        @reporter.no_mutations(method_name)
+        return
+      end
+
+      @reporter.method_loaded(klass_name, method_name, mutations_left)
+
+      until mutations_left == 0
+        @reporter.remaining_mutations(mutations_left)
+        reset_tree
+        begin
+          process current_tree
+          silence_stream(STDOUT) { run_tests }
+        rescue SyntaxError => e
+          puts "Mutation caused a syntax error: #{e.message}"
+        end
+      end
+
+      reset # in case we're validating again. we should clean up.
+
+      unless @failures.empty?
+        @reporter.no_failures
+        @failures.each do |failure|
+          @reporter.failure(failure)
+        end
+      else
+        @reporter.no_surviving_mutants
+      end
+    end
+
+    def record_passing_mutation
+      @failures << current_code
+    end
+
+    def heckle(exp)
+      src = RubyToRuby.new.process(exp)
+      @reporter.replacing(klass_name, method_name, src) if @@debug
+      klass = klass_name.to_class
+      self.count += 1
+      new_name = "#{method_name}_#{count}"
+
+      klass.send :undef_method, new_name rescue nil
+      klass.send :alias_method, new_name, method_name
+      klass.class_eval(src)
+    end
+
+    ############################################################
+    ### Processing sexps
+
+    def process_defn(exp)
+      self.method = exp.shift
+      result = [:defn, method]
+      result << process(exp.shift) until exp.empty?
+      heckle(result) if method == method_name
+      @mutated = false
+      reset_node_count
+
+      return result
+    end
+
+    def process_lit(exp)
+      mutate_node [:lit, exp.shift]
+    end
+
+    def mutate_lit(exp)
+      case exp[1]
+      when Fixnum, Float, Bignum
+        [:lit, exp[1] + rand_number]
+      when Symbol
+        [:lit, rand_symbol]
+      when Regexp
+        [:lit, /#{Regexp.escape(rand_string)}/]
+      when Range
+        [:lit, rand_range]
+      end
+    end
+
+    def process_str(exp)
+      mutate_node [:str, exp.shift]
+    end
+
+    def mutate_str(node)
+      [:str, rand_string]
+    end
+
+    def process_if(exp)
+      mutate_node [:if, process(exp.shift), process(exp.shift), process(exp.shift)]
+    end
+
+    def mutate_if(node)
+      [:if, node[1], node[3], node[2]]
+    end
+
+    def process_true(exp)
+      mutate_node [:true]
+    end
+
+    def mutate_true(node)
+      [:false]
+    end
+
+    def process_false(exp)
+      mutate_node [:false]
+    end
+
+    def mutate_false(node)
+      [:true]
+    end
+
+    def process_while(exp)
+      cond, body, head_controlled = grab_conditional_loop_parts(exp)
+      mutate_node [:while, cond, body, head_controlled]
+    end
+
+    def mutate_while(node)
+      [:until, node[1], node[2], node[3]]
+    end
+
+    def process_until(exp)
+      cond, body, head_controlled = grab_conditional_loop_parts(exp)
+      mutate_node [:until, cond, body, head_controlled]
+    end
+
+    def mutate_until(node)
+      [:while, node[1], node[2], node[3]]
+    end
+
+    def mutate_node(node)
+      raise UnsupportedNodeError unless respond_to? "mutate_#{node.first}"
+      increment_node_count node
+      if should_heckle? node
+        increment_mutation_count node
+        return send("mutate_#{node.first}", node)
+      else
+        node
+      end
+    end
+
+    ############################################################
+    ### Tree operations
+
+    def walk_and_push(node)
+      return unless node.respond_to? :each
+      return if node.is_a? String
+      node.each { |child| walk_and_push(child) }
+      if MUTATABLE_NODES.include? node.first
+        @mutatees[node.first.to_sym].push(node)
+        mutation_count[node] = 0
+      end
+    end
+
+    def grab_mutatees
+      walk_and_push(current_tree)
+    end
+
+    def current_tree
+      ParseTree.translate(klass_name.to_class, method_name)
+    end
+
+    def reset
+      reset_tree
+      reset_mutatees
+      reset_mutation_count
+    end
+
+    def reset_tree
+      return unless original_tree != current_tree
+      @mutated = false
+
+      klass = klass_name.to_class
+
+      self.count += 1
+      new_name = "#{method_name}_#{count}"
+      klass.send :undef_method, new_name rescue nil
+      klass.send :alias_method, new_name, method_name
+      klass.send :alias_method, method_name, "#{method_name}_1"
+    end
+
+    def reset_mutatees
+      @mutatees = @original_mutatees.deep_clone
+    end
+
+    def reset_mutation_count
+      mutation_count.each {|k,v| mutation_count[k] = 0}
+    end
+
+    def reset_node_count
+      node_count.each {|k,v| node_count[k] = 0}
+    end
+
+    def increment_node_count(node)
+      if node_count[node].nil?
+        node_count[node] = 1
+      else
+        node_count[node] += 1
+      end
+    end
+
+    def increment_mutation_count(node)
+      # So we don't re-mutate this later if the tree is reset
+      mutation_count[node] += 1
+      @mutatees[node.first].delete_at(@mutatees[node.first].index(node))
+      @mutated = true
+    end
+
+    ############################################################
+    ### Convenience methods
+
+    def should_heckle?(exp)
+      return false unless method == method_name
+      mutation_count[exp] = 0 if mutation_count[exp].nil?
+      return false if node_count[exp] <= mutation_count[exp]
+      mutatees[exp.first.to_sym].include?(exp) && !already_mutated?
+    end
+
+    def grab_conditional_loop_parts(exp)
+      cond = process(exp.shift)
+      body = process(exp.shift)
+      head_controlled = exp.shift
+      return cond, body, head_controlled
+    end
+
+    def already_mutated?
+      @mutated
+    end
+
+    def mutations_left
+      sum = 0
+      @mutatees.each {|mut| sum += mut.last.size }
+      sum
+    end
+
+    def current_code
+      RubyToRuby.translate(klass_name.to_class, method_name)
+    end
+
+    def rand_number
+      (rand(10) + 1)*((-1)**rand(2))
+    end
+
+    def rand_string
+      size = rand(100)
+      str = ""
+      size.times { str << rand(126).chr }
+      str
+    end
+
+    def rand_symbol
+      letters = ('a'..'z').to_a + ('A'..'Z').to_a
+      str = ""
+      rand(100).times { str << letters[rand(letters.size)] }
+      :"#{str}"
+    end
+
+    def rand_range
+      min = rand(50)
+      max = min + rand(50)
+      min..max
+    end
+
+    # silence_stream taken from Rails ActiveSupport reporting.rb
+
+    # Silences any stream for the duration of the block.
+    #
+    #   silence_stream(STDOUT) do
+    #     puts 'This will never be seen'
+    #   end
+    #
+    #   puts 'But this will'
+    def silence_stream(stream)
+      unless @@debug
+        old_stream = stream.dup
+        stream.reopen(RUBY_PLATFORM =~ /mswin/ ? 'NUL:' : '/dev/null')
+        stream.sync = true
+      end
+      yield
+    ensure
+      stream.reopen(old_stream) unless @@debug
+    end
+
+  end
+end