mutant 0.10.17 → 0.10.22

data/lib/mutant/license.rb

@@ -12,7 +12,7 @@ module Mutant
     # @return [Either<String,Subscription>]
     #
     # @api private
-    def self.apply(world)
+    def self.call(world)
       load_mutant_license(world)
         .fmap { license_path(world) }
         .bind { |path| Subscription.load(world, world.json.load(path)) }

data/lib/mutant/license/subscription.rb

@@ -30,7 +30,7 @@ module Mutant
           'oss' => Opensource
         }.fetch(value.fetch('type'))
           .from_json(value.fetch('contents'))
-          .apply(world)
+          .call(world)
       end
 
       # Subscription self description

data/lib/mutant/license/subscription/commercial.rb

@@ -15,7 +15,7 @@ module Mutant
           new(value.fetch('authors').map(&Author.public_method(:new)).to_set)
         end
 
-        def apply(world)
+        def call(world)
           candidates = candidates(world)
 
           if (licensed & candidates).any?

data/lib/mutant/license/subscription/opensource.rb

@@ -50,7 +50,7 @@ module Mutant
           )
         end
 
-        def apply(world)
+        def call(world)
           world
             .capture_stdout(%w[git remote --verbose])
             .fmap(&method(:parse_remotes))

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

@@ -8,8 +8,6 @@ module Mutant
 
         handle(:args)
 
-        PROCARG = %i[restarg mlhs].freeze
-
       private
 
         def dispatch

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

@@ -21,7 +21,7 @@ module Mutant
         end
 
         def mutate_body
-          emit_body(nil)
+          emit_body(nil) unless unconditional_loop?
           emit_body(N_RAISE)
 
           return unless body
@@ -31,6 +31,10 @@ module Mutant
           mutate_body_receiver
         end
 
+        def unconditional_loop?
+          send.eql?(s(:send, nil, :loop))
+        end
+
         def body_has_control?
           AST.find_last_path(body) do |node|
             n_break?(node) || n_next?(node)

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

@@ -13,10 +13,19 @@ module Mutant
       private
 
         def dispatch
-          emit_singletons
-          emit(N_TRUE)
+          emit(N_NIL)
+          emit_instance_variable_mutation
+        end
+
+        def emit_instance_variable_mutation
+          return unless n_ivar?(expression)
+
+          instance_variable_name = Mutant::Util.one(expression.children)
 
-          emit_expression_mutations { |node| !n_self?(node) }
+          emit(
+            s(:send, nil, :instance_variable_defined?,
+              s(:sym, instance_variable_name))
+          )
         end
 
       end # Defined

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Mutator
+    class Node
+      # Mutator for kwargs node
+      class Kwargs < self
+
+        handle(:kwargs)
+
+      private
+
+        def dispatch
+          emit_argument_presence
+          emit_argument_mutations
+        end
+
+        def emit_argument_presence
+          Util::Array::Presence.call(children).each do |children|
+            emit_type(*children)
+          end
+        end
+
+        def emit_argument_mutations
+          children.each_with_index do |child, index|
+            Mutator.mutate(child).each do |mutant|
+              emit_child_update(index, mutant)
+            end
+          end
+        end
+      end # Kwargs
+    end # Node
+  end # Mutator
+end # Mutant

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/procarg_zero.rb

@@ -4,12 +4,6 @@ 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
 

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

@@ -14,30 +14,32 @@ 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[== 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],
           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(

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
 

data/lib/mutant/parallel/driver.rb

@@ -8,7 +8,10 @@ module Mutant
         :threads,
         :var_active_jobs,
         :var_final,
-        :var_sink
+        :var_running,
+        :var_sink,
+        :var_source,
+        :workers
       )
 
       private(*anima.attribute_names)
@@ -29,7 +32,10 @@ module Mutant
 
       def finalize(status)
         status.tap do
-          threads.each(&:join) if status.done?
+          if status.done?
+            workers.each(&:join)
+            threads.each(&:join)
+          end
         end
       end
 
@@ -38,7 +44,7 @@ module Mutant
           var_sink.with do |sink|
             Status.new(
               active_jobs: active_jobs.dup.freeze,
-              done:        threads.all? { |thread| !thread.alive? },
+              done:        threads.all? { |worker| !worker.alive? },
               payload:     sink.status
             )
           end

data/lib/mutant/parallel/worker.rb

@@ -4,7 +4,10 @@ module Mutant
   module Parallel
     class Worker
       include Adamantium::Flat, Anima.new(
-        :processor,
+        :connection,
+        :index,
+        :pid,
+        :process,
         :var_active_jobs,
         :var_final,
         :var_running,
@@ -14,6 +17,45 @@ module Mutant
 
       private(*anima.attribute_names)
 
+      public :index
+
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/ParameterLists
+      def self.start(world:, block:, process_name:, **attributes)
+        io      = world.io
+        process = world.process
+
+        request  = Pipe.from_io(io)
+        response = Pipe.from_io(io)
+
+        pid = process.fork do
+          world.thread.current.name = process_name
+          world.process.setproctitle(process_name)
+
+          Child.new(
+            block:      block,
+            connection: Pipe::Connection.from_pipes(
+              marshal: world.marshal,
+              reader:  request,
+              writer:  response
+            )
+          ).call
+        end
+
+        new(
+          pid:        pid,
+          process:    process,
+          connection: Pipe::Connection.from_pipes(
+            marshal: world.marshal,
+            reader:  response,
+            writer:  request
+          ),
+          **attributes
+        )
+      end
+      # rubocop:enable Metrics/MethodLength
+      # rubocop:enable Metrics/ParameterLists
+
       # Run worker payload
       #
       # @return [self]
@@ -23,7 +65,7 @@ module Mutant
 
           job_start(job)
 
-          result = processor.call(job.payload)
+          result = connection.call(job.payload)
 
           job_done(job)
 
@@ -35,6 +77,12 @@ module Mutant
         self
       end
 
+      def join
+        process.kill('TERM', pid)
+        process.wait(pid)
+        self
+      end
+
     private
 
       def next_job
@@ -66,6 +114,16 @@ module Mutant
         var_final.put(nil) if var_running.modify(&:pred).zero?
       end
 
+      class Child
+        include Anima.new(:block, :connection)
+
+        def call
+          loop do
+            connection.send_value(block.call(connection.receive_value))
+          end
+        end
+      end
+      private_constant :Child
     end # Worker
   end # Parallel
 end # Mutant

data/lib/mutant/pipe.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Mutant
+  # Pipe abstraction
+  class Pipe
+    include Adamantium::Flat, Anima.new(:reader, :writer)
+
+    # Run block with pipe in binmode
+    #
+    # @return [undefined]
+    def self.with(io)
+      io.pipe(binmode: true) do |(reader, writer)|
+        yield new(reader: reader, writer: writer)
+      end
+    end
+
+    def self.from_io(io)
+      reader, writer = io.pipe(binmode: true)
+      new(reader: reader, writer: writer)
+    end
+
+    # Writer end of the pipe
+    #
+    # @return [IO]
+    def to_writer
+      reader.close
+      writer
+    end
+
+    # Parent reader end of the pipe
+    #
+    # @return [IO]
+    def to_reader
+      writer.close
+      reader
+    end
+
+    class Connection
+      include Anima.new(:marshal, :reader, :writer)
+
+      Error = Class.new(RuntimeError)
+
+      class Frame
+        include Concord.new(:io)
+
+        HEADER_FORMAT = 'N'
+        MAX_BYTES     = (2**32).pred
+        HEADER_SIZE   = 4
+
+        def receive_value
+          header = read(HEADER_SIZE)
+          read(Util.one(header.unpack(HEADER_FORMAT)))
+        end
+
+        def send_value(body)
+          bytesize = body.bytesize
+
+          fail Error, 'message to big' if bytesize > MAX_BYTES
+
+          io.write([bytesize].pack(HEADER_FORMAT))
+          io.write(body)
+        end
+
+      private
+
+        def read(bytes)
+          io.read(bytes) or fail Error, 'Unexpected EOF'
+        end
+      end
+
+      def call(payload)
+        send_value(payload)
+        receive_value
+      end
+
+      def receive_value
+        marshal.load(reader.receive_value)
+      end
+
+      def send_value(value)
+        writer.send_value(marshal.dump(value))
+        self
+      end
+
+      def self.from_pipes(marshal:, reader:, writer:)
+        new(
+          marshal: marshal,
+          reader:  Frame.new(reader.to_reader),
+          writer:  Frame.new(writer.to_writer)
+        )
+      end
+    end
+  end # Pipe
+end # Mutant