guard 2.9.0 → 2.9.1

data/lib/guard/jobs/sleep.rb

@@ -5,13 +5,12 @@ module Guard
   module Jobs
     class Sleep < Base
       def foreground
-        # TODO: cleanup the namespace
-        ::Guard::UI.debug "Guards jobs done. Sleeping..."
+        UI.debug "Guards jobs done. Sleeping..."
         sleep
-        ::Guard::UI.debug "Sleep interrupted by events."
+        UI.debug "Sleep interrupted by events."
         :stopped
       rescue Interrupt
-        ::Guard::UI.debug "Sleep interrupted by user."
+        UI.debug "Sleep interrupted by user."
         :exit
       end
 

data/lib/guard/notifier.rb

@@ -85,6 +85,8 @@ module Guard
 
       return unless enabled? && options[:notify]
 
+      @detected.detect
+
       turn_on
     rescue Detected::NoneAvailableError => e
       ::Guard::UI.info e.to_s

data/lib/guard/notifier/detected.rb.orig

@@ -0,0 +1,83 @@
+require "guard/internals/environment"
+
+require_relative "../notifiers/emacs"
+require_relative "../notifiers/file_notifier"
+require_relative "../notifiers/gntp"
+require_relative "../notifiers/growl"
+require_relative "../notifiers/libnotify"
+require_relative "../notifiers/notifysend"
+require_relative "../notifiers/rb_notifu"
+require_relative "../notifiers/terminal_notifier"
+require_relative "../notifiers/terminal_title"
+require_relative "../notifiers/tmux"
+
+module Guard
+  module Notifier
+    # @private api
+    class Detected
+      NO_SUPPORTED_NOTIFIERS = "Guard could not detect any of the supported" +
+        " notification libraries."
+
+      class NoneAvailableError < RuntimeError
+      end
+
+      def initialize(supported)
+        @supported = supported
+        @environment = Internals::Environment.new("GUARD").tap do |env|
+          env.create_method(:notifiers=) { |data| YAML::dump(data) }
+          env.create_method(:notifiers) { |data| data ? YAML::load(data) : [] }
+        end
+      end
+
+      def reset
+        @environment.notifiers = nil
+      end
+
+      def detect
+        return unless _data.empty?
+        @supported.each do |group|
+          group.detect { |name, _| add(name, silent: true) }
+        end
+
+        fail NoneAvailableError, NO_SUPPORTED_NOTIFIERS if _data.empty?
+      end
+
+      def available
+        _data.map { |entry| [_to_module(entry[:name]), entry[:options]] }
+      end
+
+      def add(name, opts)
+        klass = _to_module(name)
+        return false unless klass
+
+        all = @environment.notifiers
+
+        # Silently skip if it's already available, because otherwise
+        # we'd have to do :turn_off, then configure, then :turn_on
+        names = all.map(&:first).map(&:last)
+        unless names.include?(name)
+          return false unless klass.available?(opts)
+          @environment.notifiers = all << { name: name, options: opts }
+          true
+        end
+
+        # Just overwrite the options (without turning the notifier off or on),
+        # so those options will be passed in next calls to notify()
+        all.each { |item| item[:options] = opts if item[:name] == name }
+        true
+      end
+
+      def _to_module(name)
+        @supported.each do |group|
+          next unless (notifier = group.detect { |n, _| n == name })
+          return notifier.last
+        end
+        nil
+      end
+
+      def _data
+        @environment.notifiers || []
+      end
+    end
+  end
+end

data/lib/guard/plugin.rb

@@ -1,5 +1,3 @@
-require "guard/plugin/base"
-
 module Guard
   # Base class from which every Guard plugin implementation must inherit.
   #
@@ -19,8 +17,6 @@ module Guard
   # your Guard plugin method was not successful, and successive Guard plugin
   # tasks will be aborted when the group has set the `:halt_on_fail` option.
   #
-  # @see Guard::Base
-  # @see Guard::Hooker
   # @see Guard::Group
   #
   # @example Throw :task_has_failed
@@ -43,7 +39,234 @@ module Guard
   # plugins.
   #
   class Plugin
-    include Base
+    TEMPLATE_FORMAT = "%s/lib/guard/%s/templates/Guardfile"
+
+    require "guard/ui"
+
+    # Get all callbacks registered for all Guard plugins present in the
+    # Guardfile.
+    #
+    def self.callbacks
+      @callbacks ||= Hash.new { |hash, key| hash[key] = [] }
+    end
+
+    # Add a callback.
+    #
+    # @param [Block] listener the listener to notify
+    # @param [Guard::Plugin] guard_plugin the Guard plugin to add the callback
+    # @param [Array<Symbol>] events the events to register
+    #
+    def self.add_callback(listener, guard_plugin, events)
+      Array(events).each do |event|
+        callbacks[[guard_plugin, event]] << listener
+      end
+    end
+
+    # Notify a callback.
+    #
+    # @param [Guard::Plugin] guard_plugin the Guard plugin to add the callback
+    # @param [Symbol] event the event to trigger
+    # @param [Array] args the arguments for the listener
+    #
+    def self.notify(guard_plugin, event, *args)
+      callbacks[[guard_plugin, event]].each do |listener|
+        listener.call(guard_plugin, event, *args)
+      end
+    end
+
+    # Reset all callbacks.
+    #
+    # TODO: remove (not used anywhere)
+    def self.reset_callbacks!
+      @callbacks = nil
+    end
+
+    # When event is a Symbol, {#hook} will generate a hook name
+    # by concatenating the method name from where {#hook} is called
+    # with the given Symbol.
+    #
+    # @example Add a hook with a Symbol
+    #
+    #   def run_all
+    #     hook :foo
+    #   end
+    #
+    # Here, when {Guard::Plugin::Base#run_all} is called, {#hook} will notify
+    # callbacks registered for the "run_all_foo" event.
+    #
+    # When event is a String, {#hook} will directly turn the String
+    # into a Symbol.
+    #
+    # @example Add a hook with a String
+    #
+    #   def run_all
+    #     hook "foo_bar"
+    #   end
+    #
+    # When {Guard::Plugin::Base#run_all} is called, {#hook} will notify
+    # callbacks registered for the "foo_bar" event.
+    #
+    # @param [Symbol, String] event the name of the Guard event
+    # @param [Array] args the parameters are passed as is to the callbacks
+    #   registered for the given event.
+    #
+    def hook(event, *args)
+      hook_name = if event.is_a? Symbol
+                    calling_method = caller[0][/`([^']*)'/, 1]
+                    "#{ calling_method }_#{ event }"
+                  else
+                    event
+                  end
+
+      UI.debug "Hook :#{ hook_name } executed for #{ self.class }"
+
+      self.class.notify(self, hook_name.to_sym, *args)
+    end
+
+    attr_accessor :group, :watchers, :callbacks, :options
+
+    # Returns the non-namespaced class name of the plugin
+    #
+    #
+    # @example Non-namespaced class name for Guard::RSpec
+    #   Guard::RSpec.non_namespaced_classname
+    #   #=> "RSpec"
+    #
+    # @return [String]
+    #
+    def self.non_namespaced_classname
+      to_s.sub("Guard::", "")
+    end
+
+    # Returns the non-namespaced name of the plugin
+    #
+    #
+    # @example Non-namespaced name for Guard::RSpec
+    #   Guard::RSpec.non_namespaced_name
+    #   #=> "rspec"
+    #
+    # @return [String]
+    #
+    def self.non_namespaced_name
+      non_namespaced_classname.downcase
+    end
+
+    # Specify the source for the Guardfile template.
+    # Each Guard plugin can redefine this method to add its own logic.
+    #
+    # @param [String] plugin_location the plugin location
+    #
+    def self.template(plugin_location)
+      File.read TEMPLATE_FORMAT % [plugin_location, non_namespaced_name]
+    end
+
+    # Called once when Guard starts. Please override initialize method to
+    # init stuff.
+    #
+    # @raise [:task_has_failed] when start has failed
+    # @return [Object] the task result
+    #
+    # @!method start
+
+    # Called when `stop|quit|exit|s|q|e + enter` is pressed (when Guard
+    # quits).
+    #
+    # @raise [:task_has_failed] when stop has failed
+    # @return [Object] the task result
+    #
+    # @!method stop
+
+    # Called when `reload|r|z + enter` is pressed.
+    # This method should be mainly used for "reload" (really!) actions like
+    # reloading passenger/spork/bundler/...
+    #
+    # @raise [:task_has_failed] when reload has failed
+    # @return [Object] the task result
+    #
+    # @!method reload
+
+    # Called when just `enter` is pressed
+    # This method should be principally used for long action like running all
+    # specs/tests/...
+    #
+    # @raise [:task_has_failed] when run_all has failed
+    # @return [Object] the task result
+    #
+    # @!method run_all
+
+    # Default behaviour on file(s) changes that the Guard plugin watches.
+    #
+    # @param [Array<String>] paths the changes files or paths
+    # @raise [:task_has_failed] when run_on_changes has failed
+    # @return [Object] the task result
+    #
+    # @!method run_on_changes(paths)
+
+    # Called on file(s) additions that the Guard plugin watches.
+    #
+    # @param [Array<String>] paths the changes files or paths
+    # @raise [:task_has_failed] when run_on_additions has failed
+    # @return [Object] the task result
+    #
+    # @!method run_on_additions(paths)
+
+    # Called on file(s) modifications that the Guard plugin watches.
+    #
+    # @param [Array<String>] paths the changes files or paths
+    # @raise [:task_has_failed] when run_on_modifications has failed
+    # @return [Object] the task result
+    #
+    # @!method run_on_modifications(paths)
+
+    # Called on file(s) removals that the Guard plugin watches.
+    #
+    # @param [Array<String>] paths the changes files or paths
+    # @raise [:task_has_failed] when run_on_removals has failed
+    # @return [Object] the task result
+    #
+    # @!method run_on_removals(paths)
+
+    # Returns the plugin's name (without "guard-").
+    #
+    # @example Name for Guard::RSpec
+    #   Guard::RSpec.new.name
+    #   #=> "rspec"
+    #
+    # @return [String]
+    #
+    def name
+      @name ||= self.class.non_namespaced_name
+    end
+
+    # Returns the plugin's class name without the Guard:: namespace.
+    #
+    # @example Title for Guard::RSpec
+    #   Guard::RSpec.new.title
+    #   #=> "RSpec"
+    #
+    # @return [String]
+    #
+    def title
+      @title ||= self.class.non_namespaced_classname
+    end
+
+    # String representation of the plugin.
+    #
+    # @example String representation of an instance of the Guard::RSpec plugin
+    #
+    #   Guard::RSpec.new.title
+    #   #=> "#<Guard::RSpec @name=rspec @group=#<Guard::Group @name=default
+    #   @options={}> @watchers=[] @callbacks=[] @options={all_after_pass:
+    #   true}>"
+    #
+    # @return [String] the string representation
+    #
+    def to_s
+      "#<#{self.class} @name=#{name} @group=#{group} @watchers=#{watchers}"\
+        " @callbacks=#{callbacks} @options=#{options}>"
+    end
+
+    private
 
     # Initializes a Guard plugin.
     # Don't do any work here, especially as Guard plugins get initialized even
@@ -57,8 +280,21 @@ module Guard
     #   a watcher
     #
     def initialize(options = {})
-      _set_instance_variables_from_options(options)
+      group_name = options.delete(:group) { :default }
+      @group = Guard.state.session.groups.add(group_name)
+      @watchers = options.delete(:watchers) { [] }
+      @callbacks = options.delete(:callbacks) { [] }
+      @options  = options
       _register_callbacks
     end
+
+    # Add all the Guard::Plugin's callbacks to the global @callbacks array
+    # that's used by Guard to know which callbacks to notify.
+    #
+    def _register_callbacks
+      callbacks.each do |callback|
+        Hooker.add_callback(callback[:listener], self, callback[:events])
+      end
+    end
   end
 end

data/lib/guard/plugin_util.rb

@@ -96,21 +96,19 @@ module Guard
     def plugin_class(options = {})
       options = { fail_gracefully: false }.merge(options)
 
-      try_require = false
+      const = _plugin_constant
+      fail TypeError, "no constant: #{_constant_name}" unless const
+      @plugin_class ||= Guard.const_get(const)
+
+    rescue TypeError
       begin
-        if try_require
-          require "guard/#{name.downcase}"
-        end
+        require "guard/#{ name.downcase }"
+        const = _plugin_constant
+        @plugin_class ||= Guard.const_get(const)
 
-        @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
+        UI.error "Could not find class Guard::#{ _constant_name }"
+        UI.error error.backtrace.join("\n")
       rescue LoadError => error
         unless options[:fail_gracefully]
           UI.error ERROR_NO_GUARD_OR_CLASS % [name.downcase, _constant_name]
@@ -123,18 +121,21 @@ module Guard
     # Adds a plugin's template to the Guardfile.
     #
     def add_to_guardfile
+      klass = plugin_class # call here to avoid failing later
+
       require "guard/guardfile/evaluator"
-      # TODO: move this method to Generator?
-      evaluator = Guard::Guardfile::Evaluator.new
-      evaluator.evaluate_guardfile
+      # TODO: move this to Generator?
+      options = Guard.state.session.evaluator_options
+      evaluator = Guardfile::Evaluator.new(options)
+      evaluator.evaluate
       if evaluator.guardfile_include?(name)
-        ::Guard::UI.info "Guardfile already includes #{ 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))
+          f.puts(klass.template(plugin_location))
         end
 
         UI.info INFO_ADDED_GUARD_TO_GUARDFILE % name
@@ -150,7 +151,7 @@ module Guard
     #   => Guard::RSpec
     #
     def _plugin_constant
-      @_plugin_constant ||= ::Guard.constants.detect do |c|
+      @_plugin_constant ||= Guard.constants.detect do |c|
         c.to_s.downcase == _constant_name.downcase
       end
     end