mutant 0.3.0.rc1 → 0.3.0.rc2

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

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module Mutant
+  class Mutator
+    class Node
+
+      # Dstr mutator
+      class Dstr < Generic
+
+        handle(:dstr)
+
+      private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          super
+          emit_nil
+        end
+
+      end # Dstr
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module Mutant
+  class Mutator
+    class Node
+
+      # Dsym mutator
+      class Dsym < Generic
+
+        handle(:dsym)
+
+      private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          super
+          emit_nil
+        end
+
+      end # Dsym
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -11,12 +11,11 @@ module Mutant
         # your contribution is that close!
         handle(
           :next, :break, :ensure,
-          :dstr, :dsym, :yield, :rescue, :redo, :defined?,
-          :blockarg, :op_asgn, :and_asgn,
-          :regopt, :restarg, :resbody, :retry, :arg_expr,
+          :yield, :rescue, :redo, :defined?,
+          :regopt, :resbody, :retry, :arg_expr,
           :kwrestarg, :kwoptarg, :kwarg, :undef, :module, :empty,
           :alias, :for, :xstr, :back_ref, :class,
-          :sclass, :match_with_lvasgn, :match_current_line, :or_asgn, :kwbegin
+          :sclass, :match_with_lvasgn, :match_current_line, :kwbegin
         )
 
       private

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

@@ -22,6 +22,7 @@ module Mutant
           mutate_condition
           mutate_if_branch
           mutate_else_branch
+          emit_nil
         end
 
         # Emit conditon mutations

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

@@ -10,8 +10,8 @@ module Mutant
         private
 
           MAP = {
-            :true  => :false,
-            :false => :true
+            true:  :false,
+            false: :true
           }.freeze
 
           handle(*MAP.keys)

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

@@ -10,8 +10,8 @@ module Mutant
           include AbstractType
 
           MAP = {
-            :irange => :erange,
-            :erange => :irange
+            irange: :erange,
+            erange: :irange
           }.freeze
 
           children :start, :_end
@@ -29,8 +29,8 @@ module Mutant
           def dispatch
             emit_nil
             emit_inverse
-            emit_start_mutations
-            emit_end_mutations
+            emit_lower_bound_mutations
+            emit_upper_bound_mutations
           end
 
           # Return inverse node
@@ -49,7 +49,8 @@ module Mutant
           #
           # @api private
           #
-          def emit_end_mutations
+          def emit_upper_bound_mutations
+            emit__end_mutations
             emit_self(NAN, _end)
           end
 
@@ -59,7 +60,8 @@ module Mutant
           #
           # @api private
           #
-          def emit_start_mutations
+          def emit_lower_bound_mutations
+            emit_start_mutations
             emit_self(start, INFINITY)
             emit_self(start, NAN)
           end

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

@@ -6,23 +6,6 @@ module Mutant
       # Abstract mutator for literal AST nodes
       class Literal < self
         include AbstractType
-
-      private
-
-        # 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
-
       end # Literal
     end # Node
   end # Mutator

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

@@ -20,7 +20,7 @@ module Mutant
         # @api private
         #
         def dispatch
-          # noop, for now
+          emit_nil
         end
 
       end # MultipleAssignment

data/lib/mutant/mutator/node/named_value/variable_assignment.rb

@@ -11,10 +11,10 @@ module Mutant
           children :name, :value
 
           MAP = IceNine.deep_freeze(
-            :gvasgn => '$',
-            :cvasgn => '@@',
-            :ivasgn => '@',
-            :lvasgn => ''
+            gvasgn: '$',
+            cvasgn: '@@',
+            ivasgn: '@',
+            lvasgn: ''
           )
 
           handle(*MAP.keys)
@@ -30,6 +30,7 @@ module Mutant
           def dispatch
             mutate_name
             emit_value_mutations if value # mlhs!
+            emit_nil
           end
 
           # Emit name mutations

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

@@ -0,0 +1,30 @@
+# encoding: utf-8
+
+module Mutant
+  class Mutator
+    class Node
+
+      # OpAsgn mutator
+      class OpAsgn < Generic
+
+        handle(:op_asgn, :or_asgn, :and_asgn)
+
+        children :left, :right
+
+      private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        #
+        # @api private
+        #
+        def dispatch
+          super
+          emit_nil
+        end
+
+      end # OpAsgn
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+module Mutant
+  class Mutator
+    class Node
+
+      # Restarg mutator
+      class Restarg < Generic
+
+        handle(:restarg)
+
+      end # Restarg
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -22,9 +22,8 @@ module Mutant
           if value
             emit(value)
             emit_value_mutations
-          else
-            emit_nil
           end
+          emit_nil
         end
 
       end # Return

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

@@ -12,8 +12,8 @@ module Mutant
         children :receiver, :selector
 
         SELECTOR_REPLACEMENTS = {
-          :send => :public_send,
-          :gsub => :sub
+          send: :public_send,
+          gsub: :sub
         }.freeze
 
         INDEX_REFERENCE = :[]
@@ -71,6 +71,7 @@ module Mutant
           else
             non_index_dispatch
           end
+          emit_nil
         end
 
         # Perform non index dispatch
@@ -103,19 +104,19 @@ module Mutant
         #
         def normal_dispatch
           emit_naked_receiver
-          emit_selector_mutations
+          emit_selector_replacement
           mutate_receiver
           emit_argument_propagation
           mutate_arguments
         end
 
-        # Emit selector mutations
+        # Emit selector replacement
         #
         # @return [undefined]
         #
         # @api private
         #
-        def emit_selector_mutations
+        def emit_selector_replacement
           replacement = SELECTOR_REPLACEMENTS.fetch(selector) { return }
           emit_selector(replacement)
         end

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

@@ -27,6 +27,7 @@ module Mutant
             mutate_child(index)
             delete_child(index)
           end
+          emit_nil
         end
 
       end # Super

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

@@ -23,6 +23,7 @@ module Mutant
           emit_condition_mutations
           emit_body_mutations
           emit_body(nil)
+          emit_nil
         end
 
       end # While

data/lib/mutant/mutator/node.rb

@@ -181,7 +181,7 @@ module Mutant
       # @api private
       #
       def emit_nil
-        emit(N_NIL)
+        emit(N_NIL) unless agsn_left?
       end
 
       # Return new self typed child
@@ -222,6 +222,16 @@ module Mutant
         parent && parent.node.type
       end
 
+      # Test if the node is the left of an or_asgn or op_asgn
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      #
+      def agsn_left?
+        OP_ASSIGN.include?(parent_type) && parent.left.equal?(node)
+      end
+
     end # Node
   end # Mutator
 end # Mutant

data/lib/mutant/node_helpers.rb

@@ -18,13 +18,13 @@ module Mutant
     module_function :s
 
     NAN =
-      s(:begin, s(:send, s(:float,  0.0), :/, s(:args, s(:float, 0.0))))
+      s(:send, s(:float,  0.0), :/, s(:args, s(:float, 0.0)))
     INFINITY =
-      s(:begin, s(:send, s(:float,  1.0), :/, s(:args, s(:float, 0.0))))
+      s(:send, s(:float,  1.0), :/, s(:args, s(:float, 0.0)))
     NEW_OBJECT =
       s(:send, s(:const, s(:cbase), :Object), :new)
     NEGATIVE_INFINITY =
-      s(:begin, s(:send, s(:float, -1.0), :/, s(:args, s(:float, 0.0))))
+      s(:send, s(:float, -1.0), :/, s(:args, s(:float, 0.0)))
 
     RAISE             = s(:send, nil, :raise)
 

data/lib/mutant/predicate/attribute.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+module Mutant
+  class Predicate
+    # Base class for predicates on object attributes
+    class Attribute < self
+      include Concord.new(:attribute_name, :expectation)
+
+    private
+
+      # Return value for object
+      #
+      # @param [Object] object
+      #
+      # @return [Object]
+      #
+      # @api private
+      #
+      def value(object)
+        object.public_send(attribute_name)
+      end
+
+      # Regexp based attribute predicate
+      class Regexp < self
+
+        # Test for match
+        #
+        # @param [Object] object
+        #
+        # @return [true]
+        #   if attribute value matches expectation
+        #
+        # @return [false]
+        #   otherwise
+        #
+        # @api private
+        #
+        def match?(object)
+          !!(expectation =~ value(object))
+        end
+
+      end # Regexp
+
+      # Equality based attribute predicate
+      class Equality < self
+
+        PATTERN = /\Acode:(?<code>[[:xdigit:]]{1,6})\z/.freeze
+
+        # Test if class handles string
+        #
+        # @param [String] notation
+        #
+        # @return [Filter]
+        #   if notation matches pattern
+        #
+        # @return [nil]
+        #   otherwise
+        #
+        # @api private
+        #
+        def self.handle(notation)
+          match = PATTERN.match(notation)
+          new(:code, match[:code]) if match
+        end
+
+        # Test for match
+        #
+        # @param [Object] object
+        #
+        # @return [true]
+        #   if attribute value matches expectation
+        #
+        # @return [false]
+        #   otherwise
+        #
+        # @api private
+        #
+        def match?(object)
+          expectation.eql?(value(object))
+        end
+
+      end # Equality
+    end # Attribute
+  end # Filter
+end # Mutant

data/lib/mutant/predicate/blacklist.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+
+module Mutant
+  class Predicate
+    # Blacklist predicate
+    class Blacklist < self
+      include Adamantium::Flat, Concord.new(:blacklist)
+
+      # Test for match
+      #
+      # @param [Object] object
+      #
+      # @return [true]
+      #   if object matches blacklist
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      def match?(object)
+        blacklist.none? { |predicate| predicate.match?(object) }
+      end
+
+    end # Whitelist
+  end # Filter
+end # Mutant

data/lib/mutant/predicate/matcher.rb

@@ -0,0 +1,36 @@
+module Mutant
+  class Predicate
+    # Return matcher
+    class Matcher < self
+      include Concord.new(:matcher)
+
+      # Test if subject matches
+      #
+      # @param [Subject] subject
+      #
+      # @return [true]
+      #   if subject is handled by matcher
+      #
+      # @return [false]
+      #   otherwise
+      #
+      def match?(subject)
+        subjects.include?(subject)
+      end
+
+    private
+
+      # Return subjects matched by matcher
+      #
+      # @return [Set<Subject>]
+      #
+      # @api private
+      #
+      def subjects
+        matcher.to_a.to_set
+      end
+      memoize :subjects
+
+    end # Matcher
+  end # Predicate
+end # Mutant

data/lib/mutant/predicate/whitelist.rb

@@ -0,0 +1,28 @@
+# encoding: utf-8
+
+module Mutant
+  class Predicate
+
+    # Whiltelist filter
+    class Whitelist < self
+      include Adamantium::Flat, Concord.new(:whitelist)
+
+      # Test for match
+      #
+      # @param [Object] object
+      #
+      # @return [true]
+      #   if mutation matches whitelist
+      #
+      # @return [false]
+      #   otherwise
+      #
+      # @api private
+      #
+      def match?(object)
+        whitelist.any? { |filter| filter.match?(object) }
+      end
+
+    end # Whitelist
+  end # Predicate
+end # Mutant

data/lib/mutant/predicate.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+
+module Mutant
+  # Abstract base class for predicates used to filter subjects / mutations
+  class Predicate
+    include Adamantium::Flat, AbstractType
+    extend DescendantsTracker
+
+    # Check for match
+    #
+    # @param [Object] object
+    #
+    # @return [true]
+    #   if object is matched by predicate
+    #
+    # @return [false]
+    #   otherwise
+    #
+    # @api private
+    #
+    abstract_method :match?
+
+    # Build predicate from string
+    #
+    # @param [String] notation
+    #
+    # @return [Filter]
+    #   when can be build from string
+    #
+    # @return [nil]
+    #   otherwise
+    #
+    # @api private
+    #
+    def self.build(notation)
+      descendants.each do |descendant|
+        predicate = descendant.handle(notation)
+        return predicate if predicate
+      end
+
+      nil
+    end
+
+    # Return predicate for handle
+    #
+    # @param [String] _notation
+    #
+    # @return [nil]
+    #
+    # @api private
+    #
+    def self.handle(_notation)
+      nil
+    end
+
+    # Mutation predicate matching no inputs
+    Mutant.singleton_subclass_instance('CONTRADICTION', self) do
+
+      # Test for match
+      #
+      # @pram [Mutation] _mutation
+      #
+      # @return [true]
+      #
+      # @api private
+      #
+      def match?(_mutation)
+        false
+      end
+
+    end
+
+    # Mutation predicate matching all inputs
+    Mutant.singleton_subclass_instance('TAUTOLOGY', self) do
+
+      # Test for match
+      #
+      # @pram [Mutation] _mutation
+      #
+      # @return [true]
+      #
+      # @api private
+      #
+      def match?(_mutation)
+        true
+      end
+
+    end
+
+  end # Filter
+end # Mutant

data/lib/mutant/reporter/cli/printer/config.rb

@@ -20,9 +20,9 @@ module Mutant
           #
           def run
             info 'Mutant configuration:'
-            info 'Matcher:  %s', object.matcher.inspect
-            info 'Filter:   %s', object.filter.inspect
-            info 'Strategy: %s', object.strategy.inspect
+            info 'Matcher:        %s', object.matcher.inspect
+            info 'Subject Filter: %s', object.subject_predicate.inspect
+            info 'Strategy:       %s', object.strategy.inspect
             self
           end
 

data/lib/mutant/reporter/cli/printer/killer.rb

@@ -8,7 +8,7 @@ module Mutant
         # Printer for killer results
         class Killer < self
 
-          handle(Mutant::Killer::Forked)
+          handle(Mutant::Killer)
 
           SUCCESS = '.'.freeze
           FAILURE = 'F'.freeze