mutant 0.14.2 → 0.15.1

data/lib/mutant/parallel/connection.rb

@@ -5,7 +5,8 @@ module Mutant
     class Connection
       include Anima.new(:marshal, :reader, :writer)
 
-      Error = Class.new(RuntimeError)
+      class Error < RuntimeError
+      end
 
       HEADER_FORMAT = 'N'
       HEADER_SIZE   = 4
@@ -21,13 +22,9 @@ module Mutant
 
         attr_reader :log
 
-        def error
-          Util.max_one(@errors)
-        end
+        def error = Util.max_one(@errors)
 
-        def result
-          Util.max_one(@results)
-        end
+        def result = Util.max_one(@results)
 
         def initialize(*)
           super
@@ -81,9 +78,7 @@ module Mutant
 
       private
 
-        def timeout
-          @errors << Timeout::Error
-        end
+        def timeout = @errors << Timeout::Error
 
         def advance_result
           if length
@@ -96,9 +91,7 @@ module Mutant
           end
         end
 
-        def length
-          Util.max_one(@lengths)
-        end
+        def length = Util.max_one(@lengths)
 
         def advance_log
           while with_nonblock_read(io: log_reader, max_bytes: MAX_LOG_CHUNK, &@log.public_method(:<<))
@@ -138,9 +131,7 @@ module Mutant
       class Frame
         include Anima.new(:io)
 
-        def receive_value
-          read(Util.one(read(HEADER_SIZE).unpack(HEADER_FORMAT)))
-        end
+        def receive_value = read(Util.one(read(HEADER_SIZE).unpack(HEADER_FORMAT)))
 
         def send_value(body)
           bytesize = body.bytesize
@@ -160,14 +151,9 @@ module Mutant
         end
       end
 
-      def receive_value
-        marshal.load(reader.receive_value)
-      end
+      def receive_value = marshal.load(reader.receive_value)
 
-      def send_value(value)
-        writer.send_value(marshal.dump(value))
-        self
-      end
+      def send_value(value) = tap { writer.send_value(marshal.dump(value)) }
 
       def self.from_pipes(marshal:, reader:, writer:)
         new(

data/lib/mutant/parallel/driver.rb

@@ -38,11 +38,7 @@ module Mutant
       # This will cause all work to be immediately stopped.
       #
       # @return [self]
-      def stop
-        @alive = false
-        threads.each(&:kill)
-        self
-      end
+      def stop = tap { @alive = false; threads.each(&:kill) }
 
     private
 

data/lib/mutant/parallel/source.rb

@@ -10,7 +10,8 @@ module Mutant
         include Adamantium, Anima.new(:index, :payload)
       end
 
-      NoJobError = Class.new(RuntimeError)
+      class NoJobError < RuntimeError
+      end
 
       # Next job
       #

data/lib/mutant/parallel/worker.rb

@@ -40,6 +40,10 @@ module Mutant
           world.stderr.reopen(log_writer)
           world.stdout.reopen(log_writer)
 
+          # Ensure output from background threads is immediately flushed
+          world.stderr.sync = true
+          world.stdout.sync = true
+
           run_child(
             config:,
             connection: Connection.from_pipes(marshal:, reader: request, writer: response),
@@ -77,9 +81,7 @@ module Mutant
       end
       private_class_method :run_child
 
-      def index
-        config.index
-      end
+      def index = config.index
 
       # Run worker loop
       #
@@ -116,21 +118,13 @@ module Mutant
       # rubocop:enable Metrics/AbcSize
       # rubocop:enable Metrics/MethodLength
 
-      def signal
-        process.kill('TERM', pid)
-        self
-      end
+      def signal = tap { process.kill('TERM', pid) }
 
-      def join
-        process.wait(pid)
-        self
-      end
+      def join = tap { process.wait(pid) }
 
     private
 
-      def process
-        config.world.process
-      end
+      def process = config.world.process
 
       def next_job
         config.var_source.with do |source|

data/lib/mutant/registry.rb

@@ -13,7 +13,8 @@ module Mutant
     end
 
     # Raised when the type is an invalid type
-    RegistryError = Class.new(TypeError)
+    class RegistryError < TypeError
+    end
 
     # Register class for AST node class
     #

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

@@ -44,9 +44,7 @@ module Mutant
         # Report delay in seconds
         #
         # @return [Float]
-        def delay
-          self.class::REPORT_DELAY
-        end
+        def delay = self.class::REPORT_DELAY
 
         # Output abstraction to decouple tty? from buffer
         class Output
@@ -118,17 +116,11 @@ module Mutant
 
         private
 
-          def new_buffer
-            StringIO.new
-          end
+          def new_buffer = StringIO.new
 
-          def status_progressive_printer
-            tty ? Printer::StatusProgressive::Tty : Printer::StatusProgressive::Pipe
-          end
+          def status_progressive_printer = tty ? Printer::StatusProgressive::Tty : Printer::StatusProgressive::Pipe
 
-          def test_status_progressive_printer
-            tty ? Printer::Test::StatusProgressive::Tty : Printer::Test::StatusProgressive::Pipe
-          end
+          def test_status_progressive_printer = tty ? Printer::Test::StatusProgressive::Tty : Printer::Test::StatusProgressive::Pipe
 
           # Wrap progress output with TTY-specific line handling
           #

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

@@ -8,10 +8,19 @@ module Mutant
         class EnvResult < self
           delegate(:failed_subject_results)
 
+          ALIVE_EXPLANATION = <<~'MESSAGE'
+            Alive mutations require one of two actions:
+            A) Keep the mutated code: Your tests specify the correct semantics,
+               and the original code is redundant. Accept the mutation.
+            B) Add a missing test: The original code is correct, but the tests
+               do not verify the behavior the mutation removed.
+          MESSAGE
+
           # Run printer
           #
           # @return [undefined]
           def run
+            puts(ALIVE_EXPLANATION) if failed_subject_results.any?
             visit_collection(SubjectResult, failed_subject_results)
             visit(EnvProgress, object)
           end

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

@@ -14,9 +14,7 @@ module Mutant
 
         private_class_method :new
 
-        def call
-          run
-        end
+        def call = run
 
         # Create delegators to object
         #
@@ -50,9 +48,7 @@ module Mutant
 
       private
 
-        def status_color
-          success? ? Unparser::Color::GREEN : Unparser::Color::RED
-        end
+        def status_color = success? ? Unparser::Color::GREEN : Unparser::Color::RED
 
         def visit_collection(printer, collection)
           collection.each do |object|

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

@@ -24,9 +24,7 @@ module Mutant
         # Render the progress bar string
         #
         # @return [String]
-        def render
-          "#{filled}#{empty}"
-        end
+        def render = "#{filled}#{empty}"
 
         # Calculate percentage completion
         #
@@ -62,17 +60,11 @@ module Mutant
           [((current.to_f / total) * width).round, width].min
         end
 
-        def empty_width
-          width - filled_width
-        end
+        def empty_width = width - filled_width
 
-        def filled
-          filled_char * filled_width
-        end
+        def filled = filled_char * filled_width
 
-        def empty
-          empty_char * empty_width
-        end
+        def empty = empty_char * empty_width
       end # ProgressBar
     end # CLI
   end # Reporter

data/lib/mutant/reporter/cli.rb

@@ -26,55 +26,38 @@ module Mutant
       # @param [Env] env
       #
       # @return [self]
-      def start(env)
-        write(format.start(env))
-        self
-      end
+      def start(env) = tap { write(format.start(env)) }
 
       # Report test start
       #
       # @param [Env] env
       #
       # @return [self]
-      def test_start(env)
-        write(format.test_start(env))
-        self
-      end
+      def test_start(env) = tap { write(format.test_start(env)) }
 
       # Report progress object
       #
       # @param [Parallel::Status] status
       #
       # @return [self]
-      def progress(status)
-        write(format.progress(status))
-        self
-      end
+      def progress(status) = tap { write(format.progress(status)) }
 
       # Report progress object
       #
       # @return [self]
-      def test_progress(status)
-        write(format.test_progress(status))
-        self
-      end
+      def test_progress(status) = tap { write(format.test_progress(status)) }
 
       # Report delay in seconds
       #
       # @return [Float]
-      def delay
-        format.delay
-      end
+      def delay = format.delay
 
       # Report warning
       #
       # @param [String] message
       #
       # @return [self]
-      def warn(message)
-        output.puts(message) if print_warnings
-        self
-      end
+      def warn(message) = tap { output.puts(message) if print_warnings }
 
       # Report env
       #

data/lib/mutant/reporter/sequence.rb

@@ -18,9 +18,7 @@ module Mutant
       # Minimum reporter delay
       #
       # @return [Float]
-      def delay
-        reporters.map(&:delay).min
-      end
+      def delay = reporters.map(&:delay).min
 
     end # Sequence
   end # Reporter

data/lib/mutant/repository/diff.rb

@@ -44,9 +44,7 @@ module Mutant
         touched_paths.from_right { |message| fail Error, message }.fetch(path, &)
       end
 
-      def touched_paths
-        repository_root.bind(&method(:diff_index))
-      end
+      def touched_paths = repository_root.bind(&method(:diff_index))
       memoize :touched_paths
 
       def diff_index(root)

data/lib/mutant/result.rb

@@ -81,9 +81,7 @@ module Mutant
       # Failed subject results
       #
       # @return [Array<Result::Subject>]
-      def failed_subject_results
-        subject_results.reject(&:success?)
-      end
+      def failed_subject_results = subject_results.reject(&:success?)
 
       sum :amount_mutation_results, :subject_results
       sum :amount_mutations_alive,  :subject_results
@@ -94,9 +92,7 @@ module Mutant
       # Amount of mutations
       #
       # @return [Integer]
-      def amount_mutations
-        env.mutations.length
-      end
+      def amount_mutations = env.mutations.length
 
       # Test if processing needs to stop
       #
@@ -126,34 +122,22 @@ module Mutant
       # Failed subject results
       #
       # @return [Array<Result::Test>]
-      def failed_test_results
-        test_results.reject(&:success?)
-      end
+      def failed_test_results = test_results.reject(&:success?)
       memoize :failed_test_results
 
       def stop?
         env.config.fail_fast && !test_results.all?(&:success?)
       end
 
-      def testtime
-        test_results.map(&:runtime).sum(0.0)
-      end
+      def testtime = test_results.map(&:runtime).sum(0.0)
 
-      def amount_tests
-        env.integration.all_tests.length
-      end
+      def amount_tests = env.integration.all_tests.length
 
-      def amount_test_results
-        test_results.length
-      end
+      def amount_test_results = test_results.length
 
-      def amount_tests_failed
-        failed_test_results.length
-      end
+      def amount_tests_failed = failed_test_results.length
 
-      def amount_tests_success
-        test_results.count(&:passed)
-      end
+      def amount_tests_success = test_results.count(&:passed)
     end # TestEnv
 
     # Test result
@@ -200,51 +184,37 @@ module Mutant
       # Alive mutations
       #
       # @return [Array<Result::Coverage>]
-      def uncovered_results
-        coverage_results.reject(&:success?)
-      end
+      def uncovered_results = coverage_results.reject(&:success?)
       memoize :uncovered_results
 
       # Amount of mutations
       #
       # @return [Integer]
-      def amount_mutation_results
-        coverage_results.length
-      end
+      def amount_mutation_results = coverage_results.length
 
       # Amount of mutations
       #
       # @return [Integer]
-      def amount_timeouts
-        coverage_results.count(&:timeout?)
-      end
+      def amount_timeouts = coverage_results.count(&:timeout?)
 
       # Amount of mutations
       #
       # @return [Integer]
-      def amount_mutations
-        subject.mutations.length
-      end
+      def amount_mutations = subject.mutations.length
 
       # Number of killed mutations
       #
       # @return [Integer]
-      def amount_mutations_killed
-        covered_results.length
-      end
+      def amount_mutations_killed = covered_results.length
 
       # Number of alive mutations
       #
       # @return [Integer]
-      def amount_mutations_alive
-        uncovered_results.length
-      end
+      def amount_mutations_alive = uncovered_results.length
 
     private
 
-      def covered_results
-        coverage_results.select(&:success?)
-      end
+      def covered_results = coverage_results.select(&:success?)
       memoize :covered_results
 
     end # Subject
@@ -303,9 +273,7 @@ module Mutant
       # Time the tests had been running
       #
       # @return [Float]
-      def killtime
-        isolation_result.value&.runtime || 0.0
-      end
+      def killtime = isolation_result.value&.runtime || 0.0
 
       # Test for timeout
       #

data/lib/mutant/scope.rb

@@ -21,9 +21,7 @@ module Mutant
     # Unqualified name of scope
     #
     # @return [String]
-    def unqualified_name
-      name_nesting.last
-    end
+    def unqualified_name = name_nesting.last
 
     # Match expressions for scope
     #
@@ -39,9 +37,7 @@ module Mutant
 
   private
 
-    def name_nesting
-      raw.name.split(NAMESPACE_DELIMITER)
-    end
+    def name_nesting = raw.name.split(NAMESPACE_DELIMITER)
     memoize :name_nesting
 
   end # Scope

data/lib/mutant/segment.rb

@@ -10,9 +10,7 @@ module Mutant
       :timestamp_start
     )
 
-    def elapsed
-      timestamp_end - timestamp_start
-    end
+    def elapsed = timestamp_end - timestamp_start
 
     def offset_start(recording_start)
       timestamp_start - recording_start

data/lib/mutant/subject/method/instance.rb

@@ -12,15 +12,9 @@ module Mutant
         # Prepare subject for mutation insertion
         #
         # @return [self]
-        def prepare
-          scope.raw.undef_method(name)
-          self
-        end
-
-        def post_insert
-          scope.raw.__send__(visibility, name)
-          self
-        end
+        def prepare = tap { scope.raw.undef_method(name) }
+
+        def post_insert = tap { scope.raw.__send__(visibility, name) }
 
         # Mutator for memoizable memoized instance methods
         class Memoized < self

data/lib/mutant/subject/method/metaclass.rb

@@ -14,10 +14,7 @@ module Mutant
         # Prepare subject for mutation insertion
         #
         # @return [self]
-        def prepare
-          scope.raw.singleton_class.undef_method(name)
-          self
-        end
+        def prepare = tap { scope.raw.singleton_class.undef_method(name) }
 
       private
 

data/lib/mutant/subject/method/singleton.rb

@@ -12,15 +12,9 @@ module Mutant
         # Prepare subject for mutation insertion
         #
         # @return [self]
-        def prepare
-          scope.raw.singleton_class.undef_method(name)
-          self
-        end
+        def prepare = tap { scope.raw.singleton_class.undef_method(name) }
 
-        def post_insert
-          scope.raw.singleton_class.__send__(visibility, name)
-          self
-        end
+        def post_insert = tap { scope.raw.singleton_class.__send__(visibility, name) }
 
       end # Singleton
     end # Method

data/lib/mutant/subject/method.rb

@@ -9,9 +9,7 @@ module Mutant
       # Method name
       #
       # @return [Expression]
-      def name
-        node.children.fetch(self.class::NAME_INDEX)
-      end
+      def name = node.children.fetch(self.class::NAME_INDEX)
 
       # Match expression
       #
@@ -28,16 +26,12 @@ module Mutant
       # Match expressions
       #
       # @return [Array<Expression>]
-      def match_expressions
-        [expression].concat(context.match_expressions)
-      end
+      def match_expressions = [expression].concat(context.match_expressions)
       memoize :match_expressions
 
     private
 
-      def scope
-        context.scope
-      end
+      def scope = context.scope
 
     end # Method
   end # Subject

data/lib/mutant/subject.rb

@@ -37,23 +37,17 @@ module Mutant
     # Source path
     #
     # @return [Pathname]
-    def source_path
-      context.source_path
-    end
+    def source_path = context.source_path
 
     # Prepare subject for insertion of mutation
     #
     # @return [self]
-    def prepare
-      self
-    end
+    def prepare = self
 
     # Perform post insert cleanup
     #
     # @return [self]
-    def post_insert
-      self
-    end
+    def post_insert = self
 
     # Source line range
     #
@@ -67,24 +61,18 @@ module Mutant
     # First source line
     #
     # @return [Integer]
-    def source_line
-      source_lines.begin
-    end
+    def source_line = source_lines.begin
 
     # Identification string
     #
     # @return [String]
-    def identification
-      "#{expression.syntax}:#{source_path}:#{source_line}"
-    end
+    def identification = "#{expression.syntax}:#{source_path}:#{source_line}"
     memoize :identification
 
     # Source representation of AST
     #
     # @return [String]
-    def source
-      Unparser.unparse(wrap_node(node))
-    end
+    def source = Unparser.unparse(wrap_node(node))
     memoize :source
 
     # Match expression

data/lib/mutant/timer.rb

@@ -48,16 +48,12 @@ module Mutant
       # Capture a deadline status
       #
       # @return [Status]
-      def status
-        Status.new(time_left:)
-      end
+      def status = Status.new(time_left:)
 
       # Probe the time left
       #
       # @return [Float, nil]
-      def time_left
-        allowed_time - (timer.now - @start_at)
-      end
+      def time_left = allowed_time - (timer.now - @start_at)
 
       # Deadline that never expires
       class None < self