guard 1.4.0 → 2.18.0

data/lib/guard/runner.rb

@@ -1,62 +1,40 @@
-module Guard
+require "lumberjack"
+
+require "guard/ui"
+require "guard/watcher"
 
-  # The runner is responsible for running all methods defined on each guards.
+module Guard
+  # The runner is responsible for running all methods defined on each plugin.
   #
   class Runner
-
-    require 'guard'
-    require 'guard/ui'
-    require 'guard/watcher'
-
-    # Deprecation message for the `run_on_change` method
-    RUN_ON_CHANGE_DEPRECATION = <<-EOS.gsub(/^\s*/, '')
-      Starting with Guard v1.1 the use of the 'run_on_change' method in the '%s' guard is deprecated.
-
-      Please consider replacing that method-call with 'run_on_changes' if the type of change
-      is not important for your usecase or using either 'run_on_modifications' or 'run_on_additions'
-      based on the type of the changes you want to handle.
-
-      For more information on how to update existing guards, please head over to:
-      https://github.com/guard/guard/wiki/Upgrade-guide-for-existing-guards-to-Guard-v1.1
-    EOS
-
-    # Deprecation message for the `run_on_deletion` method
-    RUN_ON_DELETION_DEPRECATION = <<-EOS.gsub(/^\s*/, '')
-      Starting with Guard v1.1 the use of the 'run_on_deletion' method in the '%s' guard is deprecated.
-
-      Please consider replacing that method-call with 'run_on_removals' for future proofing your code.
-
-      For more information on how to update existing guards, please head over to:
-      https://github.com/guard/guard/wiki/Upgrade-guide-for-existing-guards-to-Guard-v1.1
-    EOS
-
-    # Displays a warning for each deprecated-method used is any registered guard.
-    #
-    def deprecation_warning
-      ::Guard.guards.each do |guard|
-        ::Guard::UI.deprecation(RUN_ON_CHANGE_DEPRECATION % guard.class.name)   if guard.respond_to?(:run_on_change)
-        ::Guard::UI.deprecation(RUN_ON_DELETION_DEPRECATION % guard.class.name) if guard.respond_to?(:run_on_deletion)
-      end
-    end
-
-    # Runs a Guard-task on all registered guards.
+    # Runs a Guard-task on all registered plugins.
     #
     # @param [Symbol] task the task to run
-    # @param [Hash] scopes either the Guard plugin or the group to run the task on
     #
-    # @see self.run_supervised_task
+    # @param [Hash] scope_hash either the Guard plugin or the group to run the task
+    # on
     #
-    def run(task, scopes = {})
-      scoped_guards(scopes) do |guard|
-        run_supervised_task(guard, task)
+    def run(task, scope_hash = {})
+      Lumberjack.unit_of_work do
+        items = Guard.state.scope.grouped_plugins(scope_hash || {})
+        items.each do |_group, plugins|
+          _run_group_plugins(plugins) do |plugin|
+            _supervise(plugin, task) if plugin.respond_to?(task)
+          end
+        end
       end
     end
 
-    MODIFICATION_TASKS = [:run_on_modifications, :run_on_changes, :run_on_change]
-    ADDITION_TASKS     = [:run_on_additions, :run_on_changes, :run_on_change]
-    REMOVAL_TASKS      = [:run_on_removals, :run_on_changes, :run_on_deletion]
+    PLUGIN_FAILED = "%s has failed, other group's plugins will be skipped."
 
-    # Runs the appropriate tasks on all registered guards
+    MODIFICATION_TASKS = [
+      :run_on_modifications, :run_on_changes, :run_on_change
+    ]
+
+    ADDITION_TASKS = [:run_on_additions, :run_on_changes, :run_on_change]
+    REMOVAL_TASKS = [:run_on_removals, :run_on_changes, :run_on_deletion]
+
+    # Runs the appropriate tasks on all registered plugins
     # based on the passed changes.
     #
     # @param [Array<String>] modified the modified paths.
@@ -64,50 +42,60 @@ module Guard
     # @param [Array<String>] removed the removed paths.
     #
     def run_on_changes(modified, added, removed)
-      ::Guard::UI.clearable
-      scoped_guards do |guard|
-        modified_paths = ::Guard::Watcher.match_files(guard, modified)
-        added_paths    = ::Guard::Watcher.match_files(guard, added)
-        removed_paths  = ::Guard::Watcher.match_files(guard, removed)
-
-        ::Guard::UI.clear if clearable?(guard, modified_paths, added_paths, removed_paths)
-
-        run_first_task_found(guard, MODIFICATION_TASKS, modified_paths) unless modified_paths.empty?
-        run_first_task_found(guard, ADDITION_TASKS, added_paths) unless added_paths.empty?
-        run_first_task_found(guard, REMOVAL_TASKS, removed_paths) unless removed_paths.empty?
+      types = {
+        MODIFICATION_TASKS => modified,
+        ADDITION_TASKS => added,
+        REMOVAL_TASKS => removed
+      }
+
+      UI.clearable
+
+      Guard.state.scope.grouped_plugins.each do |_group, plugins|
+        _run_group_plugins(plugins) do |plugin|
+          UI.clear
+          types.each do |tasks, unmatched_paths|
+            next if unmatched_paths.empty?
+            match_result = Watcher.match_files(plugin, unmatched_paths)
+            next if match_result.empty?
+            task = tasks.detect { |meth| plugin.respond_to?(meth) }
+            _supervise(plugin, task, match_result) if task
+          end
+        end
       end
     end
 
-    # Run a Guard plugin task, but remove the Guard plugin when his work leads to a system failure.
+    # Run a Guard plugin task, but remove the Guard plugin when his work leads
+    # to a system failure.
     #
-    # When the Group has `:halt_on_fail` disabled, we've to catch `:task_has_failed`
-    # here in order to avoid an uncaught throw error.
+    # When the Group has `:halt_on_fail` disabled, we've to catch
+    # `:task_has_failed` here in order to avoid an uncaught throw error.
     #
-    # @param [Guard::Guard] guard the Guard to execute
+    # @param [Guard::Plugin] plugin guard the Guard to execute
     # @param [Symbol] task the task to run
     # @param [Array] args the arguments for the task
     # @raise [:task_has_failed] when task has failed
     #
-    def run_supervised_task(guard, task, *args)
-      begin
-        catch Runner.stopping_symbol_for(guard) do
-          guard.hook("#{ task }_begin", *args)
-          result = guard.send(task, *args)
-          guard.hook("#{ task }_end", result)
-          result
+    def _supervise(plugin, task, *args)
+      catch self.class.stopping_symbol_for(plugin) do
+        plugin.hook("#{ task }_begin", *args)
+        result = UI.options.with_progname(plugin.class.name) do
+          begin
+            plugin.send(task, *args)
+          rescue Interrupt
+            throw(:task_has_failed)
+          end
         end
-
-      rescue NoMethodError
-        # Do nothing
-      rescue Exception => ex
-        ::Guard::UI.error("#{ guard.class.name } failed to achieve its <#{ task.to_s }>, exception was:" +
-                 "\n#{ ex.class }: #{ ex.message }\n#{ ex.backtrace.join("\n") }")
-
-        ::Guard.guards.delete guard
-        ::Guard::UI.info("\n#{ guard.class.name } has just been fired")
-
-        ex
+        plugin.hook("#{ task }_end", result)
+        result
       end
+    rescue ScriptError, StandardError, RuntimeError
+      UI.error("#{ plugin.class.name } failed to achieve its"\
+                        " <#{ task }>, exception was:" \
+                        "\n#{ $!.class }: #{ $!.message }" \
+                        "\n#{ $!.backtrace.join("\n") }")
+      Guard.state.session.plugins.remove(plugin)
+      UI.info("\n#{ plugin.class.name } has just been fired")
+      $!
     end
 
     # Returns the symbol that has to be caught when running a supervised task.
@@ -115,74 +103,26 @@ module Guard
     # @note If a Guard group is being run and it has the `:halt_on_fail`
     #   option set, this method returns :no_catch as it will be caught at the
     #   group level.
-    # @see .scoped_guards
     #
-    # @param [Guard::Guard] guard the Guard plugin to execute
+    # @param [Guard::Plugin] guard the Guard plugin to execute
     # @return [Symbol] the symbol to catch
     #
     def self.stopping_symbol_for(guard)
-      return :task_has_failed if guard.group.class != Symbol
-
-      group = ::Guard.groups(guard.group)
-      group.options[:halt_on_fail] ? :no_catch : :task_has_failed
+      guard.group.options[:halt_on_fail] ? :no_catch : :task_has_failed
     end
 
-  private
+    private
 
-    # Tries to run the first implemented task by a given guard
-    # from a collection of tasks.
-    #
-    # @param [Guard::Guard] guard the Guard plugin to run the first found task on
-    # @param [Array<Symbol>] tasks the tasks to run the first among
-    # @param [Object] task_param the param to pass to each task
-    #
-    def run_first_task_found(guard, tasks, task_param)
-      tasks.each do |task|
-        if guard.respond_to?(task)
-          run_supervised_task(guard, task, task_param)
-          break
-        else
-          ::Guard::UI.debug "Trying to run #{ guard.class.name }##{ task.to_s } with #{ task_param.inspect }"
+    def _run_group_plugins(plugins)
+      failed_plugin = nil
+      catch :task_has_failed do
+        plugins.each do |plugin|
+          failed_plugin = plugin
+          yield plugin
+          failed_plugin = nil
         end
       end
+      UI.info format(PLUGIN_FAILED, failed_plugin.class.name) if failed_plugin
     end
-
-    # Loop through all groups and run the given task for each Guard plugin.
-    #
-    # Stop the task run for the all Guard plugins within a group if one Guard
-    # throws `:task_has_failed`.
-    #
-    # @param [Hash] scopes hash with a Guard plugin or a group scope
-    # @yield the task to run
-    #
-    def scoped_guards(scopes = {})
-      if guard = scopes[:guard]
-        yield(guard)
-      else
-        groups = scopes[:group] ? [scopes[:group]] : ::Guard.groups
-        groups.each do |group|
-          catch :task_has_failed do
-            ::Guard.guards(:group => group.name).each do |guard|
-              yield(guard)
-            end
-          end
-        end
-      end
-    end
-
-    # Logic to know if the UI can be cleared or not in the run_on_changes method
-    # based on the guard and the changes.
-    #
-    # @param [Guard::Guard] guard the Guard plugin where run_on_changes is called
-    # @param [Array<String>] modified_paths the modified paths.
-    # @param [Array<String>] added_paths the added paths.
-    # @param [Array<String>] removed_paths the removed paths.
-    #
-    def clearable?(guard, modified_paths, added_paths, removed_paths)
-      (MODIFICATION_TASKS.any? { |task| guard.respond_to?(task) } && !modified_paths.empty?) ||
-      (ADDITION_TASKS.any? { |task| guard.respond_to?(task) } && !added_paths.empty?) ||
-      (REMOVAL_TASKS.any? { |task| guard.respond_to?(task) } && !removed_paths.empty?)
-    end
-
   end
 end

data/lib/guard/templates/Guardfile

@@ -1,2 +1,16 @@
 # A sample Guardfile
 # More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec features) \
+#  .select{|d| Dir.exist?(d) ? d : UI.warning("Directory #{d} does not exist")}
+
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), then you will want to move
+## the Guardfile to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"

data/lib/guard/terminal.rb

@@ -0,0 +1,13 @@
+require "shellany/sheller"
+
+module Guard
+  class Terminal
+    class << self
+      def clear
+        cmd = Gem.win_platform? ? "cls" : "printf '\33c\e[3J';"
+        exit_code, _, stderr = Shellany::Sheller.system(cmd)
+        fail Errno::ENOENT, stderr unless exit_code == 0
+      end
+    end
+  end
+end

data/lib/guard/ui/colors.rb

@@ -0,0 +1,56 @@
+module Guard
+  module UI
+    module Colors
+      # 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
+end

data/lib/guard/ui/config.rb

@@ -0,0 +1,70 @@
+require "guard/options"
+require "guard/ui/logger"
+
+module Guard
+  module UI
+    class Config < Guard::Options
+      DEFAULTS = {
+        only: nil,
+        except: nil,
+
+        # nil (will be whatever $stderr is later) or LumberJack device, e.g.
+        # $stderr or 'foo.log'
+        device: nil,
+      }.freeze
+
+      DEPRECATED_OPTS = %w(template time_format level progname).freeze
+
+      attr_reader :logger_config
+
+      def initialize(options = {})
+        opts = Guard::Options.new(options, DEFAULTS)
+
+        # migrate old options stored in UI config directly
+        deprecated_logger_opts = {}
+        DEPRECATED_OPTS.each do |option|
+          if opts.key?(option)
+            deprecated_logger_opts[option.to_sym] = opts.delete(option)
+          end
+        end
+
+        @logger_config = Logger::Config.new(deprecated_logger_opts)
+        super(opts.to_hash)
+      end
+
+      def device
+        # Use strings to work around Thor's indifferent Hash's bug
+        fetch("device") || $stderr
+      end
+
+      def only
+        fetch("only")
+      end
+
+      def except
+        fetch("except")
+      end
+
+      def [](name)
+        name = name.to_s
+
+        # TODO: remove in Guard 3.x
+        return logger_config[name] if DEPRECATED_OPTS.include?(name)
+        return device if name == "device"
+
+        # let Thor's Hash handle anything else
+        super(name.to_s)
+      end
+
+      def with_progname(name)
+        if Guard::UI.logger.respond_to?(:set_progname)
+          Guard::UI.logger.set_progname(name) do
+            yield if block_given?
+          end
+        elsif block_given?
+          yield
+        end
+      end
+    end
+  end
+end

data/lib/guard/ui/logger.rb

@@ -0,0 +1,30 @@
+require "guard/options"
+
+module Guard
+  module UI
+    class Logger
+      class Config < Guard::Options
+        DEFAULTS = {
+          progname: "Guard",
+          level: :info,
+          template: ":time - :severity - :message",
+          time_format: "%H:%M:%S",
+          flush_seconds: 0,
+
+          # Other LumberJack device-specific options
+          # max_size: "5M",
+          # buffer_size: 0,
+          # additional_lines: nil,
+        }.freeze
+
+        def initialize(options = {})
+          super(options, DEFAULTS)
+        end
+
+        def level=(value)
+          self["level"] = value
+        end
+      end
+    end
+  end
+end