mutant 0.10.20 → 0.10.25

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

@@ -19,6 +19,7 @@ module Mutant
           end
 
           def dispatch
+            mutate_body
             emit_singletons unless parent_node
             children.each_with_index do |child, index|
               mutate_child(index) unless n_str?(child)
@@ -27,6 +28,31 @@ module Mutant
             emit_type(s(:str, NULL_REGEXP_SOURCE), options)
           end
 
+          # NOTE: will only mutate parts of regexp body if the
+          # body is composed of only strings. Regular expressions
+          # with interpolation are skipped
+          def mutate_body
+            return unless body.all?(&method(:n_str?))
+
+            Mutator.mutate(body_ast).each do |mutation|
+              source = AST::Regexp.to_expression(mutation).to_s
+              emit_type(s(:str, source), options)
+            end
+          end
+
+          def body_ast
+            AST::Regexp.to_ast(body_expression)
+          end
+
+          def body_expression
+            AST::Regexp.parse(body.map(&:children).join)
+          end
+          memoize :body_expression
+
+          def body
+            children.slice(0...-1)
+          end
+
         end # Regex
       end # Literal
     end # Node

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

@@ -11,8 +11,6 @@ module Mutant
 
           children :value
 
-          PREFIX = '__mutant__'
-
         private
 
           def dispatch

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 = IceNine.deep_freeze(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/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 = IceNine.deep_freeze(
+            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
+          )
+
+          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/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

@@ -14,30 +14,35 @@ module Mutant
         children :receiver, :selector
 
         SELECTOR_REPLACEMENTS = IceNine.deep_freeze(
-          reverse_map:   %i[map each],
-          kind_of?:      %i[instance_of?],
+          :< =>          %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],
+          method:        %i[public_method],
+          match:         %i[match?],
           reverse_each:  %i[each],
+          reverse_map:   %i[map each],
           reverse_merge: %i[merge],
-          map:           %i[each],
-          flat_map:      %i[map],
           send:          %i[public_send __send__],
-          __send__:      %i[public_send],
-          method:        %i[public_method],
-          gsub:          %i[sub],
-          eql?:          %i[equal?],
-          to_s:          %i[to_str],
-          to_i:          %i[to_int],
           to_a:          %i[to_ary],
           to_h:          %i[to_hash],
-          at:            %i[fetch key?],
-          fetch:         %i[key?],
-          values_at:     %i[fetch_values],
-          :== =>         %i[eql? equal?],
-          :>= =>         %i[> == eql? equal?],
-          :<= =>         %i[< == eql? equal?],
-          :> =>          %i[== eql? equal?],
-          :< =>          %i[== eql? equal?]
+          to_i:          %i[to_int],
+          to_s:          %i[to_str],
+          values_at:     %i[fetch_values]
         )
 
         RECEIVER_SELECTOR_REPLACEMENTS = IceNine.deep_freeze(
@@ -79,6 +84,7 @@ module Mutant
         end
 
         def emit_selector_specific_mutations
+          emit_predicate_mutations
           emit_array_mutation
           emit_static_send
           emit_const_get_mutation
@@ -88,6 +94,13 @@ module Mutant
           emit_lambda_mutation
         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?
 
@@ -175,7 +188,11 @@ module Mutant
         end
 
         def emit_argument_propagation
-          emit_propagation(Mutant::Util.one(arguments)) if arguments.one?
+          return unless arguments.one?
+
+          argument = Mutant::Util.one(arguments)
+
+          emit_propagation(argument) unless n_kwargs?(argument)
         end
 
         def mutate_receiver

data/lib/mutant/parallel.rb

@@ -6,45 +6,61 @@ module Mutant
 
     # Run async computation returning driver
     #
+    # @param [World] world
     # @param [Config] config
     #
     # @return [Driver]
-    def self.async(config)
-      shared = {
-        var_active_jobs: shared(Variable::IVar, config, value: Set.new),
-        var_final:       shared(Variable::IVar, config),
-        var_sink:        shared(Variable::IVar, config, value: config.sink)
-      }
+    def self.async(world, config)
+      shared  = shared_state(world, config)
+      workers = workers(world, config, shared)
 
       Driver.new(
-        threads: threads(config, worker(config, **shared)),
+        workers: workers,
+        threads: threads(world, config, workers),
         **shared
       )
     end
 
-    # The worker
-    #
-    # @param [Config] config
-    #
-    # @return [Worker]
-    def self.worker(config, **shared)
-      Worker.new(
-        processor:   config.processor,
-        var_running: shared(Variable::MVar, config, value: config.jobs),
-        var_source:  shared(Variable::IVar, config, value: config.source),
-        **shared
-      )
+    def self.workers(world, config, shared)
+      Array.new(config.jobs) do |index|
+        Worker.start(
+          block:        config.block,
+          index:        index,
+          process_name: "#{config.process_name}-#{index}",
+          world:        world,
+          **shared
+        )
+      end
     end
+    private_class_method :workers
+
+    def self.shared_state(world, config)
+      {
+        var_active_jobs: shared(Variable::IVar, world, value: Set.new),
+        var_final:       shared(Variable::IVar, world),
+        var_running:     shared(Variable::MVar, world, value: config.jobs),
+        var_sink:        shared(Variable::IVar, world, value: config.sink),
+        var_source:      shared(Variable::IVar, world, value: config.source)
+      }
+    end
+    private_class_method :shared_state
+
+    def self.threads(world, config, workers)
+      thread = world.thread
 
-    def self.threads(config, worker)
-      Array.new(config.jobs) { config.thread.new(&worker.method(:call)) }
+      workers.map do |worker|
+        thread.new do
+          thread.current.name = "#{config.thread_name}-#{worker.index}"
+          worker.call
+        end
+      end
     end
     private_class_method :threads
 
-    def self.shared(klass, config, **attributes)
+    def self.shared(klass, world, **attributes)
       klass.new(
-        condition_variable: config.condition_variable,
-        mutex:              config.mutex,
+        condition_variable: world.condition_variable,
+        mutex:              world.mutex,
         **attributes
       )
     end
@@ -75,13 +91,12 @@ module Mutant
     # Parallel run configuration
     class Config
       include Adamantium::Flat, Anima.new(
-        :condition_variable,
+        :block,
         :jobs,
-        :mutex,
-        :processor,
+        :process_name,
         :sink,
         :source,
-        :thread
+        :thread_name
       )
     end # Config