mutant 0.14.2 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 19ddb5cce03b640bb465057b2e6a0ee983b44b3990fff144dcd3a737b6e7ba5c
-  data.tar.gz: c97e3a1ac3fc5f4e431e70e86ee477933f1fa59e9ce338308a785c7fdab990c5
+  metadata.gz: cdcb7051e04dfb3ff669e6f673f13837725981be61745b633fda8c00122bb439
+  data.tar.gz: bc51f9a72c0163a1bae7f56f56ce10a06cf825281d1248b380048237394e404c
 SHA512:
-  metadata.gz: aca0d3b5772f1b1caf6d075779dd6b54e02a4109917bc85f69b84afb038060f4610306b5f95c47f19cf429d287ffb4913b4cd5d71c19777a3f00a3df7cc7904e
-  data.tar.gz: 3dd977fa2018eac8935f471266af5fa77f1ca02095c130a3852f342fca3e2e099ab2cfabc75b746e3a44bcbbeeef9adf9979f92469e87df46227f98139fc859c
+  metadata.gz: 6482d04cf00047a75531c116439726545e2955b0a0df5a9104f855b29720d30d61cc7779b4adaca2982596544bf5b46dc7f34f9d42eb2f187c973bf4288051dc
+  data.tar.gz: a805ae81a1f767004c37305555778aab712f58684f0cee50bfe9428f6dd9ab8979796ffdcaa4436510e579752b2a7c2e6331b37dc4af3ced942f3ae67536c906

data/VERSION

@@ -1 +1 @@
-0.14.2
+0.15.0

data/lib/mutant/ast/named_children.rb

@@ -55,10 +55,6 @@ module Mutant
         #
         # @return [undefined]
         def define_remaining_children(names)
-          define_private_method(:remaining_children_with_index) do
-            children.each_with_index.drop(names.length)
-          end
-
           define_private_method(:remaining_children_indices) do
             children.each_index.drop(names.length)
           end

data/lib/mutant/ast/nodes.rb

@@ -17,6 +17,11 @@ module Mutant
       N_SELF              = s(:self)
       N_ZSUPER            = s(:zsuper)
       N_EMPTY_SUPER       = s(:super)
+      N_EMPTY_ARRAY       = s(:array)
+      N_EMPTY_HASH        = s(:hash)
+      N_EMPTY_STRING      = s(:str, '')
+      N_ZERO_INTEGER      = s(:int, 0)
+      N_ZERO_FLOAT        = s(:float, 0.0)
 
     end # Nodes
   end # AST

data/lib/mutant/ast/pattern/lexer.rb

@@ -3,7 +3,6 @@
 module Mutant
   class AST
     class Pattern
-      # rubocop:disable Metrics/ClassLength
       class Lexer
         WHITESPACE     = [' ', "\t", "\n"].to_set.freeze
         STRING_PATTERN = /\A[a-zA-Z][_a-zA-Z0-9]*\z/

data/lib/mutant/ast/structure.rb

@@ -463,6 +463,11 @@ module Mutant
           ),
           variable: nil
         ),
+        Node.new(
+          type:     :if_guard,
+          fixed:    Node.fixed([[Node::Fixed::Descendant, :condition]]),
+          variable: nil
+        ),
         Node.new(
           type:     :in_pattern,
           fixed:    Node.fixed(
@@ -849,6 +854,11 @@ module Mutant
           ),
           variable: nil
         ),
+        Node.new(
+          type:     :unless_guard,
+          fixed:    Node.fixed([[Node::Fixed::Descendant, :condition]]),
+          variable: nil
+        ),
         Node.new(
           type:     :when,
           fixed:    [Node::Fixed::Descendant.new(index: -1, name: :body)],

data/lib/mutant/context.rb

@@ -33,9 +33,7 @@ module Mutant
       end
     end
 
-    def match_expressions
-      scope.match_expressions
-    end
+    def match_expressions = scope.match_expressions
 
     # Return root node for mutation
     #
@@ -47,9 +45,7 @@ module Mutant
     # Identification string
     #
     # @return [String]
-    def identification
-      scope.raw.name
-    end
+    def identification = scope.raw.name
 
   end # Context
 end # Mutant

data/lib/mutant/env.rb

@@ -2,7 +2,6 @@
 
 module Mutant
   # Mutation testing execution environment
-  # rubocop:disable Metrics/ClassLength
   class Env
     include Adamantium, Anima.new(
       :config,
@@ -93,57 +92,42 @@ module Mutant
     # @param [String] warning
     #
     # @return [self]
-    def warn(message)
-      config.reporter.warn(message)
-      self
-    end
+    def warn(message) = tap { config.reporter.warn(message) }
 
     # Selected tests
     #
     # @return [Set<Test>]
-    def selected_tests
-      selections.values.flatten.to_set
-    end
+    def selected_tests = selections.values.flatten.to_set
     memoize :selected_tests
 
     # Amount of mutations
     #
     # @return [Integer]
-    def amount_mutations
-      mutations.length
-    end
+    def amount_mutations = mutations.length
     memoize :amount_mutations
 
     # Amount of all tests the integration provides
     #
     # @return [Integer]
-    def amount_all_tests
-      integration.all_tests.length
-    end
+    def amount_all_tests = integration.all_tests.length
     memoize :amount_all_tests
 
     # Amount of tests available for mutation testing
     #
     # @return [Integer]
-    def amount_available_tests
-      integration.available_tests.length
-    end
+    def amount_available_tests = integration.available_tests.length
     memoize :amount_available_tests
 
     # Amount of selected subjects
     #
     # @return [Integer]
-    def amount_subjects
-      subjects.length
-    end
+    def amount_subjects = subjects.length
     memoize :amount_subjects
 
     # Amount of selected tests
     #
     # @return [Integer]
-    def amount_selected_tests
-      selected_tests.length
-    end
+    def amount_selected_tests = selected_tests.length
     memoize :amount_selected_tests
 
     # Ratio between selected tests and subjects
@@ -180,9 +164,6 @@ module Mutant
       end
     end
 
-    def timer
-      world.timer
-    end
+    def timer = world.timer
   end # Env
-  # rubocop:enable Metrics/ClassLength
 end # Mutant

data/lib/mutant/hooks.rb

@@ -45,9 +45,7 @@ module Mutant
     end
 
     class Builder
-      def initialize
-        @map = DEFAULTS.transform_values(&:dup)
-      end
+      def initialize = @map = DEFAULTS.transform_values(&:dup)
 
       def register(name, &block)
         Hooks.assert_name(name)
@@ -57,9 +55,7 @@ module Mutant
         self
       end
 
-      def to_hooks
-        Hooks.new(map: @map.transform_values(&:freeze).freeze)
-      end
+      def to_hooks = Hooks.new(map: @map.transform_values(&:freeze).freeze)
     end # Builder
 
     # rubocop:disable Security/Eval

data/lib/mutant/integration/null.rb

@@ -7,9 +7,7 @@ module Mutant
       # Available tests for integration
       #
       # @return [Enumerable<Test>]
-      def all_tests
-        EMPTY_ARRAY
-      end
+      def all_tests = EMPTY_ARRAY
 
       # Run a collection of tests
       #

data/lib/mutant/integration.rb

@@ -110,9 +110,7 @@ module Mutant
     # Perform integration setup
     #
     # @return [self]
-    def setup
-      self
-    end
+    def setup = self
 
     # Run a collection of tests
     #
@@ -138,8 +136,6 @@ module Mutant
 
   private
 
-    def timer
-      world.timer
-    end
+    def timer = world.timer
   end # Integration
 end # Mutant

data/lib/mutant/isolation/fork.rb

@@ -64,7 +64,6 @@ module Mutant
         end
       end # Pipe
 
-      # rubocop:disable Metrics/ClassLength
       class Parent
         include(Anima.new(*ATTRIBUTES), Procto)
 
@@ -206,7 +205,6 @@ module Mutant
           status
         end
       end # Parent
-      # rubocop:enable Metrics/ClassLength
 
       class Child
         include(Adamantium, Anima.new(*ATTRIBUTES), Procto)

data/lib/mutant/matcher/method/instance.rb

@@ -52,9 +52,9 @@ module Mutant
           end
 
           def visibility
-            if scope.raw.private_instance_methods.include?(method_name)
+            if scope.raw.private_method_defined?(method_name)
               :private
-            elsif scope.raw.protected_instance_methods.include?(method_name)
+            elsif scope.raw.protected_method_defined?(method_name)
               :protected
             else
               :public

data/lib/mutant/matcher/method.rb

@@ -34,7 +34,6 @@ module Mutant
       # logic would be implemented directly on the Matcher::Method
       # instance
       #
-      # rubocop:disable Metrics/ClassLength
       class Evaluator
         include(
           AbstractType,

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

@@ -2,7 +2,6 @@
 
 module Mutant
   module Meta
-    # rubocop:disable Metrics/ClassLength
     class Example
       # Example verification
       class Verification

data/lib/mutant/mutation/operators.rb

@@ -10,47 +10,146 @@ module Mutant
         NAME = :full
 
         SELECTOR_REPLACEMENTS = {
-          :& =>          %i[| ^],
-          :< =>          %i[== eql? equal?],
-          :<< =>         %i[>>],
-          :<= =>         %i[< == eql? equal?],
-          :== =>         %i[eql? equal?],
-          :=== =>        %i[is_a?],
-          :=~ =>         %i[match?],
-          :> =>          %i[== eql? equal?],
-          :>= =>         %i[> == eql? equal?],
-          :>> =>         %i[<<],
-          :^ =>          %i[& |],
-          :| =>          %i[& ^],
-          __send__:      %i[public_send],
-          all?:          %i[any?],
-          any?:          %i[all?],
-          at:            %i[fetch key?],
-          detect:        %i[first last],
-          fetch:         %i[key?],
-          find:          %i[first last],
-          first:         %i[last],
-          flat_map:      %i[map],
-          gsub:          %i[sub],
-          is_a?:         %i[instance_of?],
-          kind_of?:      %i[instance_of?],
-          last:          %i[first],
-          map:           %i[each],
-          match:         %i[match?],
-          max:           %i[first last],
-          max_by:        %i[first last],
-          method:        %i[public_method],
-          min:           %i[first last],
-          min_by:        %i[first last],
-          reverse_each:  %i[each],
-          reverse_map:   %i[map each],
-          reverse_merge: %i[merge],
-          send:          %i[public_send __send__],
-          to_a:          %i[to_ary],
-          to_h:          %i[to_hash],
-          to_i:          %i[to_int],
-          to_s:          %i[to_str],
-          values_at:     %i[fetch_values]
+          :!= =>              %i[==],
+          :** =>              %i[*],
+          :% =>               %i[/],
+          :& =>               %i[| ^],
+          :* =>               %i[/],
+          :+ =>               %i[-],
+          :- =>               %i[+],
+          :/ =>               %i[*],
+          :< =>               %i[== eql? equal?],
+          :<< =>              %i[>>],
+          :<= =>              %i[< == eql? equal?],
+          :== =>              %i[!= eql? equal?],
+          :=== =>             %i[is_a?],
+          :=~ =>              %i[match?],
+          :> =>               %i[== eql? equal?],
+          :>= =>              %i[> == eql? equal?],
+          :>> =>              %i[<<],
+          :^ =>               %i[& |],
+          :| =>               %i[& ^],
+          __send__:           %i[public_send],
+          all?:               %i[any? none?],
+          any?:               %i[all? empty? none?],
+          append:             %i[prepend],
+          assoc:              %i[rassoc],
+          at:                 %i[fetch key?],
+          bytes:              %i[chars],
+          # Bang to non-bang mutations (Array methods)
+          capitalize!:        %i[capitalize],
+          chars:              %i[bytes],
+          chomp!:             %i[chomp],
+          chop!:              %i[chop],
+          chunk:              %i[each],
+          chunk_while:        %i[each],
+          collect:            %i[each],
+          collect!:           %i[collect],
+          collect_concat:     %i[collect],
+          compact!:           %i[compact],
+          ceil:               %i[floor],
+          count:              %i[size length],
+          delete!:            %i[delete],
+          delete_if:          %i[reject],
+          detect:             %i[first last],
+          downcase:           %i[upcase],
+          downcase!:          %i[downcase],
+          drop:               %i[take],
+          each_key:           %i[each_value],
+          each_cons:          %i[each],
+          each_slice:         %i[each],
+          each_with_index:    %i[each],
+          each_value:         %i[each_key],
+          each_with_object:   %i[each],
+          empty?:             %i[any?],
+          encode!:            %i[encode],
+          end_with?:          %i[start_with?],
+          even?:              %i[odd?],
+          fetch:              %i[key?],
+          filter:             %i[reject],
+          filter!:            %i[filter],
+          filter_map:         %i[map],
+          find:               %i[first last],
+          first:              %i[last],
+          flat_map:           %i[map],
+          flatten!:           %i[flatten],
+          floor:              %i[ceil],
+          grep:               %i[grep_v],
+          grep_v:             %i[grep],
+          gsub:               %i[sub],
+          gsub!:              %i[gsub],
+          is_a?:              %i[instance_of?],
+          keep_if:            %i[select],
+          keys:               %i[values],
+          kind_of?:           %i[instance_of?],
+          last:               %i[first],
+          lstrip!:            %i[lstrip],
+          map:                %i[each],
+          map!:               %i[map],
+          match:              %i[match?],
+          max:                %i[first last min],
+          max_by:             %i[first last min_by],
+          merge!:             %i[merge],
+          method:             %i[public_method],
+          min:                %i[first last max],
+          min_by:             %i[first last max_by],
+          negative?:          %i[positive?],
+          none?:              %i[any? all?],
+          odd?:               %i[even?],
+          pop:                %i[shift],
+          positive?:          %i[negative?],
+          pred:               %i[succ],
+          prepend:            %i[append],
+          push:               %i[unshift],
+          reject:             %i[select],
+          reject!:            %i[reject],
+          reverse!:           %i[reverse],
+          reverse_each:       %i[each],
+          reverse_map:        %i[map each],
+          reverse_merge:      %i[merge],
+          rotate!:            %i[rotate],
+          rstrip!:            %i[rstrip],
+          sample:             %i[first last],
+          scrub!:             %i[scrub],
+          rassoc:             %i[assoc],
+          select:             %i[reject],
+          select!:            %i[select],
+          send:               %i[public_send __send__],
+          shift:              %i[pop],
+          shuffle!:           %i[shuffle],
+          slice_after:        %i[each],
+          slice_before:       %i[each],
+          slice_when:         %i[each],
+          sort!:              %i[sort],
+          sort_by:            %i[sort],
+          sort_by!:           %i[sort_by],
+          squeeze!:           %i[squeeze],
+          start_with?:        %i[end_with?],
+          strip:              %i[lstrip rstrip],
+          strip!:             %i[strip],
+          sub!:               %i[sub],
+          succ:               %i[pred],
+          swapcase!:          %i[swapcase],
+          take:               %i[drop],
+          to_a:               %i[to_ary],
+          to_f:               %i[to_i],
+          to_h:               %i[to_hash],
+          to_i:               %i[to_int],
+          to_s:               %i[to_str],
+          tr!:                %i[tr],
+          tr_s!:              %i[tr_s],
+          transform_keys:     %i[transform_values],
+          transform_keys!:    %i[transform_keys],
+          transform_values:   %i[transform_keys],
+          transform_values!:  %i[transform_values],
+          unicode_normalize!: %i[unicode_normalize],
+          uniq!:              %i[uniq],
+          unshift:            %i[push],
+          upcase:             %i[downcase],
+          upcase!:            %i[upcase],
+          values:             %i[keys],
+          values_at:          %i[fetch_values],
+          zero?:              %i[nonzero?]
         }.freeze.tap { |hash| hash.each_value(&:freeze) }
       end
 
@@ -72,9 +171,7 @@ module Mutant
         self::NAME
       end
 
-      def selector_replacements
-        self.class::SELECTOR_REPLACEMENTS
-      end
+      def selector_replacements = self.class::SELECTOR_REPLACEMENTS
 
       def self.parse(value)
         klass = [Light, Full].detect { |candidate| candidate.operators_name.to_s.eql?(value) }

data/lib/mutant/mutation.rb

@@ -70,33 +70,25 @@ module Mutant
     # Mutation identification code
     #
     # @return [String]
-    def code
-      sha1[CODE_RANGE]
-    end
+    def code = sha1[CODE_RANGE]
     memoize :code
 
     # Identification string
     #
     # @return [String]
-    def identification
-      "#{self.class::SYMBOL}:#{subject.identification}:#{code}"
-    end
+    def identification = "#{self.class::SYMBOL}:#{subject.identification}:#{code}"
     memoize :identification
 
     # The monkeypatch to insert the mutation
     #
     # @return [String]
-    def monkeypatch
-      Unparser.unparse(subject.context.root(node))
-    end
+    def monkeypatch = Unparser.unparse(subject.context.root(node))
     memoize :monkeypatch
 
     # Normalized original source
     #
     # @return [String]
-    def original_source
-      subject.source
-    end
+    def original_source = subject.source
 
     # Test if mutation is killed by test reports
     #
@@ -125,16 +117,12 @@ module Mutant
       end
     end
 
-    def diff
-      Unparser::Diff.build(original_source, source)
-    end
+    def diff = Unparser::Diff.build(original_source, source)
     memoize :diff
 
   private
 
-    def sha1
-      Digest::SHA1.hexdigest(subject.identification + CODE_DELIMITER + source)
-    end
+    def sha1 = Digest::SHA1.hexdigest(subject.identification + CODE_DELIMITER + source)
 
     # Evil mutation that should case mutations to fail tests
     class Evil < self

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

@@ -16,6 +16,7 @@ module Mutant
         def dispatch
           emit_left_mutations
           emit_right_mutations
+          emit(s(:or_asgn, *children))
         end
 
       end # AndAsgn

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

@@ -20,6 +20,7 @@ module Mutant
         def dispatch
           emit_singletons unless left_lvasgn?
           emit_promotions
+          emit_operator_swap
 
           emit_left_mutations do |mutation|
             !(n_irange?(mutation) || n_erange?(mutation)) || !mutation.children.fetch(1).nil?
@@ -28,6 +29,10 @@ module Mutant
           emit_right_mutations
         end
 
+        def emit_operator_swap
+          emit(s(INVERSE.fetch(node.type), left, right))
+        end
+
         def emit_promotions
           emit(left)
           emit(right) unless left_lvasgn?

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

@@ -14,12 +14,22 @@ module Mutant
         def dispatch
           emit_singletons
           emit(send) unless n_lambda?(send)
+          emit_receiver_promotion
           emit_send_mutations(&method(:valid_send_mutation?))
           emit_arguments_mutations
 
           mutate_body
         end
 
+        def emit_receiver_promotion
+          return unless n_send?(send)
+
+          send_meta = AST::Meta::Send.new(node: send)
+          return unless send_meta.receiver
+
+          emit(send_meta.receiver)
+        end
+
         def mutate_body
           emit_body(nil) unless unconditional_loop?
           emit_body(N_RAISE)

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

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+
+      # Mutator for case/in pattern matching nodes
+      class CaseMatch < self
+
+        handle(:case_match)
+
+        children :condition
+
+        define_named_child(:else_branch, -1)
+
+        PATTERNS = (1..-2)
+
+      private
+
+        def dispatch
+          emit_condition_mutations
+          emit_in_pattern_mutations
+          emit_else_mutations
+        end
+
+        def emit_in_pattern_mutations
+          indices = children_indices(PATTERNS)
+          one = indices.one?
+
+          indices.each do |index|
+            mutate_child(index)
+            delete_child(index) unless one
+          end
+        end
+
+        def emit_else_mutations
+          return unless else_branch
+
+          emit_else_branch_mutations
+          emit_else_branch(nil)
+        end
+
+      end # CaseMatch
+    end # Node
+  end # Mutator
+end # Mutant