mutant 0.9.14 → 0.10.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e92dbf6cbb84cf8d3d5354fc5994cb1ad7cb1fb1364b1927aa89abeedcd0cef
-  data.tar.gz: 5c49178b6766424d6ded707a100ebad86cf9c5403a53b2c2c750baf69b4d636f
+  metadata.gz: 1b5a7d1620b6792fa1cef90ead01124cf50287a165a0bdd415fbc9aab9ecfde8
+  data.tar.gz: 758609938988d4d8de30a6f95a47c603fc4d5365ba98ad1a113a6de11f8e074f
 SHA512:
-  metadata.gz: e786a6ed55abf722515f3b4b9c08200dac35557e48c27430ae5683471ededf67d1fcb17ff4e5f57f1881765d10f3a8b00ef2993f163a1cceb93531d4b75a37e3
-  data.tar.gz: 2a5840a2ecc0ca7c9c6156e8c4596b21808aaf8418ecf134fff9ada56a6c20e94b5ece60a0ebf0b321f1ed51ff0e5c92d26069bcb9473f61276973c46780eb5d
+  metadata.gz: 3ecd6aea62e2d01cb68cc9c9c651190305459b7f1b796f4360ce872ce0dbb1871cb40821744d1c09a029a80f39a93cbda9a242591ceae405e47ed971d3d861f9
+  data.tar.gz: '09e132e435163308309c0185abdd39ea9b6be0d2bd0efa0956049c366f0b521df866a3b7fd04d2e13550bd4f2b09993c659530f86b00142adff69ebc14af3a16'

data/bin/mutant

@@ -8,8 +8,13 @@ end
 
 require 'mutant'
 
-namespace =
-  if ARGV.include?('--zombie')
+command = Mutant::CLI.parse(
+  arguments: ARGV,
+  world:     Mutant::WORLD
+)
+
+status =
+  if command.zombie?
     $stderr.puts('Running mutant zombified!')
     Mutant::Zombifier.call(
       namespace:        :Zombie,
@@ -31,15 +36,13 @@ namespace =
         concord
       ]
     )
-    Zombie::Mutant
+
+    Zombie::Mutant::CLI.parse(
+      arguments: ARGV,
+      world:     Zombie::Mutant::WORLD
+    ).call
   else
-    Mutant
+    command.call
   end
 
-Kernel.exit(
-  namespace::CLI.run(
-    namespace::WORLD,
-    namespace::Config::DEFAULT,
-    ARGV
-  )
-)
+Kernel.exit(status)

data/lib/mutant.rb

@@ -163,8 +163,13 @@ require 'mutant/integration/null'
 require 'mutant/selector'
 require 'mutant/selector/expression'
 require 'mutant/selector/null'
+require 'mutant/world'
 require 'mutant/config'
 require 'mutant/cli'
+require 'mutant/cli/command'
+require 'mutant/cli/command/run'
+require 'mutant/cli/command/subscription'
+require 'mutant/cli/command/root'
 require 'mutant/runner'
 require 'mutant/runner/sink'
 require 'mutant/result'
@@ -211,8 +216,8 @@ module Mutant
     open3:              Open3,
     pathname:           Pathname,
     process:            Process,
-    stderr:             STDERR,
-    stdout:             STDOUT,
+    stderr:             $stderr,
+    stdout:             $stdout,
     thread:             Thread,
     warnings:           Warnings.new(Warning)
   )
@@ -228,9 +233,9 @@ module Mutant
       ]),
       fail_fast:         false,
       includes:          EMPTY_ARRAY,
-      integration:       'null',
+      integration:       nil,
       isolation:         Mutant::Isolation::Fork.new(WORLD),
-      jobs:              Etc.nprocessors,
+      jobs:              nil,
       matcher:           Matcher::Config::DEFAULT,
       reporter:          Reporter::CLI.build(WORLD.stdout),
       requires:          EMPTY_ARRAY,

data/lib/mutant/cli.rb

@@ -1,174 +1,15 @@
 # frozen_string_literal: true
 
 module Mutant
-  # Commandline parser / runner
-  #
-  # rubocop:disable Metrics/ClassLength
-  class CLI
-    include Concord.new(:world, :config)
-
-    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 [World] world
-    #   the outside world
-    #
-    # @param [Config] default_config
-    #   the default config
-    #
-    # @param [Array<String>]
-    #   the user provided arguments
-    #
-    # @return [Boolean]
-    #
-    # rubocop:disable Style/Semicolon
-    #
-    # ignore :reek:LongParameterList
-    def self.run(world, default_config, arguments)
-      License
-        .apply(world)
-        .bind { Config.load_config_file(world, default_config) }
-        .bind { |file_config| apply(world, file_config, arguments) }
-        .bind { |cli_config| Bootstrap.apply(world, cli_config) }
-        .bind(&Runner.method(:apply))
-        .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>]
-    #
-    # ignore :reek:LongParameterList
-    def self.apply(world, config, arguments)
-      Either
-        .wrap_error(OptionParser::ParseError) { new(world, config).parse(arguments) }
-        .lmap(&:message)
-    end
-
-    # 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
+  # Commandline interface
+  module CLI
+    # Parse command
     #
-    # @param [Array<String>] arguments
-    #   Command-line options and arguments to be parsed.
-    #
-    # @return [Config]
-    def parse(arguments)
-      opts = OptionParser.new do |builder|
-        builder.banner = 'usage: mutant [options] MATCH_EXPRESSION ...'
-        OPTIONS.each do |name|
-          __send__(name, builder)
-        end
-      end
-
-      parse_match_expressions(opts.parse!(arguments.dup))
-
-      config
-    end
-
-  private
-
-    def parse_match_expressions(expressions)
-      expressions.each do |expression|
-        add_matcher(:match_expressions, config.expression_parser.apply(expression).from_right)
-      end
-    end
-
-    # rubocop:disable Metrics/MethodLength
-    def add_environment_options(opts)
-      opts.separator('Environment:')
-      opts.on('--zombie', 'Run mutant zombified') do
-        with(zombie: true)
-      end
-      opts.on('-I', '--include DIRECTORY', 'Add DIRECTORY to $LOAD_PATH') do |directory|
-        add(:includes, directory)
-      end
-      opts.on('-r', '--require NAME', 'Require file with NAME') do |name|
-        add(:requires, name)
-      end
-      opts.on('-j', '--jobs NUMBER', 'Number of kill jobs. Defaults to number of processors.') do |number|
-        with(jobs: Integer(number))
-      end
-    end
-    # rubocop:enable Metrics/MethodLength
-
-    def add_mutation_options(opts)
-      opts.separator(nil)
-      opts.separator('Options:')
-
-      opts.on('--use INTEGRATION', 'Use INTEGRATION to kill mutations') do |name|
-        with(integration: name)
-      end
-    end
-
-    # rubocop:disable Metrics/MethodLength
-    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.apply(pattern).from_right)
-      end
-      opts.on('--start-subject EXPRESSION', 'Start mutation testing at a specific subject') do |pattern|
-        add_matcher(:start_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(to: revision, world: world)
-          )
-        )
-      end
-    end
-    # rubocop:enable Metrics/MethodLength
-
-    # rubocop:disable Metrics/MethodLength
-    def add_debug_options(opts)
-      opts.on('--fail-fast', 'Fail fast') do
-        with(fail_fast: true)
-      end
-      opts.on('--version', 'Print mutants version') do
-        world.stdout.puts("mutant-#{VERSION}")
-        world.kernel.exit
-      end
-      opts.on_tail('-h', '--help', 'Show this message') do
-        world.stdout.puts(opts.to_s)
-        world.kernel.exit
-      end
-    end
-    # rubocop:enable Metrics/MethodLength
-
-    def with(attributes)
-      @config = config.with(attributes)
-    end
-
-    def add(attribute, value)
-      with(attribute => config.public_send(attribute) + [value])
-    end
-
-    def add_matcher(attribute, value)
-      with(matcher: config.matcher.add(attribute, value))
+    # @return [Command]
+    def self.parse(world:, **attributes)
+      Command::Root
+        .parse(world: world, **attributes)
+        .from_right { |message| Command::FailParse.new(world, message) }
     end
   end # CLI
-  # rubocop:enable Metrics/ClassLength
 end # Mutant

data/lib/mutant/cli/command.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module Mutant
+  module CLI
+    # rubocop:disable Metrics/ClassLength
+    class Command
+      include AbstractType, Anima.new(:world, :main, :parent, :arguments)
+
+      include Equalizer.new(:parent, :arguments)
+
+      OPTIONS     = [].freeze
+      SUBCOMMANDS = [].freeze
+
+      # 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
+
+      class FailParse < self
+        include Concord.new(:world, :message)
+
+        def call
+          world.stderr.puts(message)
+          false
+        end
+      end
+
+      # Parse command
+      #
+      # @return [Command]
+      def self.parse(**attributes)
+        new(main: nil, parent: nil, **attributes).__send__(:parse)
+      end
+
+      # Command name
+      #
+      # @return [String]
+      def self.command_name
+        self::NAME
+      end
+
+      # Command short description
+      #
+      # @return [String]
+      def self.short_description
+        self::SHORT_DESCRIPTION
+      end
+
+      # Execute the command, invoke its side effects
+      #
+      # @return [Bool]
+      def call
+        main ? main.call : execute
+      end
+
+      # Commands full name
+      #
+      # @return [String]
+      def full_name
+        [*parent&.full_name, self.class.command_name].join(' ')
+      end
+
+      # Test if command needs to be executed in zombie environment
+      #
+      # @return [Bool]
+      def zombie?
+        instance_of?(Run)
+      end
+
+    private
+
+      def subcommands
+        self.class::SUBCOMMANDS
+      end
+
+      def parser
+        OptionParser.new do |parser|
+          parser.banner = "usage: #{banner}"
+
+          add_summary(parser)
+          add_global_options(parser)
+          add_subcommands(parser)
+
+          self.class::OPTIONS.each do |method_name|
+            2.times { parser.separator(nil) }
+            __send__(method_name, parser)
+          end
+        end
+      end
+
+      def capture_main(&block)
+        @main = block
+      end
+
+      def banner
+        if subcommands.any?
+          "#{full_name} <#{subcommands.map(&:command_name).join('|')}> [options]"
+        else
+          "#{full_name} [options]"
+        end
+      end
+
+      def parse
+        Either
+          .wrap_error(OptionParser::InvalidOption) { parser.order(arguments) }
+          .lmap(&method(:with_help))
+          .bind(&method(:parse_remaining))
+      end
+
+      def add_summary(parser)
+        parser.separator(nil)
+        parser.separator("Summary: #{self.class.short_description}")
+        parser.separator(nil)
+      end
+
+      def add_global_options(parser)
+        parser.separator('Global Options:')
+        parser.separator(nil)
+
+        parser.on('--help', 'Print help') do
+          capture_main { world.stdout.puts(parser.help); true }
+        end
+
+        parser.on('--version', 'Print mutants version') do
+          capture_main { world.stdout.puts("mutant-#{VERSION}"); true }
+        end
+      end
+
+      def add_subcommands(parser)
+        return unless subcommands.any?
+
+        parser.separator(nil)
+        parser.separator('Available subcommands:')
+        parser.separator(nil)
+        parser.separator(format_subcommands)
+      end
+
+      def parse_remaining(remaining)
+        return Either::Right.new(self) if main
+
+        if subcommands.any?
+          parse_subcommand(remaining)
+        else
+          parse_remaining_arguments(remaining)
+        end
+      end
+
+      def parse_remaining_arguments(remaining)
+        if remaining.any?
+          Either::Left.new("#{full_name}: Does not expect extra arguments")
+        else
+          Either::Right.new(self)
+        end
+      end
+
+      def parse_subcommand(arguments)
+        command_name, *arguments = arguments
+
+        if command_name.nil?
+          Either::Left.new(with_help('Missing required subcommand!'))
+        else
+          find_command(command_name).bind do |command|
+            command.parse(**to_h, parent: self, arguments: arguments)
+          end
+        end
+      end
+
+      def format_subcommands
+        commands = subcommands.map do |subcommand|
+          [subcommand.command_name, subcommand.short_description]
+        end.to_h
+
+        width = commands.each_key.map(&:length).max
+
+        commands.each_key.map do |name|
+          '%-*s - %s' % [width, name, commands.fetch(name)] # rubocop:disable Style/FormatStringToken
+        end
+      end
+
+      def find_command(name)
+        subcommand = subcommands.detect { |command| command.command_name.eql?(name) }
+
+        if subcommand
+          Either::Right.new(subcommand)
+        else
+          Either::Left.new(with_help("Cannot find subcommand #{name.inspect}"))
+        end
+      end
+
+      def with_help(message)
+        "#{full_name}: #{message}\n\n#{parser}"
+      end
+    end # Command
+    # rubocop:enable Metrics/ClassLength
+  end # CLI
+end # Mutant

data/lib/mutant/cli/command/root.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Mutant
+  module CLI
+    class Command
+      class Root < self
+        SUBCOMMANDS       = [Run, Subscription].freeze
+        SHORT_DESCRIPTION = 'mutation testing engine main command'
+        NAME              = 'mutant'
+      end
+    end # Command
+  end # CLI
+end # Mutant

data/lib/mutant/cli/command/run.rb

@@ -0,0 +1,161 @@
+# frozen_string_literal: true
+
+module Mutant
+  module CLI
+    class Command
+      # rubocop:disable Metrics/ClassLength
+      class Run < self
+        NAME              = 'run'
+        SHORT_DESCRIPTION = 'Run code analysis'
+
+        OPTIONS =
+          %i[
+            add_environment_options
+            add_runner_options
+            add_integration_options
+            add_matcher_options
+          ].freeze
+
+        SLEEP = 40
+
+        UNLICENSED = <<~MESSAGE.lines.freeze
+          Soft fail, continuing in #{SLEEP} seconds
+          Next major version will enforce the license
+          See https://github.com/mbj/mutant#licensing
+        MESSAGE
+
+        # Test if command needs to be executed in zombie environment
+        #
+        # @return [Bool]
+        def zombie?
+          @config.zombie
+        end
+
+      private
+
+        def initialize(attributes)
+          super(attributes)
+          @config = Config::DEFAULT
+        end
+
+        def execute
+          soft_fail(License.apply(world))
+            .bind { Config.load_config_file(world) }
+            .fmap(&method(:expand))
+            .bind { Bootstrap.apply(world, @config) }
+            .bind(&Runner.public_method(:apply))
+            .from_right { |error| world.stderr.puts(error); return false }
+            .success?
+        end
+
+        def expand(file_config)
+          @config = Config.env.merge(file_config).merge(@config)
+        end
+
+        def soft_fail(result)
+          result.either(
+            lambda do |message|
+              stderr = world.stderr
+              stderr.puts(message)
+              UNLICENSED.each { |line| stderr.puts(unlicensed(line)) }
+              world.kernel.sleep(SLEEP)
+              Either::Right.new(nil)
+            end,
+            ->(_subscription) { Either::Right.new(nil) }
+          )
+        end
+
+        def unlicensed(message)
+          "[Mutant-License-Error]: #{message}"
+        end
+
+        def parse_remaining_arguments(arguments)
+          traverse(@config.expression_parser.public_method(:apply), arguments)
+            .fmap do |match_expressions|
+              matcher(match_expressions: match_expressions)
+              self
+            end
+        end
+
+        def traverse(action, values)
+          Either::Right.new(
+            values.map do |value|
+              action.call(value).from_right do |error|
+                return Either::Left.new(error)
+              end
+            end
+          )
+        end
+
+        def set(**attributes)
+          @config = @config.with(attributes)
+        end
+
+        def matcher(**attributes)
+          set(matcher: @config.matcher.with(attributes))
+        end
+
+        def add(attribute, value)
+          set(attribute => @config.public_send(attribute) + [value])
+        end
+
+        def add_matcher(attribute, value)
+          set(matcher: @config.matcher.add(attribute, value))
+        end
+
+        def add_environment_options(parser)
+          parser.separator('Environment:')
+          parser.on('--zombie', 'Run mutant zombified') do
+            set(zombie: true)
+          end
+          parser.on('-I', '--include DIRECTORY', 'Add DIRECTORY to $LOAD_PATH') do |directory|
+            add(:includes, directory)
+          end
+          parser.on('-r', '--require NAME', 'Require file with NAME') do |name|
+            add(:requires, name)
+          end
+        end
+
+        def add_integration_options(parser)
+          parser.separator('Integration:')
+
+          parser.on('--use INTEGRATION', 'Use INTEGRATION to kill mutations') do |name|
+            set(integration: name)
+          end
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        def add_matcher_options(parser)
+          parser.separator('Matcher:')
+
+          parser.on('--ignore-subject EXPRESSION', 'Ignore subjects that match EXPRESSION as prefix') do |pattern|
+            add_matcher(:ignore_expressions, @config.expression_parser.apply(pattern).from_right)
+          end
+          parser.on('--start-subject EXPRESSION', 'Start mutation testing at a specific subject') do |pattern|
+            add_matcher(:start_expressions, @config.expression_parser.apply(pattern).from_right)
+          end
+          parser.on('--since REVISION', 'Only select subjects touched since REVISION') do |revision|
+            add_matcher(
+              :subject_filters,
+              Repository::SubjectFilter.new(
+                Repository::Diff.new(to: revision, world: world)
+              )
+            )
+          end
+        end
+
+        def add_runner_options(parser)
+          parser.separator('Runner:')
+
+          parser.on('--fail-fast', 'Fail fast') do
+            set(fail_fast: true)
+          end
+          parser.on('-j', '--jobs NUMBER', 'Number of kill jobs. Defaults to number of processors.') do |number|
+            set(jobs: Integer(number))
+          end
+        end
+      end # Run
+      # rubocop:enable Metrics/ClassLength
+    end # Command
+  end # CLI
+end # Mutant

data/lib/mutant/cli/command/subscription.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module Mutant
+  module CLI
+    class Command
+      class Subscription < self
+        NAME              = 'subscription'
+        SHORT_DESCRIPTION = 'Subscription subcommands'
+
+      private
+
+        def license
+          License.apply(world)
+        end
+
+        class Test < self
+          NAME              = 'test'
+          SUBCOMMANDS       = [].freeze
+          SHORT_DESCRIPTION = 'Silently validates subscription, exits accordingly'
+
+        private
+
+          def execute
+            license.right?
+          end
+        end # Test
+
+        class Show < self
+          NAME              = 'show'
+          SUBCOMMANDS       = [].freeze
+          SHORT_DESCRIPTION = 'Show subscription status'
+
+        private
+
+          def execute
+            license.either(method(:unlicensed), method(:licensed))
+          end
+
+          def licensed(subscription)
+            world.stdout.puts(subscription.description)
+            true
+          end
+
+          def unlicensed(message)
+            world.stderr.puts(message)
+            false
+          end
+        end # Show
+
+        SUBCOMMANDS = [Show, Test].freeze
+      end # Subscription
+    end # Command
+  end # CLI
+end # Mutant

data/lib/mutant/config.rb

@@ -1,55 +1,6 @@
 # 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,
-      :gem_method,
-      :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
@@ -106,6 +57,23 @@ module Mutant
       mutant.yml
     ].freeze
 
+    # Merge with other config
+    #
+    # @param [Config] other
+    #
+    # @return [Config]
+    def merge(other)
+      other.with(
+        fail_fast:   fail_fast || other.fail_fast,
+        includes:    includes + other.includes,
+        jobs:        other.jobs || jobs,
+        integration: other.integration || integration,
+        matcher:     matcher.merge(other.matcher),
+        requires:    requires + other.requires,
+        zombie:      zombie || other.zombie
+      )
+    end
+
     private_constant(*constants(false))
 
     # Load config file
@@ -114,11 +82,12 @@ module Mutant
     # @param [Config] config
     #
     # @return [Either<String,Config>]
-    def self.load_config_file(world, config)
-      files = CANDIDATES.map(&world.pathname.method(:new)).select(&:readable?)
+    def self.load_config_file(world)
+      config = DEFAULT
+      files = CANDIDATES.map(&world.pathname.public_method(:new)).select(&:readable?)
 
       if files.one?
-        load_contents(files.first).fmap(&config.method(:with))
+        load_contents(files.first).fmap(&config.public_method(:with))
       elsif files.empty?
         Either::Right.new(config)
       else
@@ -133,5 +102,12 @@ module Mutant
         .lmap(&:compact_message)
     end
     private_class_method :load_contents
+
+    # The configuration from the environment
+    #
+    # @return [Config]
+    def self.env
+      DEFAULT.with(jobs: Etc.nprocessors)
+    end
   end # Config
 end # Mutant

data/lib/mutant/expression.rb

@@ -59,6 +59,5 @@ module Mutant
       names = anima.attribute_names
       new(Hash[names.zip(names.map(&match.method(:[])))])
     end
-
   end # Expression
 end # Mutant

data/lib/mutant/license.rb

@@ -4,53 +4,27 @@ module Mutant
   module License
     NAME    = 'mutant-license'
     VERSION = '~> 0.1.0'
-    SLEEP   = 40
-
-    UNLICENSED =
-      IceNine.deep_freeze(
-        [
-          "Soft fail, continuing in #{SLEEP} seconds",
-          'Next major version will enforce the license',
-          'See https://github.com/mbj/mutant#licensing'
-        ]
-      )
 
+    # Load license
+    #
+    # @param [World] world
+    #
+    # @return [Either<String,Subscription>]
+    #
+    # @api private
     def self.apply(world)
-      soft_fail(world, license_result(world))
-    end
-
-    def self.license_result(world)
       load_mutant_license(world)
         .fmap { license_path(world) }
-        .fmap { |path| Subscription.from_json(world.json.load(path)) }
-        .bind { |sub| sub.apply(world) }
+        .bind { |path| Subscription.load(world, world.json.load(path)) }
     end
-    private_class_method :license_result
-
-    # ignore :reek:NestedIterators
-    def self.soft_fail(world, result)
-      result.lmap do |message|
-        stderr = world.stderr
-        stderr.puts(message)
-        UNLICENSED.each { |line| stderr.puts(unlicensed(line)) }
-        world.kernel.sleep(SLEEP)
-      end
-
-      Either::Right.new(true)
-    end
-    private_class_method :soft_fail
 
     def self.load_mutant_license(world)
       Either
         .wrap_error(LoadError) { world.gem_method.call(NAME, VERSION) }
         .lmap(&:message)
         .lmap(&method(:check_for_rubygems_mutant_license))
-        .lmap(&method(:unlicensed))
-    end
-
-    def self.unlicensed(message)
-      "[Mutant-License-Error]: #{message}"
     end
+    private_class_method :load_mutant_license
 
     def self.check_for_rubygems_mutant_license(message)
       if message.include?('already activated mutant-license-0.0.0')

data/lib/mutant/license/subscription.rb

@@ -3,8 +3,15 @@
 module Mutant
   module License
     class Subscription
+      include Concord.new(:licensed)
 
-      MESSAGE_FORMAT = <<~'MESSAGE'
+      FORMAT = <<~'MESSAGE'
+        %<subscription_name>s subscription:
+        Licensed:
+        %<licensed>s
+      MESSAGE
+
+      FAILURE_FORMAT = <<~'MESSAGE'
         Can not validate %<subscription_name>s license.
         Licensed:
         %<expected>s
@@ -12,31 +19,46 @@ module Mutant
         %<actual>s
       MESSAGE
 
-      def self.from_json(value)
+      # Load value into subscription
+      #
+      # @param [Object] value
+      #
+      # @return [Subscription]
+      def self.load(world, value)
         {
           'com' => Commercial,
           'oss' => Opensource
-        }.fetch(value.fetch('type')).from_json(value.fetch('contents'))
+        }.fetch(value.fetch('type'))
+          .from_json(value.fetch('contents'))
+          .apply(world)
+      end
+
+      # Subscription self description
+      #
+      # @return [String]
+      def description
+        FORMAT % {
+          licensed:          licensed.to_a.join("\n"),
+          subscription_name: subscription_name
+        }
       end
 
     private
 
       def failure(expected, actual)
-        Either::Left.new(message(expected, actual))
+        Either::Left.new(failure_message(expected, actual))
       end
 
-      # ignore :reek:UtilityFunction
       def success
-        # masked by soft fail
-        Either::Right.new(nil)
+        Either::Right.new(self)
       end
 
       def subscription_name
         self.class.name.split('::').last.downcase
       end
 
-      def message(expected, actual)
-        MESSAGE_FORMAT % {
+      def failure_message(expected, actual)
+        FAILURE_FORMAT % {
           actual:            actual.any? ? actual.map(&:to_s).join("\n") : '[none]',
           expected:          expected.map(&:to_s).join("\n"),
           subscription_name: subscription_name

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

@@ -4,8 +4,6 @@ module Mutant
   module License
     class Subscription
       class Commercial < self
-        include Concord.new(:authors)
-
         class Author
           include Concord.new(:email)
 
@@ -20,10 +18,10 @@ module Mutant
         def apply(world)
           candidates = candidates(world)
 
-          if (authors & candidates).any?
+          if (licensed & candidates).any?
             success
           else
-            failure(authors, candidates)
+            failure(licensed, candidates)
           end
         end
 

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

@@ -4,8 +4,6 @@ module Mutant
   module License
     class Subscription
       class Opensource < self
-        include Concord.new(:repositories)
-
         class Repository
           include Concord.new(:host, :path)
 
@@ -43,10 +41,13 @@ module Mutant
           private_class_method :parse_url
         end
 
-        private_constant(*constants(false))
-
         def self.from_json(value)
-          new(value.fetch('repositories').map(&Repository.method(:parse)))
+          new(
+            value
+              .fetch('repositories')
+              .map(&Repository.public_method(:parse))
+              .to_set
+          )
         end
 
         def apply(world)
@@ -59,10 +60,10 @@ module Mutant
       private
 
         def check_subscription(actual)
-          if (repositories.to_set & actual).any?
+          if (licensed & actual).any?
             success
           else
-            failure(repositories, actual)
+            failure(licensed, actual)
           end
         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/mutator/node/named_value/variable_assignment.rb

@@ -18,7 +18,7 @@ module Mutant
           }
 
           MAP = IceNine.deep_freeze(
-            Hash[map.map { |type, prefix| [type, [prefix, /^#{::Regexp.escape(prefix)}/]] }]
+            map.transform_values { |prefix| [prefix, /^#{::Regexp.escape(prefix)}/] }
           )
 
           handle(*MAP.keys)

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

@@ -14,8 +14,8 @@ module Mutant
           # @return [undefined]
           def run
             info 'Matcher:         %s', object.matcher.inspect
-            info 'Integration:     %s', object.integration
-            info 'Jobs:            %d', object.jobs
+            info 'Integration:     %s', object.integration || 'null'
+            info 'Jobs:            %s', object.jobs || 'auto'
             info 'Includes:        %s', object.includes
             info 'Requires:        %s', object.requires
           end

data/lib/mutant/selector/expression.rb

@@ -14,7 +14,9 @@ module Mutant
       def call(subject)
         subject.match_expressions.each do |match_expression|
           subject_tests = integration.all_tests.select do |test|
-            match_expression.prefix?(test.expression)
+            test.expressions.any? do |test_expression|
+              match_expression.prefix?(test_expression)
+            end
           end
           return subject_tests if subject_tests.any?
         end

data/lib/mutant/test.rb

@@ -4,7 +4,7 @@ module Mutant
   # Abstract base class for test that might kill a mutation
   class Test
     include Adamantium::Flat, Anima.new(
-      :expression,
+      :expressions,
       :id
     )
 

data/lib/mutant/version.rb

@@ -2,5 +2,5 @@
 
 module Mutant
   # Current mutant version
-  VERSION = '0.9.14'
+  VERSION = '0.10.6'
 end # Mutant

data/lib/mutant/world.rb

@@ -0,0 +1,52 @@
+# 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,
+      :gem_method,
+      :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
+end # Mutant

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mutant
 version: !ruby/object:Gem::Version
-  version: 0.9.14
+  version: 0.10.6
 platform: ruby
 authors:
 - Markus Schirp
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-16 00:00:00.000000000 Z
+date: 2020-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: abstract_type
@@ -184,14 +184,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.2
+        version: 0.5.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.2
+        version: 0.5.4
 - !ruby/object:Gem::Dependency
   name: variable
   requirement: !ruby/object:Gem::Requirement
@@ -226,56 +226,56 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.9'
+        version: '3.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.9'
+        version: '3.10'
 - !ruby/object:Gem::Dependency
   name: rspec-core
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.9'
+        version: '3.10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.9'
+        version: '3.10'
 - !ruby/object:Gem::Dependency
   name: rspec-its
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 1.3.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.2.0
+        version: 1.3.0
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.79.0
+        version: '1.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.79.0
+        version: '1.2'
 description: Mutation Testing for Ruby.
 email:
 - mbj@schirp-dso.com
@@ -303,6 +303,10 @@ files:
 - lib/mutant/ast/types.rb
 - lib/mutant/bootstrap.rb
 - lib/mutant/cli.rb
+- lib/mutant/cli/command.rb
+- lib/mutant/cli/command/root.rb
+- lib/mutant/cli/command/run.rb
+- lib/mutant/cli/command/subscription.rb
 - lib/mutant/config.rb
 - lib/mutant/context.rb
 - lib/mutant/env.rb
@@ -338,7 +342,6 @@ files:
 - lib/mutant/meta/example.rb
 - lib/mutant/meta/example/dsl.rb
 - lib/mutant/meta/example/verification.rb
-- lib/mutant/minitest/coverage.rb
 - lib/mutant/mutation.rb
 - lib/mutant/mutator.rb
 - lib/mutant/mutator/node.rb
@@ -447,6 +450,7 @@ files:
 - lib/mutant/util.rb
 - lib/mutant/version.rb
 - lib/mutant/warnings.rb
+- lib/mutant/world.rb
 - lib/mutant/zombifier.rb
 homepage: https://github.com/mbj/mutant
 licenses:
@@ -460,7 +464,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="

data/lib/mutant/minitest/coverage.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require 'minitest'
-
-module Mutant
-  module Minitest
-    module Coverage
-      # Setup coverage declaration for current class
-      #
-      # @param [String]
-      #
-      # @example
-      #
-      #   class MyTest < MiniTest::Test
-      #     cover 'MyCode*'
-      #
-      #     def test_some_stuff
-      #     end
-      #   end
-      #
-      # @api public
-      def cover(expression)
-        if defined?(@cover_expression)
-          fail "#{self} already declares to cover: #{@cover_expression.inspect}"
-        end
-
-        @cover_expression = expression
-      end
-
-      # Effective coverage expression
-      #
-      # @return [String, nil]
-      #
-      # @api private
-      def resolve_cover_expression
-        return @cover_expression if defined?(@cover_expression)
-
-        try_superclass_cover_expression
-      end
-
-    private
-
-      def try_superclass_cover_expression
-        return if superclass.equal?(::Minitest::Runnable)
-
-        superclass.resolve_cover_expression
-      end
-
-    end # Coverage
-  end # Minitest
-end # Mutant
-
-Minitest::Test.extend(Mutant::Minitest::Coverage)