mutant 0.2.20 → 0.3.0.beta2

data/lib/mutant/matcher.rb

@@ -1,57 +1,47 @@
 module Mutant
-  # Abstract matcher to find ASTs to mutate
+  # Abstract matcher to find subjects to mutate
   class Matcher
     include Adamantium::Flat, Enumerable, AbstractType
     extend DescendantsTracker
 
     # Enumerate subjects
     #
-    # @api private
-    #
-    # @return [undefined]
+    # @param [Object] input
     #
-    abstract_method :each
-
-    # Return identification
+    # @return [self]
+    #   if block given
     #
-    # @return [String
+    # @return [Enumerator<Subject>]
     #
     # @api private
     #
-    abstract_method :identification
+    def self.each(input, &block)
+      return to_enum(__method__, input) unless block_given?
 
-    # Return matcher
-    #
-    # @param [String] input
-    #
-    # @return [nil]
-    #   returns nil as default implementation
+      new(input).each(&block)
+
+      self
+    end
+
+    # Enumerate subjects
     #
     # @api private
     #
-    def self.parse(input)
-      nil
-    end
-
-    # Return match from string
+    # @return [self]
+    #   if block given
     #
-    # @param [String] input
+    # @return [Enumerabe<Subject>]
+    #   otherwise
     #
-    # @return [Matcher]
-    #   returns matcher input if successful
+    abstract_method :each
+
+    # Return identification
     #
-    # @return [nil]
-    #   returns nil otherwise
+    # @return [String
     #
     # @api private
     #
-    def self.from_string(input)
-      descendants.each do |descendant|
-        matcher = descendant.parse(input)
-        return matcher if matcher
-      end
+    abstract_method :identification
 
-      nil
-    end
-  end
-end
+  end # Matcher
+end # Mutant

data/lib/mutant/mutation/evil.rb

@@ -0,0 +1,35 @@
+module Mutant
+  class Mutation
+    # Evul mutation
+    class Evil < self
+
+      # Return identification
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def identification
+        "evil:#{super}"
+      end
+      memoize :identification
+
+      # Test if killer is successful
+      #
+      # @param [Killer] killer
+      #
+      # @return [true]
+      #   if killer killed mutation
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      def success?(killer)
+        killer.killed?
+      end
+
+    end # Evil
+  end # Mutation
+end # Mutant

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

@@ -1,9 +1,9 @@
 module Mutant
   class Mutation
-    class Filter 
+    class Filter
       # Mutation filter that filters on mutation codes
       class Code < self
-        include Equalizer.new(:code)
+        include Concord::Public.new(:code)
 
         # Test for match
         #
@@ -36,33 +36,12 @@ module Mutant
         # @api private
         #
         def self.handle(notation)
-          match = PATTERN.match(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
+      end # Code
+    end # Filter
+  end # Mutation
+end # Mutant

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

@@ -3,6 +3,7 @@ module Mutant
     class Filter
       # Mutaiton filter filtering in regexp match on mutation identification
       class Regexp < self
+        include Concord::Public.new(:regexp)
 
         # Test for match
         #
@@ -17,23 +18,10 @@ module Mutant
         # @api private
         #
         def match?(mutation)
-          !!@regexp.match =~ mutation.identification
+          !!(regexp =~ mutation.identification)
         end
 
-      private
-
-        # Initialize regexp filter
-        #
-        # @param [Regexp] regexp
-        #
-        # @return [undefined]
-        #
-        # @api private
-        #
-        def initialize(regexp)
-          @regexp = regexp
-        end
-      end
-    end
-  end
-end
+      end # Regexp
+    end # Filter
+  end # Mutation
+end # Mutant

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

@@ -43,7 +43,8 @@ module Mutant
         def initialize(whitelist)
           @whitelist = whitelist
         end
-      end
-    end
-  end
-end
+
+      end # Whitelist
+    end # Filter
+  end # Mutation
+end # Mutant

data/lib/mutant/mutation/filter.rb

@@ -32,7 +32,7 @@ module Mutant
       # @api private
       #
       def self.build(notation)
-        descendants.each do |descendant| 
+        descendants.each do |descendant|
           filter = descendant.handle(notation)
           return filter if filter
         end
@@ -42,34 +42,35 @@ module Mutant
 
       # Return filter for handle
       #
-      # @param [String] notation
+      # @param [String] _notation
       #
       # @return [nil]
       #   returns nil
       #
       # @api private
       #
-      def self.handle(notation)
+      def self.handle(_notation)
         nil
       end
 
       # Mutation filter matching all mutations
-      Mutant.define_singleton_subclass('ALL', self) do
+      Mutant.singleton_subclass_instance('ALL', self) do
 
         # Test for match
         #
-        # @pram [Mutation] mutation
+        # @pram [Mutation] _mutation
         #
         # @return [true]
         #   returns true
         #
         # @api private
         #
-        def match?(mutation)
+        def match?(_mutation)
           true
         end
 
       end
-    end
-  end
-end
+
+    end # Filter
+  end # Mutation
+end # Mutant

data/lib/mutant/mutation/neutral.rb

@@ -0,0 +1,35 @@
+module Mutant
+  class Mutation
+    # Neutral mutation
+    class Neutral < self
+
+      # Return identification
+      #
+      # @return [String]
+      #
+      # @api private
+      #
+      def identification
+        "noop:#{super}"
+      end
+      memoize :identification
+
+      # Test if killer is successful
+      #
+      # @param [Killer] killer
+      #
+      # @return [true]
+      #   if killer did NOT killed mutation
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      def success?(killer)
+        !killer.killed?
+      end
+
+    end # Neutral
+  end # Mutation
+end # Mutant

data/lib/mutant/mutation.rb

@@ -1,42 +1,43 @@
 module Mutant
   # Represent a mutated node with its subject
   class Mutation
-    include Adamantium::Flat, Equalizer.new(:sha1)
+    include AbstractType, Adamantium::Flat, Concord::Public.new(:subject, :node)
 
-    # Return mutation subject
+    # Return mutated root node
     #
-    # @return [Subject]
+    # @return [Parser::AST::Node]
     #
     # @api private
     #
-    attr_reader :subject
+    def root
+      subject.root(node)
+    end
+    memoize :root
 
-    # Return mutated node
+    # Test if killer is successful
     #
-    # @return [Rubinius::AST::Node]
+    # @param [Killer] killer
     #
-    # @api private
+    # @return [true]
+    #   if killer is successful
     #
-    attr_reader :node
-
-    # Return mutated root node
-    #
-    # @return [Rubinius::AST::Node]
+    # @return [false]
+    #   otherwise
     #
     # @api private
     #
-    def root
-      subject.root(node)
-    end
-    memoize :root
+    abstract_method :success?
 
     # Insert mutated node
     #
+    # FIXME: Cache subject visibility in a better way! Ideally dont mutate it.
+    #
     # @return [self]
     #
     # @api private
     #
     def insert
+      subject.public?
       Loader::Eval.run(root, subject)
       self
     end
@@ -70,7 +71,7 @@ module Mutant
     # @api private
     #
     def sha1
-      Digest::SHA1.hexdigest(subject.identification + source)
+      Digest::SHA1.hexdigest(subject.identification + 0.chr + source)
     end
     memoize :sha1
 
@@ -81,7 +82,7 @@ module Mutant
     # @api private
     #
     def source
-      ToSource.to_source(node)
+      Unparser.unparse(node)
     end
     memoize :source
 
@@ -95,46 +96,5 @@ module Mutant
       subject.source
     end
 
-  private
-
-    # Initialize mutation object
-    #
-    # @param [Subject] subject
-    # @param [Rubinius::Node::AST] node
-    #
-    # @return [undefined]
-    #
-    # @api private
-    #
-    def initialize(subject, node)
-      @subject, @node = subject, node
-    end
-
-    # Noop mutation
-    class Noop < self
-
-      # Initialize 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
+  end # Mutation
+end # Mutant

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

@@ -0,0 +1,88 @@
+module Mutant
+  class Mutator
+    class Node
+
+      # Mutator for required arguments
+      class Argument < self
+        handle(:arg)
+
+        UNDERSCORE = '_'.freeze
+
+        children :name
+
+      private
+
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          return if skip?
+          emit_name_mutation
+        end
+
+        # Emit name mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_name_mutation
+          Mutator::Util::Symbol.each(name) do |name|
+            emit_name(name)
+          end
+        end
+
+        # Test if argument mutation is skipped
+        #
+        # @return [true]
+        #   if argument should not get mutated
+        #
+        # @return [false]
+        #   otherwise
+        #
+        # @api private
+        #
+        def skip?
+          name.to_s.start_with?(UNDERSCORE)
+        end
+
+        # Mutator for optional arguments
+        class Optional < self
+
+          handle(:optarg)
+
+          children :name, :default
+
+        private
+
+          # Perform dispatch
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def dispatch
+            emit_name_mutation
+            emit_required_mutation
+            emit_default_mutations
+          end
+
+          # Emit required mutation
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def emit_required_mutation
+            emit(s(:arg, name))
+          end
+
+        end # Optional
+
+      end # Argument
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -0,0 +1,52 @@
+module Mutant
+  class Mutator
+    class Node
+      # Mutator for arguments node
+      class Arguments < self
+
+        handle(:args)
+
+      private
+
+        # Perform dispatch
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          emit_children_mutations
+          emit_mlhs_expansion
+        end
+
+        # Emit mlhs expansions
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def emit_mlhs_expansion
+          mlhs_childs_with_index.each do |child, index|
+            dup_children = children.dup
+            dup_children.delete_at(index)
+            dup_children.insert(index, *child.children)
+            emit_self(*dup_children)
+          end
+        end
+
+        # Return mlhs childs
+        #
+        # @return [Enumerable<Parser::AST::Node, Fixnum>]
+        #
+        # @api private
+        #
+        def mlhs_childs_with_index
+          children.each_with_index.select do |child, index|
+            child.type == :mlhs
+          end
+        end
+
+      end # Arguments
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -1,55 +1,51 @@
 module Mutant
   class Mutator
     class Node
-
-      # Abstract base class for assignment mutators
+      # Mutator base class for assignments
       class Assignment < self
 
-      private
-
-        # Abstract base class for variable assignments
+        # Mutator for variable assignment
         class Variable < self
 
-          # Emit mutants
+          children :name, :value
+
+          MAP = IceNine.deep_freeze(
+            :gvasgn => '$',
+            :cvasgn => '@@',
+            :ivasgn => '@',
+            :lvasgn => ''
+          )
+
+          handle *MAP.keys
+
+        private
+
+          # Perform dispatch
           #
           # @return [undefined]
           #
           # @api private
           #
           def dispatch
-            emit_attribute_mutations(:name) do |mutation|
-              mutation.name = "#{self.class::PREFIX}#{mutation.name}".to_sym
-              mutation
-            end
-            emit_attribute_mutations(:value)
+            mutate_name
+            emit_value_mutations
           end
 
-          # Mutator for local variable assignments
-          class Local < self
-            PREFIX = ''.freeze
-            handle(Rubinius::AST::LocalVariableAssignment)
-          end
-
-          # Mutator for instance variable assignments
-          class Instance < self
-            PREFIX = '@'.freeze
-            handle(Rubinius::AST::InstanceVariableAssignment)
-          end
-
-          # Mutator for class variable assignments
-          class Class < self
-            PREFIX = '@@'.freeze
-            handle(Rubinius::AST::ClassVariableAssignment)
-          end
-
-          # Mutator for global variable assignments
-          class Global < self
-            PREFIX = '$'.freeze
-            handle(Rubinius::AST::GlobalVariableAssignment)
+          # Emit name mutations
+          #
+          # @return [undefined]
+          #
+          # @api private
+          #
+          def mutate_name
+            prefix = MAP.fetch(node.type)
+            Mutator::Util::Symbol.each(name) do |name|
+              emit_name("#{prefix}#{name}")
+            end
           end
 
-        end
-      end
-    end
-  end
-end
+        end # Variable
+      end # Assignment
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -0,0 +1,33 @@
+module Mutant
+  class Mutator
+    class Node
+
+      # Mutator for begin nodes
+      class Begin < self
+
+        handle(:begin)
+
+      private
+
+        # Emit mutants
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          Util::Array.each(children) do |children|
+            if children.length > 1
+              emit_self(*children)
+            end
+          end
+          children.each do |child|
+            emit(child)
+          end
+          emit(nil)
+        end
+
+      end # Block
+    end # Node
+  end # Mutator
+end # Mutant