Merge pull request #889 from mbj/refactor/cli

Refactor CLI

Author: mbj

lib/mutant/cli.rb

@@ -2,10 +2,22 @@
 
 module Mutant
   # Commandline parser / runner
+  #
+  # rubocop:disable Metrics/ClassLength
   class CLI
-    include Adamantium::Flat, Equalizer.new(:config), Procto.call(:config)
+    include Concord.new(:config)
 
-    Error = Class.new(RuntimeError)
+    private_class_method :new
+
+    OPTIONS =
+      %i[
+        add_environment_options
+        add_mutation_options
+        add_filter_options
+        add_debug_options
+      ].freeze
+
+    private_constant(*constants(false))
 
     # Run cli with arguments
     #
@@ -16,61 +28,57 @@ class CLI
     #   the user provided arguments
     #
     # @return [Boolean]
+    #
+    # rubocop:disable Style/Semicolon
     def self.run(config, arguments)
-      Runner.call(Env::Bootstrap.call(call(config, arguments))).success?
-    rescue Error => exception
-      config.stderr.puts(exception.message)
-      false
+      apply(config, arguments)
+        .fmap(&Env::Bootstrap.method(:call))
+        .fmap(&Runner.method(:call))
+        .from_right { |error| config.stderr.puts(error); return false }
+        .success?
     end
+    # rubocop:enable Style/Semicolon
 
-    # Initialize object
+    # Parse arguments into config
     #
     # @param [Config] config
     # @param [Array<String>] arguments
     #
-    # @return [undefined]
-    def initialize(config, arguments)
-      @config = config
-
-      parse(arguments)
+    # @return [Either<OptionParser::ParseError, Config>]
+    def self.apply(config, arguments)
+      Either
+        .wrap_error(OptionParser::ParseError) { new(config).parse(arguments) }
+        .lmap(&:message)
     end
 
-    # Config parsed from CLI
-    #
-    # @return [Config]
-    attr_reader :config
-
     # 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
 
-  private
-
     # Parse the command-line options
     #
     # @param [Array<String>] arguments
     #   Command-line options and arguments to be parsed.
     #
-    # @fail [Error]
-    #   An error occurred while parsing the options.
-    #
-    # @return [undefined]
+    # @return [Config]
     def parse(arguments)
       opts = OptionParser.new do |builder|
         builder.banner = 'usage: mutant [options] MATCH_EXPRESSION ...'
-        %i[add_environment_options add_mutation_options add_filter_options add_debug_options].each do |name|
+        OPTIONS.each do |name|
           __send__(name, builder)
         end
       end
 
       parse_match_expressions(opts.parse!(arguments))
-    rescue OptionParser::ParseError => error
-      raise(Error, error)
+
+      config
     end
 
+  private
+
     # Parse matchers
     #
     # @param [Array<String>] expressions
@@ -113,7 +121,10 @@ def add_environment_options(opts)
     def setup_integration(name)
       with(integration: Integration.setup(config.kernel, name))
     rescue LoadError
-      raise Error, "Could not load integration #{name.inspect} (you may want to try installing the gem mutant-#{name})"
+      raise(
+        OptionParser::InvalidArgument,
+        "Could not load integration #{name.inspect} (you may want to try installing the gem mutant-#{name})"
+      )
     end
 
     # Add mutation options

lib/mutant/env/bootstrap.rb

@@ -4,7 +4,7 @@ module Mutant
   class Env
     # Bootstrap environment
     class Bootstrap
-      include Adamantium::Flat, Concord::Public.new(:config), Procto.call(:env)
+      include Adamantium::Flat, Concord::Public.new(:config)
 
       SEMANTICS_MESSAGE_FORMAT =
         "%<message>s. Fix your lib to follow normal ruby semantics!\n" \
@@ -28,6 +28,15 @@ class Bootstrap
       # @return [Parser]
       attr_reader :parser
 
+      # Run Bootstrap
+      #
+      # @param [Config] config
+      #
+      # @return [Env]
+      def self.call(config)
+        new(config).env
+      end
+
       # Initialize object
       #
       # @return [Object]

spec/unit/mutant/cli_spec.rb

@@ -47,26 +47,38 @@ def apply
       described_class.run(config, arguments)
     end
 
-    let(:arguments)      { instance_double(Array)       }
-    let(:env)            { instance_double(Mutant::Env) }
-    let(:report_success) { true                         }
+    let(:arguments)      { instance_double(Array)            }
+    let(:env)            { instance_double(Mutant::Env)      }
+    let(:report_success) { true                              }
+    let(:cli_result)     { Mutant::Either::Right.new(config) }
 
     let(:report) do
       instance_double(Mutant::Result::Env, success?: report_success)
     end
 
     before do
-      allow(Mutant::CLI).to receive_messages(call: config)
+      allow(Mutant::CLI).to receive_messages(apply: cli_result)
       allow(Mutant::Env::Bootstrap).to receive_messages(call: env)
       allow(Mutant::Runner).to receive_messages(call: report)
     end
 
     it 'performs calls in expected sequence' do
       apply
 
-      expect(Mutant::CLI).to have_received(:call).with(config, arguments).ordered
-      expect(Mutant::Env::Bootstrap).to have_received(:call).with(config).ordered
-      expect(Mutant::Runner).to have_received(:call).with(env).ordered
+      expect(Mutant::CLI)
+        .to have_received(:apply)
+        .with(config, arguments)
+        .ordered
+
+      expect(Mutant::Env::Bootstrap)
+        .to have_received(:call)
+        .with(config)
+        .ordered
+
+      expect(Mutant::Runner)
+        .to have_received(:call)
+        .with(env)
+        .ordered
     end
 
     context 'when report signals success' do
@@ -85,30 +97,27 @@ def apply
       end
     end
 
-    context 'when execution raises an Mutant::CLI::Error' do
-      let(:exception)        { Mutant::CLI::Error.new('test-error') }
-      let(:expected_message) { 'test-error'                         }
-      let(:report_success)   { false                                }
-      let(:target_stream)    { stderr                               }
+    context 'when parts of the chain fail' do
+      let(:cli_result)       { Mutant::Either::Left.new(expected_message) }
+      let(:expected_message) { 'cli-error'                                }
+      let(:target_stream)    { stderr                                     }
 
-      before do
-        allow(report).to receive(:success?).and_raise(exception)
-      end
+      include_examples 'prints expected message'
 
-      it 'exits with failure' do
+      it 'exits failure' do
         expect(apply).to be(false)
       end
-
-      include_examples 'prints expected message'
     end
   end
 
-  describe '.new' do
+  describe '.apply' do
+    def apply
+      described_class.apply(config, arguments)
+    end
+
     shared_examples 'invalid arguments' do
-      it 'raises error' do
-        expect do
-          apply
-        end.to raise_error(Mutant::CLI::Error, expected_message)
+      it 'returns left error' do
+        expect(apply).to eql(Mutant::Either::Left.new(expected_message))
       end
     end
 
@@ -127,12 +136,8 @@ def apply
     end
 
     shared_examples_for 'cli parser' do
-      it { expect(apply.config.integration).to eql(expected_integration) }
-      it { expect(apply.config.matcher).to eql(expected_matcher_config)  }
-    end
-
-    def apply
-      described_class.new(config, arguments)
+      it { expect(apply.from_right.integration).to eql(expected_integration) }
+      it { expect(apply.from_right.matcher).to eql(expected_matcher_config)  }
     end
 
     before do
@@ -192,7 +197,7 @@ def apply
       include_examples 'no explicit exit'
 
       it 'configures includes' do
-        expect(apply.config.includes).to eql(%w[foo])
+        expect(apply.from_right.includes).to eql(%w[foo])
       end
     end
 
@@ -222,15 +227,18 @@ def apply
       context 'when integration does NOT exist' do
         let(:options) { %w[--use other] }
 
+        let(:expected_message) do
+          'invalid argument: '                                    \
+          '--use Could not load integration "other" '             \
+          '(you may want to try installing the gem mutant-other)'
+        end
+
         before do
           allow(Mutant::Integration).to receive(:setup).and_raise(LoadError)
         end
 
-        it 'raises error' do
-          expect { apply }.to raise_error(
-            Mutant::CLI::Error,
-            'Could not load integration "other" (you may want to try installing the gem mutant-other)'
-          )
+        it 'returns error' do
+          expect(apply).to eql(Mutant::Either::Left.new(expected_message))
         end
       end
     end
@@ -251,7 +259,7 @@ def apply
       include_examples 'no explicit exit'
 
       it 'configures expected coverage' do
-        expect(apply.config.jobs).to eql(0)
+        expect(apply.from_right.jobs).to eql(0)
       end
     end
 
@@ -262,7 +270,7 @@ def apply
       include_examples 'no explicit exit'
 
       it 'configures requires' do
-        expect(apply.config.requires).to eql(%w[foo bar])
+        expect(apply.from_right.requires).to eql(%w[foo bar])
       end
     end
 
@@ -305,7 +313,7 @@ def apply
       include_examples 'no explicit exit'
 
       it 'sets the fail fast option' do
-        expect(apply.config.fail_fast).to be(true)
+        expect(apply.from_right.fail_fast).to be(true)
       end
     end
 
@@ -316,7 +324,7 @@ def apply
       include_examples 'no explicit exit'
 
       it 'sets the zombie option' do
-        expect(apply.config.zombie).to be(true)
+        expect(apply.from_right.zombie).to be(true)
       end
     end
   end