joshbuddy-guard 0.10.0

data/lib/guard/listeners/polling.rb

@@ -0,0 +1,55 @@
+module Guard
+
+  # Polling listener that works cross-platform and
+  # has no dependencies. This is the listener that
+  # uses the most CPU processing power and has higher
+  # file IO that the other implementations.
+  #
+  class Polling < Listener
+
+    # Initialize the Listener.
+    #
+    def initialize(*)
+      super
+      @latency = 1.5
+    end
+
+    # Start the listener.
+    #
+    def start
+      @stop = false
+      super
+      watch_change
+    end
+
+    # Stop the listener.
+    #
+    def stop
+      super
+      @stop = true
+    end
+
+    # Watch the given directory for file changes.
+    #
+    # @param [String] directory the directory to watch
+    #
+    def watch(directory)
+      @existing = all_files
+    end
+
+    private
+
+    # Watch for file system changes.
+    #
+    def watch_change
+      until @stop
+        start = Time.now.to_f
+        files = modified_files([@directory], :all => true)
+        @callback.call(files) unless files.empty?
+        nap_time = @latency - (Time.now.to_f - start)
+        sleep(nap_time) if nap_time > 0
+      end
+    end
+
+  end
+end

data/lib/guard/listeners/windows.rb

@@ -0,0 +1,61 @@
+module Guard
+
+  # Listener implementation for Windows `fchange`.
+  #
+  class Windows < Listener
+
+    # Initialize the Listener.
+    #
+    def initialize(*)
+      super
+      @fchange = FChange::Notifier.new
+    end
+
+    # Start the listener.
+    #
+    def start
+      super
+      worker.run
+    end
+
+    # Stop the listener.
+    #
+    def stop
+      super
+      worker.stop
+    end
+
+    # Check if the listener is usable on the current OS.
+    #
+    # @return [Boolean] whether usable or not
+    #
+    def self.usable?(no_vendor = false)
+      $LOAD_PATH << File.expand_path('../../../vendor/windows/lib', __FILE__) unless no_vendor
+      require 'rb-fchange'
+      true
+    rescue LoadError
+      false
+    end
+
+    private
+
+    # Watch the given directory for file changes.
+    #
+    # @param [String] directory the directory to watch
+    #
+    def watch(directory)
+      worker.watch(directory, :all_events, :recursive) do |event|
+        paths = [File.expand_path(event.watcher.path)]
+        files = modified_files(paths, :all => true)
+        @callback.call(files) unless files.empty?
+      end
+    end
+
+    # Get the listener worker.
+    #
+    def worker
+      @fchange
+    end
+
+  end
+end

data/lib/guard/notifier.rb

@@ -0,0 +1,290 @@
+require 'rbconfig'
+require 'pathname'
+require 'guard/ui'
+
+module Guard
+
+  # The notifier class handles cross-platform system notifications that supports:
+  #
+  # - Growl on Mac OS X
+  # - Libnotify on Linux
+  # - Notifu on Windows
+  #
+  module Notifier
+
+    # 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))
+
+        when :growl
+          Growl.notify(message, {
+              :name => APPLICATION_NAME
+          }.merge(notification))
+        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
+      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
+
+      # 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
+
+        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
+      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
+          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
+
+      # 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
+
+      # Try to safely load libnotify and turns notifications
+      # off on load failure.
+      #
+      def require_libnotify
+        require 'libnotify'
+
+      rescue LoadError
+        turn_off
+        UI.info "Please install libnotify gem for Linux notification support and add it to your Gemfile"
+      end
+
+      # Try to safely load rb-notifu and turns notifications
+      # off on load failure.
+      #
+      def require_rbnotifu
+        require 'rb-notifu'
+
+      rescue LoadError
+        turn_off
+        UI.info "Please install rb-notifu gem for Windows notification support and add it to your Gemfile"
+      end
+
+    end
+  end
+end

data/lib/guard/templates/Guardfile

@@ -0,0 +1,2 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme

data/lib/guard/ui.rb

@@ -0,0 +1,193 @@
+module Guard
+
+  # The UI class helps to format messages for the user. Everything that is logged
+  # through this class is considered either as an error message or a diagnostic
+  # message and is written to standard error (STDERR).
+  #
+  # If your Guard does some output that is piped into another process for further
+  # processing, please just write it to STDOUT with `puts`.
+  #
+  module UI
+    class << self
+
+      color_enabled = nil
+
+      # Show an info message.
+      #
+      # @param [String] message the message to show
+      # @option options [Boolean] reset whether to clean the output before
+      #
+      def info(message, options = { })
+        unless ENV['GUARD_ENV'] == 'test'
+          reset_line if options[:reset]
+          STDERR.puts color(message) if message != ''
+        end
+      end
+
+      # Show a red error message that is prefixed with ERROR.
+      #
+      # @param [String] message the message to show
+      # @option options [Boolean] reset whether to clean the output before
+      #
+      def error(message, options = { })
+        unless ENV['GUARD_ENV'] == 'test'
+          reset_line if options[:reset]
+          STDERR.puts color('ERROR: ', :red) + message
+        end
+      end
+
+      # Show a red deprecation message that is prefixed with DEPRECATION.
+      #
+      # @param [String] message the message to show
+      # @option options [Boolean] reset whether to clean the output before
+      #
+      def deprecation(message, options = { })
+        unless ENV['GUARD_ENV'] == 'test'
+          reset_line if options[:reset]
+          STDERR.puts color('DEPRECATION: ', :red) + message
+        end
+      end
+
+      # Show a debug message that is prefixed with DEBUG and a timestamp.
+      #
+      # @param [String] message the message to show
+      # @option options [Boolean] reset whether to clean the output before
+      #
+      def debug(message, options = { })
+        unless ENV['GUARD_ENV'] == 'test'
+          reset_line if options[:reset]
+          STDERR.puts color("DEBUG (#{Time.now.strftime('%T')}): ", :yellow) + message if ::Guard.options && ::Guard.options[:debug]
+        end
+      end
+
+      # Reset a line.
+      #
+      def reset_line
+        STDERR.print(color_enabled? ? "\r\e[0m" : "\r\n")
+      end
+
+      # Clear the output.
+      #
+      def clear
+        system('clear;')
+      end
+
+      private
+
+      # Reset a color sequence.
+      #
+      # @deprecated
+      # @param [String] text the text
+      #
+      def reset_color(text)
+        deprecation('UI.reset_color(text) is deprecated, please use color(text, ' ') instead.')
+        color(text, '')
+      end
+
+      # Checks if color output can be enabled.
+      #
+      # @return [Boolean] whether color is enabled or not
+      #
+      def color_enabled?
+        if @color_enabled.nil?
+          if RbConfig::CONFIG['target_os'] =~ /mswin|mingw/i
+            if ENV['ANSICON']
+              @color_enabled = true
+            else
+              begin
+                require 'rubygems' unless ENV['NO_RUBYGEMS']
+                require 'Win32/Console/ANSI'
+                @color_enabled = true
+              rescue LoadError
+                @color_enabled = false
+                info "You must 'gem install win32console' to use color on Windows"
+              end
+            end
+          else
+            @color_enabled = true
+          end
+        end
+
+        @color_enabled
+      end
+
+      # Colorizes a text message. See the constant in the UI class for possible
+      # color_options parameters. You can pass optionally :bright, a foreground
+      # color and a background color.
+      #
+      # @example
+      #
+      #   color('Hello World', :red, :bright)
+      #
+      # @param [String] the text to colorize
+      # @param [Array] color_options the color options
+      #
+      def color(text, *color_options)
+        color_code = ''
+        color_options.each do |color_option|
+          color_option = color_option.to_s
+          if color_option != ''
+            if !(color_option =~ /\d+/)
+              color_option = const_get("ANSI_ESCAPE_#{ color_option.upcase }")
+            end
+            color_code += ';' + color_option
+          end
+        end
+        color_enabled? ? "\e[0#{ color_code }m#{ text }\e[0m" : text
+      end
+
+    end
+
+    # Brighten the color
+    ANSI_ESCAPE_BRIGHT    = '1'
+
+    # Black foreground color
+    ANSI_ESCAPE_BLACK     = '30'
+
+    # Red foreground color
+    ANSI_ESCAPE_RED       = '31'
+
+    # Green foreground color
+    ANSI_ESCAPE_GREEN     = '32'
+
+    # Yellow foreground color
+    ANSI_ESCAPE_YELLOW    = '33'
+
+    # Blue foreground color
+    ANSI_ESCAPE_BLUE      = '34'
+
+    # Magenta foreground color
+    ANSI_ESCAPE_MAGENTA   = '35'
+
+    # Cyan foreground color
+    ANSI_ESCAPE_CYAN      = '36'
+
+    # White foreground color
+    ANSI_ESCAPE_WHITE     = '37'
+
+    # Black background color
+    ANSI_ESCAPE_BGBLACK   = '40'
+
+    # Red background color
+    ANSI_ESCAPE_BGRED     = '41'
+
+    # Green background color
+    ANSI_ESCAPE_BGGREEN   = '42'
+
+    # Yellow background color
+    ANSI_ESCAPE_BGYELLOW  = '43'
+
+    # Blue background color
+    ANSI_ESCAPE_BGBLUE    = '44'
+
+    # Magenta background color
+    ANSI_ESCAPE_BGMAGENTA = '45'
+
+    # Cyan background color
+    ANSI_ESCAPE_BGCYAN    = '46'
+
+    # White background color
+    ANSI_ESCAPE_BGWHITE   = '47'
+
+  end
+end