guard-rspec 2.1.0 → 4.7.3

data/lib/guard/rspec/command.rb

@@ -0,0 +1,71 @@
+require "rspec/core"
+require "pathname"
+
+require "guard/rspec"
+
+module Guard
+  class RSpec < Plugin
+    class Command < String
+      FAILURE_EXIT_CODE = 2
+
+      attr_accessor :paths, :options
+
+      def initialize(paths, options = {})
+        @paths = paths
+        @options = options
+        super(_parts.join(" "))
+      end
+
+      private
+
+      def _parts
+        parts = [options[:cmd]]
+        parts << _visual_formatter
+        parts << _guard_formatter
+        parts << "--failure-exit-code #{FAILURE_EXIT_CODE}"
+        parts << options[:cmd_additional_args] || ""
+
+        parts << _paths(options).join(" ")
+      end
+
+      def _paths(options)
+        chdir = options[:chdir]
+        return paths unless chdir
+        paths.map { |path| path.sub(File.join(chdir, "/"), "") }
+      end
+
+      def _visual_formatter
+        return if _cmd_include_formatter?
+        _rspec_formatters || "-f progress"
+      end
+
+      def _rspec_formatters
+        # RSpec::Core::ConfigurationOptions#parse_options method was renamed to
+        # #options in rspec-core v3.0.0.beta2 so call the first one if
+        # available. Fixes #249
+        config = ::RSpec::Core::ConfigurationOptions.new([])
+        config.parse_options if config.respond_to?(:parse_options)
+        formatters = config.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
+
+        return formatters unless formatters
+        formatters.map { |entries| "-f #{entries.join ' -o '}" }.join(" ")
+      end
+
+      def _cmd_include_formatter?
+        options[:cmd] =~ /(?:^|\s)(?:-f\s*|--format(?:=|\s+))([\w:]+)/
+      end
+
+      def _guard_formatter
+        dir = Pathname.new(__FILE__).dirname.dirname
+        "-r #{dir + 'rspec_formatter.rb'} -f Guard::RSpecFormatter"
+      end
+    end
+  end
+end

data/lib/guard/rspec/deprecator.rb

@@ -0,0 +1,86 @@
+module Guard
+  class RSpec < Plugin
+    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
+        _keep_failed_option
+        _focus_on_failed_option
+      end
+
+      private
+
+      def _spec_opts_env
+        return if ENV["SPEC_OPTS"].nil?
+        Compat::UI.warning(
+          "The SPEC_OPTS environment variable is present." \
+          " This can conflict with guard-rspec."
+        )
+      end
+
+      def _version_option
+        return unless options.key?(:version)
+        _deprecated(
+          "The :version option is deprecated." \
+          " Only RSpec ~> 2.14 is now supported."
+        )
+      end
+
+      def _exclude_option
+        return unless options.key?(:exclude)
+        _deprecated(
+          "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)
+          _deprecated(
+            "The :#{option} option is deprecated." \
+            " Please customize the new :cmd option to fit your need."
+          )
+        end
+      end
+
+      def _keep_failed_option
+        return unless options.key?(:keep_failed)
+        _deprecated(
+          "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"
+        )
+      end
+
+      def _focus_on_failed_option
+        return unless options.key?(:focus_on_failed)
+        _deprecated(
+          "The :focus_on_failed option is deprecated." \
+          " Please set new :failed_mode option value to" \
+          " :focus instead." \
+          " https://github.com/guard/guard-rspec#list-of-available-options"
+        )
+      end
+
+      def _deprecated(message)
+        Compat::UI.warning %(Guard::RSpec DEPRECATION WARNING: #{message})
+      end
+    end
+  end
+end

data/lib/guard/rspec/dsl.rb

@@ -0,0 +1,72 @@
+require "ostruct"
+
+require "guard/rspec"
+
+module Guard
+  class RSpec < Plugin
+    class Dsl
+      def initialize(dsl)
+        @dsl = dsl
+      end
+
+      def watch_spec_files_for(expr)
+        @dsl.send(:watch, expr) { |m| rspec.spec.call(m[1]) }
+      end
+
+      def self.detect_spec_file_for(rspec, file)
+        # TODO: when spec not found ... run specs in topmost found path?
+        # Or show warning?
+
+        path = "#{rspec.spec_dir}/#{file}_spec.rb"
+        return path unless file.start_with?("lib/")
+        return path if Dir.exist?("#{rspec.spec_dir}/lib")
+
+        without_lib = file.sub(%r{^lib/}, "")
+        "#{rspec.spec_dir}/#{without_lib}_spec.rb"
+      end
+
+      def rspec
+        @rspec ||= OpenStruct.new(to_s: "spec").tap do |rspec|
+          rspec.spec_dir = "spec"
+          rspec.spec = ->(m) { Dsl.detect_spec_file_for(rspec, m) }
+          rspec.spec_helper = "#{rspec.spec_dir}/spec_helper.rb"
+          rspec.spec_files = %r{^#{rspec.spec_dir}/.+_spec\.rb$}
+          rspec.spec_support = %r{^#{rspec.spec_dir}/support/(.+)\.rb$}
+        end
+      end
+
+      def ruby
+        # Ruby apps
+        @ruby ||= OpenStruct.new.tap do |ruby|
+          ruby.lib_files = %r{^(lib/.+)\.rb$}
+        end
+      end
+
+      def rails(options = {})
+        # Rails example
+        @rails ||= _build_rails_rules(_view_extensions(options) * "|")
+      end
+
+      private
+
+      def _view_extensions(options)
+        options.dup.delete(:view_extensions) || %w(erb haml slim)
+      end
+
+      def _build_rails_rules(exts)
+        OpenStruct.new.tap do |rails|
+          rails.app_files = %r{^app/(.+)\.rb$}
+
+          rails.views = %r{^app/(views/.+/[^/]*\.(?:#{exts}))$}
+          rails.view_dirs = %r{^app/views/(.+)/[^/]*\.(?:#{exts})$}
+          rails.layouts = %r{^app/layouts/(.+)/[^/]*\.(?:#{exts})$}
+
+          rails.controllers = %r{^app/controllers/(.+)_controller\.rb$}
+          rails.routes = "config/routes.rb"
+          rails.app_controller = "app/controllers/application_controller.rb"
+          rails.spec_helper = "#{rspec.spec_dir}/rails_helper.rb"
+        end
+      end
+    end
+  end
+end

data/lib/guard/rspec/inspectors/base_inspector.rb

@@ -0,0 +1,73 @@
+module Guard
+  class RSpec < Plugin
+    module Inspectors
+      class BaseInspector
+        attr_accessor :options, :spec_paths
+
+        def initialize(options = {})
+          @options = options
+          @spec_paths = @options[:spec_paths]
+          @chdir = @options[:chdir]
+        end
+
+        def paths(_paths)
+          raise NotImplementedError
+        end
+
+        def failed(_locations)
+          raise NotImplementedError
+        end
+
+        def reload
+          raise NotImplementedError
+        end
+
+        private
+
+        # Leave only spec/feature files from spec_paths, remove others
+        def _clean(paths)
+          paths.uniq!
+          paths.compact!
+          spec_dirs = _select_only_spec_dirs(paths)
+          spec_files = _select_only_spec_files(paths)
+          (spec_dirs + spec_files).uniq
+        end
+
+        def _select_only_spec_dirs(paths)
+          chdir_paths = _spec_paths_with_chdir
+          paths.select do |path|
+            File.directory?(path) || chdir_paths.include?(path)
+          end
+        end
+
+        def _select_only_spec_files(paths)
+          spec_files = _collect_files("*[_.]spec.rb")
+          feature_files = _collect_files("*.feature")
+          files = (spec_files + feature_files).flatten
+
+          paths.select do |path|
+            (files & [@chdir ? File.join(@chdir, path) : path]).any?
+          end
+        end
+
+        def _spec_paths_with_chdir
+          _paths_with_chdir(spec_paths, @chdir)
+        end
+
+        def _collect_files(pattern)
+          base_paths = _spec_paths_with_chdir
+          base_paths.map do |path|
+            # TODO: not tested properly
+            Dir[File.join(path, "**{,/*/**}", pattern)]
+          end
+        end
+
+        def _paths_with_chdir(paths, chdir)
+          paths.map do |path|
+            chdir ? File.join(chdir, path) : path
+          end
+        end
+      end
+    end
+  end
+end

data/lib/guard/rspec/inspectors/factory.rb

@@ -0,0 +1,23 @@
+require "guard/rspec/inspectors/simple_inspector.rb"
+require "guard/rspec/inspectors/keeping_inspector.rb"
+require "guard/rspec/inspectors/focused_inspector.rb"
+
+module Guard
+  class RSpec < Plugin
+    module Inspectors
+      class Factory
+        class << self
+          def create(options = {})
+            case options[:failed_mode]
+            when :focus  then FocusedInspector.new(options)
+            when :keep   then KeepingInspector.new(options)
+            else; SimpleInspector.new(options)
+            end
+          end
+
+          private :new
+        end
+      end
+    end
+  end
+end

data/lib/guard/rspec/inspectors/focused_inspector.rb

@@ -0,0 +1,39 @@
+require "guard/rspec/inspectors/base_inspector.rb"
+
+module Guard
+  class RSpec < Plugin
+    module Inspectors
+      # Inspector that focuses on set of paths if any of them is failing.
+      # Returns only that set of paths on all future calls to #paths
+      # until they all pass
+      class FocusedInspector < BaseInspector
+        attr_accessor :focused_locations
+
+        def initialize(options = {})
+          super
+          @focused_locations = []
+        end
+
+        def paths(paths)
+          if focused_locations.any?
+            focused_locations
+          else
+            _clean(paths)
+          end
+        end
+
+        def failed(locations)
+          if locations.empty?
+            @focused_locations = []
+          elsif focused_locations.empty?
+            @focused_locations = locations
+          end
+        end
+
+        def reload
+          @focused_locations = []
+        end
+      end
+    end
+  end
+end

data/lib/guard/rspec/inspectors/keeping_inspector.rb

@@ -0,0 +1,97 @@
+require "guard/rspec/inspectors/base_inspector.rb"
+
+module Guard
+  class RSpec < Plugin
+    module Inspectors
+      # Inspector that remembers all failed paths and
+      # returns that paths in future calls to #paths method
+      # along with any new paths passed as parameter to #paths
+      class KeepingInspector < BaseInspector
+        attr_accessor :failed_locations
+
+        def initialize(options = {})
+          super
+          @failed_locations = []
+        end
+
+        def paths(paths)
+          _with_failed_locations(_clean(paths))
+        end
+
+        def failed(locations)
+          @failed_locations = locations
+        end
+
+        def reload
+          @failed_locations = []
+        end
+
+        private
+
+        # Return paths + failed locations.
+        # Do not include location in result if its path is already included.
+        def _with_failed_locations(paths)
+          failed_paths = failed_locations.map { |l| _location_path(l) }
+          (paths | failed_paths).uniq
+        end
+
+        # Extract file path from location
+        def _location_path(location)
+          location.match(%r{^(\./)?(.*?)(:\d+)?$})[2]
+        end
+      end
+    end
+  end
+end
+
+#
+#  FIXME uncomment when RSpec #952 will be resolved
+#
+#  This is correct version of KeepingInspector class,
+#  bit it doesn't work because of bug with RSpec
+#  https://github.com/rspec/rspec-core/issues/952
+#
+# module Guard
+#  class RSpec < Plugin
+#    module Inspectors
+#      # Inspector that remembers all failed paths and
+#      # returns that paths in future calls to #paths method
+#      # along with any new paths passed as parameter to #paths
+#      class KeepingInspector < BaseInspector
+#        attr_accessor :failed_locations
+#
+#        def initialize(options = {})
+#          super
+#          @failed_locations = []
+#        end
+#
+#        def paths(paths)
+#          _with_failed_locations(_clean(paths))
+#        end
+#
+#        def failed(locations)
+#          @failed_locations = locations
+#        end
+#
+#        def reload
+#          @failed_locations = []
+#        end
+#
+#        private
+#
+#        # Return paths + failed locations.
+#        # Do not include location in result if its path is already included.
+#        def _with_failed_locations(paths)
+#          locations = failed_locations.select { |l|
+#          !paths.include?(_location_path(l)) }
+#          paths | locations
+#        end
+#
+#        # Extract file path from location
+#        def _location_path(location)
+#          location.match(/^(\.\/)?(.*?)(:\d+)?$/)[2]
+#        end
+#      end
+#    end
+#  end
+# end

data/lib/guard/rspec/inspectors/simple_inspector.rb

@@ -0,0 +1,21 @@
+require "guard/rspec/inspectors/base_inspector"
+
+module Guard
+  class RSpec < Plugin
+    module Inspectors
+      class SimpleInspector < BaseInspector
+        def paths(paths)
+          _clean(paths)
+        end
+
+        def failed(_locations)
+          # Don't care
+        end
+
+        def reload
+          # Nothing to reload
+        end
+      end
+    end
+  end
+end

data/lib/guard/rspec/notifier.rb

@@ -0,0 +1,55 @@
+module Guard
+  class RSpec < Plugin
+    class Notifier
+      attr_accessor :options
+
+      def initialize(options = {})
+        @options = options
+      end
+
+      def notify(summary)
+        return unless options[:notification]
+        failure_count, pending_count = _parse_summary(summary)
+        image = _image(failure_count, pending_count)
+        priority = _priority(image)
+        Guard::Compat::UI.notify(summary,
+                                 title: @options[:title],
+                                 image: image,
+                                 priority: priority)
+      end
+
+      def notify_failure
+        return unless options[:notification]
+        Guard::Compat::UI.notify("Failed",
+                                 title: @options[: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,37 @@
+module Guard
+  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,
+        cmd_additional_args: nil,
+        launchy:         nil,
+        notification:    true,
+        title:           "RSpec results",
+        bundler_env:     :original_env
+      }.freeze
+
+      class << self
+        def with_defaults(options = {})
+          _deep_merge(DEFAULTS, options)
+        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/results.rb

@@ -0,0 +1,23 @@
+module Guard
+  class RSpec < Plugin
+    class Results
+      class InvalidData < RuntimeError
+      end
+
+      attr_reader :summary
+      attr_reader :failed_paths
+
+      def initialize(filename)
+        lines = File.readlines(filename)
+        if lines.empty? || lines.first.empty?
+          dump = lines.inspect
+          raise InvalidData, "Invalid results in: #{filename},"\
+            " lines:\n#{dump}\n"
+        end
+
+        @summary = lines.first.chomp
+        @failed_paths = lines[1..11].map(&:chomp).compact
+      end
+    end
+  end
+end

data/lib/guard/rspec/rspec_process.rb

@@ -0,0 +1,93 @@
+require "guard/rspec/command"
+
+module Guard
+  class RSpec < Plugin
+    class RSpecProcess
+      class Failure < RuntimeError
+      end
+
+      attr_reader :results, :options
+
+      def initialize(command, formatter_tmp_file, options = {})
+        @command = command
+        @formatter_tmp_file = formatter_tmp_file
+        @results = nil
+        @options = options
+
+        @exit_code = _run
+        @results = _read_results
+      end
+
+      def all_green?
+        exit_code.zero?
+      end
+
+      private
+
+      def _run
+        _with_desired_bundler_env do
+          exit_code = _really_run
+
+          msg = "Guard::RSpec: RSpec command %s exited with: %s"
+          Compat::UI.debug(format(msg, command, exit_code.inspect))
+
+          unless [0, Command::FAILURE_EXIT_CODE].include?(exit_code)
+            msg = "Failed: %s (exit code: %s)"
+            raise Failure, format(msg, command.inspect, exit_code.inspect)
+          end
+          exit_code
+        end
+      end
+
+      def _really_run
+        env = { "GUARD_RSPEC_RESULTS_FILE" => formatter_tmp_file }
+
+        _warn_unless_absolute_path(formatter_tmp_file)
+
+        Compat::UI.debug("Guard::RSpec: results file: #{formatter_tmp_file}")
+
+        pid = Kernel.spawn(env, command) # use spawn to stub in JRuby
+        result = ::Process.wait2(pid)
+        result.last.exitstatus
+      rescue Errno::ENOENT => ex
+        raise Failure, "Failed: #{command.inspect} (#{ex})"
+      end
+
+      def _read_results
+        Results.new(formatter_tmp_file)
+      rescue Errno::ENOENT
+        msg = "Guard::RSpec cannot open results file: %s. This is likely a bug"\
+          "so please report this at"\
+          " http://github.com/guard/guard-rspec/issues/new along with as much"\
+          "information as possible to reproduce this issue."
+        Compat::UI.error(format(msg, formatter_tmp_file.inspect))
+        raise
+      ensure
+        File.delete(formatter_tmp_file) if File.exist?(formatter_tmp_file)
+      end
+
+      def _with_desired_bundler_env
+        desired_bundler_env = options[:bundler_env]
+        if !defined?(::Bundler) || desired_bundler_env == :inherit
+          yield
+        elsif desired_bundler_env == :clean_env
+          ::Bundler.with_clean_env { yield }
+        else
+          ::Bundler.with_original_env { yield }
+        end
+      end
+
+      def _warn_unless_absolute_path(formatter_tmp_file)
+        return if Pathname(formatter_tmp_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, formatter_tmp_file.inspect))
+      end
+
+      attr_reader :command
+      attr_reader :exit_code
+      attr_reader :formatter_tmp_file
+    end
+  end
+end