mutant 0.2.4 → 0.2.5

data/lib/mutant/killer/forking.rb

@@ -1,16 +1,44 @@
 module Mutant
   class Killer
 
+    # Killer that executes other killer in forked environment
     class Forked < self
+
+      # Initialize object
+      #
+      # @param [Killer] killer
+      # @param [Strategy] strategy
+      # @param [Mutation] mutation
+      #
+      # @api private
+      #
       def initialize(killer, strategy, mutation)
         @killer = killer
         super(strategy, mutation)
       end
 
+      # Return killer type
+      #
+      # @return [String]
+      #
+      # @api private
+      #
       def type
         @killer.type
       end
 
+    private
+
+      # Run killer
+      #
+      # @return [true] 
+      #   if mutant was killed
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
       def run
         fork do
           killer = @killer.new(strategy, mutation)
@@ -22,15 +50,40 @@ module Mutant
       end
     end
 
+    # A killer that executes other killer in forked environemnts
     class Forking < self
       include Equalizer.new(:killer)
 
+      # Return killer
+      #
+      # @return [Killer]
+      #
+      # @api private
+      #
       attr_reader :killer
 
+      # Initalize killer
+      #
+      # @param [Killer] killer
+      #   the killer that will be used
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
       def initialize(killer)
         @killer = killer
       end
 
+      # Return killer instance
+      #
+      # @param [Strategy] strategy
+      # @param [Mutation] mutation
+      #
+      # @return [Killer::Forked]
+      #
+      # @api private
+      #
       def new(strategy, mutation)
         Forked.new(killer, strategy, mutation)
       end

data/lib/mutant/killer/rspec.rb

@@ -29,7 +29,7 @@ module Mutant
       #
       def run
         mutation.insert
-        !::RSpec::Core::Runner.run(command_line_arguments, @error_stream, @output_stream).zero?
+        !::RSpec::Core::Runner.run(command_line_arguments, strategy.error_stream, strategy.output_stream).zero?
       end
       memoize :run
 

data/lib/mutant/killer/static.rb

@@ -1,15 +1,29 @@
 module Mutant
   class Killer
+    # Abstract base class for killer with static result
     class Static < self
+
+      # Return result
+      #
+      # @return [true]
+      #   if mutation was killed
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
       def run
         self.class::RESULT
       end
 
+      # Killer that is always successful
       class Success < self
         TYPE = 'success'.freeze
         RESULT = true
       end
 
+      # Killer that always fails
       class Fail < self
         TYPE = 'fail'.freeze
         RESULT = false

data/lib/mutant/matcher.rb

@@ -43,6 +43,8 @@ module Mutant
     # @return [nil]
     #   returns nil otherwise
     #
+    # @api private
+    #
     def self.from_string(input)
       descendants.each do |descendant|
         matcher = descendant.parse(input)

data/lib/mutant/matcher/method.rb

@@ -72,7 +72,7 @@ module Mutant
       # @return [true]
       #   if method is public
       #
-      # @retur [false]
+      # @return [false]
       #   otherwise
       #
       # @api private
@@ -103,7 +103,7 @@ module Mutant
       # @api private
       #
       def context
-        Context::Scope.build(scope, source_path)
+        Context::Scope.new(scope, source_path)
       end
 
       # Return full ast

data/lib/mutant/matcher/method/singleton.rb

@@ -104,7 +104,8 @@ module Mutant
           when Rubinius::AST::ConstantAccess
             receiver_name?(receiver)
           else
-            raise 'Can only match receiver on Rubinius::AST::Self or Rubinius::AST::ConstantAccess'
+            $stderr.puts "Unable to find singleton method definition only match receiver on Rubinius::AST::Self or Rubinius::AST::ConstantAccess, got #{receiver.class}"
+            false
           end
         end
 

data/lib/mutant/matcher/object_space.rb

@@ -98,7 +98,7 @@ module Mutant
 
       # Yield scope if name matches pattern
       #
-      # @param [::Module,::Class]
+      # @param [::Module,::Class] scope
       #
       # @return [undefined]
       #

data/lib/mutant/matcher/scope_methods.rb

@@ -153,6 +153,8 @@ module Mutant
         #
         # @return [Enumerable<Symbol>]
         #
+        # @api private
+        #
         def method_names
           scope = self.scope
           return [] unless scope.kind_of?(Module)

data/lib/mutant/mutation.rb

@@ -109,5 +109,31 @@ module Mutant
     def initialize(subject, node)
       @subject, @node = subject, node
     end
+
+    class Noop < self
+
+      # Initialihe object
+      #
+      # @param [Subject] subject
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def initialize(subject)
+        super(subject, subject.node)
+      end
+
+      # Return identification
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def identification
+        "noop:#{super}"
+      end
+      memoize :identification
+    end
   end
 end

data/lib/mutant/mutation/filter/whitelist.rb

@@ -6,7 +6,7 @@ module Mutant
 
         # Test for match
         #
-        # @param [Mutation]
+        # @param [Mutation] mutation
         #
         # @return [true]
         #   returns true if mutation matches whitelist

data/lib/mutant/mutator.rb

@@ -12,9 +12,9 @@ module Mutant
     #
     # @api private
     #
-    def self.each(node, &block)
-      return to_enum(__method__, node) unless block_given?
-      Registry.lookup(node.class).new(node, block)
+    def self.each(input, &block)
+      return to_enum(__method__, input) unless block_given?
+      Registry.lookup(input.class).new(input, block)
 
       self
     end
@@ -32,6 +32,18 @@ module Mutant
     end
     private_class_method :handle
 
+    # Return identity of object (for deduplication)
+    #
+    # @param [Object] object
+    #
+    # @return [Object]
+    #
+    # @api private
+    #
+    def self.identity(object)
+      object
+    end
+
     # Return input
     #
     # @return [Object]
@@ -52,12 +64,13 @@ module Mutant
     # @api private
     #
     def initialize(input, block)
-      @input, @block = Helper.deep_clone(input), block
-      IceNine.deep_freeze(@input)
+      @input, @block = IceNine.deep_freeze(input), block
+      @seen = Set.new
+      guard(input)
       dispatch
     end
 
-    # Test if generated object is different from input
+    # Test if generated object is not guarded from emmitting
     #
     # @param [Object] object
     #
@@ -69,7 +82,35 @@ module Mutant
     # @api private
     #
     def new?(object)
-      input != object
+      !@seen.include?(self.class.identity(object))
+    end
+
+    # Add object to guarded values
+    #
+    # @param [Object] object
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def guard(object)
+      @seen << self.class.identity(object)
+    end
+
+    # Test if generated mutation is allowed
+    #
+    # @param [Object] object
+    #
+    # @return [true]
+    #   if mutation is allowed
+    #
+    # @return [false]
+    #   otherwise
+    #
+    # @api private
+    #
+    def allow?(object)
+      true
     end
 
     # Dispatch node generations
@@ -89,7 +130,9 @@ module Mutant
     # @api private
     #
     def emit(object)
-      return unless new?(object)
+      return unless new?(object) and allow?(object)
+
+      guard(object)
 
       emit!(object)
     end
@@ -146,7 +189,7 @@ module Mutant
     # @api private
     #
     def dup_input
-      input.dup
+      Helper.deep_clone(input)
     end
 
   end

data/lib/mutant/mutator/node.rb

@@ -5,35 +5,35 @@ module Mutant
     class Node < self
       include AbstractType
 
-    private
-
-      alias_method :node, :input
-      alias_method :dup_node, :dup_input
-
-      # Return source of input node
+      # Return identity of node
+      #
+      # @param [Rubinius::AST::Node] node
       #
       # @return [String]
       #
       # @api private
       #
-      def source
+      def self.identity(node)
         ToSource.to_source(node)
       end
-      memoize :source
 
-      # Test if generated node is new
+      private
+
+      # Return mutated node
       #
-      # @return [true]
-      #   if generated node is different from input
+      # @return [Rubinius::AST::Node]
       #
-      # @return [false]
-      #   otherwise
+      # @api private
+      #
+      alias_method :node, :input
+
+      # Return duplicated node
+      #
+      # @return [Rubinius::AST::Node]
       #
       # @api private
       #
-      def new?(node)
-        source != ToSource.to_source(node)
-      end
+      alias_method :dup_node, :dup_input
 
       # Emit a new AST node
       #
@@ -117,6 +117,7 @@ module Mutant
         Mutator.each(body) do |mutation|
           dup = dup_node
           dup.public_send(:"#{name}=", mutation)
+          yield dup if block_given?
           emit(dup)
         end
       end
@@ -155,9 +156,7 @@ module Mutant
       #
       # @api private
       #
-      def dup_node
-        node.dup
-      end
+      alias_method :dup_node, :dup_input
     end
   end
 end

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

@@ -1,6 +1,162 @@
 module Mutant
   class Mutator
     class Node
+      # Mutator for pattern arguments
+      class PatternVariable < self
+
+        handle(Rubinius::AST::PatternVariable)
+
+      private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          emit_attribute_mutations(:name)
+        end
+      end
+
+      # Mutantor for default arguments
+      class DefaultArguments < self
+        handle(Rubinius::AST::DefaultArguments)
+
+      private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          emit_attribute_mutations(:arguments) do |argument|
+            argument.names = argument.arguments.map(&:name)
+          end
+        end
+      end
+
+      # Mutator for pattern arguments
+      class PatternArguments < self
+
+        handle(Rubinius::AST::PatternArguments)
+
+      private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          Mutator.each(node.arguments.body) do |mutation|
+            dup = dup_node
+            dup.arguments.body = mutation
+            emit(dup)
+          end
+        end
+
+        # Test if mutation should be skipped
+        #
+        # @return [true]
+        #   if mutation should be skipped
+        #
+        # @return [false]
+        #   otherwise
+        #
+        # @api private
+        #
+        def allow?(object)
+          object.arguments.body.size >= 2
+        end
+      end
+
+      # Mutator for formal arguments
+      class FormatlArguments19 < self
+
+      private
+
+        handle(Rubinius::AST::FormalArguments19)
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          expand_pattern_args
+          emit_default_mutations
+          emit_required_defaults_mutation
+          emit_attribute_mutations(:required) do |mutation|
+            mutation.names = mutation.optional + mutation.required
+          end
+        end
+
+        # Emit default mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_default_mutations
+          return unless node.defaults
+          emit_attribute_mutations(:defaults) do |mutation|
+            mutation.optional = mutation.defaults.names
+            mutation.names = mutation.required + mutation.optional
+            if mutation.defaults.names.empty?
+              mutation.defaults = nil
+            end
+          end 
+        end
+
+        # Emit required defaults mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_required_defaults_mutation
+          return unless node.defaults
+          arguments = node.defaults.arguments
+          arguments.each_index do |index|
+            names = arguments.take(index+1).map(&:name)
+            dup = dup_node
+            defaults = dup.defaults
+            defaults.arguments = defaults.arguments.drop(names.size)
+            names.each { |name| dup.optional.delete(name) }
+            dup.required.concat(names)
+            if dup.optional.empty?
+              dup.defaults = nil
+            end
+            emit(dup)
+          end
+        end
+
+        # Emit pattern args expansions
+        # 
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def expand_pattern_args
+          node.required.each_with_index do |argument, index|
+            next unless argument.kind_of?(Rubinius::AST::PatternArguments)
+            dup = dup_node
+            required = dup.required
+            required.delete_at(index)
+            argument.arguments.body.reverse.each do |node|
+              required.insert(index, node.name)
+            end
+            dup.names |= required
+            emit(dup)
+          end
+        end
+      end
+
       # Mutator for arguments
       class Arguments < self