mutant 0.9.13 → 0.10.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8a634036241e157b66b8778d1645bca99d67cd81fa26042c42e43f868bafa260
-  data.tar.gz: ee46dcacd412e10634454dbdd5ec52d5a803c71fa8e9db9cc3fcdc35e35a8e5c
+  metadata.gz: c2e6667e21b413029cf11b268c6d36986a5960921945aad01199aaff5881a3c2
+  data.tar.gz: 3434159c18f80d786ecc728b3fde7eaa5e2c3939ec70c5d931e717288ba6d48f
 SHA512:
-  metadata.gz: b0d20d48dc5443ba2347c176425ec372ed2d4e2f11e0bea33c59895b9b52d00b4efcdd07e8f9b47eefbd2ebd8f20d610f3ed3a726d9d59bbed1378b2be2fea1f
-  data.tar.gz: e4ad2f3d626eaae68f390447ad94cdf1338525f010f684f524873cfab6560d25ffb67062f6f2567750c9468670241d5180ba1a8bcc32fe7e42fc16cd3ff2c4ef
+  metadata.gz: a036402f0e95f0a41b16dbbede078a56f5ccee4d241052b034022fd6a7db505037cefb5b093061d2d12326f6a4e2ae7bd250ad7bb160586aa14dc831d019a398
+  data.tar.gz: 188b1bb29e0639c6a7f3c72b5ee4ca24ac25bc799181b1f7d2e6f0b056fb92aabe6b7c657345ac080e4002625dad227752c1e7c4a57d5e0f506d608f3c4be28d

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

@@ -90,8 +90,7 @@ require 'mutant/mutator/node/arguments'
 require 'mutant/mutator/node/begin'
 require 'mutant/mutator/node/binary'
 require 'mutant/mutator/node/const'
-require 'mutant/mutator/node/dstr'
-require 'mutant/mutator/node/dsym'
+require 'mutant/mutator/node/dynamic_literal'
 require 'mutant/mutator/node/kwbegin'
 require 'mutant/mutator/node/named_value/access'
 require 'mutant/mutator/node/named_value/constant_assignment'
@@ -164,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'
@@ -212,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)
   )
@@ -229,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,196 @@
+# 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 { |error| "#{full_name}: #{error}" }
+          .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(
+            "Missing required subcommand!\n\n#{parser}"
+          )
+        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("#{full_name}: Cannot find subcommand #{name.inspect}")
+        end
+      end
+    end # Command
+    # rubocop:enable Metrics/ClassLength
+  end # CLI
+end # Mutant