mutant 0.1.1 → 0.2.0

data/lib/mutant/mutator/node/send.rb

@@ -0,0 +1,112 @@
+module Mutant
+  class Mutator
+    class Node
+      # Class for mutations where messages are send to objects
+      class Send < self
+
+        handle(Rubinius::AST::Send)
+
+      private
+
+        # Return receiver AST node
+        #
+        # @return [Rubinius::AST::Node]
+        #
+        # @api private
+        #
+        def receiver
+          node.receiver
+        end
+
+        # Return name of call
+        #
+        # @return [Symbol]
+        #
+        # @api private
+        #
+        def name
+          node.name
+        end
+
+        # Check if receiver is self
+        #
+        # @return [true]
+        #   returns true when receiver is a Rubinius::AST::Self node
+        #
+        # @return [false]
+        #   return false otherwise
+        #
+        # @api private
+        #
+        def self?
+          receiver.kind_of?(Rubinius::AST::Self)
+        end
+
+        # Emit mutation that replaces explicit send to self with implicit send to self
+        # 
+        # @example:
+        #
+        #   # This class does use Foo#a with explicitly specifing the receiver self.
+        #   # But an implicit (privately) call should be used as there is no need for 
+        #   # specifing en explicit receiver.
+        #
+        #   class Foo         # Mutation
+        #     def print_a     # def print_a
+        #       puts self.a   #   puts a
+        #     end             # end
+        #
+        #     def a
+        #       :bar
+        #     end
+        #   end
+        #
+        #   There will not be any exception so the mutant is not killed and such calls where
+        #   implicit receiver should be used will be spotted.
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_implicit_self_receiver
+          # FIXME: Edge case that is currently not very well undestood
+          return if name == :block_given?
+          return unless self?
+          mutant = dup_node
+          mutant.privately = true
+          # TODO: Fix rubinius to allow this as an attr_accessor
+          mutant.instance_variable_set(:@vcall_style, true)
+          emit(mutant)
+        end
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          emit_implicit_self_receiver
+        end
+
+        class SendWithArguments < self
+          
+          handle(Rubinius::AST::SendWithArguments)
+
+        private
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def dispatch
+            super
+            emit_attribute_mutations(:arguments)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/mutant/mutator/registry.rb

@@ -0,0 +1,48 @@
+module Mutant
+  class Mutator
+    # Registry for mutators
+    module Registry
+      # Return registry state
+      #
+      # @return [Hash]
+      #
+      # @api private
+      #
+      def self.registry
+        @registry ||= {}
+      end
+      private_class_method :registry
+
+      # Register mutator class for AST node class
+      #
+      # @param [Class] ast_class
+      # @param [Class] mutator_class
+      #
+      # @api private
+      #
+      # @return [self]
+      #
+      def self.register(ast_class,mutator_class)
+        registry[ast_class]=mutator_class
+        self
+      end
+
+      # Lookup mutator class for AST node class
+      #
+      # @param [Class] ast_class
+      #
+      # @return [Class]
+      #
+      # @raise [ArgumentError]
+      #   raises argument error when mutator class cannot be found
+      #
+      # @api private
+      #
+      def self.lookup(ast_class)
+        registry.fetch(ast_class) do
+          raise ArgumentError,"No mutator to handle: #{ast_class.inspect}"
+        end
+      end
+    end
+  end
+end

data/lib/mutant/mutator/util.rb

@@ -0,0 +1,87 @@
+module Mutant
+  class Mutator
+    # Namespace for utility mutators
+    class Util < self
+
+      # Run ulitity mutator
+      #
+      # @param [Object]
+      #
+      # @api private
+      #
+      def self.each(object, &block)
+        return to_enum(__method__, object) unless block_given?
+
+        new(object, block)
+
+        self
+      end
+
+      # Test if mutation is new
+      #
+      # @param [Object] generated
+      #
+      # @return [true]
+      #   if object is new
+      #
+      # @return [false]
+      #   otherwise
+      #
+      def new?(generated)
+        input != generated
+      end
+
+      # Mutators that mutates an array of inputs
+      class Array < self
+
+        handle(::Array)
+
+      private
+
+        # Emit mutations
+        # 
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          emit_element_presence
+          emit_element_mutations
+          emit([])
+        end
+
+        # Emit element mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_element_mutations
+          input.each_with_index do |element, index|
+            dup = dup_input
+
+            Mutator.each(element).each do |mutation|
+              dup[index]=mutation
+              emit(dup)
+            end
+          end
+        end
+
+        # Emit element presence mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_element_presence
+          input.each_index do |index|
+            dup = dup_input
+            dup.delete_at(index)
+            emit(dup)
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/mutant/random.rb

@@ -1,37 +1,34 @@
 module Mutant
-  class Random
-    ALLOWED_SYMBOL_CHARACTERS = Array('a'..'z') + Array('A'..'Z')
-    RANDOM_METHOD = Rubinius.ruby19? ? :sample : :choice
-
-    def self.string
-      ENV.fetch('RANDOM_STRING') {
-        Array.new(rand(50)) { rand(126).chr }.join
-      }
-    end
-
-    def self.symbol
-      ENV.fetch('RANDOM_SYMBOL') {
-        Array.new(rand(50).next) { ALLOWED_SYMBOL_CHARACTERS.send RANDOM_METHOD }.join
-      }.to_sym
+  # Module for generating random values
+  module Random
+    # Return random hex string
+    #
+    # @return [String]
+    #
+    # @api private
+    #
+    def self.hex_string
+      SecureRandom.hex(10)
     end
 
+    # Return random fixnum
+    #
+    # @return [Fixnum]
+    #
+    # @api private
+    #
     def self.fixnum
-      ENV.fetch('RANDOM_FIXNUM') { rand(100) }
+      ::Random.rand(1000)
     end
 
+    # Return random float
+    #
+    # @return [Float]
+    #
+    # @api private
+    #
     def self.float
-      ENV.fetch('RANDOM_FLOAT') { (rand(100) + 0.5) }
-    end
-
-    def self.range
-      if ENV['RANDOM_RANGE_MIN'] and ENV['RANDOM_RANGE_MAX']
-        min, max = ENV['RANDOM_RANGE_MIN'].to_i, ENV['RANDOM_RANGE_MAX'].to_i
-      else
-        min, max = rand(50)
-        max = min + rand(50)
-      end
-
-      Range.new(min, max)
+      ::Random.rand
     end
   end
 end

data/lib/mutant/reporter.rb

@@ -1,38 +1,56 @@
 module Mutant
+  # Abstract reporter
   class Reporter
-    WIDTH = 70
+    include Adamantium::Flat, AbstractType
 
-    def self.mutating(mutation)
-      puts "Mutating line #{mutation.line}"
-      puts "  #{mutation.from} >>>#{mutation.to.nested? ? "\n  " : " "}#{mutation.to}"
-      puts
-    end
+    # Report subject
+    #
+    # @param [Subject] subject
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    abstract_method :subject
 
-    def self.method_loaded(mutatee)
-      info "#{mutatee} loaded with #{mutatee.mutations.size} " \
-           "possible #{pluralize(mutatee.mutations.size, 'mutation')}"
-    end
+    # Report mutation
+    #
+    # @param [Mutation] mutation
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    abstract_method :mutation
 
-    def self.no_mutations(mutatee)
-      warning "#{mutatee} has no possible mutations"
-    end
+    # Report notice
+    #
+    # @param [String] notice
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    abstract_method :notice
 
-    def self.info(message)
-      puts "*" * WIDTH
-      puts "***  #{message}"
-      puts "*" * WIDTH
-      puts
-    end
+    # Report killer
+    #
+    # @param [Killer] killer
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    abstract_method :killer
 
-    def self.warning(message)
-      puts "!" * WIDTH
-      puts "!!!  #{message}"
-      puts "!" * WIDTH
-      puts
-    end
-
-    def self.pluralize(count, singular, plural = nil)
-      count == 1 ? singular : plural || singular.insert(-1, 's')
-    end
+    # Report config
+    # 
+    # @param [Mutant::Config] config
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    abstract_method :config
   end
-end
+end

data/lib/mutant/reporter/cli.rb

@@ -0,0 +1,221 @@
+module Mutant
+  class Reporter
+    # Reporter that reports in human readable format
+    class CLI < self
+      include Equalizer.new(:io)
+
+      # Reporter subject
+      #
+      # @param [Subject] subject
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def subject(subject)
+        stats.subject
+        puts("Subject: #{subject.identification}")
+      end
+
+      # Report mutation
+      #
+      # @param [Mutation] mutation
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def mutation(mutation)
+        #colorized_diff(mutation.original_source, mutation.source)
+        self
+      end
+
+      # Report config
+      #
+      # @param [Mutant::Config] config
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def config(config)
+        puts 'Mutant configuration:'
+        puts "Matcher:   #{config.matcher.inspect}"
+        puts "Filter:    #{config.filter.inspect}"
+        puts "Strategy:  #{config.strategy.inspect}"
+      end
+
+      # Reporter killer
+      #
+      # @param [Killer] killer
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def killer(killer)
+        stats.killer(killer)
+
+        color, word =
+          if killer.fail?
+            [Color::RED,   'Alive']
+          else
+            [Color::GREEN, 'Killed']
+          end
+
+        puts(colorize(color, "#{word}: #{killer.identification} (%02.2fs)" % killer.runtime))
+
+        if killer.fail?
+          mutation = killer.mutation
+          colorized_diff(mutation.original_source, mutation.source)
+        end
+
+        self
+      end
+
+      # Report errors
+      #
+      # @param [Enumerable<Killer>]
+      #
+      # @api private
+      #
+      # @return [self]
+      #
+      def errors(errors)
+        errors.each do |error|
+          failure(error)
+        end
+
+        puts
+        puts "subjects:  #{stats.subject}"
+        puts "mutations: #{stats.mutation}"
+        puts "kills:     #{stats.kill}"
+        puts "alive:     #{stats.alive}"
+        puts "mtime:     %02.2fs" % stats.time
+        puts "rtime:     %02.2fs" % stats.runtime
+      end
+
+      # Return IO stream
+      #
+      # @return [IO]
+      #
+      # @api private
+      # 
+      attr_reader :io
+
+      # Return stats
+      #
+      # @return [Stats]
+      #
+      # @api private
+      #
+      attr_reader :stats
+
+    private 
+
+      # Initialize reporter
+      #
+      # @param [IO] io
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def initialize(io)
+        @io = io
+        @stats = Stats.new
+      end
+
+      # Report failure on killer
+      # 
+      # @param [Killer] killer
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def failure(killer)
+        puts(colorize(Color::RED, "!!! Mutant alive: #{killer.identification} !!!"))
+        colorized_diff(killer.original_source, killer.mutation_source)
+        puts("Took: (%02.2fs)" % killer.runtime)
+      end
+
+      # Test for colored output
+      #
+      # @return [true]
+      #   returns true if output is colored
+      #
+      # @return [false]
+      #   returns false otherwise
+      #
+      # @api private
+      #
+      def color?
+        tty?
+      end
+
+      # Colorize message
+      #
+      # @param [Color] color
+      # @param [String] message
+      #
+      # @api private
+      #
+      # @return [String]
+      #   returns colorized string if color is enabled
+      #   returns unmodified message otherwise
+      #
+      def colorize(color, message)
+        color = Color::NONE unless color?
+        color.format(message)
+      end
+
+      # Write string to io
+      #
+      # @param [String] string
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def puts(string="\n")
+        io.puts(string)
+      end
+
+      # Write colorized diff
+      #
+      # @param [String] original
+      # @param [String] current
+      #
+      # @return [self]
+      #
+      # @api private
+      #
+      def colorized_diff(original, current)
+        differ = Differ.new(original, current)
+        diff = color? ? differ.colorized_diff : differ.diff
+        # FIXME remove this branch before release
+        if diff.empty?
+          raise "Unable to create a diff, so ast mutation or to_source has an error!"
+        end
+        puts(diff)
+        self
+      end
+
+      # Test for output to tty
+      #
+      # @return [true]
+      #   returns true if output is a tty
+      # 
+      # @return [false]
+      #   returns false otherwise
+      #
+      # @api private
+      #
+      def tty?
+        @io.respond_to?(:tty?) && @io.tty?
+      end
+      memoize :tty?
+    end
+  end
+end