mutant 0.10.23 → 0.10.28

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+      module Regexp
+        # Mutator for root expression regexp wrapper
+        class RootExpression < Node
+          handle(:regexp_root_expression)
+
+        private
+
+          def dispatch
+            children.each_index(&method(:mutate_child))
+          end
+        end # RootExpression
+      end # Regexp
+    end # Node
+  end # Mutator
+end # Mutant

data/lib/mutant/mutator/node/regexp/alternation_meta.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+      module Regexp
+        # Mutator for pipe in `/foo|bar/` regexp
+        class AlternationMeta < Node
+          handle(:regexp_alternation_meta)
+
+        private
+
+          def dispatch
+            children.each_index(&method(:delete_child))
+          end
+        end # AlternationMeta
+      end # Regexp
+    end # Node
+  end # Mutator
+end # Mutant

data/lib/mutant/mutator/node/regexp/beginning_of_line_anchor.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+      module Regexp
+        # Mutator for beginning of line anchor `^`
+        class BeginningOfLineAnchor < Node
+          handle(:regexp_bol_anchor)
+
+          private
+
+          def dispatch
+            emit(s(:regexp_bos_anchor))
+          end
+        end # BeginningOfLineAnchor
+      end # Regexp
+    end # Node
+  end # Mutator
+end # Mutant

data/lib/mutant/mutator/node/regexp/capture_group.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+      module Regexp
+        # Mutator for regexp capture groups, such as `/(foo)/`
+        class CaptureGroup < Node
+          handle(:regexp_capture_group)
+
+          children :group
+
+        private
+
+          def dispatch
+            return unless group
+
+            emit(s(:regexp_passive_group, group))
+            emit_group_mutations
+          end
+        end # EndOfLineAnchor
+      end # Regexp
+    end # Node
+  end # Mutator
+end # Mutant

data/lib/mutant/mutator/node/regexp/character_type.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+      module Regexp
+        # Character type mutator
+        class CharacterType < Node
+          map = {
+            regexp_digit_type:           :regexp_nondigit_type,
+            regexp_hex_type:             :regexp_nonhex_type,
+            regexp_space_type:           :regexp_nonspace_type,
+            regexp_word_boundary_anchor: :regexp_nonword_boundary_anchor,
+            regexp_word_type:            :regexp_nonword_type,
+            regexp_xgrapheme_type:       :regexp_linebreak_type
+          }
+
+          MAP = map.merge(map.invert)
+
+          handle(*MAP.keys)
+
+        private
+
+          def dispatch
+            emit(s(MAP.fetch(node.type)))
+          end
+        end # CharacterType
+      end # Regexp
+    end # Node
+  end # Mutator
+end # Mutant

data/lib/mutant/mutator/node/regexp/end_of_line_anchor.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+      module Regexp
+        # Mutator for end of line anchor `$`
+        class EndOfLineAnchor < Node
+          handle(:regexp_eol_anchor)
+
+        private
+
+          def dispatch
+            emit(s(:regexp_eos_anchor))
+          end
+        end # EndOfLineAnchor
+      end # Regexp
+    end # Node
+  end # Mutator
+end # Mutant

data/lib/mutant/mutator/node/regexp/end_of_string_or_before_end_of_line_anchor.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+      module Regexp
+        # Mutator for end of line or before end of string anchor `\Z`
+        class EndOfStringOrBeforeEndOfLineAnchor < Node
+          handle(:regexp_eos_ob_eol_anchor)
+
+        private
+
+          def dispatch
+            emit(s(:regexp_eos_anchor))
+          end
+        end # EndOfStringOrBeforeEndOfLineAnchor
+      end # Regexp
+    end # Node
+  end # Mutator
+end # Mutant

data/lib/mutant/mutator/node/regexp/named_group.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+      module Regexp
+        # Mutator for regexp named capture groups, such as `/(?<foo>bar)/`
+        class NamedGroup < Node
+          handle(:regexp_named_group)
+
+          children :name, :group
+
+        private
+
+          def dispatch
+            return unless group
+
+            emit_group_mutations
+
+            # Allows unused captures to be kept and named if they are explicitly prefixed with an
+            # underscore, like we allow with unused local variables.
+            return if name_underscored?
+
+            emit(s(:regexp_passive_group, group))
+            emit_name_underscore_mutation
+          end
+
+          def emit_name_underscore_mutation
+            emit_type("_#{name}", group)
+          end
+
+          def name_underscored?
+            name.start_with?('_')
+          end
+        end # EndOfLineAnchor
+      end # Regexp
+    end # Node
+  end # Mutator
+end # Mutant

data/lib/mutant/mutator/node/regexp/zero_or_more.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+      module Regexp
+        # Mutator for zero-or-more quantifier, `*`
+        class ZeroOrMore < Node
+          MAP = {
+            regexp_greedy_zero_or_more:     :regexp_greedy_one_or_more,
+            regexp_reluctant_zero_or_more:  :regexp_reluctant_one_or_more,
+            regexp_possessive_zero_or_more: :regexp_possessive_one_or_more
+          }.freeze
+
+          handle(*MAP.keys)
+
+          children :min, :max, :subject
+
+          private
+
+          # Replace:
+          # * `/a*/`  with `/a+/`
+          # * `/a*?/` with `/a+?/`
+          # * `/a*+/` with `/a++/`
+          def dispatch
+            emit(s(MAP.fetch(node.type), *children))
+            emit_subject_mutations
+            emit(subject)
+          end
+        end # ZeroOrMore
+      end # Regexp
+    end # Node
+  end # Mutator
+end # Mutant

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

@@ -7,7 +7,7 @@ module Mutant
       # Regular expression options mutation
       class Regopt < self
 
-        MUTATED_FLAGS = IceNine.deep_freeze(%i[i])
+        MUTATED_FLAGS = %i[i].freeze
 
         handle(:regopt)
 

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

@@ -14,7 +14,7 @@ module Mutant
         def dispatch
           emit_body_mutations if body
         end
-      end # Class
+      end # Sclass
     end # Node
   end # Mutator
 end # Mutant

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

@@ -13,23 +13,25 @@ module Mutant
 
         children :receiver, :selector
 
-        SELECTOR_REPLACEMENTS = IceNine.deep_freeze(
+        SELECTOR_REPLACEMENTS = {
           :< =>          %i[== eql? equal?],
           :<= =>         %i[< == eql? equal?],
           :== =>         %i[eql? equal?],
+          :=== =>        %i[is_a?],
+          :=~ =>         %i[match?],
           :> =>          %i[== eql? equal?],
           :>= =>         %i[> == eql? equal?],
           __send__:      %i[public_send],
           all?:          %i[any?],
           any?:          %i[all?],
           at:            %i[fetch key?],
-          eql?:          %i[equal?],
           fetch:         %i[key?],
           flat_map:      %i[map],
           gsub:          %i[sub],
           is_a?:         %i[instance_of?],
           kind_of?:      %i[instance_of?],
           map:           %i[each],
+          match:         %i[match?],
           method:        %i[public_method],
           reverse_each:  %i[each],
           reverse_map:   %i[map each],
@@ -40,13 +42,17 @@ module Mutant
           to_i:          %i[to_int],
           to_s:          %i[to_str],
           values_at:     %i[fetch_values]
-        )
+        }.freeze.tap { |hash| hash.values(&:freeze) }
 
-        RECEIVER_SELECTOR_REPLACEMENTS = IceNine.deep_freeze(
+        RECEIVER_SELECTOR_REPLACEMENTS = {
           Date: {
             parse: %i[jd civil strptime iso8601 rfc3339 xmlschema rfc2822 rfc822 httpdate jisx0301]
-          }
-        )
+          }.freeze
+        }.freeze
+
+        REGEXP_MATCH_METHODS    = %i[=~ match match?].freeze
+        REGEXP_START_WITH_NODES = %i[regexp_bos_anchor regexp_literal_literal].freeze
+        REGEXP_END_WITH_NODES   = %i[regexp_literal_literal regexp_eos_anchor].freeze
 
       private
 
@@ -81,6 +87,9 @@ module Mutant
         end
 
         def emit_selector_specific_mutations
+          emit_reduce_to_sum_mutation
+          emit_start_end_with_mutations
+          emit_predicate_mutations
           emit_array_mutation
           emit_static_send
           emit_const_get_mutation
@@ -90,6 +99,57 @@ module Mutant
           emit_lambda_mutation
         end
 
+        def emit_reduce_to_sum_mutation
+          return unless selector.equal?(:reduce)
+
+          reducer = arguments.last
+
+          return unless reducer.eql?(s(:sym, :+)) || reducer.eql?(s(:block_pass, s(:sym, :+)))
+
+          if arguments.length > 1
+            initial_value = arguments.first
+            emit_type(receiver, :sum, initial_value)
+          else
+            emit_type(receiver, :sum)
+          end
+        end
+
+        def emit_start_end_with_mutations # rubocop:disable Metrics/CyclomaticComplexity, Metrics/MethodLength
+          return unless REGEXP_MATCH_METHODS.include?(selector) && arguments.one?
+
+          argument = Mutant::Util.one(arguments)
+
+          return unless argument.type.equal?(:regexp) && (
+            regexp_ast = AST::Regexp.expand_regexp_ast(argument)
+          )
+
+          regexp_children = regexp_ast.children
+
+          case regexp_children.map(&:type)
+          when REGEXP_START_WITH_NODES
+            emit_start_with(regexp_children)
+          when REGEXP_END_WITH_NODES
+            emit_end_with(regexp_children)
+          end
+        end
+
+        def emit_start_with(regexp_nodes)
+          literal = Mutant::Util.one(regexp_nodes.last.children)
+          emit_type(receiver, :start_with?, s(:str, literal))
+        end
+
+        def emit_end_with(regexp_nodes)
+          literal = Mutant::Util.one(regexp_nodes.first.children)
+          emit_type(receiver, :end_with?, s(:str, literal))
+        end
+
+        def emit_predicate_mutations
+          return unless selector.match?(/\?\z/) && !selector.equal?(:defined?)
+
+          emit(s(:true))
+          emit(s(:false))
+        end
+
         def emit_array_mutation
           return unless selector.equal?(:Array) && possible_kernel_method?
 
@@ -187,11 +247,18 @@ module Mutant
         def mutate_receiver
           return unless receiver
           emit_implicit_self
+          emit_explicit_self
           emit_receiver_mutations do |node|
             !n_nil?(node)
           end
         end
 
+        def emit_explicit_self
+          return if UNARY_METHOD_OPERATORS.include?(selector)
+
+          emit_receiver(N_SELF) unless n_nil?(receiver)
+        end
+
         def emit_implicit_self
           emit_receiver(nil) if n_self?(receiver) && !(
             KEYWORDS.include?(selector) ||

data/lib/mutant/parallel.rb

@@ -90,7 +90,7 @@ module Mutant
 
     # Parallel run configuration
     class Config
-      include Adamantium::Flat, Anima.new(
+      include Adamantium, Anima.new(
         :block,
         :jobs,
         :process_name,
@@ -102,7 +102,7 @@ module Mutant
 
     # Parallel execution status
     class Status
-      include Adamantium::Flat, Anima.new(
+      include Adamantium, Anima.new(
         :active_jobs,
         :done,
         :payload

data/lib/mutant/parallel/driver.rb

@@ -4,7 +4,7 @@ module Mutant
   module Parallel
     # Driver for parallelized execution
     class Driver
-      include Adamantium::Flat, Anima.new(
+      include Adamantium, Anima.new(
         :threads,
         :var_active_jobs,
         :var_final,

data/lib/mutant/parallel/worker.rb

@@ -3,7 +3,7 @@
 module Mutant
   module Parallel
     class Worker
-      include Adamantium::Flat, Anima.new(
+      include Adamantium, Anima.new(
         :connection,
         :index,
         :pid,

data/lib/mutant/parser.rb

@@ -3,7 +3,7 @@
 module Mutant
   # An AST Parser
   class Parser
-    include Adamantium::Mutable, Equalizer.new
+    include Adamantium, Equalizer.new
 
     # Initialize object
     #