mutant 0.8.20 → 0.8.21

data/lib/mutant/meta.rb

@@ -18,9 +18,9 @@ module Mutant
       # @return [undefined]
       #
       # rubocop:disable Performance/Caller
-      def self.add(type, &block)
+      def self.add(*types, &block)
         file = caller.first.split(':in', 2).first
-        ALL << DSL.call(file, type, block)
+        ALL << DSL.call(file, Set.new(types), block)
       end
 
       Pathname.glob(Pathname.new(__dir__).parent.parent.join('meta', '*.rb'))

data/lib/mutant/meta/example.rb

@@ -3,7 +3,7 @@
 module Mutant
   module Meta
     class Example
-      include Adamantium, Anima.new(:file, :node, :node_type, :expected)
+      include Adamantium, Anima.new(:file, :node, :types, :expected)
 
       # Verification instance for example
       #
@@ -11,6 +11,7 @@ module Mutant
       def verification
         Verification.new(self, generated)
       end
+      memoize :verification
 
       # Normalized source
       #

data/lib/mutant/meta/example/dsl.rb

@@ -9,9 +9,12 @@ module Mutant
 
         # Run DSL on block
         #
+        # @param [Pathname] file
+        # @param [Set<Symbol>] types
+        #
         # @return [Example]
-        def self.call(file, type, block)
-          instance = new(file, type)
+        def self.call(file, types, block)
+          instance = new(file, types)
           instance.instance_eval(&block)
           instance.example
         end
@@ -21,9 +24,9 @@ module Mutant
         # Initialize object
         #
         # @return [undefined]
-        def initialize(file, type)
+        def initialize(file, types)
           @file     = file
-          @type     = type
+          @types    = types
           @node     = nil
           @expected = []
         end
@@ -37,10 +40,10 @@ module Mutant
         def example
           fail 'source not defined' unless @node
           Example.new(
-            file:      @file,
-            node:      @node,
-            node_type: @type,
-            expected:  @expected
+            file:     @file,
+            node:     @node,
+            types:    @types,
+            expected: @expected
           )
         end
 
@@ -96,7 +99,7 @@ module Mutant
         def node(input)
           case input
           when String
-            Unparser::Preprocessor.run(::Parser::CurrentRuby.parse(input))
+            Unparser::Preprocessor.run(Unparser.parse(input))
           when ::Parser::AST::Node
             input
           else

data/lib/mutant/meta/example/verification.rb

@@ -11,8 +11,9 @@ module Mutant
         #
         # @return [Boolean]
         def success?
-          missing.empty? && unexpected.empty? && no_diffs.empty?
+          [missing, unexpected, no_diffs, invalid_syntax].all?(&:empty?)
         end
+        memoize :success?
 
         # Error report
         #
@@ -26,20 +27,45 @@ module Mutant
             'original_source' => example.source,
             'missing'         => format_mutations(missing),
             'unexpected'      => format_mutations(unexpected),
+            'invalid_syntax'  => format_mutations(invalid_syntax),
             'no_diff'         => no_diff_report
           )
         end
+        memoize :error_report
 
       private
 
         # Unexpected mutations
         #
-        # @return [Array<Parser::AST::Node>]
+        # @return [Array<Mutation>]
         def unexpected
-          mutations.map(&:node) - example.expected
+          mutations.reject do |mutation|
+            example.expected.include?(mutation.node)
+          end
         end
         memoize :unexpected
 
+        # Missing mutations
+        #
+        # @return [Array<Mutation>]
+        def missing
+          (example.expected - mutations.map(&:node)).map do |node|
+            Mutation::Evil.new(self, node)
+          end
+        end
+        memoize :missing
+
+        # Mutations that generated invalid syntax
+        #
+        # @return [Enumerable<Mutation>]
+        def invalid_syntax
+          mutations.reject do |mutation|
+            ::Parser::CurrentRuby.parse(mutation.source)
+          rescue ::Parser::SyntaxError # rubocop:disable Lint/HandleExceptions
+          end
+        end
+        memoize :invalid_syntax
+
         # Mutations with no diff to original
         #
         # @return [Enumerable<Mutation>]
@@ -50,14 +76,14 @@ module Mutant
 
         # Mutation report
         #
-        # @param [Array<Parser::AST::Node>] nodes
+        # @param [Array<Mutation>] mutations
         #
         # @return [Array<Hash>]
-        def format_mutations(nodes)
-          nodes.map do |node|
+        def format_mutations(mutations)
+          mutations.map do |mutation|
             {
-              'node'   => node.inspect,
-              'source' => Unparser.unparse(node)
+              'node'   => mutation.node.inspect,
+              'source' => mutation.source
             }
           end
         end
@@ -74,14 +100,6 @@ module Mutant
           end
         end
 
-        # Missing mutations
-        #
-        # @return [Array<Parser::AST::Node>]
-        def missing
-          example.expected - mutations.map(&:node)
-        end
-        memoize :missing
-
       end # Verification
     end # Example
   end # Meta

data/lib/mutant/mutator/node.rb

@@ -96,6 +96,13 @@ module Mutant
         emit(::Parser::AST::Node.new(node.type, children))
       end
 
+      # Emit propagation if node can stand alone
+      #
+      # @return [undefined]
+      def emit_propagation(node)
+        emit(node) unless AST::Types::NOT_STANDALONE.include?(node.type)
+      end
+
       # Emit singleton literals
       #
       # @return [undefined]

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

@@ -67,7 +67,6 @@ module Mutant
           end
 
         end # Optional
-
       end # Argument
     end # Node
   end # Mutator

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

@@ -24,11 +24,23 @@ module Mutant
         # @return [undefined]
         def emit_argument_presence
           emit_type
+
           Util::Array::Presence.call(children).each do |children|
-            emit_type(*children)
+            if children.one? && n_mlhs?(Mutant::Util.one(children))
+              emit_procarg(Mutant::Util.one(children))
+            else
+              emit_type(*children)
+            end
           end
         end
 
+        # Emit procarg form
+        #
+        # @return [undefined]
+        def emit_procarg(arg)
+          emit_type(s(:procarg0, *arg))
+        end
+
         # Emit argument mutations
         #
         # @return [undefined]

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

@@ -17,7 +17,7 @@ module Mutant
         # @return [undefined]
         def dispatch
           emit_singletons
-          emit(send)
+          emit(send) unless n_lambda?(send)
           emit_send_mutations(&method(:n_send?))
           emit_arguments_mutations
 

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

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+      # Base mutator for index operations
+      class Index < self
+        NO_VALUE_RANGE    = (1..-1).freeze
+        SEND_REPLACEMENTS = %i[at fetch key?].freeze
+
+        private_constant(*constants(false))
+
+        children :receiver
+
+      private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          emit_singletons
+          emit_receiver_mutations { |node| !n_nil?(node) }
+          emit(receiver)
+          emit_send_forms
+          emit_drop_mutation
+          mutate_indices
+        end
+
+        # Emit send forms
+        #
+        # @return [undefined]
+        def emit_send_forms
+          return if asgn_left?
+
+          SEND_REPLACEMENTS.each do |selector|
+            emit(s(:send, receiver, selector, *indices))
+          end
+        end
+
+        # Emit mutation `foo[n..-1]` -> `foo.drop(n)`
+        #
+        # @return [undefined]
+        def emit_drop_mutation
+          return unless indices.one? && n_irange?(Mutant::Util.one(indices))
+
+          start, ending = *indices.first
+
+          return unless ending.eql?(s(:int, -1))
+
+          emit(s(:send, receiver, :drop, start))
+        end
+
+        # Mutate indices
+        #
+        # @return [undefined]
+        def mutate_indices
+          children_indices(index_range).each do |index|
+            emit_propagation(children.fetch(index)) unless asgn_left?
+            delete_child(index)
+            mutate_child(index)
+          end
+        end
+
+        # The index nodes
+        #
+        # @return [Enumerable<Parser::AST::Node>]
+        def indices
+          children[index_range]
+        end
+
+        class Read < self
+
+          handle :index
+
+        private
+
+          # The range index children can be found
+          #
+          # @return [Range]
+          def index_range
+            NO_VALUE_RANGE
+          end
+        end
+
+        # Mutator for index assignments
+        class Assign < self
+          REGULAR_RANGE = (1..-2).freeze
+
+          private_constant(*constants(false))
+
+          handle :indexasgn
+
+        private
+
+          # Emit mutations
+          #
+          # @return [undefined]
+          def dispatch
+            super()
+
+            return if asgn_left?
+
+            emit_index_read
+            emit(children.last)
+            mutate_child(children.length.pred)
+          end
+
+          # Emit index read
+          #
+          # @return [undefined]
+          def emit_index_read
+            emit(s(:index, receiver, *children[index_range]))
+          end
+
+          # Index indices
+          #
+          # @return [Range<Integer>]
+          def index_range
+            if asgn_left?
+              NO_VALUE_RANGE
+            else
+              REGULAR_RANGE
+            end
+          end
+        end # Assign
+      end # Index
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -7,7 +7,7 @@ module Mutant
       # Mutation emitter to handle noop nodes
       class Noop < self
 
-        handle(:__ENCODING__, :block_pass, :cbase)
+        handle(:__ENCODING__, :block_pass, :cbase, :lambda)
 
       private
 

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+      class ProcargZero < self
+        MAP = {
+          ::Parser::AST::Node => :emit_argument_node_mutations,
+          Symbol              => :emit_argument_symbol_mutations
+        }.freeze
+
+        private_constant(*constants(false))
+
+        handle :procarg0
+
+        children :argument
+
+      private
+
+        # Emit mutations
+        #
+        # @return [undefined]
+        def dispatch
+          __send__(MAP.fetch(argument.class))
+        end
+
+        # Emit argument symbol mutations
+        #
+        # @return [undefined]
+        def emit_argument_symbol_mutations
+          emit_type(:"_#{argument}") unless argument.to_s.start_with?('_')
+        end
+
+        # Emit argument node mutations
+        #
+        # @return [undefined]
+        def emit_argument_node_mutations
+          emit_argument_mutations
+          first = Mutant::Util.one(argument.children)
+          emit_type(first)
+        end
+      end # ProcargZero
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -40,7 +40,6 @@ module Mutant
           values_at:     %i[fetch_values],
           match:         %i[match?],
           '=~':          %i[match?],
-          :[] =>         %i[at fetch key?],
           :== =>         %i[eql? equal?],
           :>= =>         %i[> == eql? equal?],
           :<= =>         %i[< == eql? equal?],
@@ -61,17 +60,7 @@ module Mutant
         # @return [undefined]
         def dispatch
           emit_singletons
-          if meta.index_assignment?
-            run(Index::Assign)
-          else
-            non_index_dispatch
-          end
-        end
 
-        # Perform non index dispatch
-        #
-        # @return [undefined]
-        def non_index_dispatch
           if meta.binary_method_operator?
             run(Binary)
           elsif meta.attribute_assignment?
@@ -117,7 +106,6 @@ module Mutant
           emit_dig_mutation
           emit_double_negation_mutation
           emit_lambda_mutation
-          emit_drop_mutation
         end
 
         # Emit selector mutations specific to top level constants
@@ -167,19 +155,6 @@ module Mutant
           emit(s(:send, fetch_mutation, :dig, *tail))
         end
 
-        # Emit mutation `foo[n..-1]` -> `foo.drop(n)`
-        #
-        # @return [undefined]
-        def emit_drop_mutation
-          return if !selector.equal?(:[]) || !arguments.one? || !n_irange?(arguments.first)
-
-          start, ending = *arguments.first
-
-          return unless ending.eql?(s(:int, -1))
-
-          emit(s(:send, receiver, :drop, start))
-        end
-
         # Emit mutation from `to_i` to `Integer(...)`
         #
         # @return [undefined]
@@ -227,8 +202,7 @@ module Mutant
         #
         # @return [undefined]
         def emit_argument_propagation
-          node = arguments.first
-          emit(node) if arguments.one? && !NOT_STANDALONE.include?(node.type)
+          emit_propagation(Mutant::Util.one(arguments)) if arguments.one?
         end
 
         # Emit receiver mutations