guard 2.10.0 → 2.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6996dd69034de1636618026e8606df7f10b2b22b
-  data.tar.gz: c374f6846a61be304447f9518ad72d219ba0b12f
+  metadata.gz: 100b160735c5c331821d9fa8119bb168ed5f907e
+  data.tar.gz: d677f7e1a7491ff72654d415d7c571f028fbef52
 SHA512:
-  metadata.gz: 2d4cf024a8ce54ad66c2bd9ba03b46a457924da685ec6987e6ae0c4823e2ebc30fd15627b9dae5b01f7c844158cc420f1396d532c525e4b6d4175feb0167aef2
-  data.tar.gz: fc31605dee865f1371c2e6fca5d71c35ef7f4d1ca5255acf364972f9312785ebb897776e985632d966edc88b58b0d9e2d913b6987a9cc9576943041b0e74f304
+  metadata.gz: 0dcad099ca8bd1dca2486e078233215366c4236b8a1b0b465336d020667e041bd16e75df106efeef75a6013fcdb9601fdd35bd28eac8130c4eb3a910694004a3
+  data.tar.gz: 835a20ae288b6c660d9cb058eeba5b2c25f999bc3790c0dfb0ccf48a7816eff2405fe82e26cc9884b2397f02a610ba73f848c63bf89eb478fd94aae632ff31f7

data/lib/guard.rb

@@ -60,8 +60,15 @@ module Guard
       _evaluate(state.session.evaluator_options)
 
       # NOTE: this should be *after* evaluate so :directories can work
+      # TODO: move listener setup to session?
       @listener = Listen.send(*state.session.listener_args, &_listener_callback)
 
+      ignores = state.session.guardfile_ignore
+      @listener.ignore(ignores) unless ignores.empty?
+
+      ignores = state.session.guardfile_ignore_bang
+      @listener.ignore!(ignores) unless ignores.empty?
+
       Notifier.connect(state.session.notify_options)
 
       traps = Internals::Traps
@@ -86,9 +93,11 @@ module Guard
     #
     # Currently supported args:
     #
-    #   old style hash: {modified: ['foo'], added: ['bar'], removed: []}
+    #   @example Old style hash:
+    #     async_queue_add(modified: ['foo'], added: ['bar'], removed: [])
     #
-    #   new style signals with args: [:guard_pause, :unpaused ]
+    #   @example New style signals with args:
+    #     async_queue_add([:guard_pause, :unpaused ])
     #
     def async_queue_add(changes)
       @queue << changes

data/lib/guard.rb.orig

@@ -8,11 +8,13 @@ require "guard/internals/debugging"
 require "guard/internals/traps"
 require "guard/internals/helpers"
 
-require "guard/metadata"
-require "guard/options"
+require "guard/internals/queue"
+require "guard/internals/state"
 
+require "guard/options"
 require "guard/commander"
 require "guard/dsl"
+require "guard/group"
 require "guard/interactor"
 require "guard/notifier"
 require "guard/plugin_util"
@@ -20,6 +22,7 @@ require "guard/runner"
 require "guard/sheller"
 require "guard/ui"
 require "guard/watcher"
+require "guard/guardfile/evaluator"
 
 # Guard is the main module for all Guard related modules and classes.
 # Also Guard plugins should use this namespace.
@@ -30,6 +33,9 @@ module Guard
   class << self
     attr_reader :listener
 
+    # @private api
+    attr_reader :queue
+
     include Internals::Helpers
 
     # Initializes the Guard singleton:
@@ -46,103 +52,52 @@ module Guard
     # @option options [String] guardfile the path to the Guardfile
     #
     # @return [Guard] the Guard singleton
-    #
+    def setup(cmdline_options = {})
+      init(cmdline_options)
 
-    # TODO: this method has too many instance variables
-    # and some are mock and leak between tests,
-    # so ideally there should be a guard "instance"
-    # object that can be created anew between tests
-    def setup(opts = {})
-      # NOTE: must be set before anything calls Guard.options
-      reset_options(opts)
+      @queue = Internals::Queue.new(Guard)
 
-      # NOTE: must be set before anything calls Guard::UI.debug
-      ::Guard::Internals::Debugging.start if options[:debug]
+      _evaluate(state.session.evaluator_options)
 
-      @queue = Queue.new
-      self.watchdirs = Array(options[:watchdir])
+      # NOTE: this should be *after* evaluate so :directories can work
+      # TODO: move listener setup to session?
+      @listener = Listen.send(*state.session.listener_args, &_listener_callback)
 
-      ::Guard::UI.reset_and_clear
+      ignores = state.session.guardfile_ignore
+      @listener.ignore(ignores) unless ignores.empty?
 
-      @listener = _setup_listener
+      ignores = state.session.guardfile_ignore_bang
+      @listener.ignore!(ignores) unless ignores.empty?
 
-      _reset_all
-      evaluate_guardfile
-      setup_scope
-
-      ::Guard::Notifier.connect(notify: options[:notify])
+      Notifier.connect(state.session.notify_options)
 
       traps = Internals::Traps
       traps.handle("USR1") { async_queue_add([:guard_pause, :paused]) }
       traps.handle("USR2") { async_queue_add([:guard_pause, :unpaused]) }
 
-      @interactor = ::Guard::Interactor.new(options[:no_interactions])
+      @interactor = Interactor.new(state.session.interactor_name == :sleep)
       traps.handle("INT") { @interactor.handle_interrupt }
 
       self
     end
 
-    attr_reader :interactor
-
-    # Used only by tests (for all I know...)
-    def clear_options
-      @options = nil
-    end
-
-    # Initializes the groups array with the default group(s).
-    #
-    # @see DEFAULT_GROUPS
-    #
-    def reset_groups
-      @groups = DEFAULT_GROUPS.map { |name| Group.new(name) }
-    end
-
-    # Initializes the plugins array to an empty array.
-    #
-    # @see Guard.plugins
-    #
-    def reset_plugins
-      @plugins = []
+    def init(cmdline_options)
+      @state = Internals::State.new(cmdline_options)
     end
 
-    attr_reader :watchdirs
+    attr_reader :state
 
-    # Stores the scopes defined by the user via the `--group` / `-g` option (to
-    # run only a specific group) or the `--plugin` / `-P` option (to run only a
-    # specific plugin).
-    #
-    # @see CLI#start
-    # @see Dsl#scope
-    #
-    def setup_scope(scope = {})
-      # TODO: there should be a special Scope class instead
-      scope = _prepare_scope(scope)
-
-      ::Guard.scope = {
-        groups: scope[:groups].map { |item| ::Guard.add_group(item) },
-        plugins: scope[:plugins].map { |item| ::Guard.plugin(item) },
-      }
-    end
-
-    # Evaluates the Guardfile content. It displays an error message if no
-    # Guard plugins are instantiated after the Guardfile evaluation.
-    #
-    # @see Guard::Guardfile::Evaluator#evaluate_guardfile
-    #
-    def evaluate_guardfile
-      evaluator = Guard::Guardfile::Evaluator.new(options)
-      evaluator.evaluate_guardfile
-      msg = "No plugins found in Guardfile, please add at least one."
-      ::Guard::UI.error msg if _pluginless_guardfile?
-    end
+    attr_reader :interactor
 
     # Asynchronously trigger changes
     #
     # Currently supported args:
     #
-    #   old style hash: {modified: ['foo'], added: ['bar'], removed: []}
+    #   @example Old style hash:
+    #     async_queue_add(modified: ['foo'], added: ['bar'], removed: [])
     #
-    #   new style signals with args: [:guard_pause, :unpaused ]
+    #   @example New style signals with args:
+    #     async_queue_add([:guard_pause, :unpaused ])
     #
     def async_queue_add(changes)
       @queue << changes
@@ -152,60 +107,17 @@ module Guard
       Thread.new { interactor.background }
     end
 
-    def pending_changes?
-      ! @queue.empty?
-    end
-
-    def watchdirs=(dirs)
-      dirs = [Dir.pwd] if dirs.empty?
-      @watchdirs = dirs.map { |dir| File.expand_path dir }
-    end
-
     private
 
-    # Initializes the listener and registers a callback for changes.
-    #
-    def _setup_listener
-      if options[:listen_on]
-        Listen.on(options[:listen_on], &_listener_callback)
-      else
-        listener_options = {}
-        [:latency, :force_polling, :wait_for_delay].each do |option|
-          listener_options[option] = options[option] if options[option]
-        end
-        listen_args = watchdirs + [listener_options]
-        Listen.to(*listen_args, &_listener_callback)
-      end
-    end
-
-    # Process the change queue, running tasks within the main Guard thread
-    def _process_queue
-      actions, changes = [], { modified: [], added: [], removed: [] }
-
-      while pending_changes?
-        if (item = @queue.pop).first.is_a?(Symbol)
-          actions << item
-        else
-          item.each { |key, value| changes[key] += value }
-        end
-      end
-
-      _run_actions(actions)
-      return if changes.values.all?(&:empty?)
-      Runner.new.run_on_changes(*changes.values)
-    end
-
-    # TODO: Guard::Watch or Guard::Scope should provide this
-    def _scoped_watchers
-      watchers = []
-      Runner.new.send(:_scoped_plugins) { |guard| watchers += guard.watchers }
-      watchers
-    end
-
     # Check if any of the changes are actually watched for
+    # TODO: why iterate twice? reuse this info when running tasks
     def _relevant_changes?(changes)
+      # TODO: no coverage!
       files = changes.values.flatten(1)
-      watchers = _scoped_watchers
+      scope = Guard.state.scope
+      watchers = scope.grouped_plugins.map do |_group, plugins|
+        plugins.map(&:watchers).flatten
+      end.flatten
       watchers.any? { |watcher| files.any? { |file| watcher.match(file) } }
     end
 
@@ -213,19 +125,6 @@ module Guard
       paths.map { |path| _relative_pathname(path) }
     end
 
-    def _run_actions(actions)
-      actions.each do |action_args|
-        args = action_args.dup
-        namespaced_action = args.shift
-        action = namespaced_action.to_s.sub(/^guard_/, "")
-        if ::Guard.respond_to?(action)
-          ::Guard.send(action, *args)
-        else
-          fail "Unknown action: #{action.inspect}"
-        end
-      end
-    end
-
     def _listener_callback
       lambda do |modified, added, removed|
         relative_paths = {
@@ -238,12 +137,7 @@ module Guard
       end
     end
 
-    def _reset_all
-      reset_groups
-      reset_plugins
-      reset_scope
-    end
-
+    # TODO: obsoleted? (move to Dsl?)
     def _pluginless_guardfile?
       # no Reevaluator means there was no Guardfile configured that could be
       # reevaluated, so we don't have a pluginless guardfile, because we don't
@@ -252,20 +146,29 @@ module Guard
       # But, if we have a Guardfile, we'll at least have the built-in
       # Reevaluator, so the following will work:
 
-      # TODO: this is a workaround for tests
-      return true if plugins.empty?
-
-      plugins.map(&:name) == ["reevaluator"]
+      plugins = state.session.plugins.all
+      plugins.empty? || plugins.map(&:name) == ["reevaluator"]
     end
 
-    def _reset_for_tests
-      @options = nil
-      @queue = nil
-      @watchdirs = nil
-      @watchdirs = nil
-      @listener = nil
-      @interactor = nil
-      @scope = nil
+    def _evaluate(options)
+      evaluator = Guardfile::Evaluator.new(options)
+      evaluator.evaluate
+
+      # TODO: remove this workaround when options are removed
+      state.session.clearing(state.session.options[:clear])
+
+      UI.reset_and_clear
+
+      msg = "No plugins found in Guardfile, please add at least one."
+      UI.error msg if _pluginless_guardfile?
+
+      if evaluator.inline?
+        UI.info("Using inline Guardfile.")
+      elsif evaluator.custom?
+        UI.info("Using Guardfile at #{ evaluator.path }.")
+      end
+    rescue Guardfile::Evaluator::NoPluginsError => e
+      UI.error(e.message)
     end
   end
 end

data/lib/guard/dsl.rb

@@ -5,8 +5,6 @@ require "guard/ui"
 require "guard/watcher"
 
 require "guard/deprecated/dsl" unless Guard::Config.new.strict?
-
-# TODO: only for listener
 require "guard"
 
 module Guard
@@ -75,6 +73,7 @@ module Guard
     # @see Guard::Notifier for available notifier and its options.
     #
     def notification(notifier, options = {})
+      # TODO: remove dependency on Notifier (let session handle this)
       Notifier.add(notifier.to_sym, options.merge(silent: false))
     end
 
@@ -90,6 +89,7 @@ module Guard
     #   options
     #
     def interactor(options)
+      # TODO: remove dependency on Interactor (let session handle this)
       case options
       when :off
         Interactor.enabled = false
@@ -132,6 +132,7 @@ module Guard
 
       if block_given?
         groups.each do |group|
+          # TODO: let groups be added *after* evaluation
           Guard.state.session.groups.add(group, options)
         end
 
@@ -181,6 +182,7 @@ module Guard
       groups = @current_groups && @current_groups.last || [:default]
       groups.each do |group|
         opts = @plugin_options.merge(group: group)
+        # TODO: let plugins be added *after* evaluation
         Guard.state.session.plugins.add(name, opts)
       end
 
@@ -227,11 +229,10 @@ module Guard
     # `run_on_additions`, `run_on_modifications` and `run_on_removals` plugin
     # method.
     #
-    # @example Define a callback that'll be called before the `reload` action.
+    # @example Add callback before the `reload` action.
     #   callback(:reload_begin) { puts "Let's reload!" }
     #
-    # @example Define a callback that'll be called before the `start` and
-    # `stop` actions.
+    # @example Add callback before the `start` and `stop` actions.
     #
     #   my_lambda = lambda do |plugin, event, *args|
     #     puts "Let's #{event} #{plugin} with #{args}!"
@@ -264,8 +265,8 @@ module Guard
     # @param [Regexp] regexps a pattern (or list of patterns) for ignoring paths
     #
     def ignore(*regexps)
-      # TODO: instead, use Guard.reconfigure(ignore: regexps) or something
-      Guard.listener.ignore(regexps) if Guard.listener
+      # TODO: use guardfile results class
+      Guard.state.session.guardfile_ignore = regexps
     end
 
     # TODO: deprecate
@@ -281,8 +282,11 @@ module Guard
     def ignore!(*regexps)
       @ignore_regexps ||= []
       @ignore_regexps << regexps
-      Guard.listener.ignore!(@ignore_regexps) if Guard.listener
+      # TODO: use guardfile results class
+      Guard.state.session.guardfile_ignore_bang = @ignore_regexps
     end
+
+    # TODO: deprecate
     alias filter! ignore!
 
     # Configures the Guard logger.
@@ -366,6 +370,7 @@ module Guard
     # @param [Hash] scopes the scope for the groups and plugins
     #
     def scope(scope = {})
+      # TODO: use a Guardfile::Results class
       Guard.state.session.guardfile_scope(scope)
     end
 

data/lib/guard/dsl.rb.orig

@@ -26,10 +26,10 @@ module Guard
   # {Notifier} for more information about the supported libraries.
   #
   # A more advanced DSL use is the {#callback} keyword that allows you to
-  # execute arbitrary code before or after any of the {Plugin::Base#start},
-  # {Plugin::Base#stop}, {Plugin::Base#reload}, {Plugin::Base#run_all},
-  # {Plugin::Base#run_on_changes}, {Plugin::Base#run_on_additions},
-  # {Plugin::Base#run_on_modifications} and {Plugin::Base#run_on_removals}
+  # execute arbitrary code before or after any of the {Plugin#start},
+  # {Plugin#stop}, {Plugin#reload}, {Plugin#run_all},
+  # {Plugin#run_on_changes}, {Plugin#run_on_additions},
+  # {Plugin#run_on_modifications} and {Plugin#run_on_removals}
   # Guard plugins method.
   # You can even insert more hooks inside these methods. Please [checkout the
   # Wiki page](https://github.com/guard/guard/wiki/Hooks-and-callbacks) for
@@ -50,6 +50,10 @@ module Guard
   class Dsl
     Deprecated::Dsl.add_deprecated(self) unless Config.new.strict?
 
+    # Wrap exceptions during parsing Guardfile
+    class Error < RuntimeError
+    end
+
     WARN_INVALID_LOG_LEVEL = "Invalid log level `%s` ignored. "\
       "Please use either :debug, :info, :warn or :error."
 
@@ -88,9 +92,9 @@ module Guard
     def interactor(options)
       case options
       when :off
-        ::Guard::Interactor.enabled = false
+        Interactor.enabled = false
       when Hash
-        ::Guard::Interactor.options = options
+        Interactor.options = options
       end
     end
 
@@ -128,7 +132,7 @@ module Guard
 
       if block_given?
         groups.each do |group|
-          ::Guard.add_group(group, options)
+          Guard.state.session.groups.add(group, options)
         end
 
         @current_groups ||= []
@@ -138,7 +142,7 @@ module Guard
 
         @current_groups.pop
       else
-        ::Guard::UI.error \
+        UI.error \
           "No Guard plugins found in the group '#{ groups.join(", ") }',"\
           " please add at least one."
       end
@@ -176,7 +180,8 @@ module Guard
       @current_groups ||= []
       groups = @current_groups && @current_groups.last || [:default]
       groups.each do |group|
-        ::Guard.add_plugin(name, @plugin_options.merge(group: group))
+        opts = @plugin_options.merge(group: group)
+        Guard.state.session.plugins.add(name, opts)
       end
 
       @plugin_options = nil
@@ -214,7 +219,7 @@ module Guard
       @plugin_options ||= nil
       return guard(:plugin) { watch(pattern, &action) } unless @plugin_options
 
-      @plugin_options[:watchers] << ::Guard::Watcher.new(pattern, action)
+      @plugin_options[:watchers] << Watcher.new(pattern, action)
     end
 
     # Defines a callback to execute arbitrary code before or after any of
@@ -222,11 +227,10 @@ module Guard
     # `run_on_additions`, `run_on_modifications` and `run_on_removals` plugin
     # method.
     #
-    # @example Define a callback that'll be called before the `reload` action.
+    # @example Add callback before the `reload` action.
     #   callback(:reload_begin) { puts "Let's reload!" }
     #
-    # @example Define a callback that'll be called before the `start` and
-    # `stop` actions.
+    # @example Add callback before the `start` and `stop` actions.
     #
     #   my_lambda = lambda do |plugin, event, *args|
     #     puts "Let's #{event} #{plugin} with #{args}!"
@@ -237,8 +241,6 @@ module Guard
     # @param [Array] args the callback arguments
     # @yield a callback block
     #
-    # @see Guard::Hooker
-    #
     def callback(*args, &block)
       @plugin_options ||= nil
       fail "callback must be called within a guard block" unless @plugin_options
@@ -262,8 +264,10 @@ module Guard
     #
     def ignore(*regexps)
       # TODO: instead, use Guard.reconfigure(ignore: regexps) or something
-      ::Guard.listener.ignore(regexps) if ::Guard.listener
+      Guard.listener.ignore(regexps) if Guard.listener
     end
+
+    # TODO: deprecate
     alias filter ignore
 
     # Replaces ignored paths globally
@@ -276,7 +280,7 @@ module Guard
     def ignore!(*regexps)
       @ignore_regexps ||= []
       @ignore_regexps << regexps
-      ::Guard.listener.ignore!(@ignore_regexps) if ::Guard.listener
+      Guard.listener.ignore!(@ignore_regexps) if Guard.listener
     end
     alias filter! ignore!
 
@@ -341,7 +345,7 @@ module Guard
         options[name] = Regexp.new(list.join("|"), Regexp::IGNORECASE)
       end
 
-      ::Guard::UI.options.merge!(options)
+      UI.options.merge!(options)
     end
 
     # Sets the default scope on startup
@@ -361,18 +365,68 @@ module Guard
     # @param [Hash] scopes the scope for the groups and plugins
     #
     def scope(scope = {})
-      ::Guard.setup_scope(scope)
+      Guard.state.session.guardfile_scope(scope)
+    end
+
+    def evaluate(contents, filename, lineno) # :nodoc
+      instance_eval(contents, filename.to_s, lineno)
+    rescue StandardError, ScriptError => e
+      prefix = "\n\t(dsl)> "
+      cleaned_backtrace = _cleanup_backtrace(e.backtrace)
+      backtrace = "#{prefix}#{cleaned_backtrace.join(prefix)}"
+      msg = "Invalid Guardfile, original error is: \n\n%s, \nbacktrace: %s"
+      raise Error, format(msg, e, backtrace)
     end
 
-    # Sets the directories to pass to Listen (watchdirs)
+    # Sets the directories to pass to Listen
     #
     # @example watch only given directories
     #   directories %w(lib specs)
     #
-    # @param [Array] directories to watch
+    # @param [Array] directories directories for Listen to watch
+    #
+    def directories(directories)
+      directories.each do |dir|
+        fail "Directory #{dir.inspect} does not exist!" unless Dir.exist?(dir)
+      end
+      Guard.state.session.watchdirs = directories
+    end
+
+    # Sets Guard to clear the screen before every task is run
+    #
+    # @example switching clearing the screen on
+    #   clearing(:on)
     #
-    def directories(dirs)
-      ::Guard.watchdirs = dirs
+    # @param [Symbol] on ':on' to turn on, ':off' (default) to turn off
+    #
+    def clearing(on)
+      Guard.state.session.clearing(on == :on)
+    end
+
+    private
+
+    def _cleanup_backtrace(backtrace)
+      dirs = { File.realpath(Dir.pwd) => ".", }
+
+      gem_env = ENV["GEM_HOME"] || ""
+      dirs[gem_env] = "$GEM_HOME" unless gem_env.empty?
+
+      gem_paths = (ENV["GEM_PATH"] || "").split(File::PATH_SEPARATOR)
+      gem_paths.each_with_index do |path, index|
+        dirs[path] = "$GEM_PATH[#{index}]"
+      end
+
+      backtrace.dup.map do |raw_line|
+        path = nil
+        symlinked_path = raw_line.split(":").first
+        begin
+          path = raw_line.sub(symlinked_path, File.realpath(symlinked_path))
+          dirs.detect { |dir, name| path.sub!(File.realpath(dir), name) }
+          path
+        rescue Errno::ENOENT
+          path || symlinked_path
+        end
+      end
     end
   end
 end