mutant 0.8.24 → 0.9.0

data/lib/mutant/env.rb

@@ -4,20 +4,39 @@ module Mutant
   # Abstract base class for mutant environments
   class Env
     include Adamantium::Flat, Anima.new(
-      :actor_env,
       :config,
       :integration,
       :matchable_scopes,
       :mutations,
       :parser,
       :selector,
-      :subjects
+      :subjects,
+      :world
     )
 
     SEMANTICS_MESSAGE =
       "Fix your lib to follow normal ruby semantics!\n" \
       '{Module,Class}#name should return resolvable constant name as String or nil'
 
+    # Construct minimal empty env
+    #
+    # @param [World] world
+    # @param [Config] config
+    #
+    # @return [Env]
+    def self.empty(world, config)
+      new(
+        config:           config,
+        integration:      Integration::Null.new(config),
+        matchable_scopes: EMPTY_ARRAY,
+        mutations:        EMPTY_ARRAY,
+        parser:           Parser.new,
+        selector:         Selector::Null.new,
+        subjects:         EMPTY_ARRAY,
+        world:            world
+      )
+    end
+
     # Kill mutation
     #
     # @param [Mutation] mutation
@@ -26,8 +45,10 @@ module Mutant
     def kill(mutation)
       start = Timer.now
 
+      tests = selections.fetch(mutation.subject)
+
       Result::Mutation.new(
-        isolation_result: run_mutation_tests(mutation),
+        isolation_result: run_mutation_tests(mutation, tests),
         mutation:         mutation,
         runtime:          Timer.now - start
       )
@@ -43,18 +64,83 @@ module Mutant
     end
     memoize :selections
 
+    # Emit warning
+    #
+    # @param [String] warning
+    #
+    # @return [self]
+    def warn(message)
+      config.reporter.warn(message)
+      self
+    end
+
+    # Selected tests
+    #
+    # @return [Set<Test>]
+    def selected_tests
+      selections.values.flatten.to_set
+    end
+    memoize :selected_tests
+
+    # Amount of mutations
+    #
+    # @return [Integer]
+    def amount_mutations
+      mutations.length
+    end
+    memoize :amount_mutations
+
+    # Amount of tests reachable by integration
+    #
+    # @return [Integer]
+    def amount_total_tests
+      integration.all_tests.length
+    end
+    memoize :amount_total_tests
+
+    # Amount of selected subjects
+    #
+    # @return [Integer]
+    def amount_subjects
+      subjects.length
+    end
+    memoize :amount_subjects
+
+    # Amount of selected tests
+    #
+    # @return [Integer]
+    def amount_selected_tests
+      selected_tests.length
+    end
+    memoize :amount_selected_tests
+
+    # Ratio between selected tests and subjects
+    #
+    # @return [Rational]
+    def test_subject_ratio
+      return Rational(0) if amount_subjects.zero?
+
+      Rational(amount_selected_tests, amount_subjects)
+    end
+    memoize :test_subject_ratio
+
   private
 
     # Kill mutation under isolation with integration
     #
-    # @param [Isolation] isolation
-    # @param [Integration] integration
+    # @param [Mutation] mutation
+    # @param [Array<Test>] test
     #
     # @return [Result::Isolation]
-    def run_mutation_tests(mutation)
+    def run_mutation_tests(mutation, tests)
       config.isolation.call do
-        mutation.insert(config.kernel)
-        integration.call(selections.fetch(mutation.subject))
+        result = mutation.insert(world.kernel)
+
+        if result.equal?(Loader::Result::VoidValue.instance)
+          Result::Test::VoidValue.instance
+        else
+          integration.call(tests)
+        end
       end
     end
 

data/lib/mutant/expression.rb

@@ -12,6 +12,11 @@ module Mutant
 
     private_constant(*constants(false))
 
+    # Syntax of expression
+    #
+    # @return [Matcher]
+    abstract_method :matcher
+
     # Syntax of expression
     #
     # @return [String]
@@ -23,7 +28,7 @@ module Mutant
     #
     # @return [Integer]
     def match_length(other)
-      if eql?(other)
+      if syntax.eql?(other.syntax)
         syntax.length
       else
         0

data/lib/mutant/expression/parser.rb

@@ -5,45 +5,24 @@ module Mutant
     class Parser
       include Concord.new(:types)
 
-      class ParserError < RuntimeError
-        include AbstractType
-      end # ParserError
-
-      # Error raised on invalid expressions
-      class InvalidExpressionError < ParserError; end
-
-      # Error raised on ambiguous expressions
-      class AmbiguousExpressionError < ParserError; end
-
-      # Parse input into expression or raise
-      #
-      # @param [String] syntax
-      #
-      # @return [Expression]
-      #   if expression is valid
-      #
-      # @raise [ParserError]
-      #   otherwise
-      def call(input)
-        try_parse(input) or fail InvalidExpressionError, "Expression: #{input.inspect} is not valid"
-      end
-
-      # Try to parse input into expression
+      # Apply expression parsing
       #
       # @param [String] input
       #
-      # @return [Expression]
+      # @return [Either<String, Expression>]
       #   if expression is valid
       #
       # @return [nil]
       #   otherwise
-      def try_parse(input)
+      def apply(input)
         expressions = expressions(input)
         case expressions.length
-        when 0, 1
-          expressions.first
+        when 0
+          Either::Left.new("Expression: #{input.inspect} is invalid")
+        when 1
+          Either::Right.new(expressions.first)
         else
-          fail AmbiguousExpressionError, "Ambiguous expression: #{input.inspect}"
+          Either::Left.new("Expression: #{input.inspect} is ambiguous")
         end
       end
 
@@ -57,8 +36,7 @@ module Mutant
       #   if expressions can be parsed from input
       def expressions(input)
         types.each_with_object([]) do |type, aggregate|
-          expression = type.try_parse(input)
-          aggregate << expression if expression
+          expression = type.try_parse(input) and aggregate << expression
         end
       end
 

data/lib/mutant/integration.rb

@@ -6,22 +6,76 @@ module Mutant
   class Integration
     include AbstractType, Adamantium::Flat, Concord.new(:config)
 
+    LOAD_MESSAGE = <<~'MESSAGE'
+      Unable to load integration mutant-%<integration_name>s:
+      %<exception>s
+      You may have to install the gem mutant-%<integration_name>s!
+    MESSAGE
+
+    CONST_MESSAGE = <<~'MESSAGE'
+      Unable to load integration mutant-%<integration_name>s:
+      %<exception>s
+      This is a bug in the integration you have to report.
+      The integration is supposed to define %<constant_name>s!
+    MESSAGE
+
+    private_constant(*constants(false))
+
     # Setup integration
     #
-    # Integrations are supposed to define a constant under
-    # Mutant::Integration named after the capitalized +name+
-    # parameter.
+    # @param env [Bootstrap]
+    #
+    # @return [Either<String, Integration>]
+    def self.setup(env)
+      attempt_require(env)
+        .apply { attempt_const_get(env) }
+        .fmap { |klass| klass.new(env.config).setup }
+    end
+
+    # Attempt to require integration
+    #
+    # @param env [Bootstrap]
+    #
+    # @return [Either<String, undefined>]
+    #
+    # @api private
+    #
+    # rubocop:disable Style/MultilineBlockChain
+    def self.attempt_require(env)
+      integration_name = env.config.integration
+
+      Either.wrap_error(LoadError) do
+        env.world.kernel.require("mutant/integration/#{integration_name}")
+      end.lmap do |exception|
+        LOAD_MESSAGE % {
+          exception:        exception.inspect,
+          integration_name: integration_name
+        }
+      end
+    end
+    private_class_method :attempt_require
+    # rubocop:enable Style/MultilineBlockChain
+
+    # Attempt const get
     #
-    # This avoids having to maintain a mutable registry.
+    # @param env [Boostrap]
     #
-    # @param kernel [Kernel]
-    # @param name [String]
+    # @return [Either<String, Class<Integration>>]
     #
-    # @return [Class<Integration>]
-    def self.setup(kernel, name)
-      kernel.require("mutant/integration/#{name}")
-      const_get(name.capitalize)
+    # @api private
+    def self.attempt_const_get(env)
+      integration_name = env.config.integration
+      constant_name    = integration_name.capitalize
+
+      Either.wrap_error(NameError) { const_get(constant_name) }.lmap do |exception|
+        CONST_MESSAGE % {
+          constant_name:    "#{self}::#{constant_name}",
+          exception:        exception.inspect,
+          integration_name: integration_name
+        }
+      end
     end
+    private_class_method :attempt_const_get
 
     # Perform integration setup
     #
@@ -50,31 +104,5 @@ module Mutant
     def expression_parser
       config.expression_parser
     end
-
-    # Null integration that never kills a mutation
-    class Null < self
-
-      # Available tests for integration
-      #
-      # @return [Enumerable<Test>]
-      def all_tests
-        EMPTY_ARRAY
-      end
-
-      # Run a collection of tests
-      #
-      # @param [Enumerable<Mutant::Test>] tests
-      #
-      # @return [Result::Test]
-      def call(tests)
-        Result::Test.new(
-          output:  '',
-          passed:  true,
-          runtime: 0.0,
-          tests:   tests
-        )
-      end
-
-    end # Null
   end # Integration
 end # Mutant

data/lib/mutant/isolation.rb

@@ -9,6 +9,10 @@ module Mutant
     class Result
       include AbstractType, Adamantium
 
+      NULL_LOG = ''
+
+      private_constant(*constants(false))
+
       abstract_method :error
       abstract_method :next
       abstract_method :value
@@ -22,6 +26,13 @@ module Mutant
         ErrorChain.new(error, self)
       end
 
+      # The log captured from integration
+      #
+      # @return [String]
+      def log
+        NULL_LOG
+      end
+
       # Test for success
       #
       # @return [Boolean]
@@ -31,7 +42,11 @@ module Mutant
 
       # Succesful result producing value
       class Success < self
-        include Concord::Public.new(:value)
+        include Concord::Public.new(:value, :log)
+
+        def self.new(_value, _log = '')
+          super
+        end
       end # Success
 
       # Unsuccessful result by unexpected exception

data/lib/mutant/isolation/fork.rb

@@ -4,16 +4,15 @@ module Mutant
   class Isolation
     # Isolation via the fork(2) systemcall.
     class Fork < self
-      include(
-        Adamantium::Flat,
-        Anima.new(:devnull, :io, :marshal, :process, :stderr, :stdout)
-      )
+      include(Adamantium::Flat, Concord.new(:world))
 
-      ATTRIBUTES = (anima.attribute_names + %i[block reader writer]).freeze
+      READ_SIZE = 4096
+
+      ATTRIBUTES = %i[block log_pipe result_pipe world].freeze
 
       # Unsucessful result as child exited nonzero
       class ChildError < Result
-        include Concord::Public.new(:value)
+        include Concord::Public.new(:value, :log)
       end # ChildError
 
       # Unsucessful result as fork failed
@@ -21,6 +20,36 @@ module Mutant
         include Equalizer.new
       end # ForkError
 
+      # 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
+
+        # Child writer end of the pipe
+        #
+        # @return [IO]
+        def child
+          reader.close
+          writer
+        end
+
+        # Parent reader end of the pipe
+        #
+        # @return [IO]
+        def parent
+          writer.close
+          reader
+        end
+      end # Pipe
+
       # ignore :reek:InstanceVariableAssumption
       class Parent
         include(
@@ -33,9 +62,6 @@ module Mutant
 
         # Parent process
         #
-        # @param [IO] reader
-        # @param [IO] writer
-        #
         # @return [Result]
         def call
           pid = start_child or return ForkError.new
@@ -51,7 +77,14 @@ module Mutant
         #
         # @return [Integer]
         def start_child
-          process.fork { Child.call(to_h) }
+          world.process.fork do
+            Child.call(
+              to_h.merge(
+                log_pipe:    log_pipe.child,
+                result_pipe: result_pipe.child
+              )
+            )
+          end
         end
 
         # Read child result
@@ -59,14 +92,46 @@ module Mutant
         # @param [Integer] pid
         #
         # @return [undefined]
+        #
+        # rubocop:disable Metrics/MethodLength
         def read_child_result(pid)
-          writer.close
-
-          add_result(Result::Success.new(marshal.load(reader)))
-        rescue ArgumentError, EOFError => exception
-          add_result(Result::Exception.new(exception))
+          result_fragments = []
+          log_fragments    = []
+
+          read_fragments(
+            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))
+          else
+            add_result(Result::Success.new(result, log_fragments.join))
+          end
         ensure
-          wait_child(pid)
+          wait_child(pid, log_fragments)
+        end
+        # rubocop:enable Metrics/MethodLength
+
+        # Read fragments
+        #
+        # @param [Hash{FD => Array<String}] targets
+        #
+        # @return [undefined]
+        def read_fragments(targets)
+          until targets.empty?
+            ready, = world.io.select(targets.keys)
+
+            ready.each do |fd|
+              if fd.eof?
+                targets.delete(fd)
+              else
+                targets.fetch(fd) << fd.read_nonblock(READ_SIZE)
+              end
+            end
+          end
         end
 
         # Wait for child process
@@ -74,10 +139,12 @@ module Mutant
         # @param [Integer] pid
         #
         # @return [undefined]
-        def wait_child(pid)
-          _pid, status = process.wait2(pid)
+        def wait_child(pid, log_fragments)
+          _pid, status = world.process.wait2(pid)
 
-          add_result(ChildError.new(status)) unless status.success?
+          unless status.success? # rubocop:disable Style/GuardClause
+            add_result(ChildError.new(status, log_fragments.join))
+          end
         end
 
         # Add a result
@@ -97,29 +164,14 @@ module Mutant
 
         # Handle child process
         #
-        # @param [IO] reader
-        # @param [IO] writer
-        #
         # @return [undefined]
         def call
-          reader.close
-          writer.binmode
-          writer.syswrite(marshal.dump(result(&block)))
-          writer.close
+          world.stderr.reopen(log_pipe)
+          world.stdout.reopen(log_pipe)
+          result_pipe.syswrite(world.marshal.dump(block.call))
+          result_pipe.close
         end
 
-      private
-
-        # The block result computed under silencing
-        #
-        # @return [Object]
-        def result
-          devnull.call do |null|
-            stderr.reopen(null)
-            stdout.reopen(null)
-            yield
-          end
-        end
       end # Child
 
       private_constant(*(constants(false) - %i[ChildError ForkError]))
@@ -128,11 +180,24 @@ module Mutant
       #
       # @return [Result]
       #   execution result
+      #
+      # ignore :reek:NestedIterators
+      #
+      # rubocop:disable Metrics/MethodLength
       def call(&block)
-        io.pipe(binmode: true) do |(reader, writer)|
-          Parent.call(to_h.merge(block: block, reader: reader, writer: writer))
+        io = world.io
+        Pipe.with(io) do |result|
+          Pipe.with(io) do |log|
+            Parent.call(
+              block:       block,
+              log_pipe:    log,
+              result_pipe: result,
+              world:       world
+            )
+          end
         end
       end
+      # rubocop:enable Metrics/MethodLength
     end # Fork
   end # Isolation
 end # Mutant