guard-rspec 4.3.1 → 4.4.1

data/lib/guard/rspec/notifier.rb

@@ -1,5 +1,5 @@
 module Guard
-  class RSpec
+  class RSpec < Plugin
     class Notifier
       attr_accessor :options
 
@@ -7,19 +7,23 @@ module Guard
         @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)
+        ::Guard::Notifier.notify(summary,
+                                 title: @options[:title],
+                                 image: image,
+                                 priority: priority)
       end
 
       def notify_failure
         return unless options[:notification]
-        ::Guard::Notifier.notify('Failed', title: TITLE, image: :failed, priority: 2)
+        ::Guard::Notifier.notify("Failed",
+                                 title: @options[:title],
+                                 image: :failed,
+                                 priority: 2)
       end
 
       private

data/lib/guard/rspec/options.rb

@@ -1,15 +1,17 @@
 module Guard
-  class RSpec
+  class RSpec < Plugin
     module Options
       DEFAULTS = {
-          all_on_start:    false,
-          all_after_pass:  false,
-          run_all:         { message: 'Running all specs' },
-          failed_mode:     :none,  # :keep and :focus are other posibilities
-          spec_paths:      %w[spec],
-          cmd:             nil,
-          launchy:         nil,
-          notification:    true
+        all_on_start:    false,
+        all_after_pass:  false,
+        run_all:         { message: "Running all specs" },
+        failed_mode:     :none,  # :keep and :focus are other posibilities
+        spec_paths:      %w(spec),
+        cmd:             nil,
+        cmd_additional_args: nil,
+        launchy:         nil,
+        notification:    true,
+        title:           "RSpec results"
       }
 
       class << self
@@ -20,7 +22,7 @@ module Guard
         private
 
         def _deep_merge(hash1, hash2)
-          hash1.merge(hash2) do |key, oldval, newval|
+          hash1.merge(hash2) do |_key, oldval, newval|
             if oldval.instance_of?(Hash) && newval.instance_of?(Hash)
               _deep_merge(oldval, newval)
             else

data/lib/guard/rspec/runner.rb

@@ -1,11 +1,13 @@
-require 'guard/rspec/inspectors/factory'
-require 'guard/rspec/command'
-require 'guard/rspec/formatter'
-require 'guard/rspec/notifier'
+require "guard/rspec/inspectors/factory"
+require "guard/rspec/command"
+require "guard/rspec/notifier"
 
 module Guard
-  class RSpec
+  class RSpec < Plugin
     class Runner
+      # NOTE: must match with const in RspecFormatter!
+      TEMPORARY_FILE_PATH ||= "tmp/rspec_guard_result"
+
       attr_accessor :options, :inspector, :notifier
 
       def initialize(options = {})
@@ -25,7 +27,7 @@ module Guard
       def run(paths)
         paths = inspector.paths(paths)
         return true if paths.empty?
-        ::Guard::UI.info("Running: #{paths.join(' ')}", reset: true)
+        ::Guard::UI.info("Running: #{paths.join(" ")}", reset: true)
         _run(false, paths, options)
       end
 
@@ -38,20 +40,9 @@ module Guard
       def _run(all, paths, options)
         return unless _cmd_option_present(options)
         command = Command.new(paths, options)
+
         _without_bundler_env { Kernel.system(command) }.tap do |success|
-          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
+          _process_run_result(success, all)
         end
       end
 
@@ -65,29 +56,32 @@ module Guard
 
       def _cmd_option_present(options)
         return true if options[:cmd]
-        ::Guard::UI.error('No cmd option specified, unable to run specs!')
+        ::Guard::UI.error("No cmd option specified, unable to run specs!")
         notifier.notify_failure
         false
       end
 
       def _command_success?(success)
         return false if success.nil?
-        [Command::FAILURE_EXIT_CODE, 0].include?($?.exitstatus)
+        [Command::FAILURE_EXIT_CODE, 0].include?($CHILD_STATUS.exitstatus)
       end
 
       def _command_output
-        formatter_tmp_file = Formatter::TEMPORARY_FILE_PATH
+        formatter_tmp_file = _tmp_file(options[:chdir])
         lines = File.readlines(formatter_tmp_file)
-        [lines.first.strip, lines[1..11].map(&:strip).compact]
+        summary = lines.first.strip
+        failed_paths = lines[1..11].map(&:strip).compact
+
+        [summary, failed_paths]
       rescue
         [nil, nil]
       ensure
-        File.exist?(formatter_tmp_file) && File.delete(formatter_tmp_file)
+        File.delete(formatter_tmp_file) if File.exists?(formatter_tmp_file)
       end
 
       def _open_launchy
         return unless options[:launchy]
-        require 'launchy'
+        require "launchy"
         pn = Pathname.new(options[:launchy])
         ::Launchy.open(options[:launchy]) if pn.exist?
       end
@@ -96,6 +90,28 @@ module Guard
         return unless options[:all_after_pass]
         run_all
       end
+
+      def _process_run_result(result, all)
+        unless _command_success?(result)
+          notifier.notify_failure
+          return
+        end
+
+        summary, failed_paths = _command_output
+        unless summary && failed_paths
+          notifier.notify_failure
+        end
+
+        inspector.failed(failed_paths)
+        notifier.notify(summary)
+        _open_launchy
+
+        _run_all_after_pass if !all && result
+      end
+
+      def _tmp_file(chdir)
+        chdir ? File.join(chdir, TEMPORARY_FILE_PATH) : TEMPORARY_FILE_PATH
+      end
     end
   end
 end

data/lib/guard/rspec/templates/Guardfile

@@ -2,29 +2,57 @@
 #       rspec may be run, below are examples of the most common uses.
 #  * bundler: 'bundle exec rspec'
 #  * bundler binstubs: 'bin/rspec'
-#  * spring: 'bin/rsspec' (This will use spring if running and you have
+#  * spring: 'bin/rspec' (This will use spring if running and you have
 #                          installed the spring binstubs per the docs)
-#  * zeus: 'zeus rspec' (requires the server to be started separetly)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
 #  * 'just' rspec: 'rspec'
-guard :rspec, cmd: 'bundle exec rspec' do
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "ostruct"
+
+  # Generic Ruby apps
+  rspec = OpenStruct.new
+  rspec.spec = ->(m) { "spec/#{m}_spec.rb" }
+  rspec.spec_dir = "spec"
+  rspec.spec_helper = "spec/spec_helper.rb"
+
   watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
-  watch('spec/spec_helper.rb')  { "spec" }
+  watch(%r{^lib/(.+)\.rb$})     { |m| rspec.spec.("lib/#{m[1]}") }
+  watch(rspec.spec_helper)      { rspec.spec_dir }
 
   # Rails example
-  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
-  watch(%r{^app/(.*)(\.erb|\.haml|\.slim)$})          { |m| "spec/#{m[1]}#{m[2]}_spec.rb" }
-  watch(%r{^app/controllers/(.+)_(controller)\.rb$})  { |m| ["spec/routing/#{m[1]}_routing_spec.rb", "spec/#{m[2]}s/#{m[1]}_#{m[2]}_spec.rb", "spec/acceptance/#{m[1]}_spec.rb"] }
-  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
-  watch('config/routes.rb')                           { "spec/routing" }
-  watch('app/controllers/application_controller.rb')  { "spec/controllers" }
-  watch('spec/rails_helper.rb')                       { "spec" }
+  rails = OpenStruct.new
+  rails.app = %r{^app/(.+)\.rb$}
+  rails.views_n_layouts = %r{^app/(.*)(\.erb|\.haml|\.slim)$}
+  rails.controllers = %r{^app/controllers/(.+)_controller\.rb$}
+  rails.routes = "config/routes.rb"
+  rails.app_controller = "app/controllers/application_controller.rb"
+  rails.spec_helper = "spec/rails_helper.rb"
+  rails.spec_support = %r{^spec/support/(.+)\.rb$}
+  rails.views = %r{^app/views/(.+)/.*\.(erb|haml|slim)$}
+
+  watch(rails.app) { |m| rspec.spec.(m[1]) }
+  watch(rails.views_n_layouts) { |m| rspec.spec.("#{m[1]}#{m[2]}") }
+  watch(rails.controllers) do |m|
+    [
+      rspec.spec.("routing/#{m[1]}_routing"),
+      rspec.spec.("controllers/#{m[1]}_controller"),
+      rspec.spec.("acceptance/#{m[1]}")
+    ]
+  end
+
+  watch(rails.spec_support)    { rspec.spec_dir }
+  watch(rails.spec_helper)     { rspec.spec_dir }
+  watch(rails.routes)          { "spec/routing" }
+  watch(rails.app_controller)  { "spec/controllers" }
 
   # Capybara features specs
-  watch(%r{^app/views/(.+)/.*\.(erb|haml|slim)$})     { |m| "spec/features/#{m[1]}_spec.rb" }
+  watch(rails.views)     { |m| rspec.spec.("features/#{m[1]}") }
 
   # Turnip features and steps
   watch(%r{^spec/acceptance/(.+)\.feature$})
-  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$})   { |m| Dir[File.join("**/#{m[1]}.feature")][0] || 'spec/acceptance' }
-end
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$}) do |m|
+    Dir[File.join("**/#{m[1]}.feature")][0] || "spec/acceptance"
+  end
 
+end

data/lib/guard/rspec/version.rb

@@ -1,5 +1,5 @@
 module Guard
   module RSpecVersion
-    VERSION = '4.3.1'
+    VERSION = "4.4.1"
   end
 end

data/lib/guard/rspec_formatter.rb

@@ -0,0 +1,111 @@
+# NOTE: This class only exists for RSpec and should not be used by
+# other classes in this project!
+
+require "pathname"
+
+require "rspec"
+require "rspec/core/formatters/base_formatter"
+
+module Guard
+  class RSpecFormatter < ::RSpec::Core::Formatters::BaseFormatter
+    TEMPORARY_FILE_PATH ||= "tmp/rspec_guard_result"
+
+    def self.rspec_3?
+      ::RSpec::Core::Version::STRING.split(".").first == "3"
+    end
+
+    if rspec_3?
+      ::RSpec::Core::Formatters.register self, :dump_summary, :example_failed
+
+      def example_failed(failure)
+        examples.push failure.example
+      end
+
+      def examples
+        @examples ||= []
+      end
+    end
+
+    # rspec issue https://github.com/rspec/rspec-core/issues/793
+    def self.extract_spec_location(metadata)
+      root_metadata = metadata
+      location = metadata[:location]
+
+      until spec_path?(location)
+        metadata = metadata[:example_group]
+
+        unless metadata
+          STDERR.puts "no spec file found for #{root_metadata[:location]}"
+          return root_metadata[:location]
+        end
+
+        # rspec issue https://github.com/rspec/rspec-core/issues/1243
+        location = (metadata[:location] || "").split(":").first
+      end
+
+      location
+    end
+
+    def self.spec_path?(path)
+      path ||= ""
+      flags = File::FNM_PATHNAME | File::FNM_DOTMATCH
+      if File.const_defined?(:FNM_EXTGLOB) # ruby >= 2
+        flags |= File::FNM_EXTGLOB
+      end
+      pattern = ::RSpec.configuration.pattern
+      path = path.sub(/:\d+\z/, "")
+      path = Pathname.new(path).cleanpath.to_s
+      File.fnmatch(pattern, path, flags)
+    end
+
+    def dump_summary(*args)
+      if self.class.rspec_3?
+        notification = args[0]
+        write_summary(
+          notification.duration,
+          notification.example_count,
+          notification.failure_count,
+          notification.pending_count
+        )
+      else
+        write_summary(*args)
+      end
+    rescue
+      # nothing really we can do, at least don"t kill the test runner
+    end
+
+    # Write summary to temporary file for runner
+    def write_summary(duration, total, failures, pending)
+      _write do |f|
+        f.puts _message(total, failures, pending, duration)
+        f.puts _failed_paths.join("\n") if failures > 0
+      end
+    end
+
+    private
+
+    def _write(&block)
+      file = File.expand_path(TEMPORARY_FILE_PATH)
+      FileUtils.mkdir_p(File.dirname(file))
+      File.open(file, "w", &block)
+    end
+
+    def _failed_paths
+      failed = examples.select do |e|
+        e.execution_result[:status].to_s == "failed"
+      end
+
+      klass = self.class
+      failed.map { |e| klass.extract_spec_location(e.metadata) }.sort.uniq
+    end
+
+    def _message(example_count, failure_count, pending_count, duration)
+      message = "#{example_count} examples, #{failure_count} failures"
+      if pending_count > 0
+        message << " (#{pending_count} pending)"
+      end
+      message << " in #{duration.round(4)} seconds"
+      message
+    end
+  end
+end

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

@@ -1,12 +1,14 @@
-require 'spec_helper'
-require 'launchy'
+require "launchy"
 
-describe Guard::RSpec::Command do
-  let(:options) { { } }
-  let(:paths) { %w[path1 path2] }
+require "guard/compat/test/helper"
+require "guard/rspec/command"
+
+RSpec.describe Guard::RSpec::Command do
+  let(:options) { {} }
+  let(:paths) { %w(path1 path2) }
   let(:command) { Guard::RSpec::Command.new(paths, options) }
 
-  describe '.initialize' do
+  describe ".initialize" do
 
     it "sets paths at the end" do
       expect(command).to match /path1 path2$/
@@ -17,20 +19,26 @@ describe Guard::RSpec::Command do
     end
 
     it "sets formatter" do
-      expect(command).to match %r{-r .*/lib/guard/rspec/formatter.rb -f Guard::RSpec::Formatter}
+      regexp = %r{-r .*/lib/guard/rspec_formatter.rb -f Guard::RSpecFormatter}
+      expect(command).to match(regexp)
     end
 
     context "with custom cmd" do
-      let(:options) { { cmd: 'rspec -t ~slow' } }
+      let(:options) { { cmd: "rspec -t ~slow" } }
 
       it "uses custom cmd" do
-        expect(command).to match  /^rspec -t ~slow/
+        expect(command).to match /^rspec -t ~slow/
       end
     end
 
     context "with RSpec defined formatter" do
-      let(:formatters) { [['doc','output']] }
-      before { allow(RSpec::Core::ConfigurationOptions).to receive(:new) { double(options: { formatters: formatters }) } }
+      let(:formatters) { [%w(doc output)] }
+
+      before do
+        allow(RSpec::Core::ConfigurationOptions).to receive(:new) do
+          double(options: { formatters: formatters })
+        end
+      end
 
       it "uses them" do
         expect(command).to match %r{-f doc -o output}
@@ -44,12 +52,40 @@ describe Guard::RSpec::Command do
     end
 
     context "with formatter in cmd" do
-      let(:options) { { cmd: 'rspec -f doc' } }
+      let(:options) { { cmd: "rspec -f doc" } }
 
       it "sets no other formatters" do
         expect(command).to match %r{-f doc}
       end
     end
+
+    context "with cmd_additional_args" do
+      let(:options) { { cmd: "rspec", cmd_additional_args: "-f progress" } }
+
+      it "uses them" do
+        expect(command).to match %r{-f progress}
+      end
+    end
+
+    context ":chdir option present" do
+      let(:chdir) { "moduleA" }
+      let(:paths) do
+        %w[path1 path2].map { |p| "#{chdir}#{File::Separator}#{p}" }
+      end
+
+      let(:options) do
+        {
+          cmd: "cd #{chdir} && rspec",
+          chdir: chdir
+        }
+      end
+
+      it "removes chdir part from the path
+        as it should be present in the cmd" do
+
+        expect(command).to match %r{path1 path2}
+      end
+    end
   end
 
 end