guard 1.4.0 → 2.18.0

data/lib/guard/ui.rb

@@ -1,62 +1,112 @@
-module Guard
+require "guard/ui/colors"
+require "guard/ui/config"
+
+require "guard/terminal"
+require "forwardable"
+
+# TODO: rework this class from the bottom-up
+#  - remove dependency on Session and Scope
+#  - extract into a separate gem
+# - change UI to class
 
-  # 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).
+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`.
+  # 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
+            require "lumberjack"
+            Lumberjack::Logger.new(options.device, options.logger_config)
+          end
+      end
 
-      color_enabled = nil
+      # Since logger is global, for Aruba in-process to properly
+      # separate output between calls, we need to reset
+      #
+      # We don't use logger=() since it's expected to be a Lumberjack instance
+      def reset_logger
+        @logger = nil
+      end
+
+      # Get the logger options
+      #
+      # @return [Hash] the logger options
+      #
+      def options
+        @options ||= Config.new
+      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
+      #
+      # TODO: deprecate?
+      def options=(options)
+        @options = Config.new(options)
+      end
+
+      # Assigns a log level
+      def level=(new_level)
+        options.logger_config.level = new_level
+        @logger.level = new_level if @logger
+      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 = { })
-        unless ENV['GUARD_ENV'] == 'test'
-          reset_line if options[:reset]
-          STDERR.puts color(message) if message != ''
-        end
+      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 = { })
-        unless ENV['GUARD_ENV'] == 'test'
-          reset_line if options[:reset]
-          STDERR.puts color('WARNING: ', :yellow) + message
-        end
+      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 = { })
-        unless ENV['GUARD_ENV'] == 'test'
-          reset_line if options[:reset]
-          STDERR.puts color('ERROR: ', :red) + message
-        end
+      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 = { })
-        unless ENV['GUARD_ENV'] == 'test'
-          reset_line if options[:reset]
-          STDERR.puts color('DEPRECATION: ', :red) + message
+      def deprecation(message, options = {})
+        unless ENV["GUARD_GEM_SILENCE_DEPRECATIONS"] == "1"
+          backtrace = Thread.current.backtrace[1..5].join("\n\t >")
+          msg = format("%s\nDeprecation backtrace: %s", message, backtrace)
+          warning(msg, options)
         end
       end
 
@@ -64,27 +114,37 @@ module Guard
       #
       # @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 = { })
-        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
+      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")
+        $stderr.print(color_enabled? ? "\r\e[0m" : "\r\n")
       end
 
       # Clear the output if clearable.
       #
-      def clear(options = {})
-        if ::Guard.options[:clear] && (@clearable || options[:force])
-          @clearable = false
-          system('clear;')
-        end
+      def clear(opts = {})
+        return unless Guard.state.session.clear?
+
+        fail "UI not set up!" if @clearable.nil?
+        return unless @clearable || opts[:force]
+
+        @clearable = false
+        Terminal.clear
+      rescue Errno::ENOENT => e
+        warning("Failed to clear the screen: #{e.inspect}")
+      end
+
+      # TODO: arguments: UI uses Guard::options anyway
+      # @private api
+      def reset_and_clear
+        @clearable = false
+        clear(force: true)
       end
 
       # Allow the screen to be cleared again.
@@ -96,26 +156,58 @@ module Guard
       # Show a scoped action message.
       #
       # @param [String] action the action to show
-      # @param [Hash] scopes hash with a guard or a group scope
+      # @param [Hash] scope hash with a guard or a group scope
       #
-      def action_with_scopes(action, scopes)
-        scope_message ||= scopes[:guard]
-        scope_message ||= scopes[:group]
-        scope_message ||= 'all'
-
-        info "#{action} #{scope_message}"
+      def action_with_scopes(action, scope)
+        titles = Guard.state.scope.titles(scope)
+        info "#{action} #{titles.join(', ')}"
       end
 
       private
 
-      # Reset a color sequence.
+      # Filters log messages depending on either the
+      # `:only`` or `:except` option.
       #
-      # @deprecated
-      # @param [String] text the text
+      # @param [String] plugin the calling plugin name
+      # @yield When the message should be logged
+      # @yieldparam [String] param the calling plugin name
       #
-      def reset_color(text)
-        deprecation('UI.reset_color(text) is deprecated, please use color(text, ' ') instead.')
-        color(text, '')
+      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
+
+      # @private
+      def _filtered_logger_message(message, method, color_name, options = {})
+        message = color(message, color_name) if color_name
+
+        _filter(options[:plugin]) do
+          reset_line if options[:reset]
+          logger.send(method, message)
+        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
+        name = caller.lazy.map do |line|
+          %r{(?<!guard\/lib)\/(guard\/[a-z_]*)(/[a-z_]*)?.rb:}i.match(line)
+        end.reject(&:nil?).take(1).force.first
+        return "Guard" unless name || (name && name[1] == "guard/lib")
+        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.
@@ -123,26 +215,22 @@ module Guard
       # @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
+        @color_enabled_initialized ||= false
+        @color_enabled = nil unless @color_enabled_initialized
+        @color_enabled_initialized = true
+        return @color_enabled unless @color_enabled.nil?
+        return (@color_enabled = true) unless Gem.win_platform?
+        return (@color_enabled = true) if ENV["ANSICON"]
+
+        @color_enabled =
+          begin
+            require "rubygems" unless ENV["NO_RUBYGEMS"]
+            require "Win32/Console/ANSI"
+            true
+          rescue LoadError
+            info "Run 'gem install win32console' to use color on Windows"
+            false
           end
-        end
-
-        @color_enabled
       end
 
       # Colorizes a text message. See the constant in the UI class for possible
@@ -157,71 +245,18 @@ module Guard
       # @param [Array] color_options the color options
       #
       def color(text, *color_options)
-        color_code = ''
+        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
+          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
-
-    # 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

data/lib/guard/version.rb

@@ -1,4 +1,3 @@
 module Guard
-  # The current gem version of Guard
-  VERSION = '1.4.0'
+  VERSION = "2.18.0"
 end

data/lib/guard/watcher/pattern/deprecated_regexp.rb

@@ -0,0 +1,45 @@
+require_relative "matcher"
+
+module Guard
+  class Watcher
+    class Pattern
+      # TODO: remove before Guard 3.x
+      class DeprecatedRegexp
+        def initialize(pattern)
+          @original_pattern = pattern
+        end
+
+        def self.convert(pattern)
+          Matcher.new(Regexp.new(pattern))
+        end
+
+        def deprecated?
+          regexp = /(^(\^))|(>?(\\\.)|(\.\*))|(\(.*\))|(\[.*\])|(\$$)/
+          @original_pattern.is_a?(String) && regexp.match(@original_pattern)
+        end
+
+        def self.show_deprecation(pattern)
+          @warning_printed ||= false
+
+          unless @warning_printed
+            msg = "*" * 20 + "\nDEPRECATION WARNING!\n" + "*" * 20
+            msg += <<-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
+            UI.deprecation(msg)
+            @warning_printed = true
+          end
+
+          new_regexp = Regexp.new(pattern).inspect
+          UI.info "\"#{pattern}\" will be converted to #{new_regexp}\n"
+        end
+      end
+    end
+  end
+end

data/lib/guard/watcher/pattern/match_result.rb

@@ -0,0 +1,18 @@
+module Guard
+  class Watcher
+    class Pattern
+      class MatchResult
+        def initialize(match_result, original_value)
+          @match_result = match_result
+          @original_value = original_value
+        end
+
+        def [](index)
+          return @match_result[index] if index.is_a?(Symbol)
+          return @original_value if index.zero?
+          @match_result.to_a[index]
+        end
+      end
+    end
+  end
+end

data/lib/guard/watcher/pattern/matcher.rb

@@ -0,0 +1,33 @@
+module Guard
+  class Watcher
+    class Pattern
+      class Matcher
+        attr_reader :matcher
+
+        def initialize(obj)
+          @matcher = obj
+        end
+
+        # Compare with other matcher
+        # @param other [Guard::Watcher::Pattern::Matcher]
+        #   other matcher for comparing
+        # @return [true, false] equal or not
+        def ==(other)
+          matcher == other.matcher
+        end
+
+        def match(string_or_pathname)
+          @matcher.match(normalized(string_or_pathname))
+        end
+
+        private
+
+        def normalized(string_or_pathname)
+          path = Pathname.new(string_or_pathname).cleanpath
+          return path.to_s if @matcher.is_a?(Regexp)
+          path
+        end
+      end
+    end
+  end
+end

data/lib/guard/watcher/pattern/pathname_path.rb

@@ -0,0 +1,15 @@
+require_relative "simple_path"
+
+module Guard
+  class Watcher
+    class Pattern
+      class PathnamePath < SimplePath
+        protected
+
+        def normalize(string_or_pathname)
+          Pathname.new(string_or_pathname).cleanpath
+        end
+      end
+    end
+  end
+end

data/lib/guard/watcher/pattern/simple_path.rb

@@ -0,0 +1,23 @@
+module Guard
+  class Watcher
+    class Pattern
+      class SimplePath
+        def initialize(string_or_pathname)
+          @path = normalize(string_or_pathname)
+        end
+
+        def match(string_or_pathname)
+          cleaned = normalize(string_or_pathname)
+          return nil unless @path == cleaned
+          [cleaned]
+        end
+
+        protected
+
+        def normalize(string_or_pathname)
+          Pathname.new(string_or_pathname).cleanpath.to_s
+        end
+      end
+    end
+  end
+end

data/lib/guard/watcher/pattern.rb

@@ -0,0 +1,24 @@
+require "guard/ui"
+
+require_relative "pattern/match_result"
+require_relative "pattern/matcher"
+require_relative "pattern/deprecated_regexp"
+require_relative "pattern/simple_path"
+require_relative "pattern/pathname_path"
+
+module Guard
+  class Watcher
+    class Pattern
+      def self.create(pattern)
+        if DeprecatedRegexp.new(pattern).deprecated?
+          DeprecatedRegexp.show_deprecation(pattern)
+          return DeprecatedRegexp.convert(pattern)
+        end
+
+        return PathnamePath.new(pattern) if pattern.is_a?(Pathname)
+        return SimplePath.new(pattern) if pattern.is_a?(String)
+        Matcher.new(pattern)
+      end
+    end
+  end
+end