guard-rspec 4.0.4 → 4.1.0

data/lib/guard/rspec/notifier.rb

@@ -0,0 +1,52 @@
+module Guard
+  class RSpec
+    class Notifier
+      attr_accessor :options
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      TITLE = 'RSpec results'
+
+      def notify(summary)
+        return unless options[:notification]
+        failure_count, pending_count = _parse_summary(summary)
+        image = _image(failure_count, pending_count)
+        priority = _priority(image)
+        ::Guard::Notifier.notify(summary, title: TITLE, image: image, priority: priority)
+      end
+
+      def notify_failure
+        return unless options[:notification]
+        ::Guard::Notifier.notify('Failed', title: TITLE, image: :failed, priority: 2)
+      end
+
+      private
+
+      def _parse_summary(summary)
+        summary.match(/(\d+) failures( \((\d+) pending\))?/) do |m|
+          return m[1].to_i, m[3].to_i
+        end
+        [0, 0]
+      end
+
+      def _image(failure_count, pending_count)
+        if failure_count > 0
+          :failed
+        elsif pending_count > 0
+          :pending
+        else
+          :success
+        end
+      end
+
+      def _priority(image)
+        { failed:   2,
+          pending: -1,
+          success: -2
+        }[image]
+      end
+    end
+  end
+end

data/lib/guard/rspec/options.rb

@@ -0,0 +1,34 @@
+module Guard
+  class RSpec
+    module Options
+      DEFAULTS = {
+          all_on_start:    false,
+          all_after_pass:  false,
+          run_all:         { message: 'Running all specs' },
+          failed_mode:     :focus,  # :keep and :none are other posibilities
+          spec_paths:      %w[spec],
+          cmd:             'rspec',
+          launchy:         nil,
+          notification:    true
+      }.freeze
+
+      class << self
+        def with_defaults(options = {})
+          _deep_merge(DEFAULTS, options).freeze
+        end
+
+        private
+
+        def _deep_merge(hash1, hash2)
+          hash1.merge(hash2) do |key, oldval, newval|
+            if oldval.instance_of?(Hash) && newval.instance_of?(Hash)
+              _deep_merge(oldval, newval)
+            else
+              newval
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/guard/rspec/runner.rb

@@ -1,51 +1,56 @@
+require 'guard/rspec/inspectors/factory'
 require 'guard/rspec/command'
-require 'guard/rspec/inspector'
+require 'guard/rspec/formatter'
+require 'guard/rspec/notifier'
 
 module Guard
   class RSpec
     class Runner
-      attr_accessor :options, :inspector
+      attr_accessor :options, :inspector, :notifier
 
       def initialize(options = {})
-        @options = {
-          all_after_pass: false,
-          notification:   true,
-          run_all:        { message: 'Running all specs' },
-          launchy:        nil
-        }.merge(options)
-
-        @inspector = Inspector.new(@options)
+        @options = options
+        @inspector = Inspectors::Factory.create(@options)
+        @notifier = Notifier.new(@options)
       end
 
       def run_all
-        options = @options.merge(@options[:run_all])
+        paths = options[:spec_paths]
+        options = @options.merge(@options[:run_all]).freeze
+        return if paths.empty?
         ::Guard::UI.info(options[:message], reset: true)
-
-        _run(inspector.paths, [], options)
+        _run(true, paths, options)
       end
 
       def run(paths)
-        failed_paths = inspector.failed_paths
         paths = inspector.paths(paths)
         return if paths.empty?
-
         ::Guard::UI.info("Running: #{paths.join(' ')}", reset: true)
-
-        _run(paths, failed_paths, options)
+        _run(false, paths, options)
       end
 
       def reload
-        inspector.clear_paths
+        inspector.reload
       end
 
       private
 
-      def _run(paths, failed_paths, options)
+      def _run(all, paths, options)
         command = Command.new(paths, options)
         _without_bundler_env { Kernel.system(command) }.tap do |success|
-          success ? inspector.clear_paths(paths) : _notify_failure
-          _open_launchy
-          _run_all_after_pass(success, failed_paths)
+          if _command_success?(success)
+            summary, failed_paths = _command_output
+            if summary && failed_paths
+              inspector.failed(failed_paths)
+              notifier.notify(summary)
+              _open_launchy
+              _run_all_after_pass if !all && success
+            else
+              notifier.notify_failure
+            end
+          else
+            notifier.notify_failure
+          end
         end
       end
 
@@ -57,14 +62,19 @@ module Guard
         end
       end
 
-      def _notify_failure
-        return unless options[:notification]
-        return unless command_exception?
-        ::Guard::Notifier.notify('Failed', title: 'RSpec results', image: :failed, priority: 2)
+      def _command_success?(success)
+        return false if success.nil?
+        [Command::FAILURE_EXIT_CODE, 0].include?($?.exitstatus)
       end
 
-      def command_exception?
-        $?.exitstatus != Command::FAILURE_EXIT_CODE
+      def _command_output
+        formatter_tmp_file = Formatter::TEMPORARY_FILE_PATH
+        lines = File.readlines(formatter_tmp_file)
+        [lines.first.strip, lines[1..11].map(&:strip).compact]
+      rescue
+        [nil, nil]
+      ensure
+        File.exist?(formatter_tmp_file) && File.delete(formatter_tmp_file)
       end
 
       def _open_launchy
@@ -74,11 +84,10 @@ module Guard
         ::Launchy.open(options[:launchy]) if pn.exist?
       end
 
-      def _run_all_after_pass(success, failed_paths)
+      def _run_all_after_pass
         return unless options[:all_after_pass]
-        run_all if success && !failed_paths.empty?
+        run_all
       end
-
     end
   end
 end

data/lib/guard/rspec/version.rb

@@ -1,5 +1,5 @@
 module Guard
   module RSpecVersion
-    VERSION = '4.0.4'
+    VERSION = '4.1.0'
   end
 end

data/spec/lib/guard/rspec/command_spec.rb

@@ -16,12 +16,8 @@ describe Guard::RSpec::Command do
       expect(command).to match /--failure-exit-code 2/
     end
 
-    it "sets notifier formatter" do
-      expect(command).to match %r{-r .*/lib/guard/rspec/formatters/notifier.rb -f Guard::RSpec::Formatters::Notifier}
-    end
-
-    it "sets focuser formatter" do
-      expect(command).to match %r{-r .*/lib/guard/rspec/formatters/focuser.rb -f Guard::RSpec::Formatters::Focuser}
+    it "sets formatter" do
+      expect(command).to match %r{-r .*/lib/guard/rspec/formatter.rb -f Guard::RSpec::Formatter}
     end
 
     context "with custom cmd" do

data/spec/lib/guard/rspec/deprecator_spec.rb

@@ -10,13 +10,13 @@ describe Guard::RSpec::Deprecator do
       it "shows warning if SPEC_OPTS is set" do
         ENV['SPEC_OPTS'] = '-f p'
         expect(Guard::UI).to receive(:warning).with(
-          'The SPEC_OPTS environment variable is present. This can conflict with guard-rspec, particularly notifications.')
+          'The SPEC_OPTS environment variable is present. This can conflict with guard-rspec.')
         deprecator.warns_about_deprecated_options
         ENV['SPEC_OPTS'] = nil # otherwise other specs pick it up and fail
       end
       it "does not show warning if SPEC_OPTS is unset" do
         expect(Guard::UI).to_not receive(:warning).with(
-          'The SPEC_OPTS environment variable is present. This can conflict with guard-rspec, particularly notifications.')
+          'The SPEC_OPTS environment variable is present. This can conflict with guard-rspec.')
         deprecator.warns_about_deprecated_options
       end
     end
@@ -53,5 +53,24 @@ describe Guard::RSpec::Deprecator do
       end
     end
 
+    describe 'with keep_failed option' do
+      let(:options) { { keep_failed: true } }
+
+      it 'shows deprecation warning' do
+        expect(Guard::UI).to receive(:warning).with(
+          'Guard::RSpec DEPRECATION WARNING: The :keep_failed option is deprecated. Please set new :failed_mode option value to :keep instead. https://github.com/guard/guard-rspec#list-of-available-options')
+        deprecator.warns_about_deprecated_options
+      end
+    end
+
+    describe 'with focus_on_failed option' do
+      let(:options) { { focus_on_failed: true } }
+
+      it 'shows deprecation warning' do
+        expect(Guard::UI).to receive(:warning).with(
+          'Guard::RSpec DEPRECATION WARNING: The :focus_on_failed option is deprecated. Focus mode is the default and can be changed using new :failed_mode option. https://github.com/guard/guard-rspec#list-of-available-options')
+        deprecator.warns_about_deprecated_options
+      end
+    end
   end
 end

data/spec/lib/guard/rspec/formatter_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper.rb'
+
+require 'guard/rspec/formatter'
+
+describe Guard::RSpec::Formatter do
+  let(:formatter) { Guard::RSpec::Formatter.new(StringIO.new) }
+
+  describe '#dump_summary' do
+    after { File.delete('./tmp/rspec_guard_result') }
+
+    context 'with failures' do
+      let(:example) { double(
+        execution_result: { status: 'failed' },
+        metadata: { location: 'failed_location' }
+      ) }
+
+      it 'writes summary line and failed location in tmp dir' do
+        formatter.stub(:examples) { [example] }
+        formatter.dump_summary(123, 3, 1, 0)
+        result = File.open('./tmp/rspec_guard_result').read
+        expect(result).to match /^3 examples, 1 failures in 123\.0 seconds\nfailed_location\n$/
+      end
+    end
+
+    context 'with only success' do
+      it 'notifies success' do
+        formatter.dump_summary(123, 3, 0, 0)
+        result = File.open('./tmp/rspec_guard_result').read
+        expect(result).to match /^3 examples, 0 failures in 123\.0 seconds\n$/
+      end
+    end
+
+    context 'with pending' do
+      it "notifies pending too" do
+        formatter.dump_summary(123, 3, 0, 1)
+        result = File.open('./tmp/rspec_guard_result').read
+        expect(result).to match /^3 examples, 0 failures \(1 pending\) in 123\.0 seconds\n$/
+      end
+    end
+  end
+
+end

data/spec/lib/guard/rspec/inspectors/base_inspector_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Guard::RSpec::Inspectors::BaseInspector do
+  let(:options) { { custom: 'value', spec_paths: %w[myspec] } }
+  let(:inspector) { Guard::RSpec::Inspectors::BaseInspector.new(options) }
+  let(:paths) { %w[spec/foo_spec.rb spec/bar_spec.rb] }
+  let(:abstract_error) { 'Must be implemented in subclass' }
+
+  describe '.initialize' do
+    it 'sets options and spec_paths' do
+      expect(inspector.options).to include(:custom, :spec_paths)
+      expect(inspector.options[:custom]).to eq('value')
+      expect(inspector.spec_paths).to eq(%w[myspec])
+    end
+  end
+
+  describe '#paths' do
+    it 'should not be emplemented here' do
+      expect { inspector.paths(paths) }.to raise_error(abstract_error)
+    end
+  end
+
+  describe '#failed' do
+    it 'should not be emplemented here' do
+      expect { inspector.failed(paths) }.to raise_error(abstract_error)
+    end
+  end
+
+  describe '#reload' do
+    it 'should not be emplemented here' do
+      expect { inspector.reload }.to raise_error(abstract_error)
+    end
+  end
+end

data/spec/lib/guard/rspec/inspectors/factory_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe Guard::RSpec::Inspectors::Factory do
+  let(:factory) { Guard::RSpec::Inspectors::Factory }
+  let(:options) { {} }
+
+  it 'can not be instantiated' do
+    expect { factory.new(options) }.to raise_error(NoMethodError)
+  end
+
+  context 'with :focus failed mode and custom options' do
+    let(:options) { { failed_mode: :focus, custom: 'value' } }
+
+    it 'creates FocusedInspector instance with custom options' do
+      inspector = factory.create(options)
+      expect(inspector).to be_an_instance_of(Guard::RSpec::Inspectors::FocusedInspector)
+      expect(inspector.options).to eq(options)
+    end
+  end
+
+  context 'with :keep failed mode and custom options' do
+    let(:options) { { failed_mode: :keep, custom: 'value' } }
+
+    it 'creates KeepingInspector instance with custom options' do
+      inspector = factory.create(options)
+      expect(inspector).to be_an_instance_of(Guard::RSpec::Inspectors::KeepingInspector)
+      expect(inspector.options).to eq(options)
+    end
+  end
+
+  context 'with :none failed mode and custom options' do
+    let(:options) { { failed_mode: :none, custom: 'value' } }
+
+    it 'creates SimpleInspector instance with custom options' do
+      inspector = factory.create(options)
+      expect(inspector).to be_an_instance_of(Guard::RSpec::Inspectors::SimpleInspector)
+      expect(inspector.options).to eq(options)
+    end
+  end
+end

data/spec/lib/guard/rspec/inspectors/focused_inspector_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require 'lib/guard/rspec/inspectors/shared_examples'
+
+klass = Guard::RSpec::Inspectors::FocusedInspector
+
+describe klass do
+  include_examples 'inspector', klass
+
+  # Use real paths because BaseInspector#_clean will be used to clean them
+  let(:other_paths) { [
+    'spec/lib/guard/rspec/inspectors/simple_inspector_spec.rb',
+    'spec/lib/guard/rspec/runner_spec.rb'
+  ] }
+  let(:other_failed_locations) { %w[./spec/lib/guard/rspec/deprecator_spec.rb:446] }
+
+  it 'remembers failed paths and returns them until they all pass' do
+    expect(inspector.paths(paths)).to match_array(paths)
+    inspector.failed(failed_locations)
+
+    # Return failed_locations until they pass
+    3.times do
+      expect(inspector.paths(other_paths)).to match_array(failed_locations)
+      inspector.failed(other_failed_locations)
+
+      expect(inspector.paths(paths)).to match_array(failed_locations)
+      inspector.failed(other_failed_locations)
+
+      expect(inspector.paths([])).to match_array(failed_locations)
+      inspector.failed(failed_locations)
+    end
+
+    # Now all pass
+    expect(inspector.paths(paths)).to match_array(failed_locations)
+    inspector.failed([])
+
+    # And some fails again
+    expect(inspector.paths(other_paths)).to match_array(other_paths)
+    inspector.failed(other_failed_locations)
+
+    # Return other_failed_locations until they pass
+    3.times do
+      expect(inspector.paths(other_paths)).to match_array(other_failed_locations)
+      inspector.failed(other_failed_locations)
+
+      expect(inspector.paths(paths)).to match_array(other_failed_locations)
+      inspector.failed(other_failed_locations)
+
+      expect(inspector.paths([])).to match_array(other_failed_locations)
+      inspector.failed(failed_locations)
+    end
+
+    # Now all pass
+    expect(inspector.paths(paths)).to match_array(other_failed_locations)
+    inspector.failed([])
+
+    expect(inspector.paths(paths)).to match_array(paths)
+    inspector.failed([])
+
+    expect(inspector.paths(other_paths)).to match_array(other_paths)
+    inspector.failed([])
+
+    expect(inspector.paths([])).to eq([])
+  end
+
+  describe '#reload' do
+    it 'force to forget about focused locations' do
+      expect(inspector.paths(paths)).to match_array(paths)
+      inspector.failed(failed_locations)
+
+      inspector.reload
+      expect(inspector.paths(other_paths)).to match_array(other_paths)
+    end
+  end
+end