mutant 0.2.20 → 0.3.0.beta2

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

@@ -4,7 +4,11 @@ module Mutant
 
       # Mutator for super with parantheses
       class Super < self
-        handle(Rubinius::AST::Super)
+
+        handle(:super)
+
+        Z_SUPER = NodeHelpers.s(:zsuper)
+        EMPTY_SUPER = NodeHelpers.s(:super)
 
       private
 
@@ -15,24 +19,15 @@ module Mutant
         # @api private
         #
         def dispatch
-          emit_node(Rubinius::AST::ZSuper)
-          emit_without_block
-          emit_attribute_mutations(:block) if node.block
-          emit_attribute_mutations(:arguments) 
+          emit(Z_SUPER)
+          emit(EMPTY_SUPER)
+          children.each_index do |index|
+            mutate_child(index)
+            delete_child(index)
+          end
         end
 
-        # Emit without block mutation
-        #
-        # @return [undefined]
-        #
-        # @api private
-        #
-        def emit_without_block
-          dup = dup_node
-          dup.block = nil
-          emit(dup)
-        end
-      end
-    end
-  end
-end
+      end # Super
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -2,10 +2,10 @@ module Mutant
   class Mutator
     class Node
 
-      # Mutator for Rubinius::AST::When nodes
+      # Mutator for when nodes
       class When < self
 
-        handle(Rubinius::AST::When)
+        handle(:when)
 
       private
 
@@ -16,10 +16,35 @@ module Mutant
         # @api private
         #
         def dispatch
-          emit_attribute_mutations(:body)
+          mutate_body
+          mutate_conditions
         end
 
-      end
-    end
-  end
-end
+        # Emit condition mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def mutate_conditions
+          conditions = children.length - 1
+          children[0..-2].each_index do |index|
+            delete_child(index) if conditions > 1
+            mutate_child(index)
+          end
+        end
+
+        # Emit body mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def mutate_body
+          mutate_child(children.length-1)
+        end
+
+      end # When
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -5,7 +5,9 @@ module Mutant
       # Mutator for while expressions
       class While < self
 
-        handle(Rubinius::AST::While)
+        handle(:while)
+
+        children :condition, :body
 
       private
 
@@ -16,11 +18,11 @@ module Mutant
         # @api private
         #
         def dispatch
-          emit_attribute_mutations(:condition)
-          emit_attribute_mutations(:body)
+          emit_condition_mutations
+          emit_body_mutations
         end
 
-      end
-    end
-  end
-end
+      end # While
+    end # Node
+  end # Mutator
+end # Mutant

data/lib/mutant/mutator/node.rb

@@ -3,25 +3,82 @@ module Mutant
   class Mutator
     # Abstract base class for node mutators
     class Node < self
-      include AbstractType
+      include AbstractType, NodeHelpers, Unparser::Constants
 
       # Return identity of node
       #
-      # @param [Rubinius::AST::Node] node
+      # @param [Parser::AST::Node] node
       #
       # @return [String]
       #
       # @api private
       #
       def self.identity(node)
-        ToSource.to_source(node)
+        Unparser.unparse(node)
       end
 
+      # Define named child
+      #
+      # @param [Symbol] name
+      # @param [Fixnum] index
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def self.define_named_child(name, index)
+        define_method("#{name}") do
+          children.at(index)
+        end
+
+        define_method("emit_#{name}_mutations") do
+          mutate_child(index)
+        end
+
+        define_method("emit_#{name}") do |node|
+          emit_child_update(index, node)
+        end
+      end
+      private_class_method :define_named_child
+
+      # Define remaining children
+      #
+      # @param [Array<Symbol>] names
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def self.define_remaining_children(names)
+        define_method(:remaining_children_with_index) do
+          children.each_with_index.drop(names.length)
+        end
+
+        define_method(:remaining_children) do
+          children.drop(names.length)
+        end
+      end
+      private_class_method :define_remaining_children
+
+      # Create name helpers
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def self.children(*names)
+        names.each_with_index do |name, index|
+          define_named_child(name, index)
+        end
+        define_remaining_children(names)
+      end
+      private_class_method :children
+
     private
 
       # Return mutated node
       #
-      # @return [Rubinius::AST::Node]
+      # @return [Parser::AST::Node]
       #
       # @api private
       #
@@ -29,85 +86,89 @@ module Mutant
 
       # Return duplicated node
       #
-      # @return [Rubinius::AST::Node]
+      # @return [Parser::AST::Node]
       #
       # @api private
       #
       alias_method :dup_node, :dup_input
 
-      # Emit a new AST node
+      # Emit children mutations
       #
-      # @param [Rubinis::AST::Node:Class] node_class
-      #
-      # @return [Rubinius::AST::Node]
+      # @return [undefined]
       #
       # @api private
       #
-      def emit_node(node_class, *arguments)
-        emit(new(node_class, *arguments))
+      def emit_children_mutations
+        Mutator::Util::Array.each(children) do |children|
+          emit_self(*children)
+        end
       end
 
-      # Create a new AST node with same class as wrapped node
+      # Return children
       #
-      # @return [Rubinius::AST::Node]
+      # @return [Array<Parser::AST::Node>]
       #
       # @api private
       #
-      def new_self(*arguments)
-        new(node.class, *arguments)
+      def children
+        node.children
       end
 
-      # Create a new AST node with Rubnius::AST::NilLiteral class
+      # Dispatch on child index
       #
-      # @return [Rubinius::AST::Node]
+      # @param [Fixnum] index
+      #
+      # @return [undefined]
       #
       # @api private
       #
-      def new_nil
-        new(Rubinius::AST::NilLiteral)
+      def mutate_child(index, mutator = Mutator)
+        children = node.children
+        child = children[index]
+        mutator.each(child) do |mutation|
+          emit_child_update(index, mutation)
+        end
       end
 
-      # Create a new AST node with the same line as wrapped node
+      # Emit delete child mutation
       #
-      # @param [Class:Rubinius::AST::Node] node_class
+      # @param [Fixnum] index
       #
-      # @return [Rubinius::AST::Node]
+      # @return [undefined]
       #
       # @api private
       #
-      def new(node_class, *arguments)
-        node_class.new(node.line, *arguments)
+      def delete_child(index)
+        dup_children = children.dup
+        dup_children.delete_at(index)
+        emit_self(*dup_children)
       end
 
-      # Emit a new AST node with same class as wrapped node
+      # Emit updated child
+      #
+      # @param [Fixnum] index
+      # @param [Object] update
       #
       # @return [undefined]
       #
       # @api private
       #
-      def emit_self(*arguments)
-        emit(new_self(*arguments))
+      def emit_child_update(index, update)
+        new_children = children.dup
+        new_children[index]=update
+        emit_self(*new_children)
       end
 
-      # Emit body mutations
+      # Emit a new AST node with same class as wrapped node
       #
-      # @param [Symbol] name
+      # @param [Array<Parser::AST::Node>] children
       #
       # @return [undefined]
       #
       # @api private
       #
-      def emit_attribute_mutations(name, mutator = Mutator)
-        value = node.public_send(name)
-
-        mutator.each(value) do |mutation|
-          dup = dup_node
-          dup.public_send(:"#{name}=", mutation)
-          if block_given?
-            dup = yield(dup)
-          end
-          emit(dup)
-        end
+      def emit_self(*children)
+        emit(new_self(*children))
       end
 
       # Emit a new AST node with NilLiteral class
@@ -117,44 +178,33 @@ module Mutant
       # @api private
       #
       def emit_nil
-        emit(new_nil)
+        emit(N_NIL)
       end
 
-      # Return new Rubiinius::AST::SendWithArguments node
+      # Return new self typed child
       #
-      # @param [Rubnius::AST::Node] receiver
-      # @param [Symbol] name
-      # @param [Object] arguments
-      #
-      # @return [Rubinius::AST::SendWithArguments]
+      # @return [Parser::AST::Node]
       #
       # @api private
       #
-      def new_send_with_arguments(receiver, name, arguments)
-        new(Rubinius::AST::SendWithArguments, receiver, name, arguments)
+      def new_self(*children)
+        Parser::AST::Node.new(node.type, children)
       end
 
-      # Return AST representing send
+      # Emit values
       #
-      # @param [Rubinius::AST::Node] receiver
-      # @param [Symbol] name
+      # @param [Array<Object>] values
       #
-      # @return [Rubnius::AST::Send]
+      # @return [undefined]
       #
       # @api private
       #
-      def new_send(receiver, name)
-        new(Rubinius::AST::Send, receiver, name)
+      def emit_values(values)
+        values.each do |value|
+          emit_self(value)
+        end
       end
 
-      # Return duplicated (unfrozen) node each call
-      #
-      # @return [Rubinius::AST::Node]
-      #
-      # @api private
-      #
-      alias_method :dup_node, :dup_input
-
-    end
-  end
-end
+    end # Node
+  end # Mutator
+end # Mutant

data/lib/mutant/mutator/registry.rb

@@ -15,21 +15,22 @@ module Mutant
 
       # Register mutator class for AST node class
       #
-      # @param [Class] ast_class
+      # @param [Symbol] type
       # @param [Class] mutator_class
       #
       # @api private
       #
       # @return [self]
       #
-      def self.register(ast_class,mutator_class)
-        registry[ast_class]=mutator_class
+      def self.register(type, mutator_class)
+        raise "duplicate type registration: #{type}" if registry.key?(type)
+        registry[type]=mutator_class
         self
       end
 
-      # Lookup mutator class for AST node class
+      # Lookup mutator class for node
       #
-      # @param [Class] ast_class
+      # @param [Parser::AST::Node] node
       #
       # @return [Class]
       #
@@ -38,11 +39,13 @@ module Mutant
       #
       # @api private
       #
-      def self.lookup(ast_class)
-        registry.fetch(ast_class) do
-          raise ArgumentError,"No mutator to handle: #{ast_class.inspect}"
+      def self.lookup(node)
+        type = node.type
+        registry.fetch(type) do
+          raise ArgumentError,"No mutator to handle: #{type.inspect}"
         end
       end
-    end
-  end
-end
+
+    end # Registry
+  end # Mutator
+end # Mutant

data/lib/mutant/mutator/util/array.rb

@@ -26,7 +26,7 @@ module Mutant
             end
           end
 
-        end
+        end # Presence
 
         # Array element mutator
         class Element < Util
@@ -34,27 +34,27 @@ module Mutant
         private
 
           # Emit mutations
-          # 
+          #
           # @return [undefined]
           #
           # @api private
           #
           def dispatch
             input.each_with_index do |element, index|
-              dup = dup_input
               Mutator.each(element).each do |mutation|
+                dup = dup_input
                 dup[index]=mutation
                 emit(dup)
               end
             end
           end
 
-        end
+        end # Element
 
       private
 
         # Emit mutations
-        # 
+        #
         # @return [undefined]
         #
         # @api private
@@ -65,7 +65,7 @@ module Mutant
           emit([])
         end
 
-      end
-    end
-  end
-end
+      end # Array
+    end # Node
+  end # Mutant
+end # Mutator

data/lib/mutant/mutator/util/symbol.rb

@@ -2,7 +2,7 @@ module Mutant
   class Mutator
     class Util
 
-      # Mutators that mutates symbol inputs
+      # Utility symbol mutator
       class Symbol < self
 
         handle(::Symbol)
@@ -16,24 +16,10 @@ module Mutant
         # @api private
         #
         def dispatch
-          emit_new { :"s#{Random.hex_string}" } unless ignore?
+          emit_new { :"s#{Random.hex_string}" }
         end
 
-        # Test if symbol is ignored
-        #
-        # @return [true]
-        #   if symbol begins with an underscore
-        #
-        # @return [false]
-        #   otherwise
-        #
-        # @api private
-        #
-        def ignore?
-          input.to_s[0] == '_'
-        end
-
-      end
-    end
-  end
-end
+      end # Symbol
+    end # Util
+  end # Mutator
+end # Mutant

data/lib/mutant/mutator/util.rb

@@ -23,6 +23,8 @@ module Mutant
         self
       end
 
+    private
+
       # Test if mutation is new
       #
       # @param [Object] generated
@@ -38,6 +40,7 @@ module Mutant
       def new?(generated)
         input != generated
       end
-    end
-  end
-end
+
+    end # Util
+  end # Mutator
+end # Mutant

data/lib/mutant/mutator.rb

@@ -5,30 +5,30 @@ module Mutant
 
     # Run mutator on input
     #
-    # @param [Object] input
+    # @param [Parser::AST::Node] node
     # @param [#call] block
     #
     # @return [self]
     #
     # @api private
     #
-    def self.each(input, &block)
-      return to_enum(__method__, input) unless block_given?
-      Registry.lookup(input.class).new(input, block)
+    def self.each(node, &block)
+      return to_enum(__method__, node) unless block_given?
+      Registry.lookup(node).new(node, block)
 
       self
     end
 
     # Register node class handler
     #
-    # @param [Class:Rubinius::AST::Node] node_class
-    #
     # @return [undefined]
     #
     # @api private
     #
-    def self.handle(node_class)
-      Registry.register(node_class,self)
+    def self.handle(*types)
+      types.each do |type|
+        Registry.register(type, self)
+      end
     end
     private_class_method :handle
 
@@ -97,22 +97,6 @@ module Mutant
       @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
     #
     # @return [undefined]
@@ -130,7 +114,7 @@ module Mutant
     # @api private
     #
     def emit(object)
-      return unless new?(object) and allow?(object)
+      return unless new?(object)
 
       guard(object)
 
@@ -171,7 +155,7 @@ module Mutant
 
     # Call block with node
     #
-    # @param [Rubinius::AST::Node] node
+    # @param [Parser::AST::Node] node
     #
     # @return [self]
     #
@@ -202,5 +186,5 @@ module Mutant
       Helper.deep_clone(input)
     end
 
-  end
-end
+  end # Mutator
+end # Mutant

data/lib/mutant/node_helpers.rb

@@ -0,0 +1,28 @@
+module Mutant
+  # Mixin for node helpers
+  module NodeHelpers
+
+    # Build node
+    #
+    # @param [Symbol] type
+    #
+    # @return [Parser::AST::Node]
+    #
+    # @api private
+    #
+    def s(type, *children)
+      Parser::AST::Node.new(type, children)
+    end
+    module_function :s
+
+
+    NAN               = s(:send, s(:float,  0.0), :/, s(:args, s(:float, 0.0)))
+    NEGATIVE_INFINITY = s(:send, s(:float, -1.0), :/, s(:args, s(:float, 0.0)))
+    INFINITY          = s(:send, s(:float,  1.0), :/, s(:args, s(:float, 0.0)))
+    NEW_OBJECT        = s(:send, s(:const, s(:cbase), :Object), :new)
+
+    N_NIL             = s(:nil)
+    N_EMPTY           = s(:empty)
+
+  end # NodeHelpers
+end # Mutant

data/lib/mutant/random.rb

@@ -31,5 +31,6 @@ module Mutant
     def self.float
       ::Random.rand
     end
-  end
-end
+
+  end # Random
+end # Mutant