guard 2.9.0 → 2.9.1

data/lib/guard/reevaluator.rb

@@ -1,21 +1,61 @@
 require "guard/plugin"
 require "guard/guardfile/evaluator"
+require "guard/runner"
+require "guard/internals/helpers"
 
 module Guard
   class Reevaluator < Plugin
+    include Internals::Helpers
+
     def run_on_modifications(files)
-      return unless ::Guard::Watcher.match_guardfile?(files)
-      ::Guard.save_scope
-      Guard::Guardfile::Evaluator.new(Guard.options).reevaluate_guardfile
-    rescue ScriptError, StandardError => e
-      ::Guard::UI.warning("Failed to reevaluate file: #{e}")
+      # TODO: this is messed up, because reevaluator adds itself
+      # anyway, so it know what the path is
+      evaluator = _evaluator
+      path = evaluator.path
+      return unless files.any? { |file| path == Pathname(file) }
+      reevaluate
+    rescue Dsl::Error, Guardfile::Evaluator::Error => e
+      UI.warning("Failed to reevaluate file: #{e}")
+      _add_self_to_plugins
+      throw :task_has_failed
+    end
 
-      options = { watchers: [::Guard::Watcher.new("Guardfile")] }
-      ::Guard.add_plugin(:reevaluator, options)
+    def reevaluate
+      evaluator = _evaluator
+      return if evaluator.inline?
 
-      throw :task_has_failed
-    ensure
-      ::Guard.restore_scope
+      Runner.new.run(:stop)
+
+      Guard.state.reset_session
+
+      Notifier.disconnect
+      evaluator.evaluate
+      Notifier.connect(Guard.state.session.notify_options)
+
+      if Guard.send(:_pluginless_guardfile?)
+        Notifier.notify(
+          "No plugins found in Guardfile, please add at least one.",
+          title: "Guard re-evaluate",
+          image: :failed)
+      else
+        msg = "Guardfile has been re-evaluated."
+        UI.info(msg)
+        Notifier.notify(msg, title: "Guard re-evaluate")
+        Runner.new.run(:start)
+      end
+    end
+
+    private
+
+    def _evaluator
+      Guardfile::Evaluator.new(Guard.state.session.evaluator_options)
+    end
+
+    def _add_self_to_plugins
+      # TODO: do this on reload as well
+      pattern = _relative_pathname(_evaluator.path).to_s
+      options = { watchers: [Watcher.new(pattern)], group: :common }
+      Guard.state.session.plugins.add(:reevaluator, options)
     end
   end
 end

data/lib/guard/runner.rb

@@ -1,6 +1,5 @@
 require "lumberjack"
 
-require "guard/metadata"
 require "guard/ui"
 require "guard/watcher"
 
@@ -17,12 +16,17 @@ module Guard
     #
     def run(task, scope_hash = {})
       Lumberjack.unit_of_work do
-        _scoped_plugins(scope_hash || {}) do |plugin|
-          _supervise(plugin, task) if plugin.respond_to?(task)
+        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
 
+    PLUGIN_FAILED = "%s has failed, other group's plugins will be skipped."
+
     MODIFICATION_TASKS = [
       :run_on_modifications, :run_on_changes, :run_on_change
     ]
@@ -44,18 +48,18 @@ module Guard
         REMOVAL_TASKS => removed
       }
 
-      ::Guard::UI.clearable
-
-      _scoped_plugins do |plugin|
-        ::Guard::UI.clear
-
-        types.each do |tasks, unmatched_paths|
-          next if unmatched_paths.empty?
-          match_result = ::Guard::Watcher.match_files(plugin, unmatched_paths)
-          next if match_result.empty?
-
-          next unless (task = tasks.detect { |meth| plugin.respond_to?(meth) })
-          _supervise(plugin, task, match_result)
+      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
@@ -83,12 +87,12 @@ module Guard
         result
       end
     rescue ScriptError, StandardError, RuntimeError
-      ::Guard::UI.error("#{ plugin.class.name } failed to achieve its"\
+      UI.error("#{ plugin.class.name } failed to achieve its"\
                         " <#{ task }>, exception was:" \
                         "\n#{ $!.class }: #{ $!.message }" \
                         "\n#{ $!.backtrace.join("\n") }")
-      ::Guard.remove_plugin(plugin)
-      ::Guard::UI.info("\n#{ plugin.class.name } has just been fired")
+      Guard.state.session.plugins.remove(plugin)
+      UI.info("\n#{ plugin.class.name } has just been fired")
       $!
     end
 
@@ -97,7 +101,6 @@ 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_plugins
     #
     # @param [Guard::Plugin] guard the Guard plugin to execute
     # @return [Symbol] the symbol to catch
@@ -108,97 +111,16 @@ module Guard
 
     private
 
-    # Loop through all groups and run the given task for each Guard plugin.
-    #
-    # If no scope is supplied, the global Guard scope is taken into account.
-    # If both a plugin and a group scope is given, then only the plugin scope
-    # is used.
-    #
-    # Stop the task run for the all Guard plugins within a group if one Guard
-    # throws `:task_has_failed`.
-    #
-    # @param [Hash] scopes hash with plugins or a groups scope
-    # @yield the task to run
-    #
-    def _scoped_plugins(scopes = {})
-      fail "NO PLUGIN SCOPE" if scopes.nil?
-      if plugins = _current_plugins_scope(scopes)
-        plugins.each do |guard|
-          yield(guard)
-        end
-      else
-        _current_groups_scope(scopes).each do |group|
-          fail "Invalid group: #{group.inspect}" unless group.respond_to?(:name)
-          current_plugin = nil
-          block_return = catch :task_has_failed do
-            ::Guard.plugins(group: group.name).each do |guard|
-              current_plugin = guard
-              yield(guard)
-            end
-          end
-
-          next unless block_return.nil?
-
-          ::Guard::UI.info "#{ current_plugin.class.name } has failed,"\
-            " other group's plugins execution has been halted."
+    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
-    end
-
-    # Returns the current plugins scope.
-    # Local plugins scope wins over global plugins scope.
-    # If no plugins scope is found, then NO plugins are returned.
-    #
-    # @param [Hash] scopes hash with a local plugins or a groups scope
-    # @return [Array<Guard::Plugin>] the plugins to scope to
-    #
-    def _current_plugins_scope(scope)
-      return nil unless (plugins = _find_non_empty_plugins_scope(scope))
-
-      Array(plugins).map { |plugin| _instantiate(:plugin, plugin) }
-    end
-
-    # Returns the current groups scope.
-    # Local groups scope wins over global groups scope.
-    # If no groups scope is found, then ALL groups are returned.
-    #
-    # @param [Hash] scopes hash with a local plugins or a groups scope
-    # @return [Array<Guard::Group>] the groups to scope to
-    #
-    def _current_groups_scope(scope)
-      found = _find_non_empty_groups_scope(scope)
-      groups = Array(found).map { |group| _instantiate(:group, group) }
-      return groups if groups.any? { |g| g.name == :common }
-      ([_instantiate(:group, :common)] + Array(found)).compact
-    end
-
-    def _instantiate(meth, obj)
-      (obj.is_a?(Symbol) || obj.is_a?(String)) ? ::Guard.send(meth, obj) : obj
-    end
-
-    # Find the first non empty element in the given possibilities
-    #
-    def _find_non_empty_scope(type, local_scope, *additional_possibilities)
-      found = [
-        local_scope[:"#{type}s"],
-        [local_scope[type.to_sym]],
-        ::Guard.scope[:"#{type}s"],
-        additional_possibilities.flatten
-      ]
-      found.compact.detect { |a| !Array(a).compact.empty? }
-    end
-
-    # Find the first non empty plugins scope
-    #
-    def _find_non_empty_plugins_scope(scope)
-      fail "NO PLUGIN SCOPE" if scope.nil?
-      _find_non_empty_scope(:plugin, scope)
-    end
-
-    # Find the first non empty groups scope
-    #
-    def _find_non_empty_groups_scope(scope)
-      _find_non_empty_scope(:group, scope, ::Guard.groups)
+      UI.info format(PLUGIN_FAILED, failed_plugin.class.name) if failed_plugin
     end
   end
 end

data/lib/guard/ui.rb

@@ -1,8 +1,8 @@
 require "lumberjack"
 
+require "guard/internals/state"
+
 require "guard/options"
-require "guard/session"
-require "guard/metadata"
 
 require "guard/ui/colors"
 
@@ -104,8 +104,6 @@ module Guard
       # @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?
         unless ENV["GUARD_GEM_SILENCE_DEPRECATIONS"] == "1"
           backtrace = Thread.current.backtrace[1..5].join("\n\t >")
           msg = format("%s\nDeprecation backtrace: %s", message, backtrace)
@@ -132,13 +130,13 @@ module Guard
       # Clear the output if clearable.
       #
       def clear(opts = {})
-        return unless ::Guard.options[:clear]
+        return unless Guard.state.session.clear?
 
         fail "UI not set up!" if @clearable.nil?
         return unless @clearable || opts[:force]
 
         @clearable = false
-        ::Guard::Terminal.clear
+        Terminal.clear
       rescue Errno::ENOENT => e
         warning("Failed to clear the screen: #{e.inspect}")
       end
@@ -162,28 +160,12 @@ module Guard
       # @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" }"
+        titles = Guard.state.scope.titles(scope)
+        info "#{action} #{titles.join(", ")}"
       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.
       #

data/lib/guard/version.rb

@@ -1,3 +1,3 @@
 module Guard
-  VERSION = "2.9.0"
+  VERSION = "2.9.1"
 end

data/lib/guard/watcher.rb

@@ -1,3 +1,6 @@
+require "guard/config"
+require "guard/deprecated/watcher" unless Guard::Config.new.strict?
+
 require "guard/ui"
 
 module Guard
@@ -7,6 +10,7 @@ module Guard
   # enable processing the file system change result.
   #
   class Watcher
+    Deprecated::Watcher.add_deprecated(self) unless Config.new.strict?
     attr_accessor :pattern, :action
 
     # Initializes a file watcher.
@@ -77,18 +81,6 @@ module Guard
       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)
-      # TODO: move this method elsewhere
-      require "guard/guardfile/evaluator"
-      path = Guard.options[:guardfile]
-      files.any? { |file| File.expand_path(file) == path }
-    end
-
     # Test the watchers pattern against a file.
     #
     # @param [String] file the file to test

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: guard
 version: !ruby/object:Gem::Version
-  version: 2.9.0
+  version: 2.9.1
 platform: ruby
 authors:
 - Thibaud Guillaume-Gentil
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-26 00:00:00.000000000 Z
+date: 2014-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -111,8 +111,10 @@ files:
 - lib/guard/commands/show.rb
 - lib/guard/config.rb
 - lib/guard/deprecated/dsl.rb
+- lib/guard/deprecated/evaluator.rb
 - lib/guard/deprecated/guard.rb
 - lib/guard/deprecated/guardfile.rb
+- lib/guard/deprecated/watcher.rb
 - lib/guard/dsl.rb
 - lib/guard/dsl.rb.orig
 - lib/guard/dsl_describer.rb
@@ -124,16 +126,22 @@ files:
 - lib/guard/interactor.rb
 - lib/guard/internals/debugging.rb
 - lib/guard/internals/environment.rb
+- lib/guard/internals/groups.rb
 - lib/guard/internals/helpers.rb
+- lib/guard/internals/plugins.rb
+- lib/guard/internals/queue.rb
+- lib/guard/internals/scope.rb
+- lib/guard/internals/session.rb
+- lib/guard/internals/state.rb
 - lib/guard/internals/tracing.rb
 - lib/guard/internals/traps.rb
 - lib/guard/jobs/base.rb
 - lib/guard/jobs/pry_wrapper.rb
 - lib/guard/jobs/sleep.rb
-- lib/guard/metadata.rb
 - lib/guard/notifier.rb
 - lib/guard/notifier.rb.orig
 - lib/guard/notifier/detected.rb
+- lib/guard/notifier/detected.rb.orig
 - lib/guard/notifiers/base.rb
 - lib/guard/notifiers/emacs.rb
 - lib/guard/notifiers/file_notifier.rb
@@ -147,14 +155,11 @@ files:
 - lib/guard/notifiers/tmux.rb
 - lib/guard/options.rb
 - lib/guard/plugin.rb
-- lib/guard/plugin/base.rb
-- lib/guard/plugin/hooker.rb
 - lib/guard/plugin_util.rb
 - lib/guard/rake_task.rb
 - lib/guard/reevaluator.rb
 - lib/guard/reevaluator.rb.orig
 - lib/guard/runner.rb
-- lib/guard/session.rb
 - lib/guard/sheller.rb
 - lib/guard/templates/Guardfile
 - lib/guard/templates/Guardfile.orig

data/lib/guard/metadata.rb

@@ -1,190 +0,0 @@
-require "guard/group"
-
-require "guard/plugin_util"
-
-# TODO: should not be necessary
-require "guard/internals/helpers"
-
-module Guard
-  extend Internals::Helpers
-
-  # TODO: change to a normal class
-  class << self
-    DEFAULT_GROUPS = [:common, :default]
-
-    DEFAULT_OPTIONS = {
-      clear: false,
-      notify: true,
-      debug: false,
-      group: [],
-      plugin: [],
-      watchdir: nil,
-      guardfile: nil,
-      no_interactions: false,
-      no_bundler_warning: false,
-      latency: nil,
-      force_polling: false,
-      wait_for_delay: nil,
-      listen_on: nil
-    }
-
-    def add_group(name, options = {})
-      unless (group = group(name))
-        group = Group.new(name, options)
-        @groups << group
-      end
-
-      group
-    end
-
-    def group(filter)
-      groups(filter).first
-    end
-
-    def groups(filter = nil)
-      @groups ||= []
-
-      return @groups if filter.nil?
-
-      case filter
-      when String, Symbol
-        @groups.select { |group| group.name == filter.to_sym }
-      when Regexp
-        @groups.select { |group| group.name.to_s =~ filter }
-      else
-        fail "Invalid filter: #{filter.inspect}"
-      end
-    end
-
-    # TODO: remove
-    def _reset_for_tests
-      @options = nil
-      @queue = nil
-      @watchdirs = nil
-      @watchdirs = nil
-      @listener = nil
-      @interactor = nil
-      @scope = nil
-    end
-
-    # TODO: remove
-    def clear_options
-      @options = nil
-    end
-
-    # TODO: remove
-    def reset_groups
-      @groups = DEFAULT_GROUPS.map { |name| Group.new(name) }
-    end
-
-    # TODO: remove
-    def reset_plugins
-      @plugins = []
-    end
-
-    def plugins(filter = nil)
-      @plugins ||= []
-
-      return @plugins if filter.nil?
-
-      filtered_plugins = case filter
-                         when String, Symbol
-                           @plugins.select do |plugin|
-                             plugin.name == filter.to_s.downcase.gsub("-", "")
-                           end
-                         when Regexp
-                           @plugins.select do |plugin|
-                             plugin.name =~ filter
-                           end
-                         when Hash
-                           @plugins.select do |plugin|
-                             filter.all? do |k, v|
-                               case k
-                               when :name
-                                 plugin.name == v.to_s.downcase.gsub("-", "")
-                               when :group
-                                 plugin.group.name == v.to_sym
-                               end
-                             end
-                           end
-                         end
-
-      filtered_plugins
-    end
-
-    def scope
-      fail "::Guard.setup() not called" if @scope.nil?
-      @scope.dup.freeze
-    end
-
-    def plugin(filter)
-      plugins(filter).first
-    end
-
-    # Used by runner to remove a failed plugin
-    def remove_plugin(plugin)
-      # TODO: coverage/aruba
-      @plugins.delete(plugin)
-    end
-
-    # TODO: move elsewhere
-    def add_builtin_plugins(guardfile)
-      return unless guardfile
-
-      pattern = _relative_pathname(guardfile).to_s
-      watcher = ::Guard::Watcher.new(pattern)
-      ::Guard.add_plugin(:reevaluator, watchers: [watcher], group: :common)
-    end
-
-    def add_plugin(name, options = {})
-      instance = ::Guard::PluginUtil.new(name).initialize_plugin(options)
-      @plugins << instance
-      instance
-    end
-
-    def reset_scope
-      # calls Guard.scope=() to set the instance variable directly, as opposed
-      # to Guard.scope()
-      ::Guard.scope = { groups: [], plugins: [] }
-    end
-
-    # Called by Pry scope command
-
-    def scope=(new_scope)
-      @scope = new_scope
-      @scope.dup.freeze
-    end
-
-    # Used to merge CLI options with Setuper defaults
-    def reset_options(new_options)
-      @options = ::Guard::Options.new(new_options, DEFAULT_OPTIONS)
-    end
-
-    def save_scope
-      # This actually replaces scope from command line,
-      # so scope set by 'scope' Pry command will be reset
-      @saved_scope = _prepare_scope(::Guard.scope)
-    end
-
-    def restore_scope
-      ::Guard.setup_scope(@saved_scope || {})
-    end
-
-    private
-
-    def _prepare_scope(new_scope)
-      fail "Guard::setup() not called!" if options.nil?
-      {
-        plugins: _scope_names(new_scope, :plugin),
-        groups: _scope_names(new_scope, :group)
-      }
-    end
-
-    def _scope_names(new_scope, name)
-      items = Array(options[name])
-      items = Array(new_scope[:"#{name}s"] || new_scope[name]) if items.empty?
-      # Convert objects to names
-      items.map { |p| p.respond_to?(:name) ? p.name : p }
-    end
-  end
-end