mutant 0.8.24 → 0.9.0

data/lib/mutant/parallel/driver.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Mutant
+  module Parallel
+    # Driver for parallelized execution
+    class Driver
+      include Adamantium::Flat, Anima.new(
+        :threads,
+        :var_active_jobs,
+        :var_final,
+        :var_sink
+      )
+
+      private(*anima.attribute_names)
+
+      # Wait for computation to finish, with timeout
+      #
+      # @param [Float] timeout
+      #
+      # @return [Variable::Result<Sink#status>]
+      #   current status
+      def wait_timeout(timeout)
+        var_final.take_timeout(timeout)
+
+        finalize(status)
+      end
+
+    private
+
+      # Possibly finalize the exeuction
+      #
+      # @param [Status]
+      #
+      # @return [Status]
+      def finalize(status)
+        status.tap do
+          threads.each(&:join) if status.done?
+        end
+      end
+
+      # Get status
+      #
+      # @return [Status]
+      #
+      # ignore :reek:NestedIterators
+      def status
+        var_active_jobs.with do |active_jobs|
+          var_sink.with do |sink|
+            Status.new(
+              active_jobs: active_jobs.dup.freeze,
+              done:        threads.all? { |thread| !thread.alive? },
+              payload:     sink.status
+            )
+          end
+        end
+      end
+    end # Driver
+  end # Parallel
+end # Mutant

data/lib/mutant/parallel/source.rb

@@ -6,6 +6,10 @@ module Mutant
     class Source
       include AbstractType
 
+      class Job
+        include Adamantium, Anima.new(:index, :payload)
+      end
+
       NoJobError = Class.new(RuntimeError)
 
       # Next job
@@ -43,13 +47,13 @@ module Mutant
 
         # Next job
         #
-        # @return [Object]
+        # @return [Job]
         #
         # @raise [NoJobError]
         #   when no next job is available
         def next
           fail NoJobError unless next?
-          jobs.fetch(@next_index).tap do
+          Job.new(index: @next_index, payload: jobs.fetch(@next_index)).tap do
             @next_index += 1
           end
         end

data/lib/mutant/parallel/worker.rb

@@ -2,74 +2,92 @@
 
 module Mutant
   module Parallel
-    # Parallel execution worker
     class Worker
       include Adamantium::Flat, Anima.new(
-        :mailbox,
-        :parent,
-        :processor
+        :processor,
+        :var_active_jobs,
+        :var_final,
+        :var_running,
+        :var_sink,
+        :var_source
       )
 
-      # Run worker
-      #
-      # @param [Hash<Symbol, Object] attributes
+      private(*anima.attribute_names)
+
+      # Run worker payload
       #
       # @return [self]
-      def self.run(attributes)
-        new(attributes).run
+      #
+      # ignore :reek:TooManyStatements
+      def call
+        loop do
+          job = next_job or break
+
+          job_start(job)
+
+          result = processor.call(job.payload)
+
+          job_done(job)
+
+          break if add_result(result)
+        end
+
+        finalize
+
         self
       end
 
-      private_class_method :new
+    private
 
-      # Worker loop
+      # Next job, if any
       #
-      # @return [self]
-      #
-      # rubocop:disable Lint/Loop
-      def run
-        begin
-          parent.call(Actor::Message.new(:ready, mailbox.sender))
-        end until handle(mailbox.receiver.call)
+      # @return [Job, nil]
+      def next_job
+        var_source.with do |source|
+          source.next if source.next?
+        end
       end
 
-    private
-
-      # Handle job
+      # Add result
       #
-      # @param [Message] message
+      # @param [Object] result
       #
       # @return [Boolean]
-      def handle(message)
-        type, payload = message.type, message.payload
-        case message.type
-        when :job
-          handle_job(payload)
-          nil
-        when :stop
-          true
-        else
-          fail Actor::ProtocolError, "Unknown command: #{type.inspect}"
+      def add_result(result)
+        var_sink.with do |sink|
+          sink.result(result)
+          sink.stop?
+        end
+      end
+
+      # Register job to be started
+      #
+      # @param [Job] job
+      #
+      # @return [undefined]
+      def job_start(job)
+        var_active_jobs.with do |active_jobs|
+          active_jobs << job
         end
       end
 
-      # Handle mutation
+      # Register job to be done
       #
       # @param [Job] job
+      # @param [Object] result
+      #
+      # @return [undefined]
+      def job_done(job)
+        var_active_jobs.with do |active_jobs|
+          active_jobs.delete(job)
+        end
+      end
+
+      # Finalize worker
       #
       # @return [undefined]
-      def handle_job(job)
-        result = processor.call(job.payload)
-
-        parent.call(
-          Actor::Message.new(
-            :result,
-            JobResult.new(
-              job:     job,
-              payload: result
-            )
-          )
-        )
+      def finalize
+        var_final.put(nil) if var_running.modify(&:pred).zero?
       end
 
     end # Worker

data/lib/mutant/range.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Mutant
+  module Range
+    # Test if two ranges overlap
+    #
+    # @param [Range] left
+    # @param [Range] right
+    #
+    # @return [Boolean]
+    def self.overlap?(left, right)
+      left.end >= right.begin && right.end >= left.begin
+    end
+  end # Range
+end # end

data/lib/mutant/reporter/cli.rb

@@ -14,19 +14,15 @@ module Mutant
       #
       # :reek:ManualDispatch
       def self.build(output)
-        tput = Tput.detect
-        tty = output.respond_to?(:tty?) && output.tty?
-        format = if !Mutant.ci? && tty && tput
-          Format::Framed.new(tty:  tty, tput: tput)
-        else
-          Format::Progressive.new(tty: tty)
-        end
-        new(output, format)
+        new(
+          output,
+          Format::Progressive.new(output.respond_to?(:tty?) && output.tty?)
+        )
       end
 
       # Report start
       #
-      # @param [Env::Bootstrap] env
+      # @param [Env] env
       #
       # @return [self]
       def start(env)
@@ -46,8 +42,6 @@ module Mutant
 
       # Report delay in seconds
       #
-      # TODO: Move this to a callback registration
-      #
       # @return [Float]
       def delay
         format.delay

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

@@ -7,11 +7,11 @@ module Mutant
       #
       # rubocop:disable FormatString
       class Format
-        include AbstractType, Anima.new(:tty)
+        include AbstractType, Concord.new(:tty)
 
         # Start representation
         #
-        # @param [Env::Bootstrap] env
+        # @param [Env] env
         #
         # @return [String]
         abstract_method :start
@@ -72,7 +72,7 @@ module Mutant
           #
           # @return [String]
           def start(env)
-            format(Printer::Config, env.config)
+            format(Printer::Env, env)
           end
 
           # Progress representation
@@ -92,49 +92,6 @@ module Mutant
           end
 
         end # Progressive
-
-        # Format for framed rewindable output
-        class Framed < self
-          include anima.add(:tput)
-
-          BUFFER_FLAGS = 'a+'
-
-          REPORT_FREQUENCY = 20.0
-          REPORT_DELAY     = 1 / REPORT_FREQUENCY
-
-          # Format start
-          #
-          # @param [Env::Bootstrap] env
-          #
-          # @return [String]
-          def start(_env)
-            tput.prepare
-          end
-
-          # Format progress
-          #
-          # @param [Runner::Status] status
-          #
-          # @return [String]
-          def progress(status)
-            format(Printer::Status, status)
-          end
-
-        private
-
-          # New buffer
-          #
-          # @return [StringIO]
-          def new_buffer
-            # For some reason this raises an Errno::EACCESS error:
-            #
-            #  StringIO.new(Tput::INSTANCE.restore, BUFFER_FLAGS)
-            #
-            buffer = StringIO.new
-            buffer << tput.restore
-          end
-
-        end # Framed
       end # Format
     end # CLI
   end # Reporter

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

@@ -13,12 +13,11 @@ module Mutant
           #
           # @return [undefined]
           def run
-            info 'Mutant configuration:'
-            info 'Matcher:         %s',      object.matcher.inspect
-            info 'Integration:     %s',      object.integration
-            info 'Jobs:            %d',      object.jobs
-            info 'Includes:        %s',      object.includes
-            info 'Requires:        %s',      object.requires
+            info 'Matcher:         %s', object.matcher.inspect
+            info 'Integration:     %s', object.integration
+            info 'Jobs:            %d', object.jobs
+            info 'Includes:        %s', object.includes
+            info 'Requires:        %s', object.requires
           end
 
         end # Config

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Mutant
+  class Reporter
+    class CLI
+      class Printer
+        # Env printer
+        class Env < self
+          delegate(
+            :amount_mutations,
+            :amount_selected_tests,
+            :amount_subjects,
+            :amount_total_tests,
+            :config,
+            :test_subject_ratio
+          )
+
+          FORMATS = IceNine.deep_freeze([
+            [:info,   'Subjects:        %s',        :amount_subjects      ],
+            [:info,   'Total-Tests:     %s',        :amount_total_tests   ],
+            [:info,   'Selected-Tests:  %s',        :amount_selected_tests],
+            [:info,   'Tests/Subject:   %0.2f avg', :test_subject_ratio   ],
+            [:info,   'Mutations:       %s',        :amount_mutations     ]
+          ])
+
+          # Run printer
+          #
+          # @return [undefined]
+          def run
+            info('Mutant environment:')
+            visit(Config, config)
+            FORMATS.each do |report, format, value|
+              __send__(report, format, __send__(value))
+            end
+          end
+        end # EnvProgress
+      end # Printer
+    end # CLI
+  end # Reporter
+end # Mutant

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

@@ -7,36 +7,32 @@ module Mutant
         # Env progress printer
         class EnvProgress < self
           delegate(
-            :coverage,
-            :amount_subjects,
-            :amount_mutations,
+            :amount_mutation_results,
             :amount_mutations_alive,
             :amount_mutations_killed,
-            :amount_mutation_results,
-            :runtime,
+            :coverage,
+            :env,
             :killtime,
             :overhead,
-            :env
+            :runtime
           )
 
           FORMATS = IceNine.deep_freeze([
-            [:info,   'Subjects:        %s',      :amount_subjects          ],
-            [:info,   'Mutations:       %s',      :amount_mutations         ],
-            [:info,   'Results:         %s',      :amount_mutation_results  ],
-            [:info,   'Kills:           %s',      :amount_mutations_killed  ],
-            [:info,   'Alive:           %s',      :amount_mutations_alive   ],
-            [:info,   'Runtime:         %0.2fs',  :runtime                  ],
-            [:info,   'Killtime:        %0.2fs',  :killtime                 ],
-            [:info,   'Overhead:        %0.2f%%', :overhead_percent         ],
-            [:info,   'Mutations/s:     %0.2f',   :mutations_per_second     ],
-            [:status, 'Coverage:        %0.2f%%', :coverage_percent         ]
+            [:info,   'Results:         %s',      :amount_mutation_results],
+            [:info,   'Kills:           %s',      :amount_mutations_killed],
+            [:info,   'Alive:           %s',      :amount_mutations_alive ],
+            [:info,   'Runtime:         %0.2fs',  :runtime                ],
+            [:info,   'Killtime:        %0.2fs',  :killtime               ],
+            [:info,   'Overhead:        %0.2f%%', :overhead_percent       ],
+            [:info,   'Mutations/s:     %0.2f',   :mutations_per_second   ],
+            [:status, 'Coverage:        %0.2f%%', :coverage_percent       ]
           ])
 
           # Run printer
           #
           # @return [undefined]
           def run
-            visit(Config, env.config)
+            visit(Env, env)
             FORMATS.each do |report, format, value|
               __send__(report, format, __send__(value))
             end