mutant 0.2.7 → 0.2.8

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

@@ -1,161 +1,6 @@
 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

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

@@ -0,0 +1,24 @@
+module Mutant
+  class Mutator
+    class Node
+      # 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
+    end
+  end
+end

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

@@ -0,0 +1,40 @@
+module Mutant
+  class Mutator
+    class Node
+
+      # Mutator for formal arguments in 1.9 mode
+      class FormalArguments19 < self
+
+      private
+
+        handle(Rubinius::AST::FormalArguments19)
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          run(DefaultMutations)
+          run(RequireDefaults)
+          run(PatternArgumentExpansion)
+          emit_required_mutations
+        end
+
+
+        # Emit required mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_required_mutations
+          emit_attribute_mutations(:required) do |mutation|
+            mutation.names = mutation.optional + mutation.required
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mutant/mutator/node/formal_arguments_19/default_mutations.rb

@@ -0,0 +1,32 @@
+module Mutant
+  class Mutator
+    class Node
+      class FormalArguments19
+
+        # Mutator for default argument values
+        class DefaultMutations < Node
+
+        private
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def dispatch
+            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
+
+        end
+      end
+    end
+  end
+end

data/lib/mutant/mutator/node/formal_arguments_19/pattern_argument_expansion.rb

@@ -0,0 +1,35 @@
+module Mutant
+  class Mutator
+    class Node
+      class FormalArguments19
+
+        # Mutator that expands pattern arguments
+        class PatternArgumentExpansion < Node
+
+        private
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def dispatch
+            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
+      end
+    end
+  end
+end

data/lib/mutant/mutator/node/formal_arguments_19/require_defaults.rb

@@ -0,0 +1,37 @@
+module Mutant
+  class Mutator
+    class Node
+      class FormalArguments19
+
+        # Mutator for removing defaults and transform them into required arguments
+        class RequireDefaults < Node
+
+        private
+
+          # Emit mutants
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def dispatch
+            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
+        end
+      end
+    end
+  end
+end

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

@@ -19,6 +19,20 @@ module Mutant
           new(Rubinius::AST::FloatLiteral, value)
         end
 
+        # Emit a new node with wrapping class for each entry in values
+        #
+        # @param [Array] values
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_values(values)
+          values.each do |value|
+            emit_self(value)
+          end
+        end
+
         # Return AST representing NaN
         #
         # @return [Rubinius::Node::AST]

data/lib/mutant/mutator/node/literal/hash.rb

@@ -29,13 +29,7 @@ module Mutant
           # @api private
           #
           def emit_body
-            array.each_with_index do |element, index|
-              dup = dup_array
-              Mutator.each(element).each do |mutation|
-                dup[index]=mutation
-                emit_self(dup)
-              end
-            end
+            emit_attribute_mutations(:array, Mutator::Util::Array::Element)
           end
 
           # Return array of values in literal

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

@@ -0,0 +1,41 @@
+module Mutant
+  class Mutator
+    class Node
+      # 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
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+module Mutant
+  class Mutator
+    class Node
+      # Mutator for pattern variable
+      class PatternVariable < self
+
+        handle(Rubinius::AST::PatternVariable)
+
+      private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          emit_attribute_mutations(:name)
+        end
+      end
+    end
+  end
+end

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

@@ -6,6 +6,24 @@ module Mutant
 
         handle(Rubinius::AST::Send)
 
+        # Test if node corresponds to "self.class"
+        #
+        # @param [Rubinius::AST::Node] node
+        #
+        # @return [true]
+        #   if node equals to self.class
+        #
+        # @return [false]
+        #   otherwise
+        #
+        # @api private
+        #
+        def self.self_class?(node)
+          node.kind_of?(Rubinius::AST::Send) && 
+          node.name == :class                && 
+          node.receiver.kind_of?(Rubinius::AST::Self)
+        end
+
       private
 
         # Emit mutations
@@ -15,11 +33,51 @@ module Mutant
         # @api private
         #
         def dispatch
+          emit_receiver 
           emit_implicit_self_receiver
-          emit_attribute_mutations(:block) if node.block
+          emit_receiver_mutations
+          emit_block_mutations
           emit_block_absence_mutation
         end
 
+        # Emit receiver 
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_receiver
+          unless to_self?
+            emit(receiver)
+          end
+        end
+
+        # Emit block mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_block_mutations
+          if node.block
+            emit_attribute_mutations(:block) 
+          end
+        end
+
+        # Emit receiver mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_receiver_mutations
+          util = self.class
+
+          unless to_self? or util.self_class?(receiver) 
+            emit_attribute_mutations(:receiver) 
+          end
+        end
+
         # Emit block absence mutation
         #
         # @return [undefined]
@@ -55,14 +113,14 @@ module Mutant
         # Check if receiver is self
         #
         # @return [true]
-        #   returns true when receiver is a Rubinius::AST::Self node
+        #   if receiver is a Rubinius::AST::Self node
         #
         # @return [false]
         #   return false otherwise
         #
         # @api private
         #
-        def self?
+        def to_self?
           receiver.kind_of?(Rubinius::AST::Self)
         end
 
@@ -92,9 +150,8 @@ module Mutant
         # @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?
+          return unless to_self? 
+          return if self.class.self_class?(node)
           mutant = dup_node
           mutant.privately = true
           # TODO: Fix rubinius to allow this as an attr_accessor
@@ -116,9 +173,22 @@ module Mutant
           #
           def dispatch
             super
+            emit_call_remove_mutation
             emit_attribute_mutations(:arguments)
           end
 
+          # Emit transfomr call mutation
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit_call_remove_mutation
+            array = node.arguments.array
+            return unless array.length == 1
+            emit(array.first)
+          end
+
         end
       end
     end