guard 2.7.0 → 2.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f713c5e30ef7f2814a804f5fafdb58979caa6619
-  data.tar.gz: ce94c3678722ee2d4d6ddfca527d5d598fffa069
+  metadata.gz: 1c86565038c0d17ebb30f6cc008bd4daa3ec3146
+  data.tar.gz: 7de5a07cdad205ab62306ecab6f044222406dd1e
 SHA512:
-  metadata.gz: 3fdcb3cad5b86d6b36d570c4c534742ad9613e164c660c6de608a38771afd5f776a6cbc2e2a81bbc43330058175a9ee73c86a8b76766cdb6918df3b60f434cc2
-  data.tar.gz: 9ff385cce046e434c8a2b577915e58453793dce6b6aa08fccc20bf293421ba862872d7df0c80e37737c5e7bceed972ea4e26c87c11c2f2a80086c6c95a01fc8c
+  metadata.gz: 72ae5a7b063bb4fa07fcfe0dc7b7673dd97a1d3099d4dcf846b7cf3c62040f9a4850a32168df6545eb80a7e62bfdc0f20bc1967239c376a6559a96e95050ebc2
+  data.tar.gz: 0e182edbd7934d9524c6261c2db55b1d3cd9b4c9ed8aea9dd66ece1cffd9534f6226abd9b3e705caaea1543891bd36f2e783714435a3577a94824023f6617808

data/bin/guard

@@ -1,6 +1,11 @@
 #!/usr/bin/env ruby
 
 require "guard"
-require "guard/cli"
 
-Guard::CLI.start
+begin
+  require "guard/aruba_adapter"
+rescue LoadError => e
+  abort "#{e.inspect} - perhaps you need to run using `bundle exec`?"
+end
+
+Guard::ArubaAdapter.new(ARGV.dup).execute!

data/lib/guard.rb

@@ -20,22 +20,25 @@ require "guard/reevaluator"
 # Also Guard plugins should use this namespace.
 #
 module Guard
-  WINDOWS  = RbConfig::CONFIG["host_os"] =~ /(?:msdos|mswin|djgpp|mingw)/
-  DEV_NULL = WINDOWS ? "NUL" : "/dev/null"
+  DEV_NULL = Gem.win_platform? ? "NUL" : "/dev/null"
 
   extend Commander
   extend DeprecatedMethods
   extend Setuper
 
   class << self
-    attr_accessor :runner, :listener, :lock, :running
-
     # Called by Pry scope command
-    attr_reader :scope
 
     def scope=(new_scope)
       @scope = new_scope
+      @scope.dup.freeze
+    end
+
+    def scope
+      fail "::Guard.setup() not called" if @scope.nil?
+      @scope.dup.freeze
     end
+    attr_reader :runner, :listener
 
     # Smart accessor for retrieving specific plugins at once.
     #
@@ -137,6 +140,8 @@ module Guard
         @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
 
@@ -176,6 +181,12 @@ module Guard
       instance
     end
 
+    # Used by runner to remove a failed plugin
+    def remove_plugin(plugin)
+      # TODO: coverage/aruba
+      @plugins.delete(plugin)
+    end
+
     # Add a Guard plugin group.
     #
     # @param [String] name the group name

data/lib/guard.rb.orig

@@ -0,0 +1,210 @@
+require "rbconfig"
+
+require "guard/commander"
+require "guard/deprecated_methods"
+require "guard/deprecator"
+require "guard/dsl"
+require "guard/group"
+require "guard/guardfile"
+require "guard/interactor"
+require "guard/notifier"
+require "guard/plugin_util"
+require "guard/runner"
+require "guard/setuper"
+require "guard/sheller"
+require "guard/ui"
+require "guard/watcher"
+require "guard/reevaluator"
+
+# Guard is the main module for all Guard related modules and classes.
+# Also Guard plugins should use this namespace.
+#
+module Guard
+  DEV_NULL = Gem.win_platform? ? "NUL" : "/dev/null"
+
+  extend Commander
+  extend DeprecatedMethods
+  extend Setuper
+
+  class << self
+    # Called by Pry scope command
+
+    def scope=(new_scope)
+      @scope = new_scope
+      @scope.dup.freeze
+    end
+
+    def scope
+      fail "::Guard.setup() not called" if @scope.nil?
+      @scope.dup.freeze
+    end
+    attr_reader :runner, :listener
+
+    # Smart accessor for retrieving specific plugins at once.
+    #
+    # @see Guard.plugin
+    # @see Guard.group
+    # @see Guard.groups
+    #
+    # @example Filter plugins by String or Symbol
+    #   Guard.plugins('rspec')
+    #   Guard.plugins(:rspec)
+    #
+    # @example Filter plugins by Regexp
+    #   Guard.plugins(/rsp.+/)
+    #
+    # @example Filter plugins by Hash
+    #   Guard.plugins(name: 'rspec', group: 'backend')
+    #
+    # @param [String, Symbol, Regexp, Hash] filter the filter to apply to the
+    # plugins
+    # @return [Plugin, Array<Plugin>] the filtered plugin(s)
+    #
+    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
+
+    # Smart accessor for retrieving a specific plugin.
+    #
+    # @see Guard.plugins
+    # @see Guard.group
+    # @see Guard.groups
+    #
+    # @example Find a plugin by String or Symbol
+    #   Guard.plugin('rspec')
+    #   Guard.plugin(:rspec)
+    #
+    # @example Find a plugin by Regexp
+    #   Guard.plugin(/rsp.+/)
+    #
+    # @example Find a plugin by Hash
+    #   Guard.plugin(name: 'rspec', group: 'backend')
+    #
+    # @param [String, Symbol, Regexp, Hash] filter the filter for finding the
+    #   plugin the Guard plugin
+    # @return [Plugin, nil] the plugin found, nil otherwise
+    #
+    def plugin(filter)
+      plugins(filter).first
+    end
+
+    # Smart accessor for retrieving specific groups at once.
+    #
+    # @see Guard.plugin
+    # @see Guard.plugins
+    # @see Guard.group
+    #
+    # @example Filter groups by String or Symbol
+    #   Guard.groups('backend')
+    #   Guard.groups(:backend)
+    #
+    # @example Filter groups by Regexp
+    #   Guard.groups(/(back|front)end/)
+    #
+    # @param [String, Symbol, Regexp] filter the filter to apply to the Groups
+    # @return [Array<Group>] the filtered group(s)
+    #
+    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
+
+    # Smart accessor for retrieving a specific group.
+    #
+    # @see Guard.plugin
+    # @see Guard.plugins
+    # @see Guard.groups
+    #
+    # @example Find a group by String or Symbol
+    #   Guard.group('backend')
+    #   Guard.group(:backend)
+    #
+    # @example Find a group by Regexp
+    #   Guard.group(/(back|front)end/)
+    #
+    # @param [String, Symbol, Regexp] filter the filter for finding the group
+    # @return [Group] the group found, nil otherwise
+    #
+    def group(filter)
+      groups(filter).first
+    end
+
+    # Add a Guard plugin to use.
+    #
+    # @param [String] name the Guard name
+    # @param [Hash] options the plugin options (see Plugin documentation)
+    # @option options [String] group the group to which the plugin belongs
+    # @option options [Array<Watcher>] watchers the list of declared watchers
+    # @option options [Array<Hash>] callbacks the list of callbacks
+    # @return [Plugin] the added Guard plugin
+    # @see Plugin
+    #
+    def add_plugin(name, options = {})
+      instance = ::Guard::PluginUtil.new(name).initialize_plugin(options)
+      @plugins << instance
+      instance
+    end
+
+    # Used by runner to remove a failed plugin
+    def remove_plugin(plugin)
+      # TODO: coverage/aruba
+      @plugins.delete(plugin)
+    end
+
+    # Add a Guard plugin group.
+    #
+    # @param [String] name the group name
+    # @option options [Boolean] halt_on_fail if a task execution
+    #   should be halted for all Guard plugins in this group if
+    #   one Guard throws `:task_has_failed`
+    # @return [Group] the group added (or retrieved from the `@groups`
+    #   variable if already present)
+    #
+    # @see Group
+    #
+    def add_group(name, options = {})
+      unless (group = group(name))
+        group = ::Guard::Group.new(name, options)
+        @groups << group
+      end
+
+      group
+    end
+  end
+end

data/lib/guard/aruba_adapter.rb

@@ -0,0 +1,59 @@
+require "guard/cli"
+
+module Guard
+  class ArubaAdapter
+    def initialize(argv, stdin = STDIN, stdout = STDOUT, stderr = STDERR,
+                   kernel = Kernel)
+      @argv = argv
+      @stdin = stdin
+      @stdout = stdout
+      @stderr = stderr
+      @kernel = kernel
+
+      if ENV["INSIDE_ARUBA_TEST"] == "1"
+        ::Guard::UI.options = ::Guard::UI.options.merge(flush_seconds: 0)
+      end
+    end
+
+    def execute!
+      exit_code = execute
+      # Proxy our exit code back to the injected kernel.
+      @kernel.exit(exit_code)
+    end
+
+    def execute
+      # Thor accesses these streams directly rather than letting
+      # them be injected, so we replace them...
+      $stderr = @stderr
+      $stdin = @stdin
+      $stdout = @stdout
+
+      # Run our normal Thor app the way we know and love.
+      ::Guard::CLI.start(@argv)
+
+      # Thor::Base#start does not have a return value, assume
+      # success if no exception is raised.
+      0
+    rescue StandardError => e
+      # The ruby interpreter would pipe this to STDERR and exit 1 in the case
+      # of an unhandled exception
+      b = e.backtrace
+      b.unshift("#{b.shift}: #{e.message} (#{e.class})")
+      @stderr.puts(b.map { |s| "\tfrom #{s}" }.join("\n"))
+      1
+    rescue SystemExit => e
+      e.status
+    ensure
+      # flush the logger so the output doesn't appear in next CLI invocation
+      ::Guard.listener.stop if ::Guard.listener
+      ::Guard::UI.logger.flush
+      ::Guard::UI.logger.close
+      ::Guard::UI.reset_logger
+
+      # ...then we put them back.
+      $stderr = STDERR
+      $stdin = STDIN
+      $stdout = STDOUT
+    end
+  end
+end

data/lib/guard/cli.rb

@@ -141,7 +141,7 @@ module Guard
     # @see Guard::VERSION
     #
     def version
-      STDOUT.puts "Guard version #{ ::Guard::VERSION }"
+      $stdout.puts "Guard version #{ ::Guard::VERSION }"
     end
 
     desc "init [GUARDS]", "Generates a Guardfile at the current directory"\

data/lib/guard/commander.rb

@@ -24,7 +24,9 @@ module Guard
       ::Guard::UI.debug "Guard starts all plugins"
       runner.run(:start)
       listener.start
-      ::Guard::UI.info "Guard is now watching at '#{ @watchdirs.join "', '" }'"
+
+      watched = ::Guard.watchdirs.join("', '")
+      ::Guard::UI.info "Guard is now watching at '#{ watched }'"
 
       _interactor_loop
     end

data/lib/guard/commands/scope.rb

@@ -27,7 +27,7 @@ module Guard
               return
             end
 
-            ::Guard.scope = scope
+            ::Guard.setup_scope(scope)
           end
         end
       end

data/lib/guard/deprecated_methods.rb

@@ -51,5 +51,21 @@ module Guard
       UI.deprecation(Deprecator::GUARD_GEM_NAMES_DEPRECATION)
       PluginUtil.plugin_names
     end
+
+    def running
+      UI.deprecation(Deprecator::GUARD_RUNNING_DEPRECATION)
+      nil
+    end
+
+    def lock
+      UI.deprecation(Deprecator::GUARD_LOCK_DEPRECATION)
+    end
+
+    def evaluator
+      UI.deprecation(Deprecator::GUARD_EVALUATOR_DEPRECATION)
+      # TODO: this will be changed to the following when scope is reworked
+      # ::Guard.session.evaluator
+      ::Guard.instance_variable_get(:@evaluator)
+    end
   end
 end

data/lib/guard/deprecator.rb

@@ -118,5 +118,20 @@ module Guard
 
       #{MORE_INFO_ON_UPGRADING_TO_GUARD_2 % "#changes-in-guardguard"}
     EOS
+
+    GUARD_RUNNING_DEPRECATION = <<-EOS.gsub(/^\s*/, "")
+      Starting with Guard 2.7.1 it was discovered that Guard.running was never
+      initialized or used internally.
+    EOS
+
+    GUARD_LOCK_DEPRECATION = <<-EOS.gsub(/^\s*/, "")
+      Starting with Guard 2.7.1 it was discovered that this accessor was never
+      initialized or used internally.
+    EOS
+
+    GUARD_EVALUATOR_DEPRECATION = <<-EOS.gsub(/^\s*/, "")
+      Starting with Guard 2.7.1 ::Guard.session.evaluator should be used
+      instead.
+    EOS
   end
 end

data/lib/guard/dsl_describer.rb

@@ -35,8 +35,6 @@ module Guard
     # @see CLI#list
     #
     def list
-      _evaluate_guardfile
-
       names = ::Guard::PluginUtil.plugin_names.sort.uniq
       final_rows = names.inject([]) do |rows, name|
         rows << {

data/lib/guard/guardfile/evaluator.rb

@@ -50,8 +50,8 @@ module Guard
       #
       def evaluate_guardfile
         _fetch_guardfile_contents
-        ::Guard.add_builtin_plugins(guardfile_path)
         _instance_eval_guardfile(guardfile_contents)
+        ::Guard.add_builtin_plugins(guardfile_path)
       end
 
       # Re-evaluates the `Guardfile` to update
@@ -221,7 +221,7 @@ module Guard
       def _after_reevaluate_guardfile
         ::Guard::Notifier.turn_on if ::Guard::Notifier.enabled?
 
-        if !::Guard.send(:_non_builtin_plugins?)
+        if !::Guard.send(:_pluginless_guardfile?)
           ::Guard::Notifier.notify(
             "No plugins found in Guardfile, please add at least one.",
             title: "Guard re-evaluate",