mutant 0.9.10 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45484c558fad8e5115eb2b4c45712b762eb1d13f12fe7e7a29d9ec0696a16e24
-  data.tar.gz: 5354afd8cf7491687dfef3af68157e37cc549a0190d09bb8755c8bcf33d24051
+  metadata.gz: fd38b14761b4836ca3ce54a9bd8ea7a25d1f4dac6506b08ab6f6c64227a0f71d
+  data.tar.gz: dbed2538feb3240195e76b8b10895ea01ba7dc827820a6106d00fa4a55da97d1
 SHA512:
-  metadata.gz: 1546be8318d6135d2834120bcc3052b879d6568560a9ec5dd056448a46cdd240fede609a4336fb5e64937526aa2db64627285c70dc45b09aa0175d6abc471749
-  data.tar.gz: b8705cb2eb82b286d77ea87a17af903661747cfad61d3e51fcc70b1f906bcf47b07e33305810f1d59cc4f3d2e802b5eae20e0ce4ecf37b686c2fd73e1bc41933
+  metadata.gz: c70d6881956ace0d359b13dcfd41ef4eb92dbabcf5ee90d913790b8a09bb1b12877e32c85453d3be97d9fd2a1523a0af307ebf7318550cd0e3413fc8d9ecb765
+  data.tar.gz: 27b59ee208993bfc5b128269658fc4465782052613b0641c9647ace34cc10b956c72c8e05a5b8a6f86af77112589295e3289e53192d973500fe43ceed84180fc

data/bin/mutant

@@ -8,8 +8,14 @@ end
 
 require 'mutant'
 
-namespace =
-  if ARGV.include?('--zombie')
+command = Mutant::CLI.parse(
+  arguments: ARGV,
+  config:    Mutant::Config::DEFAULT,
+  world:     Mutant::WORLD
+)
+
+status =
+  if command.zombie?
     $stderr.puts('Running mutant zombified!')
     Mutant::Zombifier.call(
       namespace:        :Zombie,
@@ -31,15 +37,14 @@ namespace =
         concord
       ]
     )
-    Zombie::Mutant
+
+    Zombie::Mutant::CLI.parse(
+      arguments: ARGV,
+      config:    Zombie::Mutant::Config::DEFAULT,
+      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'
@@ -120,6 +119,7 @@ require 'mutant/mutator/node/nthref'
 require 'mutant/mutator/node/masgn'
 require 'mutant/mutator/node/return'
 require 'mutant/mutator/node/block'
+require 'mutant/mutator/node/block_pass'
 require 'mutant/mutator/node/if'
 require 'mutant/mutator/node/case'
 require 'mutant/mutator/node/splat'
@@ -165,6 +165,10 @@ require 'mutant/selector/expression'
 require 'mutant/selector/null'
 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 +215,8 @@ module Mutant
     open3:              Open3,
     pathname:           Pathname,
     process:            Process,
-    stderr:             STDERR,
-    stdout:             STDOUT,
+    stderr:             $stderr,
+    stdout:             $stdout,
     thread:             Thread,
     warnings:           Warnings.new(Warning)
   )

data/lib/mutant/bootstrap.rb

@@ -36,7 +36,7 @@ module Mutant
         .tap(&method(:infect))
         .with(matchable_scopes: matchable_scopes(world, config))
 
-      subjects = Matcher.from_config(env.config.matcher).call(env)
+      subjects = start_subject(env, Matcher.from_config(env.config.matcher).call(env))
 
       Integration.setup(env).fmap do |integration|
         env.with(
@@ -49,6 +49,19 @@ module Mutant
     end
     # rubocop:enable Metrics/MethodLength
 
+    def self.start_subject(env, subjects)
+      start_expressions = env.config.matcher.start_expressions
+
+      return subjects if start_expressions.empty?
+
+      subjects.drop_while do |subject|
+        start_expressions.none? do |expression|
+          expression.prefix?(subject.expression)
+        end
+      end
+    end
+    private_class_method :start_subject
+
     def self.infect(env)
       config, world = env.config, env.world
 

data/lib/mutant/cli.rb

@@ -1,168 +1,15 @@
 # frozen_string_literal: true
 
 module Mutant
-  # Commandline parser / runner
-  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
-    #
-    # @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('--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))
+  # Commandline interface
+  module CLI
+    # Parse command
+    #
+    # @return [Command]
+    def self.parse(world:, **attributes)
+      Command::Root
+        .parse(world: world, **attributes)
+        .from_right { |message| Command::FailParse.new(world, message) }
     end
   end # CLI
 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, :config, :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