mutant 0.2.20 → 0.3.0.beta2

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

@@ -2,10 +2,20 @@ module Mutant
   class Mutator
     class Node
       class Literal
+
         # Abstract literal range mutator
         class Range < self
           include AbstractType
 
+          MAP = {
+            :irange => :erange,
+            :erange => :irange
+          }.freeze
+
+          children :start, :_end
+
+          handle(*MAP.keys)
+
         private
 
           # Emit mutants
@@ -16,30 +26,19 @@ module Mutant
           #
           def dispatch
             emit_nil
-            emit(inverse)
-            emit_range
+            emit_inverse
+            emit_start_mutations
+            emit_end_mutations
           end
 
           # Return inverse node
           #
-          # @return [Rubinius::AST::Node]
+          # @return [Parser::AST::Node]
           #
           # @api private
           #
-          def inverse
-            node = self.node
-            new(inverse_class, node.start, node.finish)
-          end
-
-          # Emit range specific mutants
-          #
-          # @return [undefined]
-          #
-          # @api private
-          #
-          def emit_range
-            emit_finish_mutations
-            emit_start_mutations
+          def emit_inverse
+            emit(s(MAP.fetch(node.type), *children))
           end
 
           # Emit range start mutations
@@ -48,10 +47,9 @@ module Mutant
           #
           # @api private
           #
-          def emit_finish_mutations
-            finish = node.finish
+          def emit_end_mutations
             #emit_self(negative_infinity, finish)
-            emit_self(nan, finish)
+            emit_self(NAN, _end)
           end
 
           # Emit start mutations
@@ -61,35 +59,12 @@ module Mutant
           # @api private
           #
           def emit_start_mutations
-            start = node.start
-            emit_self(start, infinity)
-            emit_self(start, nan)
+            emit_self(start, INFINITY)
+            emit_self(start, NAN)
           end
 
-          # Return inverse AST node class
-          #
-          # @return [Class:Rubinius::AST::Node]
-          #
-          # @api private
-          #
-          def inverse_class
-            self.class::INVERSE_CLASS
-          end
-
-          # Mutator for range exclude literals
-          class Exclude < self
-            INVERSE_CLASS = Rubinius::AST::Range
-            handle(Rubinius::AST::RangeExclude)
-
-          end
-
-          # Mutator for range include literals
-          class Include < self
-            INVERSE_CLASS = Rubinius::AST::RangeExclude
-            handle(Rubinius::AST::Range)
-          end
-        end
-      end
-    end
-  end
-end
+        end # Range
+      end # Literal
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -5,7 +5,14 @@ module Mutant
         # Mutator for regexp literals
         class Regex < self
 
-          handle(Rubinius::AST::RegexLiteral)
+          handle(:regexp)
+
+          EMPTY_STRING = ''.freeze
+
+          # No input can ever be matched with this
+          NULL_REGEXP_SOURCE = 'a\A'.freeze
+
+          children :source, :options
 
         private
 
@@ -17,27 +24,12 @@ module Mutant
           #
           def dispatch
             emit_nil
-            emit_self('') # match all
-            emit_self('a\A') # match nothing
-            emit_new { new_self(Random.hex_string) }
+            emit_self(s(:str, EMPTY_STRING), options)
+            emit_self(s(:str, NULL_REGEXP_SOURCE), options)
           end
 
-          # Return new Rubinius::AST::Regex
-          #
-          # @param [String] source
-          #
-          # @param [Integer] options
-          #   options of regexp, defaults to mutation subject node options
-          #
-          # @return [undefined]
-          #
-          # @api private
-          #
-          def new_self(source,options=nil)
-            super(source,options || node.options)
-          end
-        end
-      end
-    end
-  end
-end
+        end # Regex
+      end # Literal
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -5,7 +5,7 @@ module Mutant
         # Mutator for string literals
         class String < self
 
-          handle(Rubinius::AST::StringLiteral)
+          handle(:str)
 
         private
 
@@ -19,8 +19,9 @@ module Mutant
             emit_nil
             emit_new { new_self(Random.hex_string) }
           end
-        end
-      end
-    end
-  end
-end
+
+        end # String
+      end # Literal
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -5,7 +5,7 @@ module Mutant
         # Mutator for symbol literals
         class Symbol < self
 
-          handle(Rubinius::AST::SymbolLiteral)
+          handle(:sym)
 
         private
 
@@ -19,8 +19,9 @@ module Mutant
             emit_nil
             emit_new { new_self(('s'+Random.hex_string).to_sym) }
           end
-        end
-      end
-    end
-  end
-end
+
+        end # Symbol
+      end # Literal
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -7,18 +7,6 @@ module Mutant
 
       private
 
-        # Return new float literal
-        #
-        # @param [#to_f] value
-        #
-        # @return [Rubinius::Node::FloatLiteral]
-        #
-        # @api private
-        #
-        def new_float(value)
-          new(Rubinius::AST::FloatLiteral, value)
-        end
-
         # Emit a new node with wrapping class for each entry in values
         #
         # @param [Array] values
@@ -33,37 +21,7 @@ module Mutant
           end
         end
 
-        # Return AST representing NaN
-        #
-        # @return [Rubinius::Node::AST]
-        #
-        # @api private
-        #
-        def nan
-          zero_float = new_float(0)
-          new_send_with_arguments(zero_float, :/, zero_float)
-        end
-
-        # Return AST representing negative infinity
-        #
-        # @return [Rubinius::Node::AST]
-        #
-        # @api private
-        #
-        def negative_infinity
-          new_send_with_arguments(new_float(-1), :/, new_float(0))
-        end
-
-        # Return AST representing infinity
-        #
-        # @return [Rubinius::Node::AST]
-        #
-        # @api private
-        #
-        def infinity
-          new_send_with_arguments(new_float(1), :/, new_float(0))
-        end
-      end
-    end
-  end
-end
+      end # Literal
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -0,0 +1,27 @@
+module Mutant
+  class Mutator
+    class Node
+      # Mutator for multiple assignment left hand side nodes
+      class MLHS < self
+
+        handle(:mlhs)
+
+      private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          children.each_index do |index|
+            mutate_child(index)
+            delete_child(index)
+          end
+        end
+
+      end # MLHS
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -5,45 +5,20 @@ module Mutant
       class Noop < self
 
         # Literal references to self do not need to be mutated?
-        handle(Rubinius::AST::Self)
+        handle(:self)
+
+        # These nodes still need a mutator, your contribution is that close!
+        handle(
+          :zsuper, :not, :or, :and, :defined,
+          :next, :break, :match, :gvar, :cvar, :ensure,
+          :dstr, :dsym, :yield, :rescue, :redo, :defined?,
+          :lvar, :splat, :const, :blockarg, :block_pass, :op_asgn, :regopt,
+          :ivar, :restarg, :casgn, :masgn, :resbody, :retry, :arg_expr,
+          :kwrestarg, :kwoptarg, :kwarg, :undef, :module, :cbase, :empty,
+          :alias, :for, :xstr, :back_ref, :nth_ref, :class, :sclass, :match_with_lvasgn,
+          :match_current_line, :or_asgn
+        )
 
-        # Currently unhandled node classes. Feel free to contribute your mutator!
-        handle(Rubinius::AST::ZSuper)
-        handle(Rubinius::AST::ElementAssignment)
-        handle(Rubinius::AST::AttributeAssignment)
-        handle(Rubinius::AST::Not)
-        handle(Rubinius::AST::And)
-        handle(Rubinius::AST::Or)
-        handle(Rubinius::AST::Defined)
-        handle(Rubinius::AST::Super)
-        handle(Rubinius::AST::Next)
-        handle(Rubinius::AST::Break)
-        handle(Rubinius::AST::Match3)
-        handle(Rubinius::AST::ZSuper)
-        handle(Rubinius::AST::MultipleAssignment)
-        handle(Rubinius::AST::ScopedConstant)
-        handle(Rubinius::AST::LocalVariableAccess)
-        handle(Rubinius::AST::InstanceVariableAccess)
-        handle(Rubinius::AST::GlobalVariableAccess)
-        handle(Rubinius::AST::ClassVariableAccess)
-        handle(Rubinius::AST::ToplevelConstant)
-        handle(Rubinius::AST::Ensure)
-        handle(Rubinius::AST::Rescue)
-        handle(Rubinius::AST::DynamicString)
-        handle(Rubinius::AST::DynamicSymbol)
-        handle(Rubinius::AST::DynamicRegex)
-        handle(Rubinius::AST::File)
-        handle(Rubinius::AST::NthRef)
-        handle(Rubinius::AST::OpAssignOr19)
-        handle(Rubinius::AST::BlockPass19)
-        handle(Rubinius::AST::OpAssign1)
-        handle(Rubinius::AST::OpAssign2)
-        handle(Rubinius::AST::SplatValue)
-        handle(Rubinius::AST::ConstantAccess)
-        handle(Rubinius::AST::Yield)
-        handle(Rubinius::AST::Begin)
-        handle(Rubinius::AST::Rescue)
-      
       private
 
         # Emit mutations
@@ -53,9 +28,9 @@ module Mutant
         # @api private
         #
         def dispatch
-          # noop
         end
-      end
-    end
-  end
-end
+
+      end # Noop
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -4,10 +4,11 @@ module Mutant
       # Mutator for return statements
       class Return < self
 
-        handle(Rubinius::AST::Return)
+        handle(:return)
 
-      private
+        children :value
 
+      private
 
         # Emit mutants
         #
@@ -16,16 +17,15 @@ module Mutant
         # @api private
         #
         def dispatch
-          value = node.value
           if value
             emit(value)
+            emit_value_mutations
           else
             emit_nil
           end
         end
 
-      end
-    end
-  end
-
-end
+      end # Return
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -0,0 +1,31 @@
+module Mutant
+  class Mutator
+    class Node
+      class Send
+
+        # Mutator for sends that correspond to a binary operator
+        class Binary < self
+
+          children :left, :operator, :right
+
+        private
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def dispatch
+            emit(left)
+            emit_left_mutations
+            emit(right) unless right.type == :splat
+            emit_right_mutations
+          end
+
+        end # Binary
+
+      end # Send
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -5,137 +5,171 @@ module Mutant
       # Namespace for send mutators
       class Send < self
 
-        handle(Rubinius::AST::Send)
+        handle(:send)
+
+        children :receiver, :selector
+
+        INDEX_REFERENCE = :[]
+        INDEX_ASSIGN    = :[]=
+        ASSIGN_SUFFIX   = :'='
+
+        # Base mutator for index operations
+        class Index < self
+
+          # Mutator for index references
+          class Reference < self
+
+            # Perform dispatch
+            #
+            # @return [undefined]
+            #
+            # @api private
+            #
+            def dispatch
+              emit(receiver)
+            end
+
+          end # Reference
+
+          # Mutator for index assignments
+          class Assign < self
+
+            # Perform dispatch
+            #
+            # @return [undefined]
+            #
+            # @api private
+            #
+            def dispatch
+              emit(receiver)
+            end
+
+          end # Assign
+        end # Index
 
       private
 
-        # Emit mutations
+        # Perform dispatch
         #
         # @return [undefined]
         #
         # @api private
         #
         def dispatch
-          emit_receiver 
-          emit_implicit_self_receiver
-          emit_receiver_mutations
-          emit_block_mutations
-          emit_block_absence_mutation
+          case selector
+          when INDEX_REFERENCE
+            run(Index::Reference)
+          when INDEX_ASSIGN
+            run(Index::Assign)
+          else
+            non_index_dispatch
+          end
         end
 
-        # Emit receiver 
+        # Perform non index dispatch
         #
         # @return [undefined]
         #
         # @api private
         #
-        def emit_receiver
-          unless to_self?
-            emit(receiver)
+        def non_index_dispatch
+          if binary_operator?
+            run(Binary)
+            return
           end
+          normal_dispatch
         end
 
-        # Emit block mutations
+        # Return arguments
         #
-        # @return [undefined]
+        # @return [Enumerable<Parser::AST::Node>]
         #
         # @api private
         #
-        def emit_block_mutations
-          emit_attribute_mutations(:block) if node.block
-        end
+        alias_method :arguments, :remaining_children
 
-        # Emit receiver mutations
+        # Perform normal, non special case dispatch
         #
         # @return [undefined]
         #
         # @api private
         #
-        def emit_receiver_mutations
-          emit_attribute_mutations(:receiver) 
+        def normal_dispatch
+          emit(receiver) if receiver
+          mutate_receiver
+          emit_argument_propagation
+          mutate_arguments
         end
 
-        # Emit block absence mutation
+        # Test for binary operator
         #
-        # @return [undefined]
+        # @return [true]
+        #   if send is a binary operator
+        #
+        # @return [false]
+        #   otherwise
         #
         # @api private
         #
-        def emit_block_absence_mutation
-          dup = dup_node
-          dup.block = nil
-          emit(dup)
+        def binary_operator?
+          arguments.one? && BINARY_METHOD_OPERATORS.include?(selector)
         end
 
-        # Return receiver AST node
+        # Mutate arguments
         #
-        # @return [Rubinius::AST::Node]
+        # @return [undefined]
         #
         # @api private
         #
-        def receiver
-          node.receiver
+        def mutate_arguments
+          return if arguments.empty?
+          emit_self(receiver, selector)
+          remaining_children_with_index.each do |node, index|
+            mutate_child(index)
+            delete_child(index)
+          end
         end
 
-        # Return name of call
+        NO_PROPAGATE = [ :splat, :block_pass ].to_set
+
+        # Emit argument propagation
         #
-        # @return [Symbol]
+        # @return [undefined]
         #
         # @api private
         #
-        def name
-          node.name
+        def emit_argument_propagation
+          return unless arguments.one?
+          node = arguments.first
+          return if NO_PROPAGATE.include?(node.type)
+          emit(arguments.first)
         end
 
-        # Check if receiver is self
-        #
-        # @return [true]
-        #   if receiver is a Rubinius::AST::Self node
+        # Emit receiver mutations
         #
-        # @return [false]
-        #   return false otherwise
+        # @return [undefined]
         #
         # @api private
         #
-        def to_self?
-          receiver.kind_of?(Rubinius::AST::Self)
+        def mutate_receiver
+          return unless receiver
+          emit_implicit_self
+          emit_receiver_mutations
         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.
+        # Emit implicit self mutation
         #
         # @return [undefined]
         #
         # @api private
         #
-        def emit_implicit_self_receiver
-          unless to_self? and !Mutant::KEYWORDS.include?(node.name)
-            return
+        def emit_implicit_self
+          if receiver.type == :self and !KEYWORDS.include?(selector)
+            emit_receiver(nil)
           end
-
-          mutant = dup_node
-          mutant.privately = true
-          emit(mutant)
         end
-      end
-    end
-  end
-end
+
+      end # Send
+    end # Node
+  end # Mutator
+end # Mutant