mutant 0.10.1 → 0.10.8

data/lib/mutant/integration.rb

@@ -4,7 +4,7 @@ module Mutant
 
   # Abstract base class mutant test framework integrations
   class Integration
-    include AbstractType, Adamantium::Flat, Concord.new(:config)
+    include AbstractType, Adamantium::Flat, Anima.new(:expression_parser, :timer)
 
     LOAD_MESSAGE = <<~'MESSAGE'
       Unable to load integration mutant-%<integration_name>s:
@@ -27,9 +27,12 @@ module Mutant
     #
     # @return [Either<String, Integration>]
     def self.setup(env)
-      attempt_require(env)
-        .bind { attempt_const_get(env) }
-        .fmap { |klass| klass.new(env.config).setup }
+      attempt_require(env).bind { attempt_const_get(env) }.fmap do |klass|
+        klass.new(
+          expression_parser: env.config.expression_parser,
+          timer:             env.world.timer
+        ).setup
+      end
     end
 
     # rubocop:disable Style/MultilineBlockChain
@@ -80,11 +83,5 @@ module Mutant
     #
     # @return [Enumerable<Test>]
     abstract_method :all_tests
-
-  private
-
-    def expression_parser
-      config.expression_parser
-    end
   end # Integration
 end # Mutant

data/lib/mutant/integration/null.rb

@@ -18,7 +18,6 @@ module Mutant
       # @return [Result::Test]
       def call(tests)
         Result::Test.new(
-          output:  '',
           passed:  true,
           runtime: 0.0,
           tests:   tests

data/lib/mutant/isolation.rb

@@ -7,57 +7,20 @@ module Mutant
 
     # Isolated computation result
     class Result
-      include AbstractType, Adamantium
-
-      NULL_LOG = ''
-
-      private_constant(*constants(false))
-
-      abstract_method :error
-      abstract_method :next
-      abstract_method :value
-
-      # Add error on top of current result
-      #
-      # @param [Result] error
-      #
-      # @return [Result]
-      def add_error(error)
-        ErrorChain.new(error, self)
-      end
-
-      # The log captured from integration
-      #
-      # @return [String]
-      def log
-        NULL_LOG
-      end
-
-      # Test for success
+      include Anima.new(
+        :exception,
+        :log,
+        :process_status,
+        :timeout,
+        :value
+      )
+
+      # Test for successful result
       #
       # @return [Boolean]
-      def success?
-        instance_of?(Success)
+      def valid_value?
+        timeout.nil? && exception.nil? && (process_status.nil? || process_status.success?)
       end
-
-      # Successful result producing value
-      class Success < self
-        include Concord::Public.new(:value, :log)
-
-        def self.new(_value, _log = '')
-          super
-        end
-      end # Success
-
-      # Unsuccessful result by unexpected exception
-      class Exception < self
-        include Concord::Public.new(:value)
-      end # Error
-
-      # Result when there where many results
-      class ErrorChain < Result
-        include Concord::Public.new(:value, :next)
-      end # ChainError
     end # Result
 
     # Call block in isolation

data/lib/mutant/isolation/fork.rb

@@ -3,22 +3,36 @@
 module Mutant
   class Isolation
     # Isolation via the fork(2) systemcall.
+    #
+    # Communication between parent and child process is done
+    # via anonymous pipes.
+    #
+    # Timeouts are initially handled relatively efficiently via IO.select
+    # but once the child process pipes are on eof via busy looping on
+    # waitpid2 with Process::WNOHANG set.
+    #
+    # Handling timeouts this way is not the conceptually most
+    # efficient solution. But its cross platform.
+    #
+    # Design constraints:
+    #
+    # * Support Linux
+    # * Support MacOSX
+    # * Avoid platform specific APIs and code.
+    # * Only use ruby corelib.
+    # * Do not use any named resource.
+    # * Never block on latency inducing systemcall without a
+    #   timeout.
+    # * Child process freezing before closing the pipes needs to
+    #   be detected by parent process.
+    # * Child process freezing after closing the pipes needs to be
+    #   detected by parent process.
     class Fork < self
       include(Adamantium::Flat, Concord.new(:world))
 
       READ_SIZE = 4096
 
-      ATTRIBUTES = %i[block log_pipe result_pipe world].freeze
-
-      # Unsuccessful result as child exited nonzero
-      class ChildError < Result
-        include Concord::Public.new(:value, :log)
-      end # ChildError
-
-      # Unsuccessful result as fork failed
-      class ForkError < Result
-        include Equalizer.new
-      end # ForkError
+      ATTRIBUTES = %i[block deadline log_pipe result_pipe world].freeze
 
       # Pipe abstraction
       class Pipe
@@ -50,7 +64,6 @@ module Mutant
         end
       end # Pipe
 
-      # ignore :reek:InstanceVariableAssumption
       class Parent
         include(
           Anima.new(*ATTRIBUTES),
@@ -64,15 +77,28 @@ module Mutant
         #
         # @return [Result]
         def call
-          pid = start_child or return ForkError.new
-
-          read_child_result(pid)
-
-          @result
+          @exception     = nil
+          @log_fragments = []
+          @timeout       = nil
+          @value         = nil
+          @pid           = start_child
+
+          read_child_result
+          result
         end
 
       private
 
+        def result
+          Result.new(
+            exception:      @exception,
+            log:            @log_fragments.join,
+            process_status: @process_status,
+            timeout:        @timeout,
+            value:          @value
+          )
+        end
+
         def start_child
           world.process.fork do
             Child.call(
@@ -85,30 +111,43 @@ module Mutant
         end
 
         # rubocop:disable Metrics/MethodLength
-        def read_child_result(pid)
+        def read_child_result
           result_fragments = []
-          log_fragments    = []
 
-          read_fragments(
-            log_pipe.parent    => log_fragments,
-            result_pipe.parent => result_fragments
-          )
+          targets =
+            {
+              log_pipe.parent    => @log_fragments,
+              result_pipe.parent => result_fragments
+            }
 
-          begin
-            result = world.marshal.load(result_fragments.join)
-          rescue ArgumentError => exception
-            add_result(Result::Exception.new(exception))
+          read_targets(targets)
+
+          if targets.empty?
+            load_result(result_fragments)
+            terminate_graceful
           else
-            add_result(Result::Success.new(result, log_fragments.join))
+            @timeout = deadline.allowed_time
+            terminate_ungraceful
           end
-        ensure
-          wait_child(pid, log_fragments)
         end
         # rubocop:enable Metrics/MethodLength
 
-        def read_fragments(targets)
+        def load_result(result_fragments)
+          @value = world.marshal.load(result_fragments.join)
+        rescue ArgumentError => exception
+          @exception = exception
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def read_targets(targets)
           until targets.empty?
-            ready, = world.io.select(targets.keys)
+            status = deadline.status
+
+            break unless status.ok?
+
+            ready, = world.io.select(targets.keys, [], [], status.time_left)
+
+            break unless ready
 
             ready.each do |fd|
               if fd.eof?
@@ -119,14 +158,42 @@ module Mutant
             end
           end
         end
+        # rubocop:enable Metrics/MethodLength
 
-        def wait_child(pid, log_fragments)
-          _pid, status = world.process.wait2(pid)
+        # rubocop:disable Metrics/MethodLength
+        def terminate_graceful
+          status = nil
+
+          loop do
+            status = peek_child
+            break if status || deadline.expired?
+            world.kernel.sleep(0.1)
+          end
 
-          unless status.success? # rubocop:disable Style/GuardClause
-            add_result(ChildError.new(status, log_fragments.join))
+          if status
+            handle_status(status)
+          else
+            terminate_ungraceful
           end
         end
+        # rubocop:enable Metrics/MethodLength
+
+        def terminate_ungraceful
+          world.process.kill('KILL', @pid)
+
+          _pid, status = world.process.wait2(@pid)
+
+          handle_status(status)
+        end
+
+        def handle_status(status)
+          @process_status = status
+        end
+
+        def peek_child
+          _pid, status = world.process.wait2(@pid, Process::WNOHANG)
+          status
+        end
 
         def add_result(result)
           @result = defined?(@result) ? @result.add_error(result) : result
@@ -157,17 +224,16 @@ module Mutant
       # Call block in isolation
       #
       # @return [Result]
-      #   execution result
-      #
-      # ignore :reek:NestedIterators
       #
       # rubocop:disable Metrics/MethodLength
-      def call(&block)
+      def call(timeout, &block)
+        deadline = world.deadline(timeout)
         io = world.io
         Pipe.with(io) do |result|
           Pipe.with(io) do |log|
             Parent.call(
               block:       block,
+              deadline:    deadline,
               log_pipe:    log,
               result_pipe: result,
               world:       world
@@ -176,6 +242,7 @@ module Mutant
         end
       end
       # rubocop:enable Metrics/MethodLength
+
     end # Fork
   end # Isolation
 end # Mutant

data/lib/mutant/isolation/none.rb

@@ -12,12 +12,25 @@ module Mutant
       #
       # @return [Result]
       #
-      # ignore :reek:UtilityFunction
-      def call
-        Result::Success.new(yield)
-      rescue => exception
-        Result::Exception.new(exception)
+      # rubocop:disable Lint/SuppressedException
+      # rubocop:disable Metrics/MethodLength
+      # ^^ it actually isn not suppressed, it assigns an lvar
+      def call(_timeout)
+        begin
+          value = yield
+        rescue => exception
+        end
+
+        Result.new(
+          exception:      exception,
+          log:            '',
+          process_status: nil,
+          timeout:        nil,
+          value:          value
+        )
       end
+      # rubocop:enable Lint/SuppressedException
+      # rubocop:enable Metrics/MethodLength
 
     end # None
   end # Isolation

data/lib/mutant/license/subscription.rb

@@ -38,7 +38,7 @@ module Mutant
       # @return [String]
       def description
         FORMAT % {
-          licensed:          licensed.join("\n"),
+          licensed:          licensed.to_a.join("\n"),
           subscription_name: subscription_name
         }
       end

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

@@ -12,7 +12,7 @@ module Mutant
         end
 
         def self.from_json(value)
-          new(value.fetch('authors').map(&Author.method(:new)).to_set)
+          new(value.fetch('authors').map(&Author.public_method(:new)).to_set)
         end
 
         def apply(world)
@@ -39,12 +39,11 @@ module Mutant
           capture(world, %w[git show --quiet --pretty=format:%ae])
         end
 
-        # ignore :reek:UtilityFunction
         def capture(world, command)
           world
             .capture_stdout(command)
             .fmap(&:chomp)
-            .fmap(&Author.method(:new))
+            .fmap(&Author.public_method(:new))
             .fmap { |value| Set.new([value]) }
             .from_right { Set.new }
         end

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

@@ -46,6 +46,7 @@ module Mutant
             value
               .fetch('repositories')
               .map(&Repository.public_method(:parse))
+              .to_set
           )
         end
 
@@ -59,14 +60,13 @@ module Mutant
       private
 
         def check_subscription(actual)
-          if (licensed.to_set & actual).any?
+          if (licensed & actual).any?
             success
           else
             failure(licensed, actual)
           end
         end
 
-        # ignore :reek:UtilityFunction
         def parse_remotes(input)
           input.lines.map(&Repository.method(:parse_remote)).to_set
         end

data/lib/mutant/matcher/config.rb

@@ -44,6 +44,19 @@ module Mutant
         with(attribute => public_send(attribute) + [value])
       end
 
+      # Merge with other config
+      #
+      # @param [Config] other
+      #
+      # @return [Config]
+      def merge(other)
+        self.class.new(
+          to_h
+            .map { |name, value| [name, value + other.public_send(name)] }
+            .to_h
+        )
+      end
+
     private
 
       def present_attributes

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

@@ -12,8 +12,6 @@ module Mutant
         # @param [UnboundMethod] method
         #
         # @return [Matcher::Method::Instance]
-        #
-        # :reek:ManualDispatch
         def self.new(scope, target_method)
           name = target_method.name
           evaluator =