guard 0.8.8 → 0.9.0

data/lib/guard/listener.rb

@@ -31,16 +31,17 @@ module Guard
     # @param [Array] args the arguments for the listener
     # @return [Guard::Listener] the chosen listener
     #
-    def self.select_and_init(*args)
-      if mac? && Darwin.usable?
-        Darwin.new(*args)
-      elsif linux? && Linux.usable?
-        Linux.new(*args)
-      elsif windows? && Windows.usable?
-        Windows.new(*args)
+    def self.select_and_init(watchdir = Dir.pwd, options = nil)
+      no_vendor = options && options.key?(:no_vendor) ? options[:no_vendor] : false
+      if mac? && Darwin.usable?(no_vendor)
+        Darwin.new(watchdir, options)
+      elsif linux? && Linux.usable?(no_vendor)
+        Linux.new(watchdir, options)
+      elsif windows? && Windows.usable?(no_vendor)
+        Windows.new(watchdir, options)
       else
         UI.info 'Using polling (Please help us to support your system better than that).'
-        Polling.new(*args)
+        Polling.new(watchdir, options)
       end
     end
 
@@ -48,18 +49,23 @@ module Guard
     #
     # @param [String] directory the root directory to listen to
     # @option options [Boolean] relativize_paths use only relative paths
+    # @option options [Boolean] watch_all_modifications to enable deleted and moved file listening.
     # @option options [Array<String>] ignore_paths the paths to ignore by the listener
     #
     def initialize(directory = Dir.pwd, options = {})
-      @directory                = directory.to_s
       @sha1_checksums_hash      = {}
       @file_timestamp_hash      = {}
-      @relativize_paths         = options.fetch(:relativize_paths, true)
       @changed_files            = []
       @paused                   = false
+
+      @directory                = directory.to_s
+
+      options                   = options.inject({}) { |h,(k,v)| h[k.to_sym] = v; h }
+      @relativize_paths         = options.fetch(:relativize_paths, true)
+      @watch_all_modifications  = options.fetch(:watch_all_modifications, false)
+
       @ignore_paths             = DEFAULT_IGNORE_PATHS
       @ignore_paths            |= options[:ignore_paths] if options[:ignore_paths]
-      @watch_all_modifications  = options.fetch(:watch_all_modifications, false)
 
       update_last_event
       start_reactor
@@ -143,7 +149,7 @@ module Guard
     def modified_files(dirs, options = {})
       last_event = @last_event
       files = []
-      if @watch_all_modifications
+      if watch_all_modifications?
         deleted_files = @file_timestamp_hash.collect do |path, ts|
           unless File.exists?(path)
             @sha1_checksums_hash.delete(path)
@@ -196,10 +202,19 @@ module Guard
       !!@relativize_paths
     end
 
+    # test if the listener should also watch for deleted and
+    # moved files
+    #
+    # @return [Boolean] whether to watch all file modifications or not
+    #
+    def watch_all_modifications?
+      !!@watch_all_modifications
+    end
+
     # Populate initial timestamp file hash to watch for deleted or moved files.
     #
     def timestamp_files
-      all_files.each {|path| set_file_timestamp_hash(path, file_timestamp(path)) } if @watch_all_modifications
+      all_files.each {|path| set_file_timestamp_hash(path, file_timestamp(path)) } if watch_all_modifications?
     end
 
     # Removes the ignored paths from the directory list.
@@ -258,7 +273,7 @@ module Guard
       elsif mtime > last_event.to_i
         set_sha1_checksums_hash(path, sha1_checksum(path))
         true
-      elsif @watch_all_modifications
+      elsif watch_all_modifications?
         ts = file_timestamp(path)
         if ts != @file_timestamp_hash[path]
           set_file_timestamp_hash(path, ts)
@@ -289,7 +304,7 @@ module Guard
     # Set save a files current timestamp
     #
     # @param [String] path the file path
-    # @param [Int] file_timestamp the files modified timestamp
+    # @param [Integer] file_timestamp the files modified timestamp
     #
     def set_file_timestamp_hash(path, file_timestamp)
         @file_timestamp_hash[path] = file_timestamp
@@ -306,8 +321,8 @@ module Guard
 
     # Gets a files modified timestamp
     #
-    # @path [String] path the file path
-    # @return [Int] file modified timestamp
+    # @param [String] path the file path
+    # @return [Integer] file modified timestamp
     #
     def file_timestamp(path)
       File.mtime(path).to_i

data/lib/guard/listeners/darwin.rb

@@ -29,17 +29,13 @@ module Guard
     #
     # @return [Boolean] whether usable or not
     #
-    def self.usable?
+    def self.usable?(no_vendor = false)
+      return false unless RbConfig::CONFIG['target_os'] =~ /darwin/i
+
+      $LOAD_PATH << File.expand_path('../../../vendor/darwin/lib', __FILE__) unless no_vendor
       require 'rb-fsevent'
-      if !defined?(FSEvent::VERSION) || (defined?(Gem::Version) &&
-          Gem::Version.new(FSEvent::VERSION) < Gem::Version.new('0.4.0'))
-        UI.info 'Please update rb-fsevent (>= 0.4.0)'
-        false
-      else
-        true
-      end
+      true
     rescue LoadError
-      UI.info 'Please install rb-fsevent gem for Mac OSX FSEvents support'
       false
     end
 

data/lib/guard/listeners/linux.rb

@@ -32,17 +32,13 @@ module Guard
     #
     # @return [Boolean] whether usable or not
     #
-    def self.usable?
+    def self.usable?(no_vendor = false)
+      return false unless RbConfig::CONFIG['target_os'] =~ /linux/i
+
+      $LOAD_PATH << File.expand_path('../../../vendor/linux/lib', __FILE__) unless no_vendor
       require 'rb-inotify'
-      if !defined?(INotify::VERSION) || (defined?(Gem::Version) &&
-          Gem::Version.new(INotify::VERSION.join('.')) < Gem::Version.new('0.8.5'))
-        UI.info 'Please update rb-inotify (>= 0.8.5)'
-        false
-      else
-        true
-      end
+      true
     rescue LoadError
-      UI.info 'Please install rb-inotify gem for Linux inotify support'
       false
     end
 
@@ -72,7 +68,7 @@ module Guard
     # @return [Boolean] whether inotify is active or not
     #
     def watch_change?
-      !!@watch_change
+      !!(defined? @watch_change and @watch_change)
     end
 
     # Watch for file system changes.

data/lib/guard/listeners/windows.rb

@@ -29,11 +29,13 @@ module Guard
     #
     # @return [Boolean] whether usable or not
     #
-    def self.usable?
+    def self.usable?(no_vendor = false)
+      return false unless RbConfig::CONFIG['target_os'] =~ /mswin|mingw/i
+
+      $LOAD_PATH << File.expand_path('../../../vendor/windows/lib', __FILE__) unless no_vendor
       require 'rb-fchange'
       true
     rescue LoadError
-      UI.info 'Please install rb-fchange gem for Windows file events support'
       false
     end
 

data/lib/guard/notifier.rb

@@ -1,290 +1,203 @@
 require 'rbconfig'
 require 'pathname'
 require 'guard/ui'
+require 'guard/notifiers/gntp'
+require 'guard/notifiers/growl'
+require 'guard/notifiers/growl_notify'
+require 'guard/notifiers/libnotify'
+require 'guard/notifiers/rb_notifu'
 
 module Guard
 
-  # The notifier class handles cross-platform system notifications that supports:
+  # The notifier handles sending messages to different notifiers. Currently the following
+  # libraries are supported:
   #
-  # - Growl on Mac OS X
-  # - Libnotify on Linux
-  # - Notifu on Windows
+  # * Ruby GNTP
+  # * Growl
+  # * GrowlNotify
+  # * Libnotify
+  # * rb-notifu
+  #
+  # Please see the documentation of each notifier for more information about the requirements
+  # and configuration possibilities.
+  #
+  # Guard knows four different notification types:
+  #
+  # * success
+  # * pending
+  # * failed
+  # * notify
+  #
+  # The notification type selection is based on the image option that is
+  # sent to {#notify}. Each image type has its own notification type, and
+  # notifications with custom images goes all sent as type `notify`. The
+  # `gntp` and `growl_notify` notifiers are able to register these types
+  # at Growl and allows customization of each notification type.
+  #
+  # Guard can be configured to make use of more than one notifier at once, @see Guard::Dsl
   #
   module Notifier
+    extend self
+
+    # List of available notifiers.
+    NOTIFIERS = {
+        :gntp         => ::Guard::Notifier::GNTP,
+        :growl        => ::Guard::Notifier::Growl,
+        :growl_notify => ::Guard::Notifier::GrowlNotify,
+        :libnotify    => ::Guard::Notifier::Libnotify,
+        :notifu       => ::Guard::Notifier::Notifu
+    }
+
+    # Get the available notifications.
+    #
+    # @return [Hash] the notifications
+    #
+    def notifications
+      @notifications ||= []
+    end
 
-    # Application name as shown in the specific notification settings
-    APPLICATION_NAME = "Guard"
-
-    class << self
-
-      attr_accessor :growl_library, :gntp
-
-      # Turn notifications off.
-      #
-      def turn_off
-        ENV["GUARD_NOTIFY"] = 'false'
-      end
-
-      # Turn notifications on. This tries to load the platform
-      # specific notification library.
-      #
-      # @return [Boolean] whether the notification could be enabled.
-      #
-      def turn_on
-        ENV["GUARD_NOTIFY"] = 'true'
-        case RbConfig::CONFIG['target_os']
-        when /darwin/i
-          require_growl
-        when /linux/i
-          require_libnotify
-        when /mswin|mingw/i
-          require_rbnotifu
-        end
-      end
-
-      # Show a message with the system notification.
-      #
-      # @see .image_path
-      #
-      # @param [String] the message to show
-      # @option options [Symbol, String] image the image symbol or path to an image
-      # @option options [String] title the notification title
-      #
-      def notify(message, options = { })
-        if enabled?
-          image = options.delete(:image) || :success
-          title = options.delete(:title) || "Guard"
-
-          case RbConfig::CONFIG['target_os']
-          when /darwin/i
-            notify_mac(title, message, image, options)
-          when /linux/i
-            notify_linux(title, message, image, options)
-          when /mswin|mingw/i
-            notify_windows(title, message, image, options)
-          end
-        end
-      end
-
-      # Test if the notifications are enabled and available.
-      #
-      # @return [Boolean] whether the notifications are available
-      #
-      def enabled?
-        ENV["GUARD_NOTIFY"] == 'true'
-      end
-
-      private
-
-      # Send a message to Growl either with the `growl` gem or the `growl_notify` gem.
-      #
-      # @param [String] title the notification title
-      # @param [String] message the message to show
-      # @param [Symbol, String] the image to user
-      # @param [Hash] options the growl options
-      #
-      def notify_mac(title, message, image, options = { })
-        require_growl # need for guard-rspec formatter that is called out of guard scope
-
-        notification = { :title => title, :icon => image_path(image) }.merge(options)
-
-        case self.growl_library
-        when :growl_notify
-          notification.delete(:name)
-
-          GrowlNotify.send_notification({
-              :description      => message,
-              :application_name => APPLICATION_NAME
-          }.merge(notification))
-
-        when :ruby_gntp
-          icon = "file://#{ notification.delete(:icon) }"
-
-          self.gntp.notify({
-              :name  => [:pending, :success, :failed].include?(image) ? image.to_s : 'notify',
-              :text  => message,
-              :icon => icon
-          }.merge(notification))
+    # Set the available notifications.
+    #
+    # @param [Array<Hash>] notifications the notifications
+    #
+    def notifications=(notifications)
+      @notifications = notifications
+    end
 
-        when :growl
-          Growl.notify(message, {
-              :name => APPLICATION_NAME
-          }.merge(notification))
+    # Turn notifications on. If no notifications are defined
+    # in the `Guardfile` Guard auto detects the first available
+    # library.
+    #
+    def turn_on
+      auto_detect_notification if notifications.empty? && (!::Guard.options || ::Guard.options[:notify])
+
+      if notifications.empty?
+        ENV['GUARD_NOTIFY'] = 'false'
+      else
+        notifications.each do |notification|
+          ::Guard::UI.info "Guard uses #{ NOTIFIERS[notification[:name]].to_s.split('::').last } to send notifications."
         end
-      end
-
-      # Send a message to libnotify.
-      #
-      # @param [String] title the notification title
-      # @param [String] message the message to show
-      # @param [Symbol, String] the image to user
-      # @param [Hash] options the libnotify options
-      #
-      def notify_linux(title, message, image, options = { })
-        require_libnotify # need for guard-rspec formatter that is called out of guard scope
 
-        notification = { :body => message, :summary => title, :icon_path => image_path(image), :transient => true }
-        Libnotify.show notification.merge(options)
-      end
-
-      # Send a message to notifu.
-      #
-      # @param [String] title the notification title
-      # @param [String] message the message to show
-      # @param [Symbol, String] the image to user
-      # @param [Hash] options the notifu options
-      #
-      def notify_windows(title, message, image, options = { })
-        require_rbnotifu # need for guard-rspec formatter that is called out of guard scope
-
-        notification = { :message => message, :title => title, :type => image_level(image), :time => 3 }
-        Notifu.show notification.merge(options)
-      end
-
-      # Get the image path for an image symbol.
-      #
-      # Known symbols are:
-      #
-      # - failed
-      # - pending
-      # - success
-      #
-      # @param [Symbol] image the image name
-      # @return [String] the image path
-      #
-      def image_path(image)
-        images_path = Pathname.new(File.dirname(__FILE__)).join('../../images')
-        case image
-        when :failed
-          images_path.join("failed.png").to_s
-        when :pending
-          images_path.join("pending.png").to_s
-        when :success
-          images_path.join("success.png").to_s
-        else
-          # path given
-          image
-        end
+        ENV['GUARD_NOTIFY'] = 'true'
       end
+    end
 
-      # The notification level type for the given image.
-      #
-      # @param [Symbol] image the image
-      # @return [Symbol] the level
-      #
-      def image_level(image)
-        case image
-        when :failed
-          :error
-        when :pending
-          :warn
-        when :success
-          :info
-        else
-          :info
-        end
-      end
+    # Turn notifications off.
+    #
+    def turn_off
+      ENV['GUARD_NOTIFY'] = 'false'
+    end
 
-      # Try to safely load growl and turns notifications off on load failure.
-      # The Guard notifier knows three different library to handle sending
-      # Growl messages and tries to loading them in the given order:
-      #
-      # - [Growl Notify](https://github.com/scottdavis/growl_notify)
-      # - [Ruby GNTP](https://github.com/snaka/ruby_gntp)
-      # - [Growl](https://github.com/visionmedia/growl)
-      #
-      # On successful loading of any of the libraries, the active library name is
-      # accessible through `.growl_library`.
-      #
-      def require_growl
-        self.growl_library = try_growl_notify || try_ruby_gntp || try_growl
+    # Test if the notifications are on.
+    #
+    # @return [Boolean] whether the notifications are on
+    #
+    def enabled?
+      ENV['GUARD_NOTIFY'] == 'true'
+    end
 
-        unless self.growl_library
-          turn_off
-          UI.info "Please install growl_notify or growl gem for Mac OS X notification support and add it to your Gemfile"
-        end
+    # Add a notification library to be used.
+    #
+    # @param [Symbol] name the name of the notifier to use
+    # @param [Boolean] silent disable any error message
+    # @param [Hash] options the notifier options
+    # @return [Boolean] if the notification could be added
+    #
+    def add_notification(name, options = { }, silent = false)
+      return turn_off if name == :off
+
+      if NOTIFIERS.has_key?(name) && NOTIFIERS[name].available?(silent)
+        notifications << { :name => name, :options => options }
+        true
+      else
+        false
       end
+    end
 
-      # Try to load the `growl_notify` gem.
-      #
-      # @return [Symbol, nil] A symbol with the name of the loaded library
-      #
-      def try_growl_notify
-        require 'growl_notify'
-
-        begin
-          if GrowlNotify.application_name != APPLICATION_NAME
-            GrowlNotify.config do |c|
-              c.notifications    = c.default_notifications = [APPLICATION_NAME]
-              c.application_name = c.notifications.first
-            end
+    # Show a system notification with all configured notifiers.
+    #
+    # @param [String] message the message to show
+    # @option options [Symbol, String] image the image symbol or path to an image
+    # @option options [String] title the notification title
+    #
+    def notify(message, options = { })
+      if enabled?
+        type  = notification_type(options[:image] || :success)
+        image = image_path(options.delete(:image) || :success)
+        title = options.delete(:title) || 'Guard'
+
+        notifications.each do |notification|
+          begin
+            NOTIFIERS[notification[:name]].notify(type, title, message, image, options.merge(notification[:options]))
+          rescue Exception => e
+            ::Guard::UI.error "Error sending notification with #{ notification[:name] }: #{ e.message }"
           end
-
-        rescue ::GrowlNotify::GrowlNotFound
-          turn_off
-          UI.info "Please install Growl from http://growl.info"
         end
-
-        :growl_notify
-
-      rescue LoadError
-      end
-
-      # Try to load the `ruby_gntp` gem and register the available
-      # notification channels.
-      #
-      # @return [Symbol, nil] A symbol with the name of the loaded library
-      #
-      def try_ruby_gntp
-        require 'ruby_gntp'
-
-        self.gntp = GNTP.new(APPLICATION_NAME)
-        self.gntp.register(:notifications => [
-            { :name => 'notify', :enabled => true },
-            { :name => 'failed', :enabled => true },
-            { :name => 'pending', :enabled => true },
-            { :name => 'success', :enabled => true }
-        ])
-
-        :ruby_gntp
-
-      rescue LoadError
       end
+    end
 
-      # Try to load the `growl_notify` gem.
-      #
-      # @return [Symbol, nil] A symbol with the name of the loaded library
-      #
-      def try_growl
-        require 'growl'
-
-        :growl
-
-      rescue LoadError
-      end
+    private
 
-      # Try to safely load libnotify and turns notifications
-      # off on load failure.
-      #
-      def require_libnotify
-        require 'libnotify'
+    # Auto detect the available notification library. This goes through
+    # the list of supported notification gems and picks the first that
+    # is available.
+    #
+    def auto_detect_notification
+      available = [:growl_notify, :gntp, :growl, :libnotify, :notifu].any? { |notifier| add_notification(notifier, { }, true) }
+      ::Guard::UI.info('Guard could not detect any of the supported notification libraries.') unless available
+    end
 
-      rescue LoadError
-        turn_off
-        UI.info "Please install libnotify gem for Linux notification support and add it to your Gemfile"
+    # Get the image path for an image symbol for the following
+    # known image types:
+    #
+    # - failed
+    # - pending
+    # - success
+    #
+    # If the image is not a known symbol, it will be returned unmodified.
+    #
+    # @param [Symbol, String] image the image symbol or path to an image
+    # @return [String] the image path
+    #
+    def image_path(image)
+      case image
+      when :failed
+        images_path.join('failed.png').to_s
+      when :pending
+        images_path.join('pending.png').to_s
+      when :success
+        images_path.join('success.png').to_s
+      else
+        image
       end
+    end
 
-      # Try to safely load rb-notifu and turns notifications
-      # off on load failure.
-      #
-      def require_rbnotifu
-        require 'rb-notifu'
+    # Paths where all Guard images are located
+    #
+    # @return [Pathname] the path to the images directory
+    #
+    def images_path
+      @images_path ||= Pathname.new(File.dirname(__FILE__)).join('../../images')
+    end
 
-      rescue LoadError
-        turn_off
-        UI.info "Please install rb-notifu gem for Windows notification support and add it to your Gemfile"
+    # Get the notification type depending on the
+    # image that has been selected for the notification.
+    #
+    # @param [Symbol, String] image the image symbol or path to an image
+    # @return [String] the notification type
+    #
+    def notification_type(image)
+      case image
+      when :failed
+        'failed'
+      when :pending
+        'pending'
+      when :success
+        'success'
+      else
+        'notify'
       end
-
     end
   end
+
 end