guard 2.6.1 → 2.7.0

data/lib/guard/cli.rb.orig

@@ -0,0 +1,215 @@
+require "thor"
+
+require "guard"
+require "guard/version"
+require "guard/dsl_describer"
+require "guard/guardfile"
+
+module Guard
+  # Facade for the Guard command line interface managed by
+  # [Thor](https://github.com/wycats/thor).
+  #
+  # This is the main interface to Guard that is called by the Guard binary
+  # `bin/guard`. Do not put any logic in here, create a class and delegate
+  # instead.
+  #
+  class CLI < Thor
+    default_task :start
+
+    desc "start", "Starts Guard"
+
+    method_option :clear,
+                  type:    :boolean,
+                  default: false,
+                  aliases: "-c",
+                  banner:  "Auto clear shell before each action"
+
+    method_option :notify,
+                  type:    :boolean,
+                  default: true,
+                  aliases: "-n",
+                  banner:  "Notifications feature"
+
+    method_option :debug,
+                  type:    :boolean,
+                  default: false,
+                  aliases: "-d",
+                  banner:  "Show debug information"
+
+    method_option :group,
+                  type:    :array,
+                  default: [],
+                  aliases: "-g",
+                  banner:  "Run only the passed groups"
+
+    method_option :plugin,
+                  type:    :array,
+                  default: [],
+                  aliases: "-P",
+                  banner:  "Run only the passed plugins"
+
+    method_option :watchdir,
+                  type:    :array,
+                  aliases: "-w",
+                  banner:  "Specify the directories to watch"
+
+    method_option :guardfile,
+                  type:    :string,
+                  aliases: "-G",
+                  banner:  "Specify a Guardfile"
+
+    method_option :no_interactions,
+                  type: :boolean,
+                  default: false,
+                  aliases: "-i",
+                  banner: "Turn off completely any Guard terminal interactions"
+
+    method_option :no_bundler_warning,
+                  type: :boolean,
+                  default: false,
+                  aliases: "-B",
+                  banner: "Turn off warning when Bundler is not present"
+
+    method_option :show_deprecations,
+                  type: :boolean,
+                  default: false,
+                  banner: "Turn on deprecation warnings"
+
+    # Listen options
+    method_option :latency,
+                  type:    :numeric,
+                  aliases: "-l",
+                  banner:  'Overwrite Listen\'s default latency'
+
+    method_option :force_polling,
+                  type:    :boolean,
+                  default: false,
+                  aliases: "-p",
+                  banner:  "Force usage of the Listen polling listener"
+
+    method_option :wait_for_delay,
+                  type:    :numeric,
+                  aliases: "-y",
+                  banner:  'Overwrite Listen\'s default wait_for_delay'
+
+    method_option :listen_on,
+                  type:    :string,
+                  aliases: "-o",
+                  default: false,
+                  banner:  "Specify a network address to Listen on for "\
+                  "file change events (e.g. for use in VMs)"
+
+    # Start Guard by initializing the defined Guard plugins and watch the file
+    # system.
+    #
+    # This is the default task, so calling `guard` is the same as calling
+    # `guard start`.
+    #
+    # @see Guard.start
+    #
+    def start
+      _verify_bundler_presence unless options[:no_bundler_warning]
+      ::Guard.start(options)
+    end
+
+    desc "list", "Lists Guard plugins that can be used with init"
+
+    # List the Guard plugins that are available for use in your system and
+    # marks those that are currently used in your `Guardfile`.
+    #
+    # @see Guard::DslDescriber.list
+    #
+    def list
+      ::Guard::DslDescriber.new(options).list
+    end
+
+    desc "notifiers", "Lists notifiers and its options"
+
+    # List the Notifiers for use in your system.
+    #
+    # @see Guard::DslDescriber.notifiers
+    #
+    def notifiers
+      ::Guard::DslDescriber.new(options).notifiers
+    end
+
+    desc "version", "Show the Guard version"
+    map %w(-v --version) => :version
+
+    # Shows the current version of Guard.
+    #
+    # @see Guard::VERSION
+    #
+    def version
+      STDOUT.puts "Guard version #{ ::Guard::VERSION }"
+    end
+
+    desc "init [GUARDS]", "Generates a Guardfile at the current directory"\
+      " (if it is not already there) and adds all installed Guard plugins"\
+      " or the given GUARDS into it"
+
+    method_option :bare,
+                  type: :boolean,
+                  default: false,
+                  aliases: "-b",
+                  banner: "Generate a bare Guardfile without adding any"\
+                  " installed plugin into it"
+
+    # Initializes the templates of all installed Guard plugins and adds them
+    # to the `Guardfile` when no Guard name is passed. When passing
+    # Guard plugin names it does the same but only for those Guard plugins.
+    #
+    # @see Guard::Guardfile.initialize_template
+    # @see Guard::Guardfile.initialize_all_templates
+    #
+    # @param [Array<String>] plugin_names the name of the Guard plugins to
+    # initialize
+    #
+    def init(*plugin_names)
+      _verify_bundler_presence unless options[:no_bundler_warning]
+
+      ::Guard::Guardfile.create_guardfile(abort_on_existence: options[:bare])
+
+      return if options[:bare]
+
+      if plugin_names.empty?
+        ::Guard::Guardfile.initialize_all_templates
+      else
+        plugin_names.each do |plugin_name|
+          ::Guard::Guardfile.initialize_template(plugin_name)
+        end
+      end
+    end
+
+    desc "show", "Show all defined Guard plugins and their options"
+    map %w(-T) => :show
+
+    # Shows all Guard plugins and their options that are defined in
+    # the `Guardfile`
+    #
+    # @see Guard::DslDescriber.show
+    #
+    def show
+      ::Guard::DslDescriber.new(options).show
+    end
+
+    private
+
+    # Verifies if Guard is run with `bundle exec` and
+    # shows a hint to do so if not.
+    #
+    def _verify_bundler_presence
+      return unless File.exist?("Gemfile")
+      return if ENV["BUNDLE_GEMFILE"] || ENV["RUBYGEMS_GEMDEPS"]
+
+      ::Guard::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
+message. Otherwise, consider using `bundle exec guard` to ensure your
+dependencies are loaded correctly.
+(You can run `guard` with --no-bundler-warning to get rid of this message.)
+EOF
+    end
+  end
+end

data/lib/guard/commander.rb

@@ -1,9 +1,8 @@
 module Guard
-
+  # Commands supported by guard
   module Commander
-
-    # Start Guard by evaluating the `Guardfile`, initializing declared Guard plugins
-    # and starting the available file change listener.
+    # Start Guard by evaluating the `Guardfile`, initializing declared Guard
+    # plugins and starting the available file change listener.
     # Main method for Guard that is called from the CLI when Guard starts.
     #
     # - Setup Guard internals
@@ -21,29 +20,23 @@ module Guard
     # @see CLI#start
     #
     def start(options = {})
-      setup(options) unless running
+      setup(options)
+      ::Guard::UI.debug "Guard starts all plugins"
+      runner.run(:start)
+      listener.start
+      ::Guard::UI.info "Guard is now watching at '#{ @watchdirs.join "', '" }'"
 
-      within_preserved_state do
-        ::Guard::UI.debug 'Guard starts all plugins'
-        runner.run(:start)
-        ::Guard::UI.info "Guard is now watching at '#{ @watchdirs.join "', '" }'"
-        listener.start
-      end
+      _interactor_loop
     end
 
-    # Stop Guard listening to file changes.
-    #
+    # TODO: refactor (left to avoid breaking too many specs)
     def stop
-      setup unless running
-
-      within_preserved_state do
-        ::Guard::UI.debug 'Guard stops all plugins'
-        runner.run(:stop)
-        ::Guard::Notifier.turn_off
-        ::Guard::UI.info 'Bye bye...', reset: true
-        listener.stop
-        @running = false
-      end
+      listener.stop
+      interactor.background
+      ::Guard::UI.debug "Guard stops all plugins"
+      runner.run(:stop)
+      ::Guard::Notifier.turn_off
+      ::Guard::UI.info "Bye bye...", reset: true
     end
 
     # Reload Guardfile and all Guard plugins currently enabled.
@@ -53,17 +46,13 @@ module Guard
     # @param [Hash] scopes hash with a Guard plugin or a group scope
     #
     def reload(scopes = {})
-      setup unless running
-
-      within_preserved_state do
-        ::Guard::UI.clear(force: true)
-        ::Guard::UI.action_with_scopes('Reload', scopes)
+      ::Guard::UI.clear(force: true)
+      ::Guard::UI.action_with_scopes("Reload", scopes)
 
-        if scopes.empty?
-          evaluator.reevaluate_guardfile
-        else
-          runner.run(:reload, scopes)
-        end
+      if scopes.empty?
+        evaluator.reevaluate_guardfile
+      else
+        runner.run(:reload, scopes)
       end
     end
 
@@ -72,50 +61,37 @@ module Guard
     # @param [Hash] scopes hash with a Guard plugin or a group scope
     #
     def run_all(scopes = {})
-      setup unless running
-
-      within_preserved_state do
-        ::Guard::UI.clear(force: true)
-        ::Guard::UI.action_with_scopes('Run', scopes)
-        runner.run(:run_all, scopes)
-      end
+      ::Guard::UI.clear(force: true)
+      ::Guard::UI.action_with_scopes("Run", scopes)
+      runner.run(:run_all, scopes)
     end
 
     # Pause Guard listening to file changes.
     #
-    def pause
-      if listener.paused?
-        ::Guard::UI.info 'Un-paused files modification listening', reset: true
-        listener.unpause
-      else
-        ::Guard::UI.info 'Paused files modification listening', reset: true
-        listener.pause
-      end
+    def pause(expected = nil)
+      paused = listener.paused?
+      states = { paused: true, unpaused: false, toggle: !paused }
+      pause = states[expected || :toggle]
+      fail ArgumentError, "invalid mode: #{expected.inspect}" if pause.nil?
+      return if pause == paused
+
+      listener.send(pause ? :pause : :unpause)
+      UI.info "File modification listening is now #{pause.to_s.upcase}"
     end
 
-    # Runs a block where the interactor is
-    # blocked and execution is synchronized
-    # to avoid state inconsistency.
-    #
-    # @param [Boolean] restart_interactor whether to restart the interactor or
-    #   not
-    # @yield the block to run
-    #
-    def within_preserved_state
-      lock.synchronize do
-        begin
-          interactor.stop if interactor
-          @result = yield
-        rescue Interrupt
-          # Bring back Pry when the block is halted with Ctrl-C
-        end
+    def show
+      ::Guard::DslDescriber.new(::Guard.options).show
+    end
 
-        interactor.start if interactor && running
-      end
+    private
 
-      @result
+    # TODO: remove (left to avoid breaking too many specs)
+    def _interactor_loop
+      while interactor.foreground != :exit
+        _process_queue while pending_changes?
+      end
+    rescue Interrupt
+      stop
     end
-
   end
-
 end

data/lib/guard/commands/all.rb

@@ -1,34 +1,36 @@
-module Guard
-  class Interactor
-
-    ALL = Pry::CommandSet.new do
-      create_command 'all' do
+# required for async_queue_add
+require "pry"
+require "guard"
 
-        group 'Guard'
-        description 'Run all plugins.'
-
-        banner <<-BANNER
+module Guard
+  module Commands
+    class All
+      def self.import
+        Pry::Commands.create_command "all" do
+          group "Guard"
+          description "Run all plugins."
+
+          banner <<-BANNER
           Usage: all <scope>
 
           Run the Guard plugin `run_all` action.
 
           You may want to specify an optional scope to the action,
           either the name of a Guard plugin or a plugin group.
-        BANNER
+          BANNER
 
-        def process(*entries)
-          scopes, rest = ::Guard::Interactor.convert_scope(entries)
+          def process(*entries)
+            scopes, unknown = ::Guard::Interactor.convert_scope(entries)
 
-          if rest.empty?
-            ::Guard.run_all scopes
-          else
-            output.puts "Unknown scope #{ rest.join(', ') }"
+            unless unknown.empty?
+              output.puts "Unknown scopes: #{ unknown.join(", ") }"
+              return
+            end
+
+            ::Guard.async_queue_add([:guard_run_all, scopes])
           end
         end
       end
     end
-
   end
 end
-
-Pry.commands.import ::Guard::Interactor::ALL

data/lib/guard/commands/change.rb

@@ -1,34 +1,29 @@
-module Guard
-  class Interactor
-
-    CHANGE = Pry::CommandSet.new do
-      create_command 'change' do
-
-        group 'Guard'
-        description 'Trigger a file change.'
+require "pry"
 
-        banner <<-BANNER
+module Guard
+  module Commands
+    class Change
+      def self.import
+        Pry::Commands.create_command "change" do
+          group "Guard"
+          description "Trigger a file change."
+
+          banner <<-BANNER
           Usage: change <file> <other_file>
 
           Pass the given files to the Guard plugin `run_on_changes` action.
-        BANNER
-
-        def process(*entries)
-          scopes, files = ::Guard::Interactor.convert_scope(entries)
+          BANNER
 
-          if files.empty?
-            output.puts 'Please specify a file.'
-          else
-            ::Guard.within_preserved_state do
-              ::Guard.runner.run_on_changes(files, [], [])
+          def process(*files)
+            if files.empty?
+              output.puts "Please specify a file."
+              return
             end
+
+            ::Guard.async_queue_add(modified: files, added: [], removed: [])
           end
         end
-
       end
     end
-
   end
 end
-
-Pry.commands.import ::Guard::Interactor::CHANGE