mutant 0.8.24 → 0.9.0

data/lib/mutant/matcher/scope.rb

@@ -20,7 +20,7 @@ module Mutant
 
       # Matched subjects
       #
-      # @param [Env::Bootstrap] env
+      # @param [Env] env
       #
       # @return [Enumerable<Subject>]
       def call(env)

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

@@ -80,14 +80,6 @@ module Mutant
           mutation('self')
         end
 
-        # Add regexp mutations
-        #
-        # @return [undefined]
-        def regexp_mutations
-          mutation('//')
-          mutation('/nomatch\A/')
-        end
-
         # Helper method to coerce input to node
         #
         # @param [String,Parser::AST::Node] input

data/lib/mutant/mutation.rb

@@ -61,7 +61,7 @@ module Mutant
     #
     # @param kernel [Kernel]
     #
-    # @return [self]
+    # @return [Loader::Result]
     def insert(kernel)
       subject.prepare
       Loader.call(
@@ -70,7 +70,6 @@ module Mutant
         source:  monkeypatch,
         subject: subject
       )
-      self
     end
 
   private

data/lib/mutant/mutator/node.rb

@@ -44,13 +44,6 @@ module Mutant
       # @return [Parser::AST::Node]
       alias_method :dup_node, :dup_input
 
-      # Original nodes children
-      #
-      # @return [Array<Parser::AST::Node>]
-      def children
-        node.children
-      end
-
       # Dispatch on child index
       #
       # @param [Integer] index
@@ -122,7 +115,7 @@ module Mutant
       #
       # @return [undefined]
       def emit_nil
-        emit(N_NIL) unless asgn_left?
+        emit(N_NIL) unless left_assignment?
       end
 
       # Parent node
@@ -150,7 +143,7 @@ module Mutant
       # Test if the node is the left of an or_asgn or op_asgn
       #
       # @return [Boolean]
-      def asgn_left?
+      def left_assignment?
         AST::Types::OP_ASSIGN.include?(parent_type) && parent.node.children.first.equal?(node)
       end
 

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

@@ -78,7 +78,7 @@ module Mutant
         #
         # @return [Enumerable<Parser::AST::Node, Integer>]
         def mlhs_childs_with_index
-          children.each_with_index.select do |child, _index|
+          children.each_with_index.select do |child,|
             n_mlhs?(child)
           end
         end

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

@@ -15,16 +15,8 @@ module Mutant
         #
         # @return [undefined]
         def dispatch
-          mutate_type
           emit_body_mutations if body
         end
-
-        # Emit class -> type mutations
-        #
-        # @return [undefined]
-        def mutate_type
-          emit(s(:module, klass, body))
-        end
       end # Class
     end # Node
   end # Mutator

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

@@ -14,7 +14,6 @@ module Mutant
         def dispatch
           emit_arguments_mutations
           emit_optarg_body_assignments
-          emit_restarg_body_mutation
           emit_body(N_RAISE)
           emit_body(N_ZSUPER)
           emit_body(nil)
@@ -32,17 +31,6 @@ module Mutant
           end
         end
 
-        # Emit mutation with arg splat as empty array assignment in method
-        #
-        # @return [undefined]
-        def emit_restarg_body_mutation
-          arguments.children.each do |argument|
-            next unless n_restarg?(argument) && argument.children.one?
-
-            emit_body_prepend(s(:lvasgn, AST::Meta::Restarg.new(argument).name, s(:array)))
-          end
-        end
-
         # Emit valid body ASTs depending on instance body
         #
         # @param node [Parser::AST::Node]

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

@@ -8,61 +8,47 @@ module Mutant
       class Generic < self
 
         unsupported_nodes = %i[
-          ensure
-          redo
-          retry
+          __FILE__
+          __LINE__
+          alias
           arg_expr
+          back_ref
           blockarg
-          kwrestarg
-          undef
-          module
+          blockarg_expr
+          complex
+          eflipflop
           empty
-          alias
+          ensure
           for
-          xstr
-          back_ref
-          restarg
-          sclass
-          match_with_lvasgn
-          while_post
-          until_post
-          preexe
-          postexe
+          ident
           iflipflop
-          eflipflop
+          kwrestarg
           kwsplat
-          shadowarg
+          match_with_lvasgn
+          meth_ref
+          module
+          objc_kwarg
+          objc_restarg
+          objc_varargs
+          postexe
+          preexe
           rational
-          complex
-          __FILE__
-          __LINE__
-        ]
-
-        unsupported_regexp_nodes = AST::Types::REGEXP.to_a - %i[
-          regexp_alternation_meta
-          regexp_bol_anchor
-          regexp_capture_group
-          regexp_digit_type
-          regexp_eol_anchor
-          regexp_eos_ob_eol_anchor
-          regexp_greedy_zero_or_more
-          regexp_hex_type
-          regexp_linebreak_type
-          regexp_nondigit_type
-          regexp_nonhex_type
-          regexp_nonspace_type
-          regexp_nonword_boundary_anchor
-          regexp_nonword_type
-          regexp_root_expression
-          regexp_space_type
-          regexp_word_boundary_anchor
-          regexp_word_type
-          regexp_xgrapheme_type
+          redo
+          restarg
+          restarg_expr
+          retry
+          root
+          sclass
+          shadowarg
+          undef
+          until_post
+          while_post
+          xstr
         ]
 
         # These nodes still need a dedicated mutator,
         # your contribution is that close!
-        handle(*(unsupported_nodes + unsupported_regexp_nodes))
+        handle(*unsupported_nodes)
 
       private
 

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

@@ -30,7 +30,7 @@ module Mutant
         #
         # @return [undefined]
         def emit_send_forms
-          return if asgn_left?
+          return if left_assignment?
 
           SEND_REPLACEMENTS.each do |selector|
             emit(s(:send, receiver, selector, *indices))
@@ -55,7 +55,7 @@ module Mutant
         # @return [undefined]
         def mutate_indices
           children_indices(index_range).each do |index|
-            emit_propagation(children.fetch(index)) unless asgn_left?
+            emit_propagation(children.fetch(index)) unless left_assignment?
             delete_child(index)
             mutate_child(index)
           end
@@ -98,7 +98,7 @@ module Mutant
           def dispatch
             super()
 
-            return if asgn_left?
+            return if left_assignment?
 
             emit_index_read
             emit(children.last)
@@ -116,7 +116,7 @@ module Mutant
           #
           # @return [Range<Integer>]
           def index_range
-            if asgn_left?
+            if left_assignment?
               NO_VALUE_RANGE
             else
               REGULAR_RANGE

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

@@ -25,7 +25,6 @@ module Mutant
           #
           # @return [undefined]
           def dispatch
-            mutate_body
             emit_singletons unless parent_node
             children.each_with_index do |child, index|
               mutate_child(index) unless n_str?(child)
@@ -34,44 +33,6 @@ module Mutant
             emit_type(s(:str, NULL_REGEXP_SOURCE), options)
           end
 
-          # Mutate regexp body
-          #
-          # @note will only mutate parts of regexp body if the
-          # body is composed of only strings. Regular expressions
-          # with interpolation are skipped
-          #
-          # @return [undefined]
-          def mutate_body
-            return unless body.all?(&method(:n_str?)) && body_ast
-
-            Mutator.mutate(body_ast).each do |mutation|
-              source = AST::Regexp.to_expression(mutation).to_s
-              emit_type(s(:str, source), options)
-            end
-          end
-
-          # AST representation of regexp body
-          #
-          # @return [Parser::AST::Node, nil]
-          def body_ast
-            body_expression and AST::Regexp.to_ast(body_expression)
-          end
-
-          # Expression representation of regexp body
-          #
-          # @return [Regexp::Expression, nil]
-          def body_expression
-            AST::Regexp.parse(body.map(&:children).join)
-          end
-          memoize :body_expression
-
-          # Children of regexp node which compose regular expression source
-          #
-          # @return [Array<Parser::AST::Node>]
-          def body
-            children.slice(0...-1)
-          end
-
         end # Regex
       end # Literal
     end # Node

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

@@ -21,11 +21,6 @@ module Mutant
           reverse_merge: %i[merge],
           map:           %i[each],
           flat_map:      %i[map],
-          sample:        %i[first last],
-          pop:           %i[last],
-          shift:         %i[first],
-          first:         %i[last],
-          last:          %i[first],
           send:          %i[public_send __send__],
           __send__:      %i[public_send],
           method:        %i[public_method],
@@ -33,13 +28,11 @@ module Mutant
           eql?:          %i[equal?],
           to_s:          %i[to_str],
           to_i:          %i[to_int],
-          to_a:          %i[to_ary to_set],
+          to_a:          %i[to_ary],
           to_h:          %i[to_hash],
           at:            %i[fetch key?],
           fetch:         %i[key?],
           values_at:     %i[fetch_values],
-          match:         %i[match?],
-          '=~':          %i[match?],
           :== =>         %i[eql? equal?],
           :>= =>         %i[> == eql? equal?],
           :<= =>         %i[< == eql? equal?],
@@ -159,7 +152,7 @@ module Mutant
         #
         # @return [undefined]
         def emit_integer_mutation
-          return unless receiver && selector.equal?(:to_i)
+          return unless selector.equal?(:to_i)
 
           emit(s(:send, nil, :Integer, receiver))
         end
@@ -193,11 +186,20 @@ module Mutant
         def mutate_arguments
           emit_type(receiver, selector)
           remaining_children_with_index.each do |_node, index|
-            mutate_child(index)
+            mutate_argument_index(index)
             delete_child(index)
           end
         end
 
+        # Mutate argument
+        #
+        # @param [Integer] index
+        #
+        # @return [undefined]
+        def mutate_argument_index(index)
+          mutate_child(index) { |node| !n_begin?(node) }
+        end
+
         # Emit argument propagation
         #
         # @return [undefined]
@@ -221,8 +223,7 @@ module Mutant
         # @return [undefined]
         def emit_implicit_self
           emit_receiver(nil) if n_self?(receiver) && !(
-            KEYWORDS.include?(selector)         ||
-            METHOD_OPERATORS.include?(selector) ||
+            KEYWORDS.include?(selector) ||
             meta.attribute_assignment?
           )
         end

data/lib/mutant/parallel.rb

@@ -4,32 +4,65 @@ module Mutant
   # Parallel execution engine of arbitrary payloads
   module Parallel
 
-    # Driver for parallelized execution
-    class Driver
-      include Concord.new(:binding)
-
-      # Scheduler status
-      #
-      # @return [Object]
-      def status
-        binding.call(__method__)
-      end
-
-      # Stop master gracefully
-      #
-      # @return [self]
-      def stop
-        binding.call(__method__)
-        self
-      end
-    end # Driver
-
     # Run async computation returning driver
     #
+    # @param [Config] config
+    #
     # @return [Driver]
     def self.async(config)
-      Driver.new(config.env.new_mailbox.bind(Master.call(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)
+      }
+
+      Driver.new(
+        threads: threads(config, worker(config, **shared)),
+        **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
+      )
+    end
+
+    # Start threads
+    #
+    # @param [Config] config
+    # @param [Worker] worker
+    #
+    # @return [Array<Thread>]
+    def self.threads(config, worker)
+      Array.new(config.jobs) { config.thread.new(&worker.method(:call)) }
     end
+    private_class_method :threads
+
+    # Create shared variable
+    #
+    # @param [Class] klass
+    # @param [Config] config
+    #
+    # @return [Mutant::Variable]
+    #
+    # ignore :reek:LongParameterList
+    def self.shared(klass, config, **attributes)
+      klass.new(
+        condition_variable: config.condition_variable,
+        mutex:              config.mutex,
+        **attributes
+      )
+    end
+    private_class_method :shared
 
     # Job result sink
     class Sink
@@ -42,7 +75,7 @@ module Mutant
       # @return [self]
       abstract_method :result
 
-      # Sink status
+      # The sink status
       #
       # @return [Object]
       abstract_method :status
@@ -53,30 +86,16 @@ module Mutant
       abstract_method :stop?
     end # Sink
 
-    # Job to push to workers
-    class Job
-      include Adamantium::Flat, Anima.new(
-        :index,
-        :payload
-      )
-    end # Job
-
-    # Job result object received from workers
-    class JobResult
-      include Adamantium::Flat, Anima.new(
-        :job,
-        :payload
-      )
-    end # JobResult
-
     # Parallel run configuration
     class Config
       include Adamantium::Flat, Anima.new(
-        :env,
+        :condition_variable,
         :jobs,
+        :mutex,
         :processor,
         :sink,
-        :source
+        :source,
+        :thread
       )
     end # Config
 
@@ -87,6 +106,8 @@ module Mutant
         :done,
         :payload
       )
+
+      alias_method :done?, :done
     end # Status
 
   end # Parallel