guard-rspec 3.1.0 → 4.0.0

data/lib/guard/rspec/command.rb

@@ -0,0 +1,61 @@
+require 'rspec/core'
+require 'pathname'
+
+module Guard
+  class RSpec
+    class Command < String
+      FAILURE_EXIT_CODE = 2
+
+      attr_accessor :paths, :options
+
+      def initialize(paths, options = {})
+        @paths = paths
+        @options = {
+          focus_on_failed: true,
+          notification: true,
+          cmd:          'rspec'
+        }.merge(options)
+
+        super(_parts.join(' '))
+      end
+
+      private
+
+      def _parts
+        parts = [options[:cmd]]
+        parts << _formatter
+        parts << _notifier
+        parts << _focuser
+        parts << "--failure-exit-code #{FAILURE_EXIT_CODE}"
+        parts << paths.join(' ')
+      end
+
+      def _formatter
+        return if _cmd_include_formatter?
+        _rspec_formatters || '-f progress'
+      end
+
+      def _rspec_formatters
+        formatters = ::RSpec::Core::ConfigurationOptions.new([]).parse_options()[:formatters] || nil
+        # RSpec's parser returns an array in the format [[formatter, output], ...], so match their format
+        # Construct a matching command line option, including output target
+        formatters && formatters.map { |formatter| "-f #{formatter.join ' -o '}" }.join(' ')
+      end
+
+      def _cmd_include_formatter?
+        options[:cmd] =~ /(?:^|\s)(?:-f\s*|--format(?:=|\s+))([\w:]+)/
+      end
+
+      def _notifier
+        return unless options[:notification]
+        "-r #{File.dirname(__FILE__)}/formatters/notifier.rb -f Guard::RSpec::Formatters::Notifier"
+      end
+
+      def _focuser
+        return unless options[:focus_on_failed]
+        "-r #{File.dirname(__FILE__)}/formatters/focuser.rb -f Guard::RSpec::Formatters::Focuser"
+      end
+
+    end
+  end
+end

data/lib/guard/rspec/deprecator.rb

@@ -0,0 +1,51 @@
+module Guard
+  class RSpec
+    class Deprecator
+      attr_accessor :options
+
+      def self.warns_about_deprecated_options(options = {})
+        new(options).warns_about_deprecated_options
+      end
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      def warns_about_deprecated_options
+        _spec_opts_env
+        _version_option
+        _exclude_option
+        _use_cmd_option
+      end
+
+      private
+
+      def _spec_opts_env
+        return if ENV['SPEC_OPTS'].nil?
+        UI.warning "The SPEC_OPTS environment variable is present. This can conflict with guard-rspec, particularly notifications."
+      end
+
+      def _version_option
+        return unless options.key?(:version)
+        _deprectated('The :version option is deprecated. Only RSpec ~> 2.14 is now supported.')
+      end
+
+      def _exclude_option
+        return unless options.key?(:exclude)
+        _deprectated('The :exclude option is deprecated. Please Guard ignore method instead. https://github.com/guard/guard#ignore')
+      end
+
+      def _use_cmd_option
+        %w[color drb fail_fast formatter env bundler binstubs rvm cli spring turnip zeus foreman].each do |option|
+          next unless options.key?(option.to_sym)
+          _deprectated("The :#{option} option is deprecated. Please customize the new :cmd option to fit your need.")
+        end
+      end
+
+      def _deprectated(message)
+        UI.warning %{Guard::RSpec DEPRECATION WARNING: #{message}}
+      end
+
+    end
+  end
+end

data/lib/guard/rspec/formatters/focuser.rb

@@ -0,0 +1,29 @@
+require 'guard/rspec'
+require 'rspec/core/formatters/base_formatter'
+
+module Guard::RSpec::Formatters
+  class Focuser < ::RSpec::Core::Formatters::BaseFormatter
+
+    def dump_summary(duration, total, failures, pending)
+      _write_failed_paths_in_tmp if failures > 0
+    end
+
+    private
+
+    # Used for focus_on_failed options
+    def _write_failed_paths_in_tmp
+      FileUtils.mkdir_p('tmp')
+      File.open('./tmp/rspec_guard_result','w') do |f|
+        f.puts _failed_paths.join("\n")
+      end
+    rescue
+      # nothing really we can do, at least don't kill the test runner
+    end
+
+    def _failed_paths
+      failed = examples.select { |e| e.execution_result[:status] == 'failed' }
+      failed.map { |e| e.metadata[:location] }
+    end
+
+  end
+end

data/lib/guard/rspec/formatters/notifier.rb

@@ -0,0 +1,47 @@
+require 'guard/rspec'
+require 'guard/notifier'
+require 'rspec/core/formatters/base_formatter'
+
+module Guard::RSpec::Formatters
+  class Notifier < ::RSpec::Core::Formatters::BaseFormatter
+
+    def dump_summary(duration, total, failures, pending)
+      message = _message(total, failures, pending, duration)
+      status  = _status(failures, pending)
+      _notify(message, status)
+    end
+
+    private
+
+    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 << "\nin #{duration.round(4)} seconds"
+      message
+    end
+
+    def _status(failure_count, pending_count)
+      if failure_count > 0
+        :failed
+      elsif pending_count > 0
+        :pending
+      else
+        :success
+      end
+    end
+
+    def _notify(message, status)
+      Guard::Notifier.notify(message, title: 'RSpec results', image: status, priority: _priority(status))
+    end
+
+    def _priority(status)
+      { failed:   2,
+        pending: -1,
+        success: -2
+      }[status]
+    end
+
+  end
+end

data/lib/guard/rspec/inspector.rb

@@ -1,64 +1,68 @@
 module Guard
   class RSpec
     class Inspector
+      FOCUSED_FILE_PATH = './tmp/rspec_guard_result'
 
-      attr_accessor :excluded, :spec_paths
+      attr_accessor :options, :failed_paths, :spec_paths
 
       def initialize(options = {})
-        self.excluded   = options.fetch(:exclude, [])
-        self.spec_paths = options.fetch(:spec_paths, [])
-      end
-
-      def excluded=(pattern)
-        @excluded = Dir[pattern.to_s]
-      end
+        @options = {
+          focus_on_failed: true,
+          keep_failed:     false,
+          spec_paths:      %w[spec]
+        }.merge(options)
 
-      def spec_paths=(paths)
-        @spec_paths = Array(paths)
+        @failed_paths = []
+        @spec_paths = @options[:spec_paths]
       end
 
-      def clean(paths)
-        paths.uniq!
-        paths.compact!
-        clear_spec_files_list_after do
-          paths = paths.select { |path| should_run_spec_file?(path) }
+      def paths(paths = nil)
+        if paths
+          _paths(paths)
+        else
+          spec_paths
         end
-        paths.reject { |p| included_in_other_path?(p, paths) }
-      end
-
-    private
-
-      def should_run_spec_file?(path)
-        (spec_file?(path) || feature_file?(path) || spec_folder?(path)) && !excluded.include?(path)
       end
 
-      def spec_file?(path)
-        spec_files.include?(path)
-      end
-
-      def feature_file?(path)
-        feature_files.include?(path)
+      def clear_paths(paths = nil)
+        if paths
+          @failed_paths -= paths
+        else
+          @failed_paths.clear
+        end
       end
 
-      def spec_folder?(path)
-        path.match(%r{^(#{spec_paths.join("|")})[^\.]*$})
-      end
+      private
 
-      def spec_files
-        @spec_files ||= spec_paths.collect { |path| Dir[File.join(path, "**{,/*/**}", "*[_.]spec.rb")] }.flatten
+      def _paths(paths)
+        _focused_paths || if options[:keep_failed]
+          @failed_paths += _clean(paths)
+        else
+          _clean(paths)
+        end
       end
 
-      def feature_files
-        @feature_files ||= spec_paths.collect { |path| Dir[File.join(path, "**{,/*/**}", "*.feature")] }.flatten
+      def _focused_paths
+        return nil unless options[:focus_on_failed]
+        File.open(FOCUSED_FILE_PATH).read.split("\n")[0..10]
+      rescue
+        nil
+      ensure
+        File.exist?(FOCUSED_FILE_PATH) && File.delete(FOCUSED_FILE_PATH)
       end
 
-      def clear_spec_files_list_after
-        yield
-        @spec_files = nil
+      def _clean(paths)
+        paths.uniq!
+        paths.compact!
+        paths = _select_only_spec_files(paths)
+        paths
       end
 
-      def included_in_other_path?(path, paths)
-        (paths - [path]).any? { |p| path.include?(p) && path.sub(p, '').include?('/') }
+      def _select_only_spec_files(paths)
+        spec_files = spec_paths.collect { |path| Dir[File.join(path, "**{,/*/**}", "*[_.]spec.rb")] }
+        feature_files = spec_paths.collect { |path| Dir[File.join(path, "**{,/*/**}", "*.feature")] }
+        files = (spec_files + feature_files).flatten
+        paths.select { |p| files.include?(p) }
       end
 
     end

data/lib/guard/rspec/runner.rb

@@ -1,285 +1,84 @@
-require 'drb/drb'
-require 'rspec'
-require 'pathname'
+require 'guard/rspec/command'
+require 'guard/rspec/inspector'
 
 module Guard
   class RSpec
     class Runner
+      attr_accessor :options, :inspector
 
-      FAILURE_EXIT_CODE = 2
-
-      attr_accessor :options
       def initialize(options = {})
         @options = {
-          :bundler      => true,
-          :binstubs     => false,
-          :rvm          => nil,
-          :cli          => nil,
-          :env          => nil,
-	        :launchy	    => nil,
-          :notification => true,
-          :spring       => false,
-          :turnip       => false,
-          :zeus         => false,
-          :foreman      => false
+          all_after_pass: false,
+          notification:   true,
+          run_all:        { message: 'Running all specs' },
+          launchy:        nil
         }.merge(options)
 
-        unless ENV['SPEC_OPTS'].nil?
-          UI.warning "The SPEC_OPTS environment variable is present. This can conflict with guard-rspec, particularly notifications."
-        end
-
-        if options[:bundler] && !options[:binstubs]
-          if options[:zeus]
-            UI.warning "Running Zeus within bundler is waste of time. Bundler option is set to false, when using Zeus."
-          elsif options[:spring]
-            UI.warning "Running Spring within bundler is waste of time. Bundler option is set to false, when using Spring."
-          end
-        end
-
-        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(runtime_options = {})
-        command = parallel?(runtime_options) ? 'parallel_rspec' : 'rspec'
-        @rspec_executable ||= (binstubs? && !executable_prefix?) ? "#{binstubs}/#{command}" : command
-      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 #{zeus_guard_env_file.path}" if zeus?
-          arg_parts << "-r #{File.dirname(__FILE__)}/formatter.rb"
-          arg_parts << "-f Guard::RSpec::Formatter"
-        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 zeus_guard_env_file
-        unless @zeus_guard_env_file
-          @zeus_guard_env_file = Tempfile.new(['zeus_guard_env','.rb'])
-          @zeus_guard_env_file.puts '# encoding: UTF-8'
-          @zeus_guard_env_file.puts '# Extra settings for Guard when using Zeus'
-          @zeus_guard_env_file.puts "ENV['GUARD_NOTIFICATIONS']=#{ENV['GUARD_NOTIFICATIONS'].inspect}" if ENV['GUARD_NOTIFICATIONS']
-          @zeus_guard_env_file.puts "ENV['GUARD_NOTIFY']=#{ENV['GUARD_NOTIFY'].inspect}" if ENV['GUARD_NOTIFY']
-          @zeus_guard_env_file.close
-        end
-
-        @zeus_guard_env_file
-      end
-
-      def parallel_rspec_arguments(paths, options)
-        arg_parts = []
-        arg_parts << options[:parallel_cli]
-        arg_parts << "-o '#{rspec_arguments([], options).strip}'"
-        arg_parts << paths.join(' ')
-
-        arg_parts.compact.join(' ')
+        @inspector = Inspector.new(@options)
       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 << bin_command('foreman run') if foreman?
-        cmd_parts << "bundle exec" if bundle_exec?
-        cmd_parts << executable_prefix if executable_prefix?
-        cmd_parts << rspec_executable(options)
-        cmd_parts << rspec_arguments(paths, options) if !parallel?(options)
-        cmd_parts << parallel_rspec_arguments(paths, options) if parallel?(options)
-        cmd_parts.compact.join(' ')
-      end
+      def run_all
+        options = @options.merge(@options[:run_all])
+        UI.info(options[:message], reset: true)
 
-      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
-
-        if options[:launchy]
-          require 'launchy'
-          pn = Pathname.new(options[:launchy])
-          if pn.exist?
-            Launchy.open(options[:launchy])
-          end
-        end
-        success
+        _run(inspector.paths, [], options)
       end
 
-      def rspec_command_exited_with_an_exception?
-        failure_exit_code_supported? && $?.exitstatus != FAILURE_EXIT_CODE
-      end
+      def run(paths)
+        failed_paths = inspector.failed_paths
+        paths = inspector.paths(paths)
+        return if paths.empty?
 
-      # 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
+        UI.info("Running: #{paths.join(' ')}", reset: true)
 
-        # 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
-        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')
+        _run(paths, failed_paths, options)
       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://127.0.0.1:0")
-          rescue SocketError, Errno::EADDRNOTAVAIL
-            DRb.start_service("druby://:0")
-          end
-
-          @drb_listener_running = true
-        end
-
-        @drb_services ||= {}
-        @drb_services[port.to_i] ||= DRbObject.new_with_uri("druby://127.0.0.1:#{port}")
+      def reload
+        inspector.clear_paths
       end
 
-      def bundler_allowed?
-        @bundler_allowed ||= (File.exist?("#{Dir.pwd}/Gemfile") && !zeus? && !spring?)
-      end
-
-      def bundler?
-        @bundler ||= bundler_allowed? && @options[:bundler]
-      end
-
-      def binstubs?
-        @binstubs ||= !!@options[:binstubs]
-      end
-
-      def executable_prefix?
-        zeus? || spring? || foreman?
-      end
+      private
 
-      def executable_prefix
-        if zeus?
-          bin_command('zeus')
-        elsif spring? && !parallel?
-          bin_command('spring')
+      def _run(paths, failed_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)
         end
       end
 
-      def zeus?
-        options.fetch(:zeus, false)
-      end
-
-      def parallel?(runtime_options = {})
-        if runtime_options[:run_all_specs]
-          runtime_options[:parallel]
+      def _without_bundler_env
+        if defined?(Bundler)
+          Bundler.with_clean_env { yield }
         else
-          options.fetch(:parallel, false)
+          yield
         end
       end
 
-      def spring?
-        options.fetch(:spring, false)
-      end
-
-      def foreman?
-        options.fetch(:foreman, false)
-      end
-
-      def binstubs
-        options[:binstubs] == true ? "bin" : options[:binstubs]
+      def _notify_failure
+        return unless options[:notification]
+        return unless command_exception?
+        Notifier.notify('Failed', title: 'RSpec results', image: :failed, priority: 2)
       end
 
-      def bin_command(command)
-        binstubs? ? "#{binstubs}/#{command}" : command
+      def command_exception?
+        $?.exitstatus != Command::FAILURE_EXIT_CODE
       end
 
-      def bundle_exec?
-        bundler? && !binstubs?
+      def _open_launchy
+        return unless options[:launchy]
+        require 'launchy'
+        pn = Pathname.new(options[:launchy])
+        Launchy.open(options[:launchy]) if pn.exist?
       end
 
-      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
-        end
-        if options.key?(:version)
-          @options.delete(:version)
-          UI.info %{DEPRECATION WARNING: The :version option is deprecated. Only RSpec 2 is now supported.}
-        end
+      def _run_all_after_pass(success, failed_paths)
+        return unless options[:all_after_pass]
+        run_all if success && !failed_paths.empty?
       end
 
-      def formatter_regex
-        @formatter_regex ||= /(?:^|\s)(?:-f\s*|--format(?:=|\s+))([\w:]+)/
-      end
     end
   end
 end