mutant 0.11.28 → 0.11.29

data/lib/mutant/meta/example.rb

@@ -39,8 +39,9 @@ module Mutant
       # @return [Context]
       def context
         Context.new(
-          scope:       Object,
-          source_path: location.path
+          constant_scope: Context::ConstantScope::None.new,
+          scope:          scope,
+          source_path:    location.path
         )
       end
 
@@ -65,6 +66,15 @@ module Mutant
       end
       memoize :generated
 
+    private
+
+      def scope
+        Scope.new(
+          expression: Expression::Namespace::Exact.new(scope_name: 'Object'),
+          raw:        Object
+        )
+      end
+
     end # Example
   end # Meta
 end # Mutant

data/lib/mutant/mutation/runner/sink.rb

@@ -4,6 +4,8 @@ module Mutant
   class Mutation
     module Runner
       class Sink
+        include Parallel::Sink
+
         include Anima.new(:env)
 
         # Initialize object
@@ -35,11 +37,13 @@ module Mutant
 
         # Handle mutation finish
         #
-        # @param [Result::MutationIndex] mutation_index_result
+        # @param [Parallel::Response] response
         #
         # @return [self]
-        def result(mutation_index_result)
-          mutation_result = mutation_result(mutation_index_result)
+        def response(response)
+          fail response.error if response.error
+
+          mutation_result = mutation_result(response.result)
 
           subject = mutation_result.mutation.subject
 

data/lib/mutant/mutation/runner.rb

@@ -15,8 +15,6 @@ module Mutant
       def self.run_mutation_analysis(env)
         reporter = reporter(env)
 
-        env.world.process_warmup
-
         env
           .record(:analysis) { run_driver(reporter, async_driver(env)) }
           .tap { |result| env.record(:report) { reporter.report(result) } }
@@ -24,7 +22,7 @@ module Mutant
       private_class_method :run_mutation_analysis
 
       def self.async_driver(env)
-        Parallel.async(env.world, mutation_test_config(env))
+        Parallel.async(world: env.world, config: mutation_test_config(env))
       end
       private_class_method :async_driver
 
@@ -49,6 +47,7 @@ module Mutant
           process_name:     'mutant-worker-process',
           sink:             Sink.new(env: env),
           source:           Parallel::Source::Array.new(jobs: env.mutations.each_index.to_a),
+          timeout:          nil,
           thread_name:      'mutant-worker-thread'
         )
       end

data/lib/mutant/parallel/connection.rb

@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+module Mutant
+  module Parallel
+    class Connection
+      include Anima.new(:marshal, :reader, :writer)
+
+      Error = Class.new(RuntimeError)
+
+      HEADER_FORMAT = 'N'
+      HEADER_SIZE   = 4
+      MAX_BYTES     = (2**32).pred
+
+      class Reader
+        include Anima.new(:deadline, :io, :marshal, :response_reader, :log_reader)
+
+        private(*anima.attribute_names)
+
+        private_class_method :new
+
+        attr_reader :log
+
+        def error
+          @errors.first
+        end
+
+        def result
+          @results.first
+        end
+
+        def initialize(*)
+          super
+
+          @buffer  = +''
+          @log     = +''
+
+          # Array of size max 1 as surrogate for
+          # terrible default nil ivars.
+          @errors  = []
+          @lengths = []
+          @results = []
+        end
+
+        def self.read_response(job:, **attributes)
+          reader = new(**attributes).read_till_final
+
+          Response.new(
+            error:  reader.error,
+            job:    job,
+            log:    reader.log,
+            result: reader.result
+          )
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def read_till_final
+          readers = [response_reader, log_reader]
+
+          until !@results.empty? || error
+            status = deadline.status
+
+            break timeout unless status.ok?
+
+            reads, _others = io.select(readers, nil, nil, status.time_left)
+
+            break timeout unless reads
+
+            reads.each do |ready|
+              if ready.equal?(response_reader)
+                advance_result
+              else
+                advance_log
+              end
+            end
+          end
+
+          self
+        end
+      # rubocop:enable Metrics/MethodLength
+
+      private
+
+        def timeout
+          @errors << Timeout::Error
+        end
+
+        def advance_result
+          if length
+            if read_buffer(length)
+              @results << marshal.load(@buffer)
+            end
+          elsif read_buffer(HEADER_SIZE)
+            @lengths << Util.one(@buffer.unpack(HEADER_FORMAT))
+            @buffer = +''
+          end
+        end
+
+        def length
+          @lengths.first
+        end
+
+        def advance_log
+          with_nonblock_read(io: log_reader, max_bytes: 4096, &log.public_method(:<<))
+        end
+
+        def read_buffer(max_bytes)
+          with_nonblock_read(
+            io:        response_reader,
+            max_bytes: max_bytes - @buffer.bytesize
+          ) do |chunk|
+            @buffer << chunk
+            @buffer.bytesize.equal?(max_bytes)
+          end
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def with_nonblock_read(io:, max_bytes:)
+          io.binmode
+
+          chunk = io.read_nonblock(max_bytes, exception: false)
+
+          case chunk
+          when nil
+            @errors << EOFError
+            false
+          when String
+            yield chunk
+          else
+            fail "Unexpected nonblocking read return: #{chunk.inspect}"
+          end
+        end
+        # rubocop:enable Metrics/MethodLength
+      end
+
+      class Frame
+        include Anima.new(:io)
+
+        def receive_value
+          read(Util.one(read(HEADER_SIZE).unpack(HEADER_FORMAT)))
+        end
+
+        def send_value(body)
+          bytesize = body.bytesize
+
+          fail Error, 'message to big' if bytesize > MAX_BYTES
+
+          io.binmode
+          io.write([bytesize].pack(HEADER_FORMAT))
+          io.write(body)
+        end
+
+      private
+
+        def read(bytes)
+          io.binmode
+          io.read(bytes) or fail Error, 'Unexpected EOF'
+        end
+      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(io: reader.to_reader),
+          writer:  Frame.new(io: writer.to_writer)
+        )
+      end
+    end # Connection
+  end # Parallel
+end # Mutant

data/lib/mutant/parallel/pipe.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Mutant
+  module Parallel
+    class Pipe
+      include Adamantium, 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
+    end # Pipe
+  end # Parallel
+end # Mutant

data/lib/mutant/parallel/worker.rb

@@ -9,6 +9,7 @@ module Mutant
           :index,
           :on_process_start,
           :process_name,
+          :timeout,
           :var_active_jobs,
           :var_final,
           :var_running,
@@ -18,38 +19,49 @@ module Mutant
         )
       end
 
-      include Adamantium, Anima.new(:connection, :config, :pid)
+      include Adamantium, Anima.new(:config, :connection, :log_reader, :pid, :response_reader)
 
       def self.start(**attributes)
         start_config(Config.new(**attributes))
       end
 
       # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/AbcSize
       def self.start_config(config)
         world   = config.world
         io      = world.io
         marshal = world.marshal
 
-        request  = Pipe.from_io(io)
-        response = Pipe.from_io(io)
+        log, request, response = Pipe.from_io(io), Pipe.from_io(io), Pipe.from_io(io)
 
         pid = world.process.fork do
+          log_writer = log.to_writer
+
+          world.stderr.reopen(log_writer)
+          world.stdout.reopen(log_writer)
+
           run_child(
             config:     config,
-            connection: Pipe::Connection.from_pipes(marshal: marshal, reader: request, writer: response)
+            connection: Connection.from_pipes(marshal: marshal, reader: request, writer: response),
+            log_writer: log_writer
           )
         end
 
+        connection = Connection.from_pipes(marshal: marshal, reader: response, writer: request)
+
         new(
-          pid:        pid,
-          config:     config,
-          connection: Pipe::Connection.from_pipes(marshal: marshal, reader: response, writer: request)
+          config:          config,
+          connection:      connection,
+          log_reader:      log.to_reader,
+          response_reader: connection.reader.io,
+          pid:             pid
         )
       end
       private_class_method :start_config
+      # rubocop:enable Metrics/AbcSize
       # rubocop:enable Metrics/MethodLength
 
-      def self.run_child(config:, connection:)
+      def self.run_child(config:, connection:, log_writer:)
         world = config.world
 
         world.thread.current.name = config.process_name
@@ -58,7 +70,9 @@ module Mutant
         config.on_process_start.call(index: config.index)
 
         loop do
-          connection.send_value(config.block.call(connection.receive_value))
+          value = config.block.call(connection.receive_value)
+          log_writer.flush
+          connection.send_value(value)
         end
       end
       private_class_method :run_child
@@ -67,26 +81,40 @@ module Mutant
         config.index
       end
 
-      # Run worker payload
+      # Run worker loop
       #
       # @return [self]
+      #
+      # rubocop:disable Metrics/MethodLength
+      # rubocop:disable Metrics/AbcSize
       def call
         loop do
           job = next_job or break
 
           job_start(job)
 
-          result = connection.call(job.payload)
+          connection.send_value(job.payload)
+
+          response = Connection::Reader.read_response(
+            deadline:        config.world.deadline(config.timeout),
+            io:              config.world.io,
+            job:             job,
+            log_reader:      log_reader,
+            marshal:         config.world.marshal,
+            response_reader: response_reader
+          )
 
           job_done(job)
 
-          break if add_result(result)
+          break if add_response(response) || response.error
         end
 
         finalize
 
         self
       end
+      # rubocop:enable Metrics/AbcSize
+      # rubocop:enable Metrics/MethodLength
 
       def signal
         process.kill('TERM', pid)
@@ -110,9 +138,9 @@ module Mutant
         end
       end
 
-      def add_result(result)
+      def add_response(response)
         config.var_sink.with do |sink|
-          sink.result(result)
+          sink.response(response)
           sink.stop?
         end
       end

data/lib/mutant/parallel.rb

@@ -9,8 +9,11 @@ module Mutant
     # @param [Config] config
     #
     # @return [Driver]
-    def self.async(world, config)
-      shared  = shared_state(world, config)
+    def self.async(config:, world:)
+      shared = shared_state(world, config)
+
+      world.process_warmup
+
       workers = workers(world, config, shared)
 
       Driver.new(
@@ -20,6 +23,7 @@ module Mutant
       )
     end
 
+    # rubocop:disable Metric/MethodLength
     def self.workers(world, config, shared)
       Array.new(config.jobs) do |index|
         Worker.start(
@@ -27,12 +31,14 @@ module Mutant
           index:            index,
           on_process_start: config.on_process_start,
           process_name:     "#{config.process_name}-#{index}",
+          timeout:          config.timeout,
           world:            world,
           **shared
         )
       end
     end
     private_class_method :workers
+    # rubocop:enable Metric/MethodLength
 
     def self.shared_state(world, config)
       {
@@ -66,16 +72,16 @@ module Mutant
     end
     private_class_method :shared
 
-    # Job result sink
-    class Sink
+    # Job result sink signature
+    module Sink
       include AbstractType
 
       # Process job result
       #
-      # @param [Object]
+      # @param [Response]
       #
       # @return [self]
-      abstract_method :result
+      abstract_method :response
 
       # The sink status
       #
@@ -97,10 +103,15 @@ module Mutant
         :process_name,
         :sink,
         :source,
-        :thread_name
+        :thread_name,
+        :timeout
       )
     end # Config
 
+    class Response
+      include Anima.new(:error, :job, :log, :result)
+    end
+
     # Parallel execution status
     class Status
       include Adamantium, Anima.new(

data/lib/mutant/reporter/cli/format.rb

@@ -18,11 +18,14 @@ module Mutant
 
         # Progress representation
         #
-        # @param [Runner::Status] status
-        #
         # @return [String]
         abstract_method :progress
 
+        # Progress representation
+        #
+        # @return [String]
+        abstract_method :test_progress
+
         # Report delay in seconds
         #
         # @return [Float]
@@ -69,6 +72,13 @@ module Mutant
             format(Printer::Env, env)
           end
 
+          # Test start representation
+          #
+          # @return [String]
+          def test_start(env)
+            format(Printer::Test::Env, env)
+          end
+
           # Progress representation
           #
           # @return [String]
@@ -76,6 +86,13 @@ module Mutant
             format(Printer::StatusProgressive, status)
           end
 
+          # Progress representation
+          #
+          # @return [String]
+          def test_progress(status)
+            format(Printer::Test::StatusProgressive, status)
+          end
+
         private
 
           def new_buffer

data/lib/mutant/reporter/cli/printer/test.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Reporter
+    class CLI
+      class Printer
+        class Test < self
+          # Printer for test config
+          class Config < self
+
+            # Report configuration
+            #
+            # @param [Mutant::Config] config
+            #
+            # @return [undefined]
+            #
+            def run
+              info('Fail-Fast:    %s', object.fail_fast)
+              info('Integration:  %s', object.integration.name || 'null')
+              info('Jobs:         %s', object.jobs || 'auto')
+            end
+          end # Config
+
+          # Env printer
+          class Env < self
+            delegate(
+              :amount_available_tests,
+              :amount_selected_tests,
+              :amount_all_tests,
+              :config
+            )
+
+            FORMATS = [
+            ].each(&:freeze)
+
+            # Run printer
+            #
+            # @return [undefined]
+            def run
+              info('Test environment:')
+              visit(Config, config)
+              info('Tests:        %s', amount_all_tests)
+            end
+          end # Env
+
+          # Full env result reporter
+          class EnvResult < self
+            delegate(
+              :amount_test_results,
+              :amount_tests_failed,
+              :amount_tests_success,
+              :runtime,
+              :testtime
+            )
+
+            FORMATS = [
+              [:info,   'Test-Results: %0d',     :amount_test_results    ],
+              [:info,   'Test-Failed:  %0d',     :amount_tests_failed    ],
+              [:info,   'Test-Success: %0d',     :amount_tests_success   ],
+              [:info,   'Runtime:      %0.2fs',  :runtime                ],
+              [:info,   'Testtime:     %0.2fs',  :testtime               ],
+              [:info,   'Efficiency:   %0.2f%%', :efficiency_percent     ]
+            ].each(&:freeze)
+
+            private_constant(*constants(false))
+
+            # Run printer
+            #
+            # @return [undefined]
+            def run
+              visit_collection(Result, object.failed_test_results)
+              visit(Env, object.env)
+              FORMATS.each do |report, format, value|
+                __send__(report, format, __send__(value))
+              end
+            end
+
+          private
+
+            def efficiency_percent
+              (testtime / runtime) * 100
+            end
+          end # EnvResult
+
+          # Reporter for test results
+          class Result < self
+
+            # Run report printer
+            #
+            # @return [undefined]
+            def run
+              puts(object.output)
+            end
+
+          end # Result
+
+          # Reporter for progressive output format on scheduler Status objects
+          class StatusProgressive < self
+            FORMAT = 'progress: %02d/%02d failed: %d runtime: %0.02fs testtime: %0.02fs tests/s: %0.02f'
+
+            delegate(
+              :amount_test_results,
+              :amount_tests,
+              :amount_tests_failed,
+              :testtime,
+              :runtime
+            )
+
+            # Run printer
+            #
+            # @return [undefined]
+            def run
+              status(
+                FORMAT,
+                amount_test_results,
+                amount_tests,
+                amount_tests_failed,
+                runtime,
+                testtime,
+                tests_per_second
+              )
+            end
+
+          private
+
+            def object
+              super().payload
+            end
+
+            def tests_per_second
+              amount_test_results / runtime
+            end
+          end # StatusProgressive
+        end # Test
+      end # Printer
+    end # CLI
+  end # Reporter
+end # Mutant