guard 2.7.1 → 2.7.2

data/lib/guard/ui.rb.orig

@@ -1,264 +0,0 @@
-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
-
-      # 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 ||= ::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 = {})
-        msg = "neither ::Guard.setup nor ::Guard.reset_options was called"
-        fail msg if ::Guard.options.nil?
-        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 Gem.win_platform?
-            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/watcher.rb.orig

@@ -1,119 +0,0 @@
-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.
-    #
-    # @param [String, Regexp] pattern the pattern to be watched by the Guard
-    #   plugin
-    # @param [Block] action the action to execute before passing the result to
-    #   the Guard plugin
-    #
-    def initialize(pattern, action = nil)
-      @pattern, @action = pattern, action
-      @@warning_printed ||= false
-
-      # deprecation warning
-      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
-
-      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.
-    #
-    # @param [Guard::Plugin] guard the Guard plugin which watchers are used
-    # @param [Array<String>] files the changed files
-    # @return [Array<Object>] the matched watcher response
-    #
-    def self.match_files(guard, files)
-      return [] if files.empty?
-
-      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
-              next
-            end
-          else
-            paths << matches[0]
-          end
-
-          break if guard.options[:first_match]
-        end
-
-        guard.options[:any_return] ? paths : paths.flatten.map(&:to_s)
-      end
-    end
-
-    # Tests if any of the files is the Guardfile.
-    #
-    # @param [Array<String>] files the files to test
-    # @return [Boolean] whether one of these files is the Guardfile
-    #
-    def self.match_guardfile?(files)
-      path = ::Guard.evaluator.guardfile_path
-      files.any? { |file| File.expand_path(file) == path }
-    end
-
-    # Test the watchers pattern against a file.
-    #
-    # @param [String] file the file to test
-    # @return [Array<String>] an array of matches (or containing a single path
-    #   if the pattern is a string)
-    #
-    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.
-    #
-    # @param [String, MatchData] matches the matched path or the match from the
-    #   Regex
-    # @return [String] the final paths
-    #
-    def call_action(matches)
-      @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