mutant 0.8.24 → 0.9.0

data/lib/mutant/bootstrap.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Mutant
+  # Bootstrap process
+  #
+  # The role of the boostrap is to take the pure config and apply it against
+  # the impure world to produce an environment.
+  #
+  # env = config interpreted against the world
+  module Bootstrap
+    include Adamantium::Flat, Anima.new(:config, :parser, :world)
+
+    SEMANTICS_MESSAGE_FORMAT =
+      "%<message>s. Fix your lib to follow normal ruby semantics!\n" \
+      '{Module,Class}#name should return resolvable constant name as String or nil'
+
+    CLASS_NAME_RAISED_EXCEPTION =
+      '%<scope_class>s#name from: %<scope>s raised an error: %<exception>s'
+
+    CLASS_NAME_TYPE_MISMATCH_FORMAT =
+      '%<scope_class>s#name from: %<scope>s returned %<name>s'
+
+    private_constant(*constants(false))
+
+    # Run Bootstrap
+    #
+    # @param [World] world
+    # @param [Config] config
+    #
+    # @return [Either<String, Env>]
+    #
+    # rubocop:disable Metrics/MethodLength
+    def self.apply(world, config)
+      env = Env
+        .empty(world, config)
+        .tap(&method(:infect))
+        .with(matchable_scopes: matchable_scopes(world, config))
+
+      subjects = Matcher.from_config(env.config.matcher).call(env)
+
+      Integration.setup(env).fmap do |integration|
+        env.with(
+          integration: integration,
+          mutations:   subjects.flat_map(&:mutations),
+          selector:    Selector::Expression.new(integration),
+          subjects:    subjects
+        )
+      end
+    end
+    # rubocop:enable Metrics/MethodLength
+
+    # Infect environment
+    #
+    # @return [undefined]
+    def self.infect(env)
+      config, world = env.config, env.world
+
+      config.includes.each(&world.load_path.method(:<<))
+      config.requires.each(&world.kernel.method(:require))
+    end
+    private_class_method :infect
+
+    # Matchable scopes
+    #
+    # @param [World] world
+    # @param [Config] config
+    #
+    # @return [Array<Scope>]
+    def self.matchable_scopes(world, config)
+      scopes = world.object_space.each_object(Module).each_with_object([]) do |scope, aggregate|
+        expression = expression(config.reporter, config.expression_parser, scope) || next
+        aggregate << Scope.new(scope, expression)
+      end
+
+      scopes.sort_by { |scope| scope.expression.syntax }
+    end
+    private_class_method :matchable_scopes
+
+    # Scope name from scoping object
+    #
+    # @param [Class, Module] scope
+    #
+    # @return [String]
+    #   if scope has a name and does not raise exceptions obtaining it
+    #
+    # @return [nil]
+    #   otherwise
+    def self.scope_name(reporter, scope)
+      scope.name
+    rescue => exception
+      semantics_warning(
+        reporter,
+        CLASS_NAME_RAISED_EXCEPTION,
+        exception:   exception.inspect,
+        scope:       scope,
+        scope_class: scope.class
+      )
+      nil
+    end
+    private_class_method :scope_name
+
+    # Try to turn scope into expression
+    #
+    # @param [Expression::Parser] expression_parser
+    # @param [Class, Module] scope
+    #
+    # @return [Expression]
+    #   if scope can be represented in an expression
+    #
+    # @return [nil]
+    #   otherwise
+    #
+    # rubocop:disable Metrics/MethodLength
+    #
+    # ignore :reek:LongParameterList
+    def self.expression(reporter, expression_parser, scope)
+      name = scope_name(reporter, scope) or return
+
+      unless name.instance_of?(String)
+        semantics_warning(
+          reporter,
+          CLASS_NAME_TYPE_MISMATCH_FORMAT,
+          name:        name,
+          scope_class: scope.class,
+          scope:       scope
+        )
+        return
+      end
+
+      expression_parser.apply(name).from_right {}
+    end
+    private_class_method :expression
+    # rubocop:enable Metrics/MethodLength
+
+    # Write a semantics warning
+    #
+    # @return [undefined]
+    #
+    # ignore :reek:LongParameterList
+    def self.semantics_warning(reporter, format, options)
+      reporter.warn(SEMANTICS_MESSAGE_FORMAT % { message: format % options })
+    end
+    private_class_method :semantics_warning
+  end # Bootstrap
+end # Mutant

data/lib/mutant/cli.rb

@@ -3,63 +3,91 @@
 module Mutant
   # Commandline parser / runner
   class CLI
-    include Adamantium::Flat, Equalizer.new(:config), Procto.call(:config)
+    include Concord.new(:world, :config)
 
-    # Error failed when CLI argv is invalid
-    Error = Class.new(RuntimeError)
+    private_class_method :new
+
+    OPTIONS =
+      %i[
+        add_environment_options
+        add_mutation_options
+        add_filter_options
+        add_debug_options
+      ].freeze
+
+    private_constant(*constants(false))
 
     # Run cli with arguments
     #
-    # @param [Array<String>] arguments
+    # @param [World] world
+    #   the outside world
+    #
+    # @param [Config] default_config
+    #   the default config
+    #
+    # @param [Array<String>]
+    #   the user provided arguments
     #
     # @return [Boolean]
-    def self.run(arguments)
-      Runner.call(Env::Bootstrap.call(call(arguments))).success?
-    rescue Error => exception
-      $stderr.puts(exception.message)
-      false
+    #
+    # rubocop:disable Style/Semicolon
+    #
+    # ignore :reek:LongParameterList
+    def self.run(world, default_config, arguments)
+      License
+        .apply(world)
+        .apply { Config.load_config_file(world, default_config) }
+        .apply { |file_config| apply(world, file_config, arguments) }
+        .apply { |cli_config| Bootstrap.apply(world, cli_config) }
+        .apply(&Runner.method(:apply))
+        .from_right { |error| world.stderr.puts(error); return false }
+        .success?
     end
+    # rubocop:enable Style/Semicolon
 
-    # Initialize object
+    # Parse arguments into config
     #
-    # @param [Array<String>]
+    # @param [World] world
+    # @param [Config] config
+    # @param [Array<String>] arguments
     #
-    # @return [undefined]
-    def initialize(arguments)
-      @config = Config::DEFAULT
-
-      parse(arguments)
+    # @return [Either<OptionParser::ParseError, Config>]
+    #
+    # ignore :reek:LongParameterList
+    def self.apply(world, config, arguments)
+      Either
+        .wrap_error(OptionParser::ParseError) { new(world, config).parse(arguments) }
+        .lmap(&:message)
     end
 
-    # Config parsed from CLI
-    #
-    # @return [Config]
-    attr_reader :config
-
-  private
+    # Local opt out of option parser defaults
+    class OptionParser < ::OptionParser
+      # Kill defaults added by option parser that
+      # inference with ours under mutation testing.
+      define_method(:add_officious) {}
+    end # OptionParser
 
     # Parse the command-line options
     #
     # @param [Array<String>] arguments
     #   Command-line options and arguments to be parsed.
     #
-    # @fail [Error]
-    #   An error occurred while parsing the options.
-    #
-    # @return [undefined]
+    # @return [Config]
     def parse(arguments)
       opts = OptionParser.new do |builder|
         builder.banner = 'usage: mutant [options] MATCH_EXPRESSION ...'
-        %i[add_environment_options add_mutation_options add_filter_options add_debug_options].each do |name|
+        OPTIONS.each do |name|
           __send__(name, builder)
         end
       end
 
-      parse_match_expressions(opts.parse!(arguments))
-    rescue OptionParser::ParseError => error
-      raise(Error, error)
+      parse_match_expressions(opts.parse!(arguments.dup))
+
+      config
     end
 
+  private
+
     # Parse matchers
     #
     # @param [Array<String>] expressions
@@ -67,7 +95,7 @@ module Mutant
     # @return [undefined]
     def parse_match_expressions(expressions)
       expressions.each do |expression|
-        add_matcher(:match_expressions, config.expression_parser.(expression))
+        add_matcher(:match_expressions, config.expression_parser.apply(expression).from_right)
       end
     end
 
@@ -94,17 +122,6 @@ module Mutant
       end
     end
 
-    # Use integration
-    #
-    # @param [String] name
-    #
-    # @return [undefined]
-    def setup_integration(name)
-      with(integration: Integration.setup(config.kernel, name))
-    rescue LoadError
-      raise Error, "Could not load integration #{name.inspect} (you may want to try installing the gem mutant-#{name})"
-    end
-
     # Add mutation options
     #
     # @param [OptionParser] opts
@@ -114,7 +131,9 @@ module Mutant
       opts.separator(nil)
       opts.separator('Options:')
 
-      opts.on('--use INTEGRATION', 'Use INTEGRATION to kill mutations', &method(:setup_integration))
+      opts.on('--use INTEGRATION', 'Use INTEGRATION to kill mutations') do |name|
+        with(integration: name)
+      end
     end
 
     # Add filter options
@@ -124,17 +143,13 @@ module Mutant
     # @return [undefined]
     def add_filter_options(opts)
       opts.on('--ignore-subject EXPRESSION', 'Ignore subjects that match EXPRESSION as prefix') do |pattern|
-        add_matcher(:ignore_expressions, config.expression_parser.(pattern))
+        add_matcher(:ignore_expressions, config.expression_parser.apply(pattern).from_right)
       end
       opts.on('--since REVISION', 'Only select subjects touched since REVISION') do |revision|
         add_matcher(
           :subject_filters,
           Repository::SubjectFilter.new(
-            Repository::Diff.new(
-              config: config,
-              from:   Repository::Diff::HEAD,
-              to:     revision
-            )
+            Repository::Diff.new(to: revision, world: world)
           )
         )
       end
@@ -150,12 +165,12 @@ module Mutant
         with(fail_fast: true)
       end
       opts.on('--version', 'Print mutants version') do
-        puts("mutant-#{VERSION}")
-        config.kernel.exit
+        world.stdout.puts("mutant-#{VERSION}")
+        world.kernel.exit
       end
       opts.on_tail('-h', '--help', 'Show this message') do
-        puts(opts.to_s)
-        config.kernel.exit
+        world.stdout.puts(opts.to_s)
+        world.kernel.exit
       end
     end
 
@@ -193,6 +208,5 @@ module Mutant
     def add_matcher(attribute, value)
       with(matcher: config.matcher.add(attribute, value))
     end
-
   end # CLI
 end # Mutant

data/lib/mutant/config.rb

@@ -1,6 +1,54 @@
 # frozen_string_literal: true
 
 module Mutant
+  # The outer world IO objects mutant does interact with
+  class World
+    include Adamantium::Flat, Anima.new(
+      :condition_variable,
+      :gem,
+      :io,
+      :json,
+      :kernel,
+      :load_path,
+      :marshal,
+      :mutex,
+      :object_space,
+      :open3,
+      :pathname,
+      :process,
+      :stderr,
+      :stdout,
+      :thread,
+      :warnings
+    )
+
+    INSPECT = '#<Mutant::World>'
+
+    private_constant(*constants(false))
+
+    # Object inspection
+    #
+    # @return [String]
+    def inspect
+      INSPECT
+    end
+
+    # Capture stdout of a command
+    #
+    # @param [Array<String>] command
+    #
+    # @return [Either<String,String>]
+    def capture_stdout(command)
+      stdout, status = open3.capture2(*command, binmode: true)
+
+      if status.success?
+        Either::Right.new(stdout)
+      else
+        Either::Left.new("Command #{command} failed!")
+      end
+    end
+  end # World
+
   # Standalone configuration of a mutant execution.
   #
   # Does not reference any "external" volatile state. The configuration applied
@@ -9,17 +57,13 @@ module Mutant
     include Adamantium::Flat, Anima.new(
       :expression_parser,
       :fail_fast,
-      :integration,
       :includes,
+      :integration,
       :isolation,
       :jobs,
-      :kernel,
-      :load_path,
       :matcher,
-      :open3,
-      :pathname,
-      :requires,
       :reporter,
+      :requires,
       :zombie
     )
 
@@ -27,5 +71,74 @@ module Mutant
       define_method(:"#{name}?") { public_send(name) }
     end
 
+    boolean = Transform::Boolean.new
+    integer = Transform::Primitive.new(Integer)
+    string  = Transform::Primitive.new(String)
+
+    string_array = Transform::Array.new(string)
+
+    TRANSFORM = Transform::Sequence.new(
+      [
+        Transform::Exception.new(SystemCallError, :read.to_proc),
+        Transform::Exception.new(YAML::SyntaxError, YAML.method(:safe_load)),
+        Transform::Hash.new(
+          optional: [
+            Transform::Hash::Key.new('fail_fast',   boolean),
+            Transform::Hash::Key.new('includes',    string_array),
+            Transform::Hash::Key.new('integration', string),
+            Transform::Hash::Key.new('jobs',        integer),
+            Transform::Hash::Key.new('requires',    string_array)
+          ],
+          required: []
+        ),
+        Transform::Hash::Symbolize.new
+      ]
+    )
+
+    MORE_THAN_ONE_CONFIG_FILE = <<~'MESSAGE'
+      Found more than one candidate for use as implicit config file: %s
+    MESSAGE
+
+    CANDIDATES = %w[
+      .mutant.yml
+      config/mutant.yml
+      mutant.yml
+    ].freeze
+
+    private_constant(*constants(false))
+
+    # Load config file
+    #
+    # @param [World] world
+    # @param [Config] config
+    #
+    # @return [Either<String,Config>]
+    def self.load_config_file(world, config)
+      files = CANDIDATES.map(&world.pathname.method(:new)).select(&:readable?)
+
+      if files.one?
+        load_contents(files.first).fmap(&config.method(:with))
+      elsif files.empty?
+        Either::Right.new(config)
+      else
+        Either::Left.new(MORE_THAN_ONE_CONFIG_FILE % files.join(', '))
+      end
+    end
+
+    # Load contents of file
+    #
+    # @param [Pathname] path
+    #
+    # @return [Config]
+    #
+    # @raise [Either<String, Hash{Symbol => Object}>]
+    #   in case of config file error
+    def self.load_contents(path)
+      Transform::Named
+        .new(path.to_s, TRANSFORM)
+        .apply(path)
+        .lmap(&:compact_message)
+    end
+    private_class_method :load_contents
   end # Config
 end # Mutant