guard 2.7.2 → 2.7.3

data/lib/guard/plugin_util.rb.orig

@@ -0,0 +1,186 @@
+require "guard/ui"
+
+module Guard
+  # This class contains useful methods to:
+  #
+  # * Fetch all the Guard plugins names;
+  # * Initialize a plugin, get its location;
+  # * Return its class name;
+  # * Add its template to the Guardfile.
+  #
+  class PluginUtil
+    ERROR_NO_GUARD_OR_CLASS = "Could not load 'guard/%s' or'\
+    ' find class Guard::%s"
+
+    INFO_ADDED_GUARD_TO_GUARDFILE = "%s guard added to Guardfile,"\
+      " feel free to edit it"
+
+    attr_accessor :name
+
+    # Returns a list of Guard plugin Gem names installed locally.
+    #
+    # @return [Array<String>] a list of Guard plugin gem names
+    #
+    def self.plugin_names
+      if Gem::Version.create(Gem::VERSION) >= Gem::Version.create("1.8.0")
+        Gem::Specification.find_all.select do |x|
+          if x.name =~ /^guard-/
+            true
+          elsif x.name != "guard"
+
+            guard_plugin_path = File.join(
+              x.full_gem_path,
+              "lib/guard/#{ x.name }.rb"
+            )
+
+            File.exist?(guard_plugin_path)
+          end
+        end
+      else
+        ::Guard::UI.deprecation \
+          "Rubygems version prior to 1.8.0 are no longer supported"\
+          " and may not work"
+
+        Gem.source_index.find_name(/^guard-/)
+      end.map { |x| x.name.sub(/^guard-/, "") }.uniq
+    end
+
+    # Initializes a new `Guard::PluginUtil` object.
+    #
+    # @param [String] name the name of the Guard plugin
+    #
+    def initialize(name)
+      @name = name.to_s.sub(/^guard-/, "")
+    end
+
+    # Initializes a new `Guard::Plugin` with the given `options` hash. This
+    # methods handles plugins that inherit from the deprecated `Guard::Guard`
+    # class as well as plugins that inherit from `Guard::Plugin`.
+    #
+    # @see Guard::Plugin
+    # @see https://github.com/guard/guard/wiki/Upgrading-to-Guard-2.0 How to
+    # upgrade for Guard 2.0
+    #
+    # @return [Guard::Plugin] the initialized plugin
+    # @return [Guard::Guard] the initialized plugin. This return type is
+    #   deprecated and the plugin's maintainer should update it to be
+    #   compatible with Guard 2.0. For more information on how to upgrade for
+    #   Guard 2.0, please head over to:
+    #   https://github.com/guard/guard/wiki/Upgrading-to-Guard-2.0
+    #
+    def initialize_plugin(options)
+      klass = plugin_class
+      fail "Could not load class: #{_constant_name.inspect}" unless klass
+      if klass.superclass.to_s == "Guard::Guard"
+        klass.new(options.delete(:watchers), options)
+      else
+        begin
+          klass.new(options)
+        rescue ArgumentError => e
+          fail "Failed to call #{klass}.new(options): #{e}"
+        end
+      end
+    end
+
+    # Locates a path to a Guard plugin gem.
+    #
+    # @return [String] the full path to the plugin gem
+    #
+    def plugin_location
+      @plugin_location ||= begin
+        if Gem::Version.create(Gem::VERSION) >= Gem::Version.create("1.8.0")
+          Gem::Specification.find_by_name("guard-#{ name }").full_gem_path
+        else
+          Gem.source_index.find_name("guard-#{ name }").last.full_gem_path
+        end
+      end
+    rescue
+      ::Guard::UI.error "Could not find 'guard-#{ name }' gem path."
+    end
+
+    # Tries to load the Guard plugin main class. This transforms the supplied
+    # plugin name into a class name:
+    #
+    # * `guardname` will become `Guard::Guardname`
+    # * `dashed-guard-name` will become `Guard::DashedGuardName`
+    # * `underscore_guard_name` will become `Guard::UnderscoreGuardName`
+    #
+    # When no class is found with the strict case sensitive rules, another
+    # try is made to locate the class without matching case:
+    #
+    # * `rspec` will find a class `Guard::RSpec`
+    #
+    # @option options [Boolean] fail_gracefully whether error messages should
+    # not be printed
+    #
+    # @return [Class, nil] the loaded class
+    #
+    def plugin_class(options = {})
+      options = { fail_gracefully: false }.merge(options)
+
+      try_require = false
+      begin
+        require "guard/#{ name.downcase }" if try_require
+
+        @plugin_class ||= ::Guard.const_get(_plugin_constant)
+      rescue TypeError => error
+        if try_require
+          ::Guard::UI.error "Could not find class Guard::#{ _constant_name }"
+          ::Guard::UI.error error.backtrace.join("\n")
+        else
+          try_require = true
+          retry
+        end
+      rescue LoadError => error
+        unless options[:fail_gracefully]
+          UI.error ERROR_NO_GUARD_OR_CLASS % [name.downcase, _constant_name]
+          UI.error error.backtrace.join("\n")
+        end
+      end
+    end
+
+    # Adds a plugin's template to the Guardfile.
+    #
+    def add_to_guardfile
+      msg = "Guard.evaluator not initialized"
+      fail msg if ::Guard.evaluator.nil?
+      if ::Guard.evaluator.guardfile_include?(name)
+        ::Guard::UI.info "Guardfile already includes #{ name } guard"
+      else
+        content = File.read("Guardfile")
+        File.open("Guardfile", "wb") do |f|
+          f.puts(content)
+          f.puts("")
+          f.puts(plugin_class.template(plugin_location))
+        end
+
+        UI.info INFO_ADDED_GUARD_TO_GUARDFILE % name
+      end
+    end
+
+    private
+
+    # Returns the constant for the current plugin.
+    #
+    # @example Returns the constant for a plugin
+    #   > Guard::PluginUtil.new('rspec').send(:_plugin_constant)
+    #   => Guard::RSpec
+    #
+    def _plugin_constant
+      @_plugin_constant ||= ::Guard.constants.detect do |c|
+        c.to_s.downcase == _constant_name.downcase
+      end
+    end
+
+    # Guesses the most probable name for the current plugin based on its name.
+    #
+    # @example Returns the most probable name for a plugin
+    #   > Guard::PluginUtil.new('rspec').send(:_constant_name)
+    #   => "Rspec"
+    #
+    def _constant_name
+      @_constant_name ||= name.gsub(/\/(.?)/) { "::#{ $1.upcase }" }.
+        gsub(/(?:^|[_-])(.)/) { $1.upcase }
+    end
+  end
+end

data/lib/guard/runner.rb.orig

@@ -0,0 +1,210 @@
+require "lumberjack"
+
+require "guard/ui"
+require "guard/watcher"
+
+module Guard
+  # The runner is responsible for running all methods defined on each plugin.
+  #
+  class Runner
+    # Runs a Guard-task on all registered plugins.
+    #
+    # @param [Symbol] task the task to run
+    #
+    # @param [Hash] scopes either the Guard plugin or the group to run the task
+    # on
+    #
+    def run(task, scope_hash = {})
+      Lumberjack.unit_of_work do
+        _scoped_plugins(scope_hash || {}) do |plugin|
+          _supervise(plugin, task) if plugin.respond_to?(task)
+        end
+      end
+    end
+
+    MODIFICATION_TASKS = [
+      :run_on_modifications, :run_on_changes, :run_on_change
+    ]
+
+    ADDITION_TASKS     = [:run_on_additions, :run_on_changes, :run_on_change]
+    REMOVAL_TASKS      = [:run_on_removals, :run_on_changes, :run_on_deletion]
+
+    # Runs the appropriate tasks on all registered plugins
+    # based on the passed changes.
+    #
+    # @param [Array<String>] modified the modified paths.
+    # @param [Array<String>] added the added paths.
+    # @param [Array<String>] removed the removed paths.
+    #
+    def run_on_changes(modified, added, removed)
+      types = {
+        MODIFICATION_TASKS => modified,
+        ADDITION_TASKS => added,
+        REMOVAL_TASKS => removed
+      }
+
+      ::Guard::UI.clearable
+
+      _scoped_plugins do |plugin|
+        ::Guard::UI.clear
+
+        types.each do |tasks, unmatched_paths|
+          next if unmatched_paths.empty?
+          match_result = ::Guard::Watcher.match_files(plugin, unmatched_paths)
+          next if match_result.empty?
+
+          next unless (task = tasks.detect { |meth| plugin.respond_to?(meth) })
+          _supervise(plugin, task, match_result)
+          ::Guard::UI.clearable
+        end
+      end
+    end
+
+    # Run a Guard plugin task, but remove the Guard plugin when his work leads
+    # to a system failure.
+    #
+    # When the Group has `:halt_on_fail` disabled, we've to catch
+    # `:task_has_failed` here in order to avoid an uncaught throw error.
+    #
+    # @param [Guard::Plugin] guard the Guard to execute
+    # @param [Symbol] task the task to run
+    # @param [Array] args the arguments for the task
+    # @raise [:task_has_failed] when task has failed
+    #
+    def _supervise(plugin, task, *args)
+      catch self.class.stopping_symbol_for(plugin) do
+        plugin.hook("#{ task }_begin", *args)
+        begin
+          result = plugin.send(task, *args)
+        rescue Interrupt
+          throw(:task_has_failed)
+        end
+        plugin.hook("#{ task }_end", result)
+        result
+      end
+    rescue ScriptError, StandardError, RuntimeError
+      ::Guard::UI.error("#{ plugin.class.name } failed to achieve its"\
+                        " <#{ task }>, exception was:" \
+                        "\n#{ $!.class }: #{ $!.message }" \
+                        "\n#{ $!.backtrace.join("\n") }")
+      ::Guard.remove_plugin(plugin)
+      ::Guard::UI.info("\n#{ plugin.class.name } has just been fired")
+      $!
+    end
+
+    # Returns the symbol that has to be caught when running a supervised task.
+    #
+    # @note If a Guard group is being run and it has the `:halt_on_fail`
+    #   option set, this method returns :no_catch as it will be caught at the
+    #   group level.
+    # @see ._scoped_plugins
+    #
+    # @param [Guard::Plugin] guard the Guard plugin to execute
+    # @return [Symbol] the symbol to catch
+    #
+    def self.stopping_symbol_for(guard)
+      guard.group.options[:halt_on_fail] ? :no_catch : :task_has_failed
+    end
+
+    private
+
+    # Loop through all groups and run the given task for each Guard plugin.
+    #
+    # If no scope is supplied, the global Guard scope is taken into account.
+    # If both a plugin and a group scope is given, then only the plugin scope
+    # is used.
+    #
+    # Stop the task run for the all Guard plugins within a group if one Guard
+    # throws `:task_has_failed`.
+    #
+    # @param [Hash] scopes hash with plugins or a groups scope
+    # @yield the task to run
+    #
+    def _scoped_plugins(scopes = {})
+      fail "NO PLUGIN SCOPE" if scopes.nil?
+      if plugins = _current_plugins_scope(scopes)
+        plugins.each do |guard|
+          yield(guard)
+        end
+      else
+        _current_groups_scope(scopes).each do |group|
+          fail "Invalid group: #{group.inspect}" unless group.respond_to?(:name)
+          current_plugin = nil
+          block_return = catch :task_has_failed do
+            ::Guard.plugins(group: group.name).each do |guard|
+              current_plugin = guard
+              yield(guard)
+            end
+          end
+
+          next unless block_return.nil?
+
+          ::Guard::UI.info "#{ current_plugin.class.name } has failed,"\
+            " other group's plugins execution has been halted."
+        end
+      end
+    end
+
+    # Returns the current plugins scope.
+    # Local plugins scope wins over global plugins scope.
+    # If no plugins scope is found, then NO plugins are returned.
+    #
+    # @param [Hash] scopes hash with a local plugins or a groups scope
+    # @return [Array<Guard::Plugin>] the plugins to scope to
+    #
+    def _current_plugins_scope(scope)
+      return nil unless (plugins = _find_non_empty_plugins_scope(scope))
+
+      Array(plugins).map { |plugin| _instantiate(:plugin, plugin) }
+    end
+
+    # Returns the current groups scope.
+    # Local groups scope wins over global groups scope.
+    # If no groups scope is found, then ALL groups are returned.
+    #
+    # @param [Hash] scopes hash with a local plugins or a groups scope
+    # @return [Array<Guard::Group>] the groups to scope to
+    #
+    def _current_groups_scope(scope)
+<<<<<<< HEAD
+      found = _find_non_empty_groups_scope(scope)
+      groups = Array(found).map { |group| _instantiate(:group, group) }
+      return groups if groups.any? { |g| g.name == :common }
+      ([_instantiate(:group, :common)] + Array(found)).compact
+=======
+      groups = _find_non_empty_groups_scope(scope)
+      Array(groups).map { |group| _instantiate(:group, group) }
+>>>>>>> origin/api_safe_refactoring
+    end
+
+    def _instantiate(meth, obj)
+      (obj.is_a?(Symbol) || obj.is_a?(String)) ? ::Guard.send(meth, obj) : obj
+    end
+
+    # Find the first non empty element in the given possibilities
+    #
+    def _find_non_empty_scope(type, local_scope, *additional_possibilities)
+      found = [
+        local_scope[:"#{type}s"],
+        [local_scope[type.to_sym]],
+        ::Guard.scope[:"#{type}s"],
+        additional_possibilities.flatten
+      ]
+      found.compact.detect { |a| !Array(a).compact.empty? }
+    end
+
+    # Find the first non empty plugins scope
+    #
+    def _find_non_empty_plugins_scope(scope)
+      fail "NO PLUGIN SCOPE" if scope.nil?
+      _find_non_empty_scope(:plugin, scope)
+    end
+
+    # Find the first non empty groups scope
+    #
+    def _find_non_empty_groups_scope(scope)
+      common = [::Guard.group(:common)]
+      common + _find_non_empty_scope(:group, scope, ::Guard.groups)
+    end
+  end
+end

data/lib/guard/setuper.rb.orig

@@ -0,0 +1,395 @@
+require "thread"
+require "listen"
+require "guard/options"
+
+module Guard
+  # Sets up initial variables and options
+  module Setuper
+    DEFAULT_OPTIONS = {
+      clear: false,
+      notify: true,
+      debug: false,
+      group: [],
+      plugin: [],
+      watchdir: nil,
+      guardfile: nil,
+      no_interactions: false,
+      no_bundler_warning: false,
+      show_deprecations: false,
+      latency: nil,
+      force_polling: false,
+      wait_for_delay: nil,
+      listen_on: nil
+    }
+    DEFAULT_GROUPS = [:common, :default]
+
+    # Initializes the Guard singleton:
+    #
+    # * Initialize the internal Guard state;
+    # * Create the interactor
+    # * Select and initialize the file change listener.
+    #
+    # @option options [Boolean] clear if auto clear the UI should be done
+    # @option options [Boolean] notify if system notifications should be shown
+    # @option options [Boolean] debug if debug output should be shown
+    # @option options [Array<String>] group the list of groups to start
+    # @option options [Array<String>] watchdir the directories to watch
+    # @option options [String] guardfile the path to the Guardfile
+    # @option options [Boolean] watch_all_modifications **[deprecated]** watches all file modifications if true
+    # @option options [Boolean] no_vendor **[deprecated]** ignore vendored dependencies
+    #
+    # @return [Guard] the Guard singleton
+    #
+
+    # TODO: this method has too many instance variables
+    # and some are mock and leak between tests,
+    # so ideally there should be a guard "instance"
+    # object that can be created anew between tests
+    def setup(opts = {})
+      reset_options(opts)
+      reset_evaluator(opts)
+
+      @queue = Queue.new
+      @runner = ::Guard::Runner.new
+      @watchdirs = _setup_watchdirs
+
+      ::Guard::UI.setup(options)
+
+<<<<<<< HEAD
+      _setup_debug if options[:debug]
+      @listener = _setup_listener
+      _setup_signal_traps
+=======
+      ::Guard::Deprecator.deprecated_options_warning(options)
+      ::Guard::Deprecator.deprecated_plugin_methods_warning
+
+      _setup_notifier
+      _setup_interactor
+>>>>>>> parent of a5162d2... Remove deprecated methods and options. Fixes #425.
+
+      _load_guardfile
+      @interactor = _setup_interactor
+      self
+    end
+
+    attr_reader :options, :interactor
+
+    # Used only by tests (for all I know...)
+    def clear_options
+      @options = nil
+    end
+
+    # Initializes the groups array with the default group(s).
+    #
+    # @see DEFAULT_GROUPS
+    #
+    def reset_groups
+      @groups = DEFAULT_GROUPS.map { |name| Group.new(name) }
+    end
+
+    # Initializes the plugins array to an empty array.
+    #
+    # @see Guard.plugins
+    #
+    def reset_plugins
+      @plugins = []
+    end
+
+    # Initializes the scope hash to `{ groups: [], plugins: [] }`.
+    #
+    # @see Guard.setup_scope
+    #
+    def reset_scope
+      # calls Guard.scope=() to set the instance variable directly, as opposed
+      # to Guard.scope()
+      ::Guard.scope = { groups: [], plugins: [] }
+    end
+
+    # Used to merge CLI options with Setuper defaults
+    def reset_options(new_options)
+      @options = ::Guard::Options.new(new_options, DEFAULT_OPTIONS)
+    end
+
+    # TODO: code smell - too many reset_* methods
+    def reset_evaluator(new_options)
+      @evaluator = ::Guard::Guardfile::Evaluator.new(new_options)
+    end
+
+    def save_scope
+      # This actually replaces scope from command line,
+      # so scope set by 'scope' Pry command will be reset
+      @saved_scope = _prepare_scope(::Guard.scope)
+    end
+
+    def restore_scope
+      ::Guard.setup_scope(@saved_scope)
+    end
+
+    attr_reader :watchdirs
+
+    # Stores the scopes defined by the user via the `--group` / `-g` option (to
+    # run only a specific group) or the `--plugin` / `-P` option (to run only a
+    # specific plugin).
+    #
+    # @see CLI#start
+    # @see Dsl#scope
+    #
+    def setup_scope(scope = {})
+      # TODO: there should be a special Scope class instead
+      scope = _prepare_scope(scope)
+
+      ::Guard.scope = {
+        groups: scope[:groups].map { |item| ::Guard.add_group(item) },
+        plugins: scope[:plugins].map { |item| ::Guard.plugin(item) },
+      }
+    end
+
+    # Evaluates the Guardfile content. It displays an error message if no
+    # Guard plugins are instantiated after the Guardfile evaluation.
+    #
+    # @see Guard::Guardfile::Evaluator#evaluate_guardfile
+    #
+    def evaluate_guardfile
+      evaluator.evaluate_guardfile
+      msg = "No plugins found in Guardfile, please add at least one."
+      ::Guard::UI.error msg unless _pluginless_guardfile?
+    end
+
+    # Asynchronously trigger changes
+    #
+    # Currently supported args:
+    #
+    #   old style hash: {modified: ['foo'], added: ['bar'], removed: []}
+    #
+    #   new style signals with args: [:guard_pause, :unpaused ]
+    #
+    def async_queue_add(changes)
+      @queue << changes
+
+      # Putting interactor in background puts guard into foreground
+      # so it can handle change notifications
+      Thread.new { interactor.background }
+    end
+
+    def pending_changes?
+      ! @queue.empty?
+    end
+
+    def add_builtin_plugins(guardfile)
+      return unless guardfile
+
+      pattern = _relative_pathname(guardfile).to_s
+      watcher = ::Guard::Watcher.new(pattern)
+      ::Guard.add_plugin(:reevaluator, watchers: [watcher], group: :common)
+    end
+
+    private
+
+    # Sets up various debug behaviors:
+    #
+    # * Abort threads on exception;
+    # * Set the logging level to `:debug`;
+    # * Modify the system and ` methods to log themselves before being executed
+    #
+    # @see #_debug_command_execution
+    #
+    def _setup_debug
+      Thread.abort_on_exception = true
+      ::Guard::UI.options[:level] = :debug
+      _debug_command_execution
+    end
+
+    # Initializes the listener and registers a callback for changes.
+    #
+    def _setup_listener
+      if options[:listen_on]
+        Listen.on(options[:listen_on], &_listener_callback)
+      else
+        listener_options = {}
+        [:latency, :force_polling, :wait_for_delay].each do |option|
+          listener_options[option] = options[option] if options[option]
+        end
+        listen_args = watchdirs + [listener_options]
+        Listen.to(*listen_args, &_listener_callback)
+      end
+    end
+
+    # Process the change queue, running tasks within the main Guard thread
+    def _process_queue
+      actions, changes = [], { modified: [], added: [], removed: [] }
+
+      while pending_changes?
+        if (item = @queue.pop).first.is_a?(Symbol)
+          actions << item
+        else
+          item.each { |key, value| changes[key] += value }
+        end
+      end
+
+      _run_actions(actions)
+      return if changes.values.all?(&:empty?)
+      runner.run_on_changes(*changes.values)
+    end
+
+    # Sets up traps to catch signals used to control Guard.
+    #
+    # Currently two signals are caught:
+    # - `USR1` which pauses listening to changes.
+    # - `USR2` which resumes listening to changes.
+    # - 'INT' which is delegated to Pry if active, otherwise stops Guard.
+    #
+    def _setup_signal_traps
+      return if defined?(JRUBY_VERSION)
+
+      if Signal.list.keys.include?("USR1")
+        Signal.trap("USR1") { async_queue_add([:guard_pause, :paused]) }
+      end
+
+      if Signal.list.keys.include?("USR2")
+        Signal.trap("USR2") { async_queue_add([:guard_pause, :unpaused]) }
+      end
+
+      return unless Signal.list.keys.include?("INT")
+      Signal.trap("INT") { interactor.handle_interrupt }
+    end
+
+    # Enables or disables the notifier based on user's configurations.
+    #
+    def _setup_notifier
+      if options[:notify] && ENV["GUARD_NOTIFY"] != "false"
+        ::Guard::Notifier.turn_on
+      else
+        ::Guard::Notifier.turn_off
+      end
+    end
+
+    # Adds a command logger in debug mode. This wraps common command
+    # execution functions and logs the executed command before execution.
+    #
+    def _debug_command_execution
+      Kernel.send(:alias_method, :original_system, :system)
+      Kernel.send(:define_method, :system) do |command, *args|
+        ::Guard::UI.debug "Command execution: #{ command } #{ args.join(" ") }"
+        Kernel.send :original_system, command, *args
+      end
+
+      Kernel.send(:alias_method, :original_backtick, :'`')
+      Kernel.send(:define_method, :'`') do |command|
+        ::Guard::UI.debug "Command execution: #{ command }"
+        Kernel.send :original_backtick, command
+      end
+    end
+
+    # TODO: Guard::Watch or Guard::Scope should provide this
+    def _scoped_watchers
+      watchers = []
+      runner.send(:_scoped_plugins) { |guard| watchers += guard.watchers }
+      watchers
+    end
+
+    # Check if any of the changes are actually watched for
+    def _relevant_changes?(changes)
+      files = changes.values.flatten(1)
+      watchers = _scoped_watchers
+      watchers.any? { |watcher| files.any? { |file| watcher.match(file) } }
+    end
+
+    def _relative_pathname(path)
+      full_path = Pathname(path)
+      full_path.relative_path_from(Pathname.pwd)
+    rescue ArgumentError
+      full_path
+    end
+
+    def _relative_pathnames(paths)
+      paths.map { |path| _relative_pathname(path) }
+    end
+
+    def _run_actions(actions)
+      actions.each do |action_args|
+        args = action_args.dup
+        namespaced_action = args.shift
+        action = namespaced_action.to_s.sub(/^guard_/, "")
+        if ::Guard.respond_to?(action)
+          ::Guard.send(action, *args)
+        else
+          fail "Unknown action: #{action.inspect}"
+        end
+      end
+    end
+
+    def _setup_watchdirs
+      dirs = Array(options[:watchdir])
+      dirs.empty? ? [Dir.pwd] : dirs.map { |dir| File.expand_path dir }
+    end
+
+    def _listener_callback
+      lambda do |modified, added, removed|
+        relative_paths = {
+          modified: _relative_pathnames(modified),
+          added: _relative_pathnames(added),
+          removed: _relative_pathnames(removed)
+        }
+
+        async_queue_add(relative_paths) if _relevant_changes?(relative_paths)
+      end
+    end
+
+    def _reset_all
+      reset_groups
+      reset_plugins
+      reset_scope
+    end
+
+    def _setup_interactor
+      ::Guard::Interactor.new(options[:no_interactions])
+    end
+
+    def _load_guardfile
+      _reset_all
+      evaluate_guardfile
+      setup_scope
+      _setup_notifier
+    end
+
+    def _prepare_scope(scope)
+      fail "Guard::setup() not called!" if options.nil?
+      plugins = Array(options[:plugin])
+      plugins = Array(scope[:plugins] || scope[:plugin]) if plugins.empty?
+
+      # Convert objects to names
+      plugins.map! { |p| p.respond_to?(:name) ? p.name : p }
+
+      groups = Array(options[:group])
+      groups = Array(scope[:groups] || scope[:group]) if groups.empty?
+
+      # Convert objects to names
+      groups.map! { |g| g.respond_to?(:name) ? g.name : g }
+
+      { plugins: plugins, groups: groups }
+    end
+
+    def _pluginless_guardfile?
+      # no Reevaluator means there was no Guardfile configured that could be
+      # reevaluated, so we don't have a pluginless guardfile, because we don't
+      # have a Guardfile to begin with...
+      #
+      # But, if we have a Guardfile, we'll at least have the built-in
+      # Reevaluator, so the following will work:
+
+      plugins.map(&:name) != ["reevaluator"]
+    end
+
+    def _reset_for_tests
+      @options = nil
+      @queue = nil
+      @runner = nil
+      @evaluator = nil
+      @watchdirs = nil
+      @watchdirs = nil
+      @listener = nil
+      @interactor = nil
+      @scope = nil
+    end
+  end
+end