Merge pull request #891 from mbj/add/mutant-world

Add Mutant::World

Author: mbj

bin/mutant

@@ -37,4 +37,10 @@ namespace =
     Mutant
   end
 
-Kernel.exit(namespace::CLI.run(namespace::Config::DEFAULT, ARGV))
+Kernel.exit(
+  namespace::CLI.run(
+    namespace::WORLD,
+    namespace::Config::DEFAULT,
+    ARGV
+  )
+)

lib/mutant.rb

@@ -191,39 +191,39 @@ def self.ci?
 require 'mutant/zombifier'
 
 module Mutant
+  WORLD = World.new(
+    condition_variable: ConditionVariable,
+    io:                 IO,
+    kernel:             Kernel,
+    load_path:          $LOAD_PATH,
+    marshal:            Marshal,
+    mutex:              Mutex,
+    open3:              Open3,
+    pathname:           Pathname,
+    process:            Process,
+    stderr:             STDOUT,
+    stdout:             STDOUT,
+    thread:             Thread
+  )
+
   # Reopen class to initialize constant to avoid dep circle
   class Config
     DEFAULT = new(
-      condition_variable: ConditionVariable,
-      expression_parser:  Expression::Parser.new([
+      expression_parser: Expression::Parser.new([
         Expression::Method,
         Expression::Methods,
         Expression::Namespace::Exact,
         Expression::Namespace::Recursive
       ]),
-      fail_fast:          false,
-      includes:           EMPTY_ARRAY,
-      integration:        Integration::Null,
-      isolation:          Mutant::Isolation::Fork.new(
-        io:      IO,
-        marshal: Marshal,
-        process: Process,
-        stderr:  STDOUT,
-        stdout:  STDOUT
-      ),
-      jobs:               Etc.nprocessors,
-      kernel:             Kernel,
-      load_path:          $LOAD_PATH,
-      matcher:            Matcher::Config::DEFAULT,
-      mutex:              Mutex,
-      open3:              Open3,
-      pathname:           Pathname,
-      reporter:           Reporter::CLI.build(STDOUT),
-      requires:           EMPTY_ARRAY,
-      stderr:             STDERR,
-      stdout:             STDOUT,
-      thread:             Thread,
-      zombie:             false
+      fail_fast:         false,
+      includes:          EMPTY_ARRAY,
+      integration:       Integration::Null,
+      isolation:         Mutant::Isolation::Fork.new(WORLD),
+      jobs:              Etc.nprocessors,
+      matcher:           Matcher::Config::DEFAULT,
+      reporter:          Reporter::CLI.build(WORLD.stdout),
+      requires:          EMPTY_ARRAY,
+      zombie:            false
     )
   end # Config
 end # Mutant

lib/mutant/cli.rb

@@ -5,7 +5,7 @@ module Mutant
   #
   # rubocop:disable Metrics/ClassLength
   class CLI
-    include Concord.new(:config)
+    include Concord.new(:world, :config)
 
     private_class_method :new
 
@@ -21,6 +21,9 @@ class CLI
 
     # Run cli with arguments
     #
+    # @param [World] world
+    #   the outside world
+    #
     # @param [Config] config
     #   the default config
     #
@@ -30,24 +33,29 @@ class CLI
     # @return [Boolean]
     #
     # rubocop:disable Style/Semicolon
-    def self.run(config, arguments)
-      apply(config, arguments)
-        .fmap(&Env::Bootstrap.method(:call))
+    #
+    # ignore :reek:LongParameterList
+    def self.run(world, config, arguments)
+      apply(world, config, arguments)
+        .fmap { |cli_config| Env::Bootstrap.call(world, cli_config) }
         .fmap(&Runner.method(:call))
-        .from_right { |error| config.stderr.puts(error); return false }
+        .from_right { |error| world.stderr.puts(error); return false }
         .success?
     end
     # rubocop:enable Style/Semicolon
 
     # Parse arguments into config
     #
+    # @param [World] world
     # @param [Config] config
     # @param [Array<String>] arguments
     #
     # @return [Either<OptionParser::ParseError, Config>]
-    def self.apply(config, arguments)
+    #
+    # ignore :reek:LongParameterList
+    def self.apply(world, config, arguments)
       Either
-        .wrap_error(OptionParser::ParseError) { new(config).parse(arguments) }
+        .wrap_error(OptionParser::ParseError) { new(world, config).parse(arguments) }
         .lmap(&:message)
     end
 
@@ -119,7 +127,7 @@ def add_environment_options(opts)
     #
     # @return [undefined]
     def setup_integration(name)
-      with(integration: Integration.setup(config.kernel, name))
+      with(integration: Integration.setup(world.kernel, name))
     rescue LoadError
       raise(
         OptionParser::InvalidArgument,
@@ -153,9 +161,9 @@ def add_filter_options(opts)
           :subject_filters,
           Repository::SubjectFilter.new(
             Repository::Diff.new(
-              config: config,
-              from:   Repository::Diff::HEAD,
-              to:     revision
+              from:  Repository::Diff::HEAD,
+              to:    revision,
+              world: world
             )
           )
         )
@@ -172,12 +180,12 @@ def add_debug_options(opts)
         with(fail_fast: true)
       end
       opts.on('--version', 'Print mutants version') do
-        config.stdout.puts("mutant-#{VERSION}")
-        config.kernel.exit
+        world.stdout.puts("mutant-#{VERSION}")
+        world.kernel.exit
       end
       opts.on_tail('-h', '--help', 'Show this message') do
-        config.stdout.puts(opts.to_s)
-        config.kernel.exit
+        world.stdout.puts(opts.to_s)
+        world.kernel.exit
       end
     end
 

lib/mutant/config.rb

@@ -1,30 +1,39 @@
 # frozen_string_literal: true
 
 module Mutant
+  # The outer world IO objects mutant does interact with
+  class World
+    include Adamantium::Flat, Anima.new(
+      :condition_variable,
+      :io,
+      :kernel,
+      :load_path,
+      :marshal,
+      :mutex,
+      :open3,
+      :pathname,
+      :process,
+      :stderr,
+      :stdout,
+      :thread
+    )
+  end # World
+
   # Standalone configuration of a mutant execution.
   #
   # Does not reference any "external" volatile state. The configuration applied
   # to current environment is being represented by the Mutant::Env object.
   class Config
     include Adamantium::Flat, Anima.new(
-      :condition_variable,
       :expression_parser,
       :fail_fast,
       :includes,
       :integration,
       :isolation,
       :jobs,
-      :kernel,
-      :load_path,
       :matcher,
-      :mutex,
-      :open3,
-      :pathname,
       :reporter,
       :requires,
-      :stderr,
-      :stdout,
-      :thread,
       :zombie
     )
 

lib/mutant/env.rb

@@ -10,7 +10,8 @@ class Env
       :mutations,
       :parser,
       :selector,
-      :subjects
+      :subjects,
+      :world
     )
 
     SEMANTICS_MESSAGE =
@@ -49,7 +50,7 @@ def selections
     # @return [Result::Isolation]
     def run_mutation_tests(mutation)
       config.isolation.call do
-        result = mutation.insert(config.kernel)
+        result = mutation.insert(world.kernel)
 
         if result.equal?(Loader::Result::VoidValue.instance)
           Result::Test::VoidValue.instance

lib/mutant/env/bootstrap.rb

@@ -4,7 +4,7 @@ module Mutant
   class Env
     # Bootstrap environment
     class Bootstrap
-      include Adamantium::Flat, Concord::Public.new(:config)
+      include Adamantium::Flat, Concord::Public.new(:world, :config)
 
       SEMANTICS_MESSAGE_FORMAT =
         "%<message>s. Fix your lib to follow normal ruby semantics!\n" \
@@ -30,11 +30,12 @@ class Bootstrap
 
       # Run Bootstrap
       #
+      # @param [World] world
       # @param [Config] config
       #
       # @return [Env]
-      def self.call(config)
-        new(config).env
+      def self.call(world, config)
+        new(world, config).env
       end
 
       # Initialize object
@@ -72,7 +73,8 @@ def env
           mutations:        subjects.flat_map(&:mutations),
           parser:           parser,
           selector:         Selector::Expression.new(integration),
-          subjects:         subjects
+          subjects:         subjects,
+          world:            world
         )
       end
 
@@ -108,8 +110,8 @@ def scope_name(scope)
       #
       # @return [undefined]
       def infect
-        config.includes.each(&config.load_path.method(:<<))
-        config.requires.each(&config.kernel.method(:require))
+        config.includes.each(&world.load_path.method(:<<))
+        config.requires.each(&world.kernel.method(:require))
       end
 
       # Matched subjects

lib/mutant/isolation/fork.rb

@@ -4,15 +4,11 @@ module Mutant
   class Isolation
     # Isolation via the fork(2) systemcall.
     class Fork < self
-      include(
-        Adamantium::Flat,
-        Anima.new(:io, :marshal, :process, :stderr, :stdout)
-      )
+      include(Adamantium::Flat, Concord.new(:world))
 
       READ_SIZE = 4096
 
-      ATTRIBUTES =
-        (anima.attribute_names + %i[block log_pipe result_pipe]).freeze
+      ATTRIBUTES = %i[block log_pipe result_pipe world].freeze
 
       # Unsucessful result as child exited nonzero
       class ChildError < Result
@@ -57,7 +53,7 @@ def parent
       # ignore :reek:InstanceVariableAssumption
       class Parent
         include(
-          Anima.new(*(ATTRIBUTES + %i[io])),
+          Anima.new(*ATTRIBUTES),
           Procto.call
         )
 
@@ -81,7 +77,7 @@ def call
         #
         # @return [Integer]
         def start_child
-          process.fork do
+          world.process.fork do
             Child.call(
               to_h.merge(
                 log_pipe:    log_pipe.child,
@@ -108,7 +104,7 @@ def read_child_result(pid)
           )
 
           begin
-            result = marshal.load(result_fragments.join)
+            result = world.marshal.load(result_fragments.join)
           rescue ArgumentError => exception
             add_result(Result::Exception.new(exception))
           else
@@ -126,7 +122,7 @@ def read_child_result(pid)
         # @return [undefined]
         def read_fragments(targets)
           until targets.empty?
-            ready, = io.select(targets.keys)
+            ready, = world.io.select(targets.keys)
 
             ready.each do |fd|
               if fd.eof?
@@ -144,7 +140,7 @@ def read_fragments(targets)
         #
         # @return [undefined]
         def wait_child(pid, log_fragments)
-          _pid, status = process.wait2(pid)
+          _pid, status = world.process.wait2(pid)
 
           unless status.success? # rubocop:disable Style/GuardClause
             add_result(ChildError.new(status, log_fragments.join))
@@ -170,9 +166,9 @@ class Child
         #
         # @return [undefined]
         def call
-          stderr.reopen(log_pipe)
-          stdout.reopen(log_pipe)
-          result_pipe.syswrite(marshal.dump(block.call))
+          world.stderr.reopen(log_pipe)
+          world.stdout.reopen(log_pipe)
+          result_pipe.syswrite(world.marshal.dump(block.call))
           result_pipe.close
         end
 
@@ -189,14 +185,14 @@ def call
       #
       # rubocop:disable Metrics/MethodLength
       def call(&block)
+        io = world.io
         Pipe.with(io) do |result|
           Pipe.with(io) do |log|
             Parent.call(
-              to_h.merge(
-                block:       block,
-                log_pipe:    log,
-                result_pipe: result
-              )
+              block:       block,
+              log_pipe:    log,
+              result_pipe: result,
+              world:       world
             )
           end
         end

lib/mutant/matcher/method.rb

@@ -87,7 +87,7 @@ def ast
         #
         # @return [Pathname]
         def source_path
-          env.config.pathname.new(source_location.first)
+          env.world.pathname.new(source_location.first)
         end
         memoize :source_path