guard 2.10.0 → 2.10.1

data/lib/guard/notifier/detected.rb.orig

@@ -1,83 +0,0 @@
-require "guard/internals/environment"
-
-require_relative "../notifiers/emacs"
-require_relative "../notifiers/file_notifier"
-require_relative "../notifiers/gntp"
-require_relative "../notifiers/growl"
-require_relative "../notifiers/libnotify"
-require_relative "../notifiers/notifysend"
-require_relative "../notifiers/rb_notifu"
-require_relative "../notifiers/terminal_notifier"
-require_relative "../notifiers/terminal_title"
-require_relative "../notifiers/tmux"
-
-module Guard
-  module Notifier
-    # @private api
-    class Detected
-      NO_SUPPORTED_NOTIFIERS = "Guard could not detect any of the supported" +
-        " notification libraries."
-
-      class NoneAvailableError < RuntimeError
-      end
-
-      def initialize(supported)
-        @supported = supported
-        @environment = Internals::Environment.new("GUARD").tap do |env|
-          env.create_method(:notifiers=) { |data| YAML::dump(data) }
-          env.create_method(:notifiers) { |data| data ? YAML::load(data) : [] }
-        end
-      end
-
-      def reset
-        @environment.notifiers = nil
-      end
-
-      def detect
-        return unless _data.empty?
-        @supported.each do |group|
-          group.detect { |name, _| add(name, silent: true) }
-        end
-
-        fail NoneAvailableError, NO_SUPPORTED_NOTIFIERS if _data.empty?
-      end
-
-      def available
-        _data.map { |entry| [_to_module(entry[:name]), entry[:options]] }
-      end
-
-      def add(name, opts)
-        klass = _to_module(name)
-        return false unless klass
-
-        all = @environment.notifiers
-
-        # Silently skip if it's already available, because otherwise
-        # we'd have to do :turn_off, then configure, then :turn_on
-        names = all.map(&:first).map(&:last)
-        unless names.include?(name)
-          return false unless klass.available?(opts)
-          @environment.notifiers = all << { name: name, options: opts }
-          true
-        end
-
-        # Just overwrite the options (without turning the notifier off or on),
-        # so those options will be passed in next calls to notify()
-        all.each { |item| item[:options] = opts if item[:name] == name }
-        true
-      end
-
-      def _to_module(name)
-        @supported.each do |group|
-          next unless (notifier = group.detect { |n, _| n == name })
-          return notifier.last
-        end
-        nil
-      end
-
-      def _data
-        @environment.notifiers || []
-      end
-    end
-  end
-end

data/lib/guard/plugin.rb.orig

@@ -1,300 +0,0 @@
-module Guard
-  # Base class from which every Guard plugin implementation must inherit.
-  #
-  # Guard will trigger the {#start}, {#stop}, {#reload}, {#run_all} and
-  # {#run_on_changes} ({#run_on_additions}, {#run_on_modifications} and
-  # {#run_on_removals}) task methods depending on user interaction and file
-  # modification.
-  #
-  # {#run_on_changes} could be implemented to handle all the changes task case
-  # (additions, modifications, removals) in once, or each task can be
-  # implemented separately with a specific behavior.
-  #
-  # In each of these Guard task methods you have to implement some work when
-  # you want to support this kind of task. The return value of each Guard task
-  # method is not evaluated by Guard, but it'll be passed to the "_end" hook
-  # for further evaluation. You can throw `:task_has_failed` to indicate that
-  # your Guard plugin method was not successful, and successive Guard plugin
-  # tasks will be aborted when the group has set the `:halt_on_fail` option.
-  #
-  # @see Guard::Group
-  #
-  # @example Throw :task_has_failed
-  #
-  #   def run_all
-  #     if !runner.run(['all'])
-  #       throw :task_has_failed
-  #     end
-  #   end
-  #
-  # Each Guard plugin should provide a template Guardfile located within the Gem
-  # at `lib/guard/guard-name/templates/Guardfile`.
-  #
-  # Watchers for a Guard plugin should return a file path or an array of files
-  # paths to Guard, but if your Guard plugin wants to allow any return value
-  # from a watcher, you can set the `any_return` option to true.
-  #
-  # If one of those methods raises an exception other than `:task_has_failed`,
-  # the `Guard::GuardName` instance will be removed from the active Guard
-  # plugins.
-  #
-  class Plugin
-    TEMPLATE_FORMAT = "%s/lib/guard/%s/templates/Guardfile"
-
-    require "guard/ui"
-
-    # Get all callbacks registered for all Guard plugins present in the
-    # Guardfile.
-    #
-    def self.callbacks
-      @callbacks ||= Hash.new { |hash, key| hash[key] = [] }
-    end
-
-    # Add a callback.
-    #
-    # @param [Block] listener the listener to notify
-    # @param [Guard::Plugin] guard_plugin the Guard plugin to add the callback
-    # @param [Array<Symbol>] events the events to register
-    #
-    def self.add_callback(listener, guard_plugin, events)
-      Array(events).each do |event|
-        callbacks[[guard_plugin, event]] << listener
-      end
-    end
-
-    # Notify a callback.
-    #
-    # @param [Guard::Plugin] guard_plugin the Guard plugin to add the callback
-    # @param [Symbol] event the event to trigger
-    # @param [Array] args the arguments for the listener
-    #
-    def self.notify(guard_plugin, event, *args)
-      callbacks[[guard_plugin, event]].each do |listener|
-        listener.call(guard_plugin, event, *args)
-      end
-    end
-
-    # Reset all callbacks.
-    #
-    # TODO: remove (not used anywhere)
-    def self.reset_callbacks!
-      @callbacks = nil
-    end
-
-    # When event is a Symbol, {#hook} will generate a hook name
-    # by concatenating the method name from where {#hook} is called
-    # with the given Symbol.
-    #
-    # @example Add a hook with a Symbol
-    #
-    #   def run_all
-    #     hook :foo
-    #   end
-    #
-    # Here, when {Guard::Plugin::Base#run_all} is called, {#hook} will notify
-    # callbacks registered for the "run_all_foo" event.
-    #
-    # When event is a String, {#hook} will directly turn the String
-    # into a Symbol.
-    #
-    # @example Add a hook with a String
-    #
-    #   def run_all
-    #     hook "foo_bar"
-    #   end
-    #
-    # When {Guard::Plugin::Base#run_all} is called, {#hook} will notify
-    # callbacks registered for the "foo_bar" event.
-    #
-    # @param [Symbol, String] event the name of the Guard event
-    # @param [Array] args the parameters are passed as is to the callbacks
-    #   registered for the given event.
-    #
-    def hook(event, *args)
-      hook_name = if event.is_a? Symbol
-                    calling_method = caller[0][/`([^']*)'/, 1]
-                    "#{ calling_method }_#{ event }"
-                  else
-                    event
-                  end
-
-      UI.debug "Hook :#{ hook_name } executed for #{ self.class }"
-
-      self.class.notify(self, hook_name.to_sym, *args)
-    end
-
-    attr_accessor :group, :watchers, :callbacks, :options
-
-    # Returns the non-namespaced class name of the plugin
-    #
-    #
-    # @example Non-namespaced class name for Guard::RSpec
-    #   Guard::RSpec.non_namespaced_classname
-    #   #=> "RSpec"
-    #
-    # @return [String]
-    #
-    def self.non_namespaced_classname
-      to_s.sub("Guard::", "")
-    end
-
-    # Returns the non-namespaced name of the plugin
-    #
-    #
-    # @example Non-namespaced name for Guard::RSpec
-    #   Guard::RSpec.non_namespaced_name
-    #   #=> "rspec"
-    #
-    # @return [String]
-    #
-    def self.non_namespaced_name
-      non_namespaced_classname.downcase
-    end
-
-    # Specify the source for the Guardfile template.
-    # Each Guard plugin can redefine this method to add its own logic.
-    #
-    # @param [String] plugin_location the plugin location
-    #
-    def self.template(plugin_location)
-      File.read TEMPLATE_FORMAT % [plugin_location, non_namespaced_name]
-    end
-
-    # Called once when Guard starts. Please override initialize method to
-    # init stuff.
-    #
-    # @raise [:task_has_failed] when start has failed
-    # @return [Object] the task result
-    #
-    # @!method start
-
-    # Called when `stop|quit|exit|s|q|e + enter` is pressed (when Guard
-    # quits).
-    #
-    # @raise [:task_has_failed] when stop has failed
-    # @return [Object] the task result
-    #
-    # @!method stop
-
-    # Called when `reload|r|z + enter` is pressed.
-    # This method should be mainly used for "reload" (really!) actions like
-    # reloading passenger/spork/bundler/...
-    #
-    # @raise [:task_has_failed] when reload has failed
-    # @return [Object] the task result
-    #
-    # @!method reload
-
-    # Called when just `enter` is pressed
-    # This method should be principally used for long action like running all
-    # specs/tests/...
-    #
-    # @raise [:task_has_failed] when run_all has failed
-    # @return [Object] the task result
-    #
-    # @!method run_all
-
-    # Default behaviour on file(s) changes that the Guard plugin watches.
-    #
-    # @param [Array<String>] paths the changes files or paths
-    # @raise [:task_has_failed] when run_on_changes has failed
-    # @return [Object] the task result
-    #
-    # @!method run_on_changes(paths)
-
-    # Called on file(s) additions that the Guard plugin watches.
-    #
-    # @param [Array<String>] paths the changes files or paths
-    # @raise [:task_has_failed] when run_on_additions has failed
-    # @return [Object] the task result
-    #
-    # @!method run_on_additions(paths)
-
-    # Called on file(s) modifications that the Guard plugin watches.
-    #
-    # @param [Array<String>] paths the changes files or paths
-    # @raise [:task_has_failed] when run_on_modifications has failed
-    # @return [Object] the task result
-    #
-    # @!method run_on_modifications(paths)
-
-    # Called on file(s) removals that the Guard plugin watches.
-    #
-    # @param [Array<String>] paths the changes files or paths
-    # @raise [:task_has_failed] when run_on_removals has failed
-    # @return [Object] the task result
-    #
-    # @!method run_on_removals(paths)
-
-    # Returns the plugin's name (without "guard-").
-    #
-    # @example Name for Guard::RSpec
-    #   Guard::RSpec.new.name
-    #   #=> "rspec"
-    #
-    # @return [String]
-    #
-    def name
-      @name ||= self.class.non_namespaced_name
-    end
-
-    # Returns the plugin's class name without the Guard:: namespace.
-    #
-    # @example Title for Guard::RSpec
-    #   Guard::RSpec.new.title
-    #   #=> "RSpec"
-    #
-    # @return [String]
-    #
-    def title
-      @title ||= self.class.non_namespaced_classname
-    end
-
-    # String representation of the plugin.
-    #
-    # @example String representation of an instance of the Guard::RSpec plugin
-    #
-    #   Guard::RSpec.new.title
-    #   #=> "#<Guard::RSpec @name=rspec @group=#<Guard::Group @name=default
-    #   @options={}> @watchers=[] @callbacks=[] @options={all_after_pass:
-    #   true}>"
-    #
-    # @return [String] the string representation
-    #
-    def to_s
-      "#<#{self.class} @name=#{name} @group=#{group} @watchers=#{watchers}"\
-        " @callbacks=#{callbacks} @options=#{options}>"
-    end
-
-    private
-
-    # Initializes a Guard plugin.
-    # Don't do any work here, especially as Guard plugins get initialized even
-    # if they are not in an active group!
-    #
-    # @param [Hash] options the Guard plugin options
-    # @option options [Array<Guard::Watcher>] watchers the Guard plugin file
-    #   watchers
-    # @option options [Symbol] group the group this Guard plugin belongs to
-    # @option options [Boolean] any_return allow any object to be returned from
-    #   a watcher
-    #
-    def initialize(options = {})
-      group_name = options.delete(:group) { :default }
-      @group = Guard.state.session.groups.add(group_name)
-      @watchers = options.delete(:watchers) { [] }
-      @callbacks = options.delete(:callbacks) { [] }
-      @options  = options
-      _register_callbacks
-    end
-
-    # Add all the Guard::Plugin's callbacks to the global @callbacks array
-    # that's used by Guard to know which callbacks to notify.
-    #
-    def _register_callbacks
-      callbacks.each do |callback|
-        Hooker.add_callback(callback[:listener], self, callback[:events])
-      end
-    end
-  end
-end

data/lib/guard/reevaluator.rb.orig

@@ -1,22 +0,0 @@
-require "guard/plugin"
-require "guard/guardfile/evaluator"
-
-module Guard
-  class Reevaluator < Plugin
-    def run_on_modifications(files)
-      STDERR.puts files.inspect
-      return unless ::Guard::Watcher.match_guardfile?(files)
-      ::Guard.save_scope
-      Guard::Guardfile::Evaluator.new.reevaluate_guardfile
-    rescue ScriptError, StandardError => e
-      ::Guard::UI.warning("Failed to reevaluate file: #{e}")
-
-      options = { watchers: [::Guard::Watcher.new("Guardfile")] }
-      ::Guard.add_plugin(:reevaluator, options)
-
-      throw :task_has_failed
-    ensure
-      ::Guard.restore_scope
-    end
-  end
-end

data/lib/guard/templates/Guardfile.orig

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

data/lib/guard/ui.rb.orig

@@ -1,274 +0,0 @@
-require "lumberjack"
-
-require "guard/internals/state"
-
-require "guard/options"
-
-require "guard/ui/colors"
-
-require "guard/terminal"
-
-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
-      #
-      # TODO: deprecate?
-      def options=(options)
-        @options = ::Guard::Options.new(options)
-      end
-
-      # Assigns a log level
-      def level=(new_level)
-        logger.level = new_level
-      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 = {})
-        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
-
-      # 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(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.
-      #
-      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)
-        titles = Guard.state.scope.titles(scope)
-        info "#{action} #{titles.join(", ")}"
-      end
-
-      private
-
-      # 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