mutant 0.1.1 → 0.2.0

data/lib/mutant/mutation/filter.rb

@@ -0,0 +1,75 @@
+module Mutant
+  class Mutation
+    # Abstract filter for mutations
+    class Filter
+      include Adamantium::Flat, AbstractType
+      extend DescendantsTracker
+
+      # Check for match
+      #
+      # @param [Mutation] mutation
+      #
+      # @return [true]
+      #   returns true if mutation is matched by filter
+      #
+      # @return [false]
+      #   returns false otherwise
+      #
+      # @api private
+      #
+      abstract_method :match?
+
+      # Build filter from string
+      #
+      # @param [String] notation
+      #
+      # @return [Filter]
+      #   returns filter when can be buld from string
+      #
+      # @return [nil]
+      #   returns nil otherwise
+      #
+      # @api private
+      #
+      def self.build(notation)
+        descendants.each do |descendant| 
+          filter = descendant.handle(notation)
+          return filter if filter
+        end
+
+        nil
+      end
+
+      # Return filter for handle
+      #
+      # @param [String] notation
+      #
+      # @return [nil]
+      #   returns nil
+      #
+      # @api private
+      #
+      def self.handle(notation)
+        nil
+      end
+
+      # Mutation filter matching all mutations
+      Mutant.define_singleton_subclass('ALL', self) do
+
+        # Test for match
+        #
+        # @pram [Mutation] mutation
+        #
+        # @return [true]
+        #   returns true
+        #
+        # @api private
+        #
+        def match?(mutation)
+          true
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+module Mutant
+  class Mutation
+    class Filter 
+      # Mutation filter that filters on mutation codes
+      class Code < self
+        include Equalizer.new(:code)
+
+        # Test for match
+        #
+        # @param [Mutation] mutation
+        #
+        # @return [true]
+        #   returns true if mutation code matches filter code
+        #
+        # @return [false]
+        #   returns false otherwise
+        #
+        # @api private
+        #
+        def match?(mutation)
+          mutation.code.eql?(code)
+        end
+
+        PATTERN = %r(\Acode:([a-f0-9]{1,6})\z).freeze
+
+        # Test if class handles string
+        #
+        # @param [String] notation
+        #
+        # @return [Filter]
+        #   return code filter instance if notation matches pattern
+        #
+        # @return [nil]
+        #   returns nil otherwise
+        #
+        # @api private
+        #
+        def self.handle(notation)
+          match = PATTERN.match(notation) 
+          return unless match
+          new(match[1])
+        end
+
+        # Return code
+        #
+        # @return [String]
+        #
+        # @api private
+        #
+        attr_reader :code
+
+      private
+
+        # Initialize code filter
+        #
+        # @param [String] code
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def initialize(code)
+          @code = code
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,39 @@
+module Mutant
+  class Mutation
+    class Filter
+      # Mutaiton filter filtering in regexp match on mutation identification
+      class Regexp < self
+
+        # Test for match
+        #
+        # @param [Mutation] mutation
+        #
+        # @return [true]
+        #   returns true if mutation identification is matched by regexp
+        #
+        # @return [false]
+        #   returns false otherwise
+        #
+        # @api private
+        #
+        def match?(mutation)
+          !!@regexp.match =~ mutation.identification
+        end
+
+      private
+
+        # Initialize regexp filter
+        #
+        # @param [Regexp] regexp
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def initialize(regexp)
+          @regexp = regexp
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Mutant
+  class Mutation
+    class Filter
+      class Whitelist < self
+        include Adamantium::Flat, Equalizer.new(:whitelist)
+
+        # Test for match
+        #
+        # @param [Mutation]
+        #
+        # @return [true]
+        #   returns true if mutation matches whitelist
+        #
+        # @return [false]
+        #   returns false otherwise
+        #
+        # @api private
+        #
+        def match?(mutation)
+          @whitelist.any? { |filter| filter.match?(mutation) }
+        end
+
+        # Return whitelist
+        #
+        # @return [Enumerable<Filter>]
+        #
+        # @api private
+        #
+        attr_reader :whitelist
+
+      private
+
+        # Initalize white list
+        #
+        # @param [Enumerable<Filter>] whitelist
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def initialize(whitelist)
+          @whitelist = whitelist
+        end
+      end
+    end
+  end
+end

data/lib/mutant/mutator.rb

@@ -1,49 +1,153 @@
 module Mutant
+  # Generator for mutations
   class Mutator
-    COMPILER = Rubinius::Compiler.new(:bytecode, :compiled_method)
+    include Adamantium::Flat, AbstractType
 
-    def initialize(mutatee)
-      @mutatee = mutatee
+    # Run mutator on input
+    #
+    # @param [Object] input
+    # @param [#call] block
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def self.each(node, &block)
+      return to_enum(__method__, node) unless block_given?
+      Registry.lookup(node.class).new(node, block)
+
+      self
     end
 
-    def mutate
-      @mutatee.clean
-      @mutatee.set_mutations
+    # 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)
+    end
+    private_class_method :handle
 
-      if @mutatee.mutations.size.zero?
-        Reporter.no_mutations(@mutatee)
-        return
-      else
-        Reporter.method_loaded(@mutatee)
-      end
+    # Return input
+    #
+    # @return [Object]
+    #
+    # @api private
+    #
+    attr_reader :input
 
-      @mutatee.mutations.each do |mutation|
-        @mutatee.body.array = mutation.mutate && mutation.array
-        Reporter.mutating(mutation)
-        # setup the compiler
-        COMPILER.generator.input(root)
-        # compile the script and replace the original method
-        # with the mutated method
-        Rubinius.run_script(compiled_method)
-      end
+  private
+
+    # Initialize object
+    #
+    # @param [Object] input
+    # @param [#call(node)] block
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def initialize(input, block)
+      @input, @block = Helper.deep_clone(input), block
+      IceNine.deep_freeze(@input)
+      dispatch
     end
 
-    def block
-      Rubinius::AST::Block.new(1, [ @mutatee.ast ])
+    # Test if generated object is different from input
+    #
+    # @param [Object] object
+    #
+    # @return [true]
+    #   if generated object is different
+    #
+    # @return [false]
+    #
+    # @api private
+    #
+    def new?(object)
+      input != object
     end
 
-    def class_ast
-      Rubinius::AST::Class.new(1, @mutatee.class_name.to_sym, nil, block)
+    # Dispatch node generations
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    abstract_method :dispatch
+
+    # Emit generated mutation if object is not equivalent to input
+    #
+    # @param [Object] object
+    #
+    # @return [undefined]
+    #
+    # @api private
+    #
+    def emit(object)
+      return unless new?(object)
+
+      emit!(object)
     end
 
-    def root
-      Rubinius::AST::Script.new(class_ast).tap do |script|
-        script.file = @mutatee.rbx_method.source_file
+    # Maximum amount of tries to generate a new object
+    MAX_TRIES = 3
+
+    # Call block until it generates a mutation
+    #
+    # The primary use of this method is to give the random generated object
+    # a nice interface for retring generation when generation accidentally generated the
+    # input
+    #
+    # @yield
+    #   Execute block until object is generated where new?(object) returns true
+    #
+    # @return [self]
+    #
+    # @raise [RuntimeError]
+    #   raises RuntimeError in case no new ast node can be generated after MAX_TRIES.
+    #
+    # @api private
+    #
+    def emit_new
+      MAX_TRIES.times do
+        object = yield
+
+        if new?(object)
+          emit!(object)
+          return
+        end
       end
+
+      raise "New AST could not be generated after #{MAX_TRIES} attempts"
     end
 
-    def compiled_method
-      COMPILER.run.create_script.compiled_method
+    # Call block with node
+    #
+    # @param [Rubinius::AST::Node] node
+    #
+    # @return [self]
+    #
+    # @api private
+    #
+    def emit!(node)
+      @block.call(node)
+      self
     end
+
+    # Shortcut to create a new unfrozen duplicate of input
+    #
+    # @return [Object]
+    #
+    # @api private
+    #
+    def dup_input
+      input.dup
+    end
+
   end
 end

data/lib/mutant/mutator/node.rb

@@ -0,0 +1,163 @@
+module Mutant
+  # Generator for mutations
+  class Mutator
+    # Abstract base class for node mutators
+    class Node < self
+      include AbstractType
+
+    private
+
+      alias_method :node, :input
+      alias_method :dup_node, :dup_input
+
+      # Return source of input node
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def source
+        ToSource.to_source(node)
+      end
+      memoize :source
+
+      # Test if generated node is new
+      #
+      # @return [true]
+      #   if generated node is different from input
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      def new?(node)
+        source != ToSource.to_source(node)
+      end
+
+      # Emit a new AST node
+      #
+      # @param [Rubinis::AST::Node:Class] node_class
+      #
+      # @return [Rubinius::AST::Node]
+      #
+      # @api private
+      #
+      def emit_node(node_class, *arguments)
+        emit(new(node_class, *arguments))
+      end
+
+      # Create a new AST node with same class as wrapped node
+      #
+      # @return [Rubinius::AST::Node]
+      #
+      # @api private
+      #
+      def new_self(*arguments)
+        new(node.class, *arguments)
+      end
+
+      # Create a new AST node with Rubnius::AST::NilLiteral class
+      #
+      # @return [Rubinius::AST::Node]
+      #
+      # @api private
+      #
+      def new_nil
+        new(Rubinius::AST::NilLiteral)
+      end
+
+      # Create a new AST node with the same line as wrapped node
+      #
+      # @param [Class:Rubinius::AST::Node] node_class
+      #
+      # @return [Rubinius::AST::Node]
+      #
+      # @api private
+      #
+      def new(node_class, *arguments)
+        node_class.new(node.line, *arguments)
+      end
+
+      # Emit a new AST node with same class as wrapped node
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_self(*arguments)
+        emit(new_self(*arguments))
+      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
+
+      # Emit body mutations
+      #
+      # @param [Symbol] name
+      #
+      # @return [undefined]
+      #
+      # @api private
+      #
+      def emit_attribute_mutations(name)
+        body = node.public_send(name)
+
+        Mutator.each(body) do |mutation|
+          dup = dup_node
+          dup.public_send(:"#{name}=", mutation)
+          emit(dup)
+        end
+      end
+
+      # Emit a new AST node with NilLiteral class
+      #
+      # @return [Rubinius::AST::NilLiteral]
+      #
+      # @api private
+      #
+      def emit_nil
+        emit(new_nil)
+      end
+
+      # Return AST representing send
+      #
+      # @param [Rubinius::AST::Node] receiver
+      # @param [Symbol] name
+      # @param [Rubinius::AST::Node] arguments
+      #
+      # @return [Rubnius::AST::SendWithArguments]
+      #
+      # @api private
+      #
+      def new_send(receiver, name, arguments=nil)
+        if arguments
+          new(Rubinius::AST::SendWithArguments, receiver, name, arguments)
+        else
+          new(Rubinius::AST::Send, receiver, name)
+        end
+      end
+
+      # Return duplicated (unfrozen) node each call
+      #
+      # @return [Rubinius::AST::Node]
+      #
+      # @api private
+      #
+      def dup_node
+        node.dup
+      end
+    end
+  end
+end