mutant 0.1.1 → 0.2.0

data/lib/mutant/differ.rb

@@ -0,0 +1,100 @@
+module Mutant
+  # Class to create diffs from source code
+  class Differ
+    include Adamantium::Flat
+
+    # Return source diff 
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def diff
+      output = ''
+      @diffs.each do |piece|
+        hunk = Diff::LCS::Hunk.new(@old, @new, piece, CONTEXT_LINES, length_difference)
+        output << hunk.diff(FORMAT)
+        output << "\n"
+      end
+      output
+    end
+    memoize :diff
+
+    # Return colorized source diff 
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def colorized_diff
+      diff.lines.map do |line|
+        self.class.colorize_line(line)
+      end.join
+    end
+    memoize :colorized_diff
+
+  private
+
+    FORMAT = :unified
+    CONTEXT_LINES = 3
+
+    # Initialize differ object
+    #
+    # @param [String] old 
+    # @param [String] new
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize(old, new)
+      @old, @new = self.class.lines(old), self.class.lines(new)
+      @diffs = Diff::LCS.diff(@old, @new)
+    end
+
+    # Return length difference
+    #
+    # @return [Fixnum]
+    #
+    # @api private
+    #
+    def length_difference
+      @new.size - @old.size
+    end
+
+    # Break up source into lines
+    #
+    # @param [String] source
+    #
+    # @return [Array<String>]
+    #
+    # @api private
+    #
+    def self.lines(source)
+      source.lines.map { |line| line.chomp }
+    end
+
+    # Return colorized diff line
+    #
+    # @param [String] line
+    #
+    # @return [String]
+    #   returns colorized line
+    #
+    # @api private
+    #
+    def self.colorize_line(line)
+      case line[0].chr
+      when '+'
+        Color::GREEN
+      when '-'
+        Color::RED
+      when '@'
+        line[1].chr == '@' ? Color::BLUE : Color::NONE
+      else
+        Color::NONE
+      end.format(line)
+    end
+  end
+end
+

data/lib/mutant/helper.rb

@@ -0,0 +1,38 @@
+module Mutant
+  # Module for support methods
+  #
+  # They would normally be defined on the root namespace.
+  # But it is easier to create the Zombie when there are no
+  # References to the root namespace name within the library.
+  #
+  module Helper
+
+    # Return deep clone of object
+    #
+    # @param [Object] object
+    #
+    # @return [Object] object
+    #
+    # @api private
+    #
+    def self.deep_clone(object)
+      Marshal.load(Marshal.dump(object))
+    end
+
+    # Extract option from options hash
+    #
+    # @param [Hash] options
+    # @param [Object] key
+    #
+    # @return [Object] value
+    # 
+    # @api private
+    #
+    def self.extract_option(options, key)
+      options.fetch(key) do
+        raise ArgumentError,"Missing #{key.inspect} in options"
+      end
+    end
+
+  end
+end

data/lib/mutant/killer.rb

@@ -0,0 +1,136 @@
+module Mutant
+  # Abstract base class for mutant killers
+  class Killer
+    include Adamantium::Flat, AbstractType
+    
+    # Test for kill failure
+    #
+    # @return [true]
+    #   returns true when mutant was killed
+    #
+    # @return [false]
+    #   returns false otherwise
+    #
+    # @api private
+    #
+    def fail?
+      !@killed
+    end
+
+    # Return runtime of killer
+    #
+    # @return [Float]
+    #
+    # @api private
+    #
+    attr_reader :runtime
+
+    # Return original source
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def original_source
+      mutation.original_source
+    end
+
+    # Return mutated source
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def mutation_source
+      mutation.source
+    end
+
+    # Return strategy
+    #
+    # @return [Strategy]
+    #
+    # @api private
+    #
+    attr_reader :strategy
+
+    # Return name of killer
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def self.type
+      self::TYPE
+    end
+
+    # Return identification
+    #
+    # @return [String]
+    #
+    # @api private
+    # 
+    def identification
+      "#{type}:#{mutation.identification}".freeze
+    end
+    memoize :identification
+
+    # Return mae of killer
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def type
+      self.class.type
+    end
+
+    # Return mutation to kill
+    #
+    # @return [Mutation]
+    #
+    # @api private
+    #
+    attr_reader :mutation
+
+  private
+
+    # Initialize killer object
+    #
+    # @param [Mutation] mutation
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize(strategy, mutation)
+      @strategy, @mutation = strategy, mutation
+
+      run_with_benchmark
+    end
+
+    # Run with taking the time
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def run_with_benchmark
+      start_time = Time.now
+      @killed = run
+      end_time = Time.now
+      @runtime = end_time - start_time 
+    end
+
+    # Run test
+    #
+    # @return [true]
+    #   returns true when mutant was killed
+    #
+    # @return [false]
+    #   returns false otherwise
+    #
+    # @api private
+    #
+    abstract_method :run
+  end
+end

data/lib/mutant/killer/forking.rb

@@ -0,0 +1,41 @@
+module Mutant
+  class Killer
+
+    class Forked < self
+      def initialize(killer, strategy, mutation)
+        @killer = killer
+        super(strategy, mutation)
+      end
+
+      def type
+        @killer.type
+      end
+
+      def run
+        fork do
+          killer = @killer.new(strategy, mutation)
+          Kernel.exit(killer.fail? ? 1 : 0)
+        end
+
+        status = Process.wait2.last
+        status.exitstatus.zero?
+      end
+    end
+
+    class Forking < self
+      include Equalizer.new(:killer)
+
+      attr_reader :killer
+
+      def initialize(killer)
+        @killer = killer
+      end
+
+      def new(strategy, mutation)
+        Forked.new(killer, strategy, mutation)
+      end
+
+    end
+
+  end
+end

data/lib/mutant/killer/rspec.rb

@@ -0,0 +1,49 @@
+module Mutant
+  class Killer
+    # Runner for rspec tests
+    class Rspec < self
+      TYPE = 'rspec'.freeze
+
+    private
+
+      # Initialize rspec runner
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def initialize(*)
+        @error_stream, @output_stream = StringIO.new, StringIO.new
+        super
+      end
+
+      # Run rspec test
+      #
+      # @return [true]
+      #   returns true when test is NOT successful and the mutant was killed
+      #
+      # @return [false]
+      #   returns false otherwise
+      #
+      # @api private
+      #
+      def run
+        mutation.insert
+        !::RSpec::Core::Runner.run(command_line_arguments, @error_stream, @output_stream).zero?
+      end
+      memoize :run
+
+      # Return command line arguments
+      #
+      # @return [Array]
+      #
+      # @api private
+      #
+      def command_line_arguments
+        %W(
+          --fail-fast
+        ) + strategy.spec_files(mutation)
+      end
+    end
+  end
+end

data/lib/mutant/killer/static.rb

@@ -0,0 +1,19 @@
+module Mutant
+  class Killer
+    class Static < self
+      def run
+        self.class::RESULT
+      end
+
+      class Success < self
+        TYPE = 'success'.freeze
+        RESULT = true
+      end
+
+      class Fail < self
+        TYPE = 'fail'.freeze
+        RESULT = false
+      end
+    end
+  end
+end

data/lib/mutant/loader.rb

@@ -0,0 +1,129 @@
+module Mutant
+  # Base class for code loaders
+  class Loader
+    include AbstractType
+    extend MethodObject
+
+  private
+
+    # Run the loader
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    abstract_method :run
+
+    # Initialize and insert mutation into vm
+    #
+    # @param [Rubinius::AST::Script] root
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize(root)
+      @root = Helper.deep_clone(root)
+      run
+    end
+
+    # Eval based loader
+    class Eval < self
+      private
+
+      # Run loader
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def run
+        eval(source, TOPLEVEL_BINDING)
+      end
+
+      # Return source
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def source
+        ToSource.to_source(@root)
+      end
+    end
+
+    # Rubinius script node based loaded
+    class Rubinius < self
+      private
+
+      # Run loader
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def run(root)
+        Rubinius.run_script(compiled_code)
+      end
+
+      # Return compiled code
+      #
+      # @return [Rubinius::CompiledCode]
+      #
+      # @api private
+      #
+      # FIXME: rbx on travis is older than on my devbox.
+      #
+      def compiled_code
+        _script = script
+        _script.respond_to?(:compiled_code) ? _script.compiled_code : _script.compiled_method
+      end
+
+      # Return code script
+      #
+      # @return [Rubinius::CompiledCode::Script]
+      #
+      # @api private
+      #
+      def script
+        compiled_code_raw.create_script
+      end
+
+      # Return compiled code for node
+      #
+      # @return [Rubinius::CompiledCode]
+      #
+      # @api private
+      #
+      def compiled_code_raw
+        compiler.run
+      end
+
+      # Return compiler loaded with mutated ast
+      #
+      # @return [Rubinius::Compiler]
+      #
+      # @api private
+      #
+      def compiler
+        Rubinius::Compiler.new(:bytecode, :compiled_method).tap do |compiler|
+          compiler.generator.input(@root)
+        end
+      end
+
+      # Return script node
+      #
+      # @param [Rubinius::AST::Node] node
+      #
+      # @return [Rubinius::AST::Script]
+      #
+      # @api private
+      #
+      def script(node)
+        Rubinius::AST::Script.new(node).tap do |script|
+          script.file = source_path
+        end
+      end
+    end
+  end
+end