guard 2.9.0 → 2.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2438b30b1e270d58f79c7f2ae9b8e2dce82fd6ad
-  data.tar.gz: 50e9fa2441d8eefc8aa4adb62405765086eaeda3
+  metadata.gz: d5b1ccadd885e53f1a8063e6f6d78038874115e7
+  data.tar.gz: ed83d150185583201d3d6a76ebadc54172c94573
 SHA512:
-  metadata.gz: d87720ec63302aaeeaacd21db3b76bc76768649af94ead543aba9cba5422f3a934db2e3d6172f7e5f3ec5d8a0ac3d7d3a7d4ba275c16adc52acdf51b2f510f4b
-  data.tar.gz: 09427674cac325111ae666ec7043e559c5fd4ec7f96125d9ac929e6858aa962ca40a021541b3de6c67f8eb1e49b29c4a5aede1f98daa42617c73e257381833dd
+  metadata.gz: 30542f519409c98e17fe922651fb5d461ed771803b46833fd918ae74576bc0e2b5aefe23ec60686d55408fe1bcba687fa587a2f569ae29ede158d915dbbfd0d7
+  data.tar.gz: 8e352a2a2b4ec695b4ed2dd029bb5a1b46e38fcd308c2dddbcfcc007395b29498c7e0bbc28caec0c579482f1e3bd7326526f04a413f4a3ea972465cc7770383f

data/lib/guard.rb

@@ -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,37 @@ module Guard
     # @option options [String] guardfile the path to the Guardfile
     #
     # @return [Guard] the Guard singleton
-    #
-
-    # 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)
-
-      # NOTE: must be set before anything calls Guard::UI.debug
-      ::Guard::Internals::Debugging.start if options[:debug]
+    def setup(cmdline_options = {})
+      init(cmdline_options)
 
-      @queue = Queue.new
-      self.watchdirs = Array(options[:watchdir])
+      @queue = Internals::Queue.new(Guard)
 
-      ::Guard::UI.reset_and_clear
+      UI.reset_and_clear
 
-      _reset_all
-      evaluate_guardfile
-      setup_scope
+      _evaluate(state.session.evaluator_options)
 
-      @listener = _setup_listener
+      # NOTE: this should be *after* evaluate so :directories can work
+      @listener = Listen.send(*state.session.listener_args, &_listener_callback)
 
-      ::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 = []
-    end
-
-    attr_reader :watchdirs
-
-    # 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) },
-      }
+    def init(cmdline_options)
+      @state = Internals::State.new(cmdline_options)
     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
+    attr_reader :state
 
-      # FIXME: temporary hack while due to upcoming refactorings
-      options[:guardfile] = evaluator.guardfile_path
-
-      msg = "No plugins found in Guardfile, please add at least one."
-      ::Guard::UI.error msg if _pluginless_guardfile?
-    end
-
-    # @private api
-    # used solely for match_guardfile?
-    attr_reader :guardfile_path
+    attr_reader :interactor
 
     # Asynchronously trigger changes
     #
@@ -160,60 +100,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
 
@@ -221,19 +118,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 = {
@@ -246,12 +130,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
@@ -260,19 +139,23 @@ 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
-      @listener = nil
-      @interactor = nil
-      @scope = nil
+    def _evaluate(options)
+      evaluator = Guardfile::Evaluator.new(options)
+      evaluator.evaluate
+      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/cli.rb

@@ -2,9 +2,8 @@ require "thor"
 
 require "guard"
 require "guard/version"
-require "guard/dsl_describer"
-require "guard/guardfile/evaluator"
 require "guard/guardfile/generator"
+require "guard/dsl_describer"
 
 module Guard
   # Facade for the Guard command line interface managed by
@@ -49,6 +48,7 @@ module Guard
                   aliases: "-P",
                   banner:  "Run only the passed plugins"
 
+    # TODO: make it plural
     method_option :watchdir,
                   type:    :array,
                   aliases: "-w",
@@ -105,7 +105,7 @@ module Guard
     #
     def start
       _verify_bundler_presence unless options[:no_bundler_warning]
-      ::Guard.start(options)
+      _start(options)
     end
 
     desc "list", "Lists Guard plugins that can be used with init"
@@ -116,7 +116,8 @@ module Guard
     # @see Guard::DslDescriber.list
     #
     def list
-      ::Guard::DslDescriber.new(options).list
+      _require_guardfile(options) # just to show which plugins are actually used
+      DslDescriber.new.list
     end
 
     desc "notifiers", "Lists notifiers and its options"
@@ -126,8 +127,8 @@ module Guard
     # @see Guard::DslDescriber.notifiers
     #
     def notifiers
-      ::Guard.reset_options(options)
-      ::Guard::DslDescriber.new(options).notifiers
+      _require_guardfile(options)
+      DslDescriber.new.notifiers
     end
 
     desc "version", "Show the Guard version"
@@ -138,7 +139,7 @@ module Guard
     # @see Guard::VERSION
     #
     def version
-      $stdout.puts "Guard version #{ ::Guard::VERSION }"
+      $stdout.puts "Guard version #{ VERSION }"
     end
 
     desc "init [GUARDS]", "Generates a Guardfile at the current directory"\
@@ -164,19 +165,23 @@ module Guard
     #
     def init(*plugin_names)
       _verify_bundler_presence unless options[:no_bundler_warning]
+      bare = options[:bare]
 
-      ::Guard.reset_options(options) # Since UI.deprecated uses config
+      generator = Guardfile::Generator.new
+      Guard.init(options)
+      session = Guard.state.session
 
-      generator = Guardfile::Generator.new(abort_on_existence: options[:bare])
-      generator.create_guardfile
+      begin
+        Guardfile::Evaluator.new(session.evaluator_options).evaluate
+      rescue Guardfile::Evaluator::NoGuardfileError
+        generator.create_guardfile
+      end
 
-      # Note: this reset "hack" will be fixed after refactoring
-      ::Guard.reset_plugins
+      return if bare
 
       # Evaluate because it might have existed and creating was skipped
-      ::Guard::Guardfile::Evaluator.new(Guard.options).evaluate_guardfile
-
-      return if options[:bare]
+      # FIXME: still, I don't know why this is needed
+      Guardfile::Evaluator.new(session.evaluator_options).evaluate
 
       if plugin_names.empty?
         generator.initialize_all_templates
@@ -196,7 +201,9 @@ module Guard
     # @see Guard::DslDescriber.show
     #
     def show
-      ::Guard::DslDescriber.new(options).show
+      _require_guardfile(options)
+      # TODO: use Metadata class
+      DslDescriber.new.show
     end
 
     private
@@ -204,11 +211,12 @@ module Guard
     # Verifies if Guard is run with `bundle exec` and
     # shows a hint to do so if not.
     #
+    # TODO: move this elsewhere!!! (because of complex specs)
     def _verify_bundler_presence
       return unless File.exist?("Gemfile")
       return if ENV["BUNDLE_GEMFILE"] || ENV["RUBYGEMS_GEMDEPS"]
 
-      ::Guard::UI.info <<EOF
+      UI.info <<EOF
 
 Guard here! It looks like your project has a Gemfile, yet you are running
 `guard` outside of Bundler. If this is your intent, feel free to ignore this
@@ -217,5 +225,29 @@ dependencies are loaded correctly.
 (You can run `guard` with --no-bundler-warning to get rid of this message.)
 EOF
     end
+
+    def _require_guardfile(options)
+      Guard.init(options) # to setup metadata
+      session = Guard.state.session
+      Guardfile::Evaluator.new(session.evaluator_options).evaluate
+    rescue Dsl::Error,
+           Guardfile::Evaluator::NoPluginsError,
+           Guardfile::Evaluator::NoGuardfileError,
+           Guardfile::Evaluator::NoCustomGuardfile => e
+      # catch to throw message instead of call stack
+      UI.error(e.message)
+      abort
+    end
+
+    def _start(options)
+      Guard.start(options)
+    rescue Dsl::Error,
+           Guardfile::Evaluator::NoPluginsError,
+           Guardfile::Evaluator::NoGuardfileError,
+           Guardfile::Evaluator::NoCustomGuardfile => e
+      # catch to throw message instead of call stack
+      UI.error(e.message)
+      abort
+    end
   end
 end

data/lib/guard/commander.rb

@@ -3,6 +3,8 @@ require "listen"
 require "guard/notifier"
 require "guard/interactor"
 require "guard/runner"
+require "guard/reevaluator"
+require "guard/dsl_describer"
 require "guard"
 
 module Guard
@@ -28,16 +30,16 @@ module Guard
     #
     def start(options = {})
       setup(options)
-      ::Guard::UI.debug "Guard starts all plugins"
-      Guard::Runner.new.run(:start)
+      UI.debug "Guard starts all plugins"
+      Runner.new.run(:start)
       listener.start
 
-      watched = ::Guard.watchdirs.join("', '")
-      ::Guard::UI.info "Guard is now watching at '#{ watched }'"
+      watched = Guard.state.session.watchdirs.join("', '")
+      UI.info "Guard is now watching at '#{ watched }'"
 
       begin
         while interactor.foreground != :exit
-          _process_queue while pending_changes?
+          Guard.queue.process while Guard.queue.pending?
         end
       rescue Interrupt
       end
@@ -45,14 +47,13 @@ module Guard
       stop
     end
 
-    # TODO: refactor (left to avoid breaking too many specs)
     def stop
       listener.stop
       interactor.background
-      ::Guard::UI.debug "Guard stops all plugins"
-      Guard::Runner.new.run(:stop)
-      ::Guard::Notifier.disconnect
-      ::Guard::UI.info "Bye bye...", reset: true
+      UI.debug "Guard stops all plugins"
+      Runner.new.run(:stop)
+      Notifier.disconnect
+      UI.info "Bye bye...", reset: true
     end
 
     # Reload Guardfile and all Guard plugins currently enabled.
@@ -63,13 +64,13 @@ module Guard
     #
     def reload(scopes = {})
       # TODO: guard reevaluator should probably handle all this
-      ::Guard::UI.clear(force: true)
-      ::Guard::UI.action_with_scopes("Reload", scopes)
+      UI.clear(force: true)
+      UI.action_with_scopes("Reload", scopes)
 
       if scopes.empty?
-        Guard::Guardfile::Evaluator.new(Guard.options).reevaluate_guardfile
+        Reevaluator.new.reevaluate
       else
-        Guard::Runner.new.run(:reload, scopes)
+        Runner.new.run(:reload, scopes)
       end
     end
 
@@ -78,8 +79,8 @@ module Guard
     # @param [Hash] scopes hash with a Guard plugin or a group scope
     #
     def run_all(scopes = {})
-      ::Guard::UI.clear(force: true)
-      ::Guard::UI.action_with_scopes("Run", scopes)
+      UI.clear(force: true)
+      UI.action_with_scopes("Run", scopes)
       Guard::Runner.new.run(:run_all, scopes)
     end
 
@@ -97,7 +98,7 @@ module Guard
     end
 
     def show
-      ::Guard::DslDescriber.new(::Guard.options).show
+      DslDescriber.new.show
     end
   end
   extend Commander