guard-rspec 2.1.0 → 4.7.3

data/lib/guard/rspec/runner.rb

@@ -1,202 +1,99 @@
-require 'drb/drb'
-require 'rspec'
+require "guard/rspec_defaults"
+
+require "guard/rspec/inspectors/factory"
+require "guard/rspec/command"
+require "guard/rspec/notifier"
+require "guard/rspec/results"
+require "guard/rspec/rspec_process"
 
 module Guard
-  class RSpec
+  class RSpec < Plugin
     class Runner
-
-      FAILURE_EXIT_CODE = 2
-
-      def initialize(options = {})
-        @options = {
-          :bundler      => true,
-          :binstubs     => false,
-          :rvm          => nil,
-          :cli          => nil,
-          :env          => nil,
-          :notification => true,
-          :turnip       => false,
-          :zeus         => false
-        }.merge(options)
-
-        deprecations_warnings
-      end
-
-      def run(paths, options = {})
-        return false if paths.empty?
-
-        message = options[:message] || "Running: #{paths.join(' ')}"
-        UI.info(message, :reset => true)
-
-        options = @options.merge(options)
-
-        if drb_used?
-          run_via_drb(paths, options)
-        else
-          run_via_shell(paths, options)
-        end
-      end
-
-      def rspec_executable
-        @rspec_executable ||= binstubs? ? "#{binstubs}/rspec" : "rspec"
-      end
-
-      def failure_exit_code_supported?
-        @failure_exit_code_supported ||= begin
-          cmd_parts = []
-          cmd_parts << "bundle exec" if bundle_exec?
-          cmd_parts << rspec_executable
-          cmd_parts << "--help"
-          `#{cmd_parts.join(' ')}`.include? "--failure-exit-code"
-        end
-      end
-
-      def parsed_or_default_formatter
-        @parsed_or_default_formatter ||= begin
-          # Use RSpec's parser to parse formatters
-          formatters = ::RSpec::Core::ConfigurationOptions.new([]).parse_options()[:formatters]
-          # Use a default formatter if none exists.
-          # RSpec's parser returns an array in the format [[formatter, output], ...], so match their format
-          formatters = [['progress']] if formatters.nil? || formatters.empty?
-          # Construct a matching command line option, including output target
-          formatters.map { |formatter| "-f #{formatter.join ' -o '}" }.join ' '
-        end
-      end
-
-    private
-
-      def environment_variables
-        return if @options[:env].nil?
-        "export " + @options[:env].map {|key, value| "#{key}=#{value}"}.join(' ') + ';'
-      end
-
-      def rspec_arguments(paths, options)
-        arg_parts = []
-        arg_parts << options[:cli]
-        if @options[:notification]
-          arg_parts << parsed_or_default_formatter unless options[:cli] =~ formatter_regex
-          arg_parts << "-r #{File.dirname(__FILE__)}/formatter.rb"
-          arg_parts << "-f Guard::RSpec::Formatter --out /dev/null"
+      class NoCmdOptionError < RuntimeError
+        def initialize
+          super "No cmd option specified, unable to run specs!"
         end
-        arg_parts << "--failure-exit-code #{FAILURE_EXIT_CODE}" if failure_exit_code_supported?
-        arg_parts << "-r turnip/rspec" if @options[:turnip]
-        arg_parts << paths.join(' ')
-
-        arg_parts.compact.join(' ')
       end
 
-      def rspec_command(paths, options)
-        cmd_parts = []
-        cmd_parts << environment_variables
-        cmd_parts << "rvm #{@options[:rvm].join(',')} exec" if @options[:rvm].respond_to?(:join)
-        cmd_parts << "bundle exec" if bundle_exec?
-        cmd_parts << 'zeus' if zeus?
-        cmd_parts << rspec_executable
-        cmd_parts << rspec_arguments(paths, options)
-        cmd_parts.compact.join(' ')
-      end
-
-      def run_via_shell(paths, options)
-        success = system(rspec_command(paths, options))
-
-        if @options[:notification] && !drb_used? && !success && rspec_command_exited_with_an_exception?
-          Notifier.notify("Failed", :title => "RSpec results", :image => :failed, :priority => 2)
-        end
-
-        success
-      end
-
-      def rspec_command_exited_with_an_exception?
-        failure_exit_code_supported? && $?.exitstatus != FAILURE_EXIT_CODE
-      end
+      attr_accessor :options, :inspector, :notifier
 
-      # We can optimize this path by hitting up the drb server directly, circumventing the overhead
-      # of the user's shell, bundler and ruby environment.
-      def run_via_drb(paths, options)
-        require "shellwords"
-        argv = rspec_arguments(paths, options).shellsplit
-
-        # The user can specify --drb-port for rspec, we need to honor it.
-        if idx = argv.index("--drb-port")
-          port = argv[idx + 1].to_i
+      def initialize(options = {})
+        @options = options
+        @inspector = Inspectors::Factory.create(@options)
+        @notifier = Notifier.new(@options)
+      end
+
+      def run_all
+        paths = options[:spec_paths]
+        options = @options.merge(@options[:run_all])
+        return true if paths.empty?
+        Compat::UI.info(options[:message], reset: true)
+        _run(paths, options)
+      end
+
+      def run(paths)
+        paths = inspector.paths(paths)
+        return true if paths.empty?
+        Compat::UI.info("Running: #{paths.join(' ')}", reset: true)
+        _run(paths, options) do |all_green|
+          next false unless all_green
+          next true unless options[:all_after_pass]
+          run_all
         end
-        port = ENV["RSPEC_DRB"] || 8989 unless port && port > 0
-        ret = drb_service(port.to_i).run(argv, $stderr, $stdout)
-
-        [0, true].include?(ret)
-      rescue DRb::DRbConnError
-        # Fall back to the shell runner; we don't want to mangle the environment!
-        run_via_shell(paths, options)
       end
 
-      def drb_used?
-        @drb_used ||= @options[:cli] && @options[:cli].include?('--drb')
+      def reload
+        inspector.reload
       end
 
-      # W we can avoid loading a large chunk of rspec
-      # just to let DRb know what to do.
-      #
-      # For reference:
-      #
-      # * RSpec: https://github.com/rspec/rspec-core/blob/master/lib/rspec/core/drb_command_line.rb
-      def drb_service(port)
-        require "drb/drb"
-
-        # Make sure we have a listener running
-        unless @drb_listener_running
-          begin
-            DRb.start_service("druby://localhost:0")
-          rescue SocketError, Errno::EADDRNOTAVAIL
-            DRb.start_service("druby://:0")
-          end
-
-          @drb_listener_running = true
-        end
+      private
 
-        @drb_services ||= {}
-        @drb_services[port.to_i] ||= DRbObject.new_with_uri("druby://127.0.0.1:#{port}")
+      def _run(paths, options, &block)
+        raise NoCmdOptionError unless options[:cmd]
+        command = Command.new(paths, options)
+        _really_run(command, options, &block)
+      rescue RSpecProcess::Failure, NoCmdOptionError => ex
+        Compat::UI.error(ex.to_s)
+        notifier.notify_failure
+        false
       end
 
-      def bundler_allowed?
-        @bundler_allowed ||= File.exist?("#{Dir.pwd}/Gemfile")
-      end
+      def _really_run(cmd, options)
+        # TODO: add option to specify the file
+        file = _results_file(options[:results_file], options[:chdir])
 
-      def bundler?
-        @bundler ||= bundler_allowed? && @options[:bundler]
-      end
+        process = RSpecProcess.new(cmd, file, options)
+        results = process.results
 
-      def binstubs?
-        @binstubs ||= !!@options[:binstubs]
-      end
+        inspector.failed(results.failed_paths)
+        notifier.notify(results.summary)
+        _open_launchy
 
-      def zeus?
-        @options[:zeus] || false
+        all_green = process.all_green?
+        return yield all_green if block_given?
+        all_green
       end
 
-      def binstubs
-        @options[:binstubs] == true ? "bin" : @options[:binstubs]
+      def _open_launchy
+        return unless options[:launchy]
+        require "launchy"
+        pn = Pathname.new(options[:launchy])
+        ::Launchy.open(options[:launchy]) if pn.exist?
       end
 
-      def bundle_exec?
-        bundler? && !binstubs?
-      end
+      def _results_file(results_file, chdir)
+        results_file ||= File.expand_path(RSpecDefaults::TEMPORARY_FILE_PATH)
+        return results_file unless Pathname(results_file).relative?
+        results_file = File.join(chdir, results_file) if chdir
+        return results_file unless Pathname(results_file).relative?
 
-      def deprecations_warnings
-        [:color, :drb, [:fail_fast, "fail-fast"], [:formatter, "format"]].each do |option|
-          key, value = option.is_a?(Array) ? option : [option, option.to_s]
-          if @options.key?(key)
-            @options.delete(key)
-            UI.info %{DEPRECATION WARNING: The :#{key} option is deprecated. Pass standard command line argument "--#{value}" to RSpec with the :cli option.}
-          end
+        unless Pathname(results_file).absolute?
+          msg = "Guard::RSpec: The results file %s is not an absolute path."\
+            " Please provide an absolute path to avoid issues."
+          Compat::UI.warning(format(msg, results_file.inspect))
         end
-        if @options.key?(:version)
-            @options.delete(:version)
-            UI.info %{DEPRECATION WARNING: The :version option is deprecated. Only RSpec 2 is now supported.}
-        end
-      end
 
-      def formatter_regex
-        @formatter_regex ||= /(?:^|\s)(?:-f\s*|--format(?:=|\s+))([\w:]+)/
+        File.expand_path(results_file)
       end
     end
   end

data/lib/guard/rspec/templates/Guardfile

@@ -1,21 +1,53 @@
-guard 'rspec' do
-  watch(%r{^spec/.+_spec\.rb$})
-  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/lib/#{m[1]}_spec.rb" }
-  watch('spec/spec_helper.rb')  { "spec" }
-
-  # Rails example
-  watch(%r{^app/(.+)\.rb$})                           { |m| "spec/#{m[1]}_spec.rb" }
-  watch(%r{^app/(.*)(\.erb|\.haml)$})                 { |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" }
-
-  # Capybara request specs
-  watch(%r{^app/views/(.+)/.*\.(erb|haml)$})          { |m| "spec/requests/#{m[1]}_spec.rb" }
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * 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 separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+
+  # Rails files
+  rails = dsl.rails(view_extensions: %w(erb haml slim))
+  dsl.watch_spec_files_for(rails.app_files)
+  dsl.watch_spec_files_for(rails.views)
+
+  watch(rails.controllers) do |m|
+    [
+      rspec.spec.call("routing/#{m[1]}_routing"),
+      rspec.spec.call("controllers/#{m[1]}_controller"),
+      rspec.spec.call("acceptance/#{m[1]}")
+    ]
+  end
+
+  # Rails config changes
+  watch(rails.spec_helper)     { rspec.spec_dir }
+  watch(rails.routes)          { "#{rspec.spec_dir}/routing" }
+  watch(rails.app_controller)  { "#{rspec.spec_dir}/controllers" }
+
+  # Capybara features specs
+  watch(rails.view_dirs)     { |m| rspec.spec.call("features/#{m[1]}") }
+  watch(rails.layouts)       { |m| rspec.spec.call("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' }
+  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 = "2.1.0"
+    VERSION = "4.7.3".freeze
   end
 end

data/lib/guard/rspec.rb

@@ -1,80 +1,51 @@
-require 'guard'
-require 'guard/guard'
+require "guard/compat/plugin"
+
+require "guard/rspec/options"
+require "guard/rspec/deprecator"
+require "guard/rspec/runner"
+
+# NOTE: To avoid 'superclass mismatch for class RSpec' errors,
+# every file has to have
+#
+#   class RSpec < Plugin
+#
+# and not just
+#
+#   class RSpec
 
 module Guard
-  class RSpec < Guard
-    autoload :Runner,    'guard/rspec/runner'
-    autoload :Inspector, 'guard/rspec/inspector'
+  class RSpec < Plugin
+    attr_accessor :options, :runner
 
-    def initialize(watchers = [], options = {})
+    def initialize(options = {})
       super
-      @options = {
-        :all_after_pass => true,
-        :all_on_start   => true,
-        :keep_failed    => true,
-        :spec_paths     => ["spec"],
-        :run_all        => {}
-      }.merge(options)
-      @last_failed  = false
-      @failed_paths = []
-
-      @inspector = Inspector.new(@options)
-      @runner    = Runner.new(@options)
+      @options = Options.with_defaults(options)
+      Deprecator.warns_about_deprecated_options(@options)
+      @runner = Runner.new(@options)
     end
 
-    # Call once when guard starts
     def start
-      UI.info "Guard::RSpec is running"
-      run_all if @options[:all_on_start]
+      Compat::UI.info "Guard::RSpec is running"
+      run_all if options[:all_on_start]
     end
 
     def run_all
-      passed = @runner.run(@inspector.spec_paths, @options[:run_all].merge(:message => 'Running all specs'))
-
-      unless @last_failed = !passed
-        @failed_paths = []
-      else
-        throw :task_has_failed
-      end
+      _throw_if_failed { runner.run_all }
     end
 
     def reload
-      @failed_paths = []
+      runner.reload
     end
 
-    def run_on_changes(paths)
-      paths += @failed_paths if @options[:keep_failed]
-      paths  = @inspector.clean(paths)
-
-      if passed = @runner.run(paths)
-        remove_failed(paths)
-
-        # run all the specs if the run before this one failed
-        if @last_failed && @options[:all_after_pass]
-          @last_failed = false
-          run_all
-        end
-      else
-        @last_failed = true
-        add_failed(paths)
-
-        throw :task_has_failed
-      end
+    def run_on_modifications(paths)
+      return false if paths.empty?
+      _throw_if_failed { runner.run(paths) }
     end
 
-  private
+    private
 
-    def run(paths)
+    def _throw_if_failed
+      throw :task_has_failed unless yield
     end
-
-    def remove_failed(paths)
-      @failed_paths -= paths if @options[:keep_failed]
-    end
-
-    def add_failed(paths)
-      @failed_paths += paths if @options[:keep_failed]
-    end
-
   end
 end
-

data/lib/guard/rspec_defaults.rb

@@ -0,0 +1,5 @@
+module Guard
+  class RSpecDefaults
+    TEMPORARY_FILE_PATH = "tmp/rspec_guard_result".freeze
+  end
+end

data/lib/guard/rspec_formatter.rb

@@ -0,0 +1,147 @@
+# NOTE: This class only exists for RSpec and should not be used by
+# other classes in this project!
+
+require "pathname"
+require "fileutils"
+
+require "rspec"
+require "rspec/core/formatters/base_formatter"
+
+require_relative "rspec_formatter_results_path"
+
+module Guard
+  class RSpecFormatter < ::RSpec::Core::Formatters::BaseFormatter
+    UNSUPPORTED_PATTERN =
+      "Your RSpec.configuration.pattern uses characters "\
+      "unsupported by your Ruby version (File::FNM_EXTGLOB is undefined)".freeze
+
+    class Error < RuntimeError
+      class UnsupportedPattern < Error
+        def initialize(msg = UNSUPPORTED_PATTERN)
+          super
+        end
+      end
+    end
+
+    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
+
+    class << self
+      # rspec issue https://github.com/rspec/rspec-core/issues/793
+      def extract_spec_location(metadata)
+        root_metadata = metadata
+        location = metadata[:location]
+
+        until spec_path?(location)
+          unless (metadata = _extract_group(metadata))
+            STDERR.puts "no spec file location in #{root_metadata.inspect}"
+            return root_metadata[:location]
+          end
+
+          # rspec issue https://github.com/rspec/rspec-core/issues/1243
+          location = first_colon_separated_entry(metadata[:location])
+        end
+
+        location
+      end
+
+      def spec_path?(path)
+        pattern = ::RSpec.configuration.pattern
+
+        flags = supported_fnmatch_flags(pattern)
+        path ||= ""
+        path = path.sub(/:\d+\z/, "")
+        path = Pathname.new(path).cleanpath.to_s
+        stripped = "{#{pattern.gsub(/\s*,\s*/, ',')}}"
+        File.fnmatch(stripped, path, flags)
+      end
+
+      private
+
+      def first_colon_separated_entry(entries)
+        (entries || "").split(":").first
+      end
+
+      def supported_fnmatch_flags(pattern)
+        flags = File::FNM_PATHNAME | File::FNM_DOTMATCH
+
+        # ruby >= 2
+        return flags |= File::FNM_EXTGLOB if File.const_defined?(:FNM_EXTGLOB)
+
+        raise Error::UnsupportedPattern if pattern =~ /[{}]/
+
+        flags
+      end
+
+      def _extract_group(metadata)
+        metadata[:parent_example_group] || metadata[:example_group]
+      end
+    end
+
+    def dump_summary(*args)
+      return write_summary(*args) unless self.class.rspec_3?
+
+      notification = args[0]
+      write_summary(
+        notification.duration,
+        notification.example_count,
+        notification.failure_count,
+        notification.pending_count
+      )
+    end
+
+    private
+
+    # 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
+
+    def _write(&block)
+      file = RSpecFormatterResultsPath.new.path
+      if ENV['GUARD_RSPEC_DEBUGGING'] == '1'
+        msg = "Guard::RSpec: using results file: #{file.inspect}"
+        STDERR.puts format(msg, file)
+      end
+      FileUtils.mkdir_p(File.dirname(file))
+      File.open(file, "w", &block)
+    end
+
+    def _failed_paths
+      klass = self.class
+      failed = examples.select { |example| _status_failed?(example) }
+      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"
+      message << " (#{pending_count} pending)" if pending_count > 0
+      message << " in #{duration.round(4)} seconds"
+      message
+    end
+
+    def _status_failed?(example)
+      if self.class.rspec_3?
+        example.execution_result.status.to_s == "failed"
+      else
+        example.execution_result[:status].to_s == "failed"
+      end
+    end
+  end
+end

data/lib/guard/rspec_formatter_results_path.rb

@@ -0,0 +1,29 @@
+require_relative "rspec_defaults"
+
+module Guard
+  # Just a wrapper class for the results file filename
+  class RSpecFormatterResultsPath
+    WIKI_ENV_WARN_URL =
+      "https://github.com/guard/guard-rspec/wiki/Warning:-no-environment".
+      freeze
+
+    NO_ENV_WARNING_MSG =
+      "no environment passed - see #{WIKI_ENV_WARN_URL}".freeze
+
+    NO_RESULTS_VALUE_MSG =
+      ":results_file value unknown (using defaults)".freeze
+
+    attr_reader :path
+
+    def initialize
+      path = ENV["GUARD_RSPEC_RESULTS_FILE"]
+      if path.nil?
+        STDERR.puts("Guard::RSpec: Warning: #{NO_ENV_WARNING_MSG}\n" \
+                    "Guard::RSpec: Warning: #{NO_RESULTS_VALUE_MSG}")
+        path = RSpecDefaults::TEMPORARY_FILE_PATH
+      end
+
+      @path = File.expand_path(path)
+    end
+  end
+end

data/spec/acceptance/fixtures/succeeding_spec.rb

@@ -0,0 +1,4 @@
+RSpec.describe "succeeding spec" do
+  it "works" do
+  end
+end