mutant 0.9.14 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e92dbf6cbb84cf8d3d5354fc5994cb1ad7cb1fb1364b1927aa89abeedcd0cef
-  data.tar.gz: 5c49178b6766424d6ded707a100ebad86cf9c5403a53b2c2c750baf69b4d636f
+  metadata.gz: fd38b14761b4836ca3ce54a9bd8ea7a25d1f4dac6506b08ab6f6c64227a0f71d
+  data.tar.gz: dbed2538feb3240195e76b8b10895ea01ba7dc827820a6106d00fa4a55da97d1
 SHA512:
-  metadata.gz: e786a6ed55abf722515f3b4b9c08200dac35557e48c27430ae5683471ededf67d1fcb17ff4e5f57f1881765d10f3a8b00ef2993f163a1cceb93531d4b75a37e3
-  data.tar.gz: 2a5840a2ecc0ca7c9c6156e8c4596b21808aaf8418ecf134fff9ada56a6c20e94b5ece60a0ebf0b321f1ed51ff0e5c92d26069bcb9473f61276973c46780eb5d
+  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

@@ -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/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, :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

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,151 @@
+# 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 execute
+          soft_fail(License.apply(world))
+            .bind { Config.load_config_file(world, config) }
+            .bind { |cli_config| Bootstrap.apply(world, cli_config) }
+            .bind(&Runner.public_method(:apply))
+            .from_right { |error| world.stderr.puts(error); return false }
+            .success?
+        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/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.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,12 @@ 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))
+          )
         end
 
         def apply(world)
@@ -59,10 +59,10 @@ module Mutant
       private
 
         def check_subscription(actual)
-          if (repositories.to_set & actual).any?
+          if (licensed.to_set & actual).any?
             success
           else
-            failure(repositories, actual)
+            failure(licensed, actual)
           end
         end
 

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/version.rb

@@ -2,5 +2,5 @@
 
 module Mutant
   # Current mutant version
-  VERSION = '0.9.14'
+  VERSION = '0.10.0'
 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.0
 platform: ruby
 authors:
 - Markus Schirp
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-16 00:00:00.000000000 Z
+date: 2020-10-29 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.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.5.2
+        version: 0.5.3
 - !ruby/object:Gem::Dependency
   name: variable
   requirement: !ruby/object:Gem::Requirement
@@ -254,28 +254,28 @@ dependencies:
     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.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.79.0
+        version: '1.0'
 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
@@ -460,14 +464,14 @@ 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:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.0.rc.1
 signing_key:
 specification_version: 4
 summary: ''