guard 2.6.1 → 2.7.0

data/lib/guard/ui.rb.orig

@@ -0,0 +1,254 @@
+require "lumberjack"
+
+require "guard/options"
+require "guard/ui/colors"
+
+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 plugin does some output that is piped into another process
+  # for further processing, please just write it to STDOUT with `puts`.
+  #
+  module UI
+    include Colors
+
+    class << self
+      # Get the Guard::UI logger instance
+      #
+      def logger
+        @logger ||= begin
+                      Lumberjack::Logger.new(
+                        options.fetch(:device) { $stderr },
+                        options)
+                    end
+      end
+
+      # Get the logger options
+      #
+      # @return [Hash] the logger options
+      #
+      def options
+        @options ||= ::Guard::Options.new(
+          level: :info,
+          template: ":time - :severity - :message",
+          time_format: "%H:%M:%S")
+      end
+
+      # Set the logger options
+      #
+      # @param [Hash] options the logger options
+      # @option options [Symbol] level the log level
+      # @option options [String] template the logger template
+      # @option options [String] time_format the time format
+      #
+      def options=(options)
+        @options = ::Guard::Options.new(options)
+      end
+
+      # Show an info message.
+      #
+      # @param [String] message the message to show
+      # @option options [Boolean] reset whether to clean the output before
+      # @option options [String] plugin manually define the calling plugin
+      #
+      def info(message, options = {})
+        _filtered_logger_message(message, :info, nil, options)
+      end
+
+      # Show a yellow warning message that is prefixed with WARNING.
+      #
+      # @param [String] message the message to show
+      # @option options [Boolean] reset whether to clean the output before
+      # @option options [String] plugin manually define the calling plugin
+      #
+      def warning(message, options = {})
+        _filtered_logger_message(message, :warn, :yellow, options)
+      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
+      # @option options [String] plugin manually define the calling plugin
+      #
+      def error(message, options = {})
+        _filtered_logger_message(message, :error, :red, options)
+      end
+
+      # Show a red deprecation message that is prefixed with DEPRECATION.
+      # It has a log level of `warn`.
+      #
+      # @param [String] message the message to show
+      # @option options [Boolean] reset whether to clean the output before
+      # @option options [String] plugin manually define the calling plugin
+      #
+      def deprecation(message, options = {})
+        warning(message, options) if ::Guard.options[:show_deprecations]
+      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
+      # @option options [String] plugin manually define the calling plugin
+      #
+      def debug(message, options = {})
+        _filtered_logger_message(message, :debug, :yellow, options)
+      end
+
+      # Reset a line.
+      #
+      def reset_line
+        $stderr.print(color_enabled? ? "\r\e[0m" : "\r\n")
+      end
+
+      # Clear the output if clearable.
+      #
+      def clear(options = {})
+        return unless ::Guard.options[:clear] && (@clearable || options[:force])
+        @clearable = false
+        ::Guard::Sheller.run("clear;")
+      end
+
+      # Allow the screen to be cleared again.
+      #
+      def clearable
+        @clearable = true
+      end
+
+      # Show a scoped action message.
+      #
+      # @param [String] action the action to show
+      # @param [Hash] scope hash with a guard or a group scope
+      #
+      def action_with_scopes(action, scope)
+        first_non_blank_scope = _first_non_blank_scope(scope)
+        unless first_non_blank_scope.nil?
+          scope_message = first_non_blank_scope.map(&:title).join(", ")
+        end
+
+        info "#{ action } #{ scope_message || "all" }"
+      end
+
+      private
+
+      # Returns the first non-blank scope by searching in the given `scope`
+      # hash and in Guard.scope. Returns nil if no non-blank scope is found.
+      #
+      def _first_non_blank_scope(scope)
+        [:plugins, :groups].each do |scope_name|
+          s = scope[scope_name] || ::Guard.scope[scope_name]
+          return s if !s.nil? && !s.empty?
+        end
+
+        nil
+      end
+
+      # Filters log messages depending on either the
+      # `:only`` or `:except` option.
+      #
+      # @param [String] plugin the calling plugin name
+      # @yield When the message should be logged
+      # @yieldparam [String] param the calling plugin name
+      #
+      def _filter(plugin)
+        only   = options[:only]
+        except = options[:except]
+        plugin ||= calling_plugin_name
+
+        match = !(only || except)
+        match ||= (only && only.match(plugin))
+        match ||= (except && !except.match(plugin))
+        return unless match
+        yield plugin
+      end
+
+      # Display a message of the type `method` and with the color `color_name`
+      # (no color by default) conditionnaly given a `plugin_name`.
+      #
+      # @param [String] plugin_name the calling plugin name
+      # @option options [Boolean] reset whether to clean the output before
+      # @option options [String] plugin manually define the calling plugin
+      #
+      def _filtered_logger_message(message, method, color_name, options = {})
+        message = color(message, color_name) if color_name
+
+        _filter(options[:plugin]) do |plugin|
+          reset_line if options[:reset]
+          logger.send(method, message, plugin)
+        end
+      end
+
+      # Tries to extract the calling Guard plugin name
+      # from the call stack.
+      #
+      # @param [Integer] depth the stack depth
+      # @return [String] the Guard plugin name
+      #
+      def calling_plugin_name(depth = 2)
+        name = /(guard\/[a-z_]*)(\/[a-z_]*)?.rb:/i.match(caller[depth])
+        return "Guard" unless name
+        name[1].split("/").map do |part|
+          part.split(/[^a-z0-9]/i).map(&:capitalize).join
+        end.join("::")
+      end
+
+      # Checks if color output can be enabled.
+      #
+      # @return [Boolean] whether color is enabled or not
+      #
+      def color_enabled?
+        @color_enabled_initialized ||= false
+        @color_enabled = nil unless @color_enabled_initialized
+        @color_enabled_initialized = true
+        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 "Run '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] text 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
+          next if color_option == ""
+
+          unless color_option =~ /\d+/
+            color_option = const_get("ANSI_ESCAPE_#{ color_option.upcase }")
+          end
+          color_code += ";" + color_option
+        end
+        color_enabled? ? "\e[0#{ color_code }m#{ text }\e[0m" : text
+      end
+    end
+  end
+end

data/lib/guard/ui/colors.rb

@@ -1,60 +1,56 @@
 module Guard
   module UI
-
     module Colors
-
       # Brighten the color
-      ANSI_ESCAPE_BRIGHT    = '1'
+      ANSI_ESCAPE_BRIGHT    = "1"
 
       # Black foreground color
-      ANSI_ESCAPE_BLACK     = '30'
+      ANSI_ESCAPE_BLACK     = "30"
 
       # Red foreground color
-      ANSI_ESCAPE_RED       = '31'
+      ANSI_ESCAPE_RED       = "31"
 
       # Green foreground color
-      ANSI_ESCAPE_GREEN     = '32'
+      ANSI_ESCAPE_GREEN     = "32"
 
       # Yellow foreground color
-      ANSI_ESCAPE_YELLOW    = '33'
+      ANSI_ESCAPE_YELLOW    = "33"
 
       # Blue foreground color
-      ANSI_ESCAPE_BLUE      = '34'
+      ANSI_ESCAPE_BLUE      = "34"
 
       # Magenta foreground color
-      ANSI_ESCAPE_MAGENTA   = '35'
+      ANSI_ESCAPE_MAGENTA   = "35"
 
       # Cyan foreground color
-      ANSI_ESCAPE_CYAN      = '36'
+      ANSI_ESCAPE_CYAN      = "36"
 
       # White foreground color
-      ANSI_ESCAPE_WHITE     = '37'
+      ANSI_ESCAPE_WHITE     = "37"
 
       # Black background color
-      ANSI_ESCAPE_BGBLACK   = '40'
+      ANSI_ESCAPE_BGBLACK   = "40"
 
       # Red background color
-      ANSI_ESCAPE_BGRED     = '41'
+      ANSI_ESCAPE_BGRED     = "41"
 
       # Green background color
-      ANSI_ESCAPE_BGGREEN   = '42'
+      ANSI_ESCAPE_BGGREEN   = "42"
 
       # Yellow background color
-      ANSI_ESCAPE_BGYELLOW  = '43'
+      ANSI_ESCAPE_BGYELLOW  = "43"
 
       # Blue background color
-      ANSI_ESCAPE_BGBLUE    = '44'
+      ANSI_ESCAPE_BGBLUE    = "44"
 
       # Magenta background color
-      ANSI_ESCAPE_BGMAGENTA = '45'
+      ANSI_ESCAPE_BGMAGENTA = "45"
 
       # Cyan background color
-      ANSI_ESCAPE_BGCYAN    = '46'
+      ANSI_ESCAPE_BGCYAN    = "46"
 
       # White background color
-      ANSI_ESCAPE_BGWHITE   = '47'
-
+      ANSI_ESCAPE_BGWHITE   = "47"
     end
-
   end
 end

data/lib/guard/version.rb

@@ -1,3 +1,3 @@
 module Guard
-  VERSION = '2.6.1'
+  VERSION = "2.7.0"
 end

data/lib/guard/version.rb.orig

@@ -0,0 +1,3 @@
+module Guard
+  VERSION = "2.6.1"
+end

data/lib/guard/watcher.rb

@@ -1,14 +1,12 @@
-require 'guard/ui'
+require "guard/ui"
 
 module Guard
-
   # The watcher defines a RegExp that will be matched against file system
   # modifications.
   # When a watcher matches a change, an optional action block is executed to
   # enable processing the file system change result.
   #
   class Watcher
-
     attr_accessor :pattern, :action
 
     # Initializes a file watcher.
@@ -23,20 +21,26 @@ module Guard
       @@warning_printed ||= false
 
       # deprecation warning
-      if @pattern.is_a?(String) && @pattern =~ /(^(\^))|(>?(\\\.)|(\.\*))|(\(.*\))|(\[.*\])|(\$$)/
-        unless @@warning_printed
-          ::Guard::UI.info "*"*20 + "\nDEPRECATION WARNING!\n" + "*"*20
-          ::Guard::UI.info <<-MSG
-            You have a string in your Guardfile watch patterns that seem to represent a Regexp.
+      regexp = /(^(\^))|(>?(\\\.)|(\.\*))|(\(.*\))|(\[.*\])|(\$$)/
+      return unless @pattern.is_a?(String) && @pattern =~ regexp
+
+      unless @@warning_printed
+        ::Guard::UI.info "*" * 20 + "\nDEPRECATION WARNING!\n" + "*" * 20
+        ::Guard::UI.info <<-MSG
+            You have a string in your Guardfile watch patterns that seem to
+            represent a Regexp.
+
             Guard matches String with == and Regexp with Regexp#match.
-            You should either use plain String (without Regexp special characters) or real Regexp.
-          MSG
-          @@warning_printed = true
-        end
 
-        ::Guard::UI.info "\"#{@pattern}\" has been converted to #{ Regexp.new(@pattern).inspect }\n"
-        @pattern = Regexp.new(@pattern)
+            You should either use plain String (without Regexp special
+            characters) or real Regexp.
+        MSG
+        @@warning_printed = true
       end
+
+      new_regexp = Regexp.new(@pattern).inspect
+      ::Guard::UI.info "\"#{@pattern}\" has been converted to #{ new_regexp }\n"
+      @pattern = Regexp.new(@pattern)
     end
 
     # Finds the files that matches a Guard plugin.
@@ -48,38 +52,28 @@ module Guard
     def self.match_files(guard, files)
       return [] if files.empty?
 
-      guard.watchers.inject([]) do |paths, watcher|
-        files.each do |file|
-          if matches = watcher.match(file)
-            if watcher.action
-              result = watcher.call_action(matches)
-              if guard.options[:any_return]
-                paths << result
-              elsif result.respond_to?(:empty?) && !result.empty?
-                paths << Array(result)
-              end
+      files.inject([]) do |paths, file|
+        guard.watchers.each do |watcher|
+          matches = watcher.match(file)
+          next unless matches
+
+          if watcher.action
+            result = watcher.call_action(matches)
+            if guard.options[:any_return]
+              paths << result
+            elsif result.respond_to?(:empty?) && !result.empty?
+              paths << Array(result)
             else
-              paths << matches[0]
+              next
             end
+          else
+            paths << matches[0]
           end
-        end
 
-        guard.options[:any_return] ? paths : paths.flatten.map { |p| p.to_s }
-      end
-    end
-
-    # Tests if a file would be matched by any of the Guard plugin watchers.
-    #
-    # @param [Array<Guard::Plugin>] plugins the Guard plugins to use the
-    #   watchers from
-    # @param [Array<String>] files the files to test
-    # @return [Boolean] Whether a file matches
-    #
-    def self.match_files?(plugins, files)
-      plugins.any? do |plugin|
-        plugin.watchers.any? do |watcher|
-          files.any? { |file| watcher.match(file) }
+          break if guard.options[:first_match]
         end
+
+        guard.options[:any_return] ? paths : paths.flatten.map(&:to_s)
       end
     end
 
@@ -89,7 +83,8 @@ module Guard
     # @return [Boolean] whether one of these files is the Guardfile
     #
     def self.match_guardfile?(files)
-      files.any? { |file| File.expand_path(file) == ::Guard.evaluator.guardfile_path }
+      path = ::Guard.evaluator.guardfile_path
+      files.any? { |file| File.expand_path(file) == path }
     end
 
     # Test the watchers pattern against a file.
@@ -98,19 +93,14 @@ module Guard
     # @return [Array<String>] an array of matches (or containing a single path
     #   if the pattern is a string)
     #
-    def match(file)
-      f = file
-      deleted = file.start_with?('!')
-      f = deleted ? f[1..-1] : f
-      if @pattern.is_a?(Regexp)
-        if m = f.match(@pattern)
-          m = m.to_a
-          m[0] = file
-          m
-        end
-      else
-        f == @pattern ? [file] : nil
-      end
+    def match(string_or_pathname)
+      # TODO: use only match() - and show fnmatch example
+      file = string_or_pathname.to_s
+      return (file == @pattern ? [file] : nil) unless @pattern.is_a?(Regexp)
+      return unless (m = @pattern.match(file))
+      m = m.to_a
+      m[0] = file
+      m
     end
 
     # Executes a watcher action.
@@ -120,13 +110,10 @@ module Guard
     # @return [String] the final paths
     #
     def call_action(matches)
-      begin
-        @action.arity > 0 ? @action.call(matches) : @action.call
-      rescue Exception => ex
-        ::Guard::UI.error "Problem with watch action!\n#{ ex.message }"
-        ::Guard::UI.error ex.backtrace.join("\n")
-      end
+      @action.arity > 0 ? @action.call(matches) : @action.call
+    rescue => ex
+      ::Guard::UI.error "Problem with watch action!\n#{ ex.message }"
+      ::Guard::UI.error ex.backtrace.join("\n")
     end
-
   end
 end