guard 2.7.0 → 2.7.1

data/lib/guard/interactor.rb.orig

@@ -2,6 +2,7 @@ require "guard/ui"
 
 require "guard/jobs/sleep"
 require "guard/jobs/pry_wrapper"
+require "guard/jobs/stdin"
 
 module Guard
   class Interactor
@@ -12,7 +13,11 @@ module Guard
     def initialize(no_interaction = false)
       @interactive = !no_interaction && self.class.enabled?
 
-      job_klass = interactive? ? Jobs::PryWrapper : Jobs::Sleep
+
+      # TODO: restore
+      # job_klass = interactive? ? Jobs::PryWrapper : Jobs::Sleep
+      job_klass = Jobs::StdinJob
+
       @idle_job = job_klass.new(self.class.options)
     end
 

data/lib/guard/jobs/pry_wrapper.rb

@@ -74,6 +74,7 @@ module Guard
         _start_pry
         @thread.join
         thread = @thread
+        # TODO: rename :stopped to continue
         thread.nil? ? :stopped : :exit
       ensure
         ::Guard::UI.reset_line

data/lib/guard/jobs/stdin.rb.orig

@@ -0,0 +1,46 @@
+require "guard/jobs/base"
+
+module Guard
+  module Jobs
+    class StdinJob
+      def initialize(options)
+        @mode = :stopped
+        @sleeping = false
+      end
+
+      def foreground
+        output "Guard is idle" # needed for child-process cucumber tests
+
+        line = $stdin.readline.chomp
+        return :exit if line == "exit"
+
+        m = /^sleep (?<seconds>\d+)$/.match(line)
+        return @mode unless m
+
+        seconds = Integer(m[:seconds][/\d+/])
+        @sleeping = true
+        sleep seconds
+        @sleeping = false
+        @mode
+      rescue EOFError, Interrupt
+        @sleeping = false
+        :exit
+      end
+
+      def background
+        Thread.main.wakeup if @sleeping
+      end
+
+      def handle_interrupt
+        @mode = :exit
+      end
+
+      private
+
+      def output(text)
+        $stdout.puts text
+        $stdout.flush
+      end
+    end
+  end
+end

data/lib/guard/notifiers/emacs.rb

@@ -18,18 +18,13 @@ module Guard
       }
 
       def self.available?(opts = {})
-        super && _emacs_client_available?(opts)
-      end
+        return false unless super
 
-      # @private
-      #
-      # @return [Boolean] whether or not the emacs client is available
-      #
-      def self._emacs_client_available?(opts)
         client_name = opts.fetch(:client, DEFAULTS[:client])
         cmd = "#{client_name} --eval '1' 2> #{DEV_NULL} || echo 'N/A'"
         stdout = Sheller.stdout(cmd)
-        !%w(N/A 'N/A').include?(stdout.chomp!)
+        return false if stdout.nil?
+        !%w(N/A 'N/A').include?(stdout.chomp)
       end
 
       # Shows a system notification.

data/lib/guard/notifiers/emacs.rb.orig

@@ -0,0 +1,103 @@
+require "guard/notifiers/base"
+
+module Guard
+  module Notifier
+    # Send a notification to Emacs with emacsclient
+    # (http://www.emacswiki.org/emacs/EmacsClient).
+    #
+    # @example Add the `:emacs` notifier to your `Guardfile`
+    #   notification :emacs
+    #
+    class Emacs < Base
+      DEFAULTS = {
+        client:    "emacsclient",
+        success:   "ForestGreen",
+        failed:    "Firebrick",
+        default:   "Black",
+        fontcolor: "White",
+      }
+
+      def self.available?(opts = {})
+        super && _emacs_client_available?(opts)
+      end
+
+      # @private
+      #
+      # @return [Boolean] whether or not the emacs client is available
+      #
+      def self._emacs_client_available?(opts)
+        client_name = opts.fetch(:client, DEFAULTS[:client])
+        cmd = "#{client_name} --eval '1' 2> #{DEV_NULL} || echo 'N/A'"
+        stdout = Sheller.stdout(cmd)
+        !%w(N/A 'N/A').include?(stdout.chomp!)
+      end
+
+      # Shows a system notification.
+      #
+      # @param [String] type the notification type. Either 'success',
+      #   'pending', 'failed' or 'notify'
+      # @param [String] title the notification title
+      # @param [String] message the notification message body
+      # @param [String] image the path to the notification image
+      # @param [Hash] opts additional notification library options
+      # @option opts [String] success the color to use for success
+      #   notifications (default is 'ForestGreen')
+      # @option opts [String] failed the color to use for failure
+      #   notifications (default is 'Firebrick')
+      # @option opts [String] pending the color to use for pending
+      #   notifications
+      # @option opts [String] default the default color to use (default is
+      #   'Black')
+      # @option opts [String] client the client to use for notification
+      #   (default is 'emacsclient')
+      # @option opts [String, Integer] priority specify an int or named key
+      #   (default is 0)
+      #
+      def notify(message, opts = {})
+        super
+
+        opts      = DEFAULTS.merge(opts)
+        color     = emacs_color(opts[:type], opts)
+        fontcolor = emacs_color(:fontcolor, opts)
+        elisp = <<-EOF.gsub(/\s+/, " ").strip
+          (set-face-attribute 'mode-line nil
+               :background "#{color}"
+               :foreground "#{fontcolor}")
+        EOF
+
+        _run_cmd(opts[:client], "--eval", elisp)
+      end
+
+      # Get the Emacs color for the notification type.
+      # You can configure your own color by overwrite the defaults.
+      #
+      # @param [String] type the notification type
+      # @param [Hash] options aditional notification options
+      #
+      # @option options [String] success the color to use for success
+      # notifications (default is 'ForestGreen')
+      #
+      # @option options [String] failed the color to use for failure
+      # notifications (default is 'Firebrick')
+      #
+      # @option options [String] pending the color to use for pending
+      # notifications
+      #
+      # @option options [String] default the default color to use (default is
+      # 'Black')
+      #
+      # @return [String] the name of the emacs color
+      #
+      def emacs_color(type, options = {})
+        default = options.fetch(:default, DEFAULTS[:default])
+        options.fetch(type.to_sym, default)
+      end
+
+      private
+
+      def _run_cmd(cmd, *args)
+        Sheller.run(cmd, *args)
+      end
+    end
+  end
+end

data/lib/guard/plugin_util.rb

@@ -69,10 +69,12 @@ module Guard
     #   https://github.com/guard/guard/wiki/Upgrading-to-Guard-2.0
     #
     def initialize_plugin(options)
-      if plugin_class.superclass.to_s == "Guard::Guard"
-        plugin_class.new(options.delete(:watchers), 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
-        plugin_class.new(options)
+        klass.new(options)
       end
     end
 

data/lib/guard/runner.rb

@@ -14,12 +14,10 @@ module Guard
     # @param [Hash] scopes either the Guard plugin or the group to run the task
     # on
     #
-    # @see self.run_supervised_task
-    #
-    def run(task, scope = {})
+    def run(task, scope_hash = {})
       Lumberjack.unit_of_work do
-        _scoped_plugins(scope) do |guard|
-          run_supervised_task(guard, task) if guard.respond_to?(task)
+        _scoped_plugins(scope_hash || {}) do |plugin|
+          _supervise(plugin, task) if plugin.respond_to?(task)
         end
       end
     end
@@ -47,15 +45,16 @@ module Guard
 
       ::Guard::UI.clearable
 
-      _scoped_plugins do |guard|
+      _scoped_plugins do |plugin|
         ::Guard::UI.clear
 
         types.each do |tasks, unmatched_paths|
-          paths = ::Guard::Watcher.match_files(guard, unmatched_paths)
-          next if paths.empty?
+          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| guard.respond_to?(meth) })
-          run_supervised_task(guard, task, paths)
+          next unless (task = tasks.detect { |meth| plugin.respond_to?(meth) })
+          _supervise(plugin, task, match_result)
         end
       end
     end
@@ -71,24 +70,24 @@ module Guard
     # @param [Array] args the arguments for the task
     # @raise [:task_has_failed] when task has failed
     #
-    def run_supervised_task(guard, task, *args)
-      catch self.class.stopping_symbol_for(guard) do
-        guard.hook("#{ task }_begin", *args)
+    def _supervise(plugin, task, *args)
+      catch self.class.stopping_symbol_for(plugin) do
+        plugin.hook("#{ task }_begin", *args)
         begin
-          result = guard.send(task, *args)
+          result = plugin.send(task, *args)
         rescue Interrupt
           throw(:task_has_failed)
         end
-        guard.hook("#{ task }_end", result)
+        plugin.hook("#{ task }_end", result)
         result
       end
     rescue ScriptError, StandardError, RuntimeError
-      ::Guard::UI.error("#{ guard.class.name } failed to achieve its"\
+      ::Guard::UI.error("#{ plugin.class.name } failed to achieve its"\
                         " <#{ task }>, exception was:" \
                         "\n#{ $!.class }: #{ $!.message }" \
                         "\n#{ $!.backtrace.join("\n") }")
-      ::Guard.plugins.delete guard
-      ::Guard::UI.info("\n#{ guard.class.name } has just been fired")
+      ::Guard.remove_plugin(plugin)
+      ::Guard::UI.info("\n#{ plugin.class.name } has just been fired")
       $!
     end
 
@@ -121,12 +120,14 @@ module Guard
     # @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|
@@ -151,13 +152,9 @@ module Guard
     # @return [Array<Guard::Plugin>] the plugins to scope to
     #
     def _current_plugins_scope(scope)
-      if plugins = _find_non_empty_plugins_scope(scope)
-        Array(plugins).map do |plugin|
-          plugin.is_a?(Symbol) ? ::Guard.plugin(plugin) : plugin
-        end
-      else
-        nil
-      end
+      return nil unless (plugins = _find_non_empty_plugins_scope(scope))
+
+      Array(plugins).map { |plugin| _instantiate(:plugin, plugin) }
     end
 
     # Returns the current groups scope.
@@ -168,9 +165,14 @@ module Guard
     # @return [Array<Guard::Group>] the groups to scope to
     #
     def _current_groups_scope(scope)
-      Array(_find_non_empty_groups_scope(scope)).map do |group|
-        group.is_a?(Symbol) ? ::Guard.group(group) : group
-      end
+      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
+    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
@@ -178,16 +180,17 @@ module Guard
     def _find_non_empty_scope(type, local_scope, *additional_possibilities)
       found = [
         local_scope[:"#{type}s"],
-        local_scope[type.to_sym],
+        [local_scope[type.to_sym]],
         ::Guard.scope[:"#{type}s"],
         additional_possibilities.flatten
-      ].compact.detect { |a| !Array(a).empty? }
-      found ? [::Guard.group(:common)] + Array(found) : found
+      ]
+      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
 

data/lib/guard/setuper.rb

@@ -51,7 +51,7 @@ module Guard
       @runner = ::Guard::Runner.new
       @watchdirs = _setup_watchdirs
 
-      ::Guard::UI.clear(force: true)
+      ::Guard::UI.setup(options)
 
       _setup_debug if options[:debug]
       @listener = _setup_listener
@@ -62,7 +62,7 @@ module Guard
       self
     end
 
-    attr_reader :options, :evaluator, :interactor
+    attr_reader :options, :interactor
 
     # Used only by tests (for all I know...)
     def clear_options
@@ -127,12 +127,11 @@ module Guard
     def setup_scope(scope = {})
       # TODO: there should be a special Scope class instead
       scope = _prepare_scope(scope)
-      { groups: :add_group, plugins: :plugin }.each do |type, meth|
-        next unless scope[type].any?
-        ::Guard.scope[type] = scope[type].map do |item|
-          ::Guard.send(meth, item)
-        end
-      end
+
+      ::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
@@ -143,7 +142,7 @@ module Guard
     def evaluate_guardfile
       evaluator.evaluate_guardfile
       msg = "No plugins found in Guardfile, please add at least one."
-      ::Guard::UI.error msg unless _non_builtin_plugins?
+      ::Guard::UI.error msg unless _pluginless_guardfile?
     end
 
     # Asynchronously trigger changes
@@ -343,16 +342,30 @@ module Guard
     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 _non_builtin_plugins?
+    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
 
@@ -365,7 +378,7 @@ module Guard
       @watchdirs = nil
       @listener = nil
       @interactor = nil
-      ::Guard.scope = nil
+      @scope = nil
     end
   end
 end

data/lib/guard/setuper.rb.orig

@@ -38,8 +38,18 @@ module Guard
     #
     # @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 = {})
-      _init_options(opts)
+      reset_options(opts)
+      reset_evaluator(opts)
+
+      @queue = Queue.new
+      @runner = ::Guard::Runner.new
+      @watchdirs = _setup_watchdirs
 
       ::Guard::UI.clear(force: true)
 
@@ -52,7 +62,7 @@ module Guard
       self
     end
 
-    attr_reader :options, :evaluator, :interactor
+    attr_reader :options, :interactor
 
     # Used only by tests (for all I know...)
     def clear_options
@@ -85,6 +95,16 @@ module Guard
       ::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
@@ -107,12 +127,11 @@ module Guard
     def setup_scope(scope = {})
       # TODO: there should be a special Scope class instead
       scope = _prepare_scope(scope)
-      { groups: :add_group, plugins: :plugin }.each do |type, meth|
-        next unless scope[type].any?
-        ::Guard.scope[type] = scope[type].map do |item|
-          ::Guard.send(meth, item)
-        end
-      end
+
+      ::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
@@ -123,7 +142,7 @@ module Guard
     def evaluate_guardfile
       evaluator.evaluate_guardfile
       msg = "No plugins found in Guardfile, please add at least one."
-      ::Guard::UI.error msg unless _non_builtin_plugins?
+      ::Guard::UI.error msg unless _pluginless_guardfile?
     end
 
     # Asynchronously trigger changes
@@ -146,8 +165,7 @@ module Guard
       ! @queue.empty?
     end
 
-    def add_builtin_plugins
-      guardfile = ::Guard.evaluator.guardfile_path
+    def add_builtin_plugins(guardfile)
       return unless guardfile
 
       pattern = _relative_pathname(guardfile).to_s
@@ -306,14 +324,6 @@ module Guard
       end
     end
 
-    def _init_options(opts)
-      @queue = Queue.new
-      @runner = ::Guard::Runner.new
-      @evaluator = ::Guard::Guardfile::Evaluator.new(opts)
-      @options = ::Guard::Options.new(opts, DEFAULT_OPTIONS)
-      @watchdirs = _setup_watchdirs
-    end
-
     def _reset_all
       reset_groups
       reset_plugins
@@ -332,17 +342,43 @@ module Guard
     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 _non_builtin_plugins?
+    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