rerun 0.11.0 → 0.12.0

data/lib/rerun/options.rb

@@ -1,119 +1,142 @@
-require 'optparse'
-require 'pathname'
-require 'rerun/watcher'
-
-libdir = "#{File.expand_path(File.dirname(File.dirname(__FILE__)))}"
-
-$spec = Gem::Specification.load(File.join(libdir, "..", "rerun.gemspec"))
-
-module Rerun
-  class Options
-    DEFAULT_PATTERN = "**/*.{rb,js,coffee,css,scss,sass,erb,html,haml,ru,yml,slim,md,feature}"
-    DEFAULT_DIRS = ["."]
-
-    DEFAULTS = {
-        :pattern => DEFAULT_PATTERN,
-        :signal => "TERM",
-        :notify => true,
-        :name => Pathname.getwd.basename.to_s.capitalize,
-        :ignore => [],
-        :dir => DEFAULT_DIRS
-    }
-
-    def self.parse args = ARGV
-
-      default_options = DEFAULTS.dup
-      options = {
-          ignore: []
-      }
-
-      opts = OptionParser.new("", 24, '  ') do |opts|
-        opts.banner = "Usage: rerun [options] [--] cmd"
-
-        opts.separator ""
-        opts.separator "Launches an app, and restarts it when the filesystem changes."
-        opts.separator "See http://github.com/alexch/rerun for more info."
-        opts.separator "Version: #{$spec.version}"
-        opts.separator ""
-        opts.separator "Options:"
-
-        opts.on("-d dir", "--dir dir", "directory to watch, default = \"#{DEFAULT_DIRS}\".  Specify multiple paths with ',' or separate '-d dir' option pairs.") do |dir|
-          elements = dir.split(",")
-          options[:dir] = (options[:dir] || []) + elements
-        end
-
-        # todo: rename to "--watch"
-        opts.on("-p pattern", "--pattern pattern", "file glob to watch, default = \"#{DEFAULTS[:pattern]}\"") do |pattern|
-          options[:pattern] = pattern
-        end
-
-        opts.on("-i pattern", "--ignore pattern", "file glob to ignore (can be set many times). To ignore a directory, you must append '/*' e.g. --ignore 'coverage/*'") do |pattern|
-          options[:ignore] += [pattern]
-        end
-
-        opts.on("-s signal", "--signal signal", "terminate process using this signal, default = \"#{DEFAULTS[:signal]}\"") do |signal|
-          options[:signal] = signal
-        end
-
-        opts.on("-r", "--restart", "expect process to restart itself (uses the HUP signal unless overridden using --signal)") do |signal|
-          options[:restart] = true
-          default_options[:signal] = "HUP"
-        end
-
-        opts.on("-c", "--clear", "clear screen before each run") do
-          options[:clear] = true
-        end
-
-        opts.on("-x", "--exit", "expect the program to exit. With this option, rerun checks the return value; without it, rerun checks that the process is running.") do |dir|
-          options[:exit] = true
-        end
-
-        opts.on("-b", "--background", "disable on-the-fly commands, allowing the process to be backgrounded") do
-          options[:background] = true
-        end
-
-        opts.on("-n name", "--name name", "name of app used in logs and notifications, default = \"#{DEFAULTS[:name]}\"") do |name|
-          options[:name] = name
-        end
-
-        opts.on("--no-growl", "don't use growl [OBSOLETE]") do
-          options[:growl] = false
-          $stderr.puts "--no-growl is obsolete; use --no-notify instead"
-          return
-        end
-
-        opts.on("--[no-]notify [notifier]", "send messages through growl (requires growlnotify) or osx (requires terminal-notifier gem)") do |notifier|
-          notifier = true if notifier.nil?
-          options[:notify] = notifier
-        end
-
-        opts.on_tail("-h", "--help", "--usage", "show this message") do
-          puts opts
-          return
-        end
-
-        opts.on_tail("--version", "show version") do
-          puts $spec.version
-          return
-        end
-
-        opts.on_tail ""
-        opts.on_tail "On top of --pattern and --ignore, we ignore any changes to files and dirs starting with a dot."
-
-      end
-
-      if args.empty?
-        puts opts
-        nil
-      else
-        opts.parse! args
-        default_options[:cmd] = args.join(" ")
-
-        options = default_options.merge(options)
-
-        options
-      end
-    end
-
-  end
-end
+require 'optparse'
+require 'pathname'
+require 'rerun/watcher'
+require 'rerun/system'
+
+libdir = "#{File.expand_path(File.dirname(File.dirname(__FILE__)))}"
+
+$spec = Gem::Specification.load(File.join(libdir, "..", "rerun.gemspec"))
+
+module Rerun
+  class Options
+
+    extend Rerun::System
+
+    # If you change the default pattern, please update the README.md file -- the list appears twice therein, which at the time of this comment are lines 17 and 119
+    DEFAULT_PATTERN = "**/*.{rb,js,coffee,css,scss,sass,erb,html,haml,ru,yml,slim,md,feature,c,h}"
+    DEFAULT_DIRS = ["."]
+
+    DEFAULTS = {
+        :pattern => DEFAULT_PATTERN,
+        :signal => (windows? ? "TERM,KILL" : "TERM,INT,KILL"),
+        :wait => 2,
+        :notify => true,
+        :quiet => false,
+        :verbose => false,
+        :name => Pathname.getwd.basename.to_s.capitalize,
+        :ignore => [],
+        :dir => DEFAULT_DIRS,
+        :force_polling => false,
+    }
+
+    def self.parse args = ARGV
+
+      default_options = DEFAULTS.dup
+      options = {
+          ignore: []
+      }
+
+      opts = OptionParser.new("", 24, '  ') do |opts|
+        opts.banner = "Usage: rerun [options] [--] cmd"
+
+        opts.separator ""
+        opts.separator "Launches an app, and restarts it when the filesystem changes."
+        opts.separator "See http://github.com/alexch/rerun for more info."
+        opts.separator "Version: #{$spec.version}"
+        opts.separator ""
+        opts.separator "Options:"
+
+        opts.on("-d dir", "--dir dir", "directory to watch, default = \"#{DEFAULT_DIRS}\".  Specify multiple paths with ',' or separate '-d dir' option pairs.") do |dir|
+          elements = dir.split(",")
+          options[:dir] = (options[:dir] || []) + elements
+        end
+
+        # todo: rename to "--watch"
+        opts.on("-p pattern", "--pattern pattern", "file glob to watch, default = \"#{DEFAULTS[:pattern]}\"") do |pattern|
+          options[:pattern] = pattern
+        end
+
+        opts.on("-i pattern", "--ignore pattern", "file glob to ignore (can be set many times). To ignore a directory, you must append '/*' e.g. --ignore 'coverage/*'") do |pattern|
+          options[:ignore] += [pattern]
+        end
+
+        opts.on("-s signal", "--signal signal", "terminate process using this signal. To try several signals in series, use a comma-delimited list. Default: \"#{DEFAULTS[:signal]}\"") do |signal|
+          options[:signal] = signal
+        end
+
+        opts.on("-w sec", "--wait sec", "after asking the process to terminate, wait this long (in seconds) before either aborting, or trying the next signal in series. Default: #{DEFAULTS[:wait]} sec")
+
+        opts.on("-r", "--restart", "expect process to restart itself, so just send a signal and continue watching. Uses the HUP signal unless overridden using --signal") do |signal|
+          options[:restart] = true
+          default_options[:signal] = "HUP"
+        end
+
+        opts.on("-x", "--exit", "expect the program to exit. With this option, rerun checks the return value; without it, rerun checks that the process is running.") do |dir|
+          options[:exit] = true
+        end
+
+        opts.on("-c", "--clear", "clear screen before each run") do
+          options[:clear] = true
+        end
+
+        opts.on("-b", "--background", "disable on-the-fly commands, allowing the process to be backgrounded") do
+          options[:background] = true
+        end
+
+        opts.on("-n name", "--name name", "name of app used in logs and notifications, default = \"#{DEFAULTS[:name]}\"") do |name|
+          options[:name] = name
+        end
+
+        opts.on("--force-polling", "use polling instead of a native filesystem scan (useful for Vagrant)") do
+          options[:force_polling] = true
+        end
+
+        opts.on("--no-growl", "don't use growl [OBSOLETE]") do
+          options[:growl] = false
+          $stderr.puts "--no-growl is obsolete; use --no-notify instead"
+          return
+        end
+
+        opts.on("--[no-]notify [notifier]", "send messages through a desktop notification application. Supports growl (requires growlnotify), osx (requires terminal-notifier gem), and notify-send on GNU/Linux (notify-send must be installed)") do |notifier|
+          notifier = true if notifier.nil?
+          options[:notify] = notifier
+        end
+
+        opts.on("-q", "--quiet", "don't output any logs") do
+          options[:quiet] = true
+        end
+
+        opts.on("--verbose", "log extra stuff like PIDs (unless you also specified `--quiet`") do
+          options[:verbose] = true
+        end
+
+        opts.on_tail("-h", "--help", "--usage", "show this message") do
+          puts opts
+          return
+        end
+
+        opts.on_tail("--version", "show version") do
+          puts $spec.version
+          return
+        end
+
+        opts.on_tail ""
+        opts.on_tail "On top of --pattern and --ignore, we ignore any changes to files and dirs starting with a dot."
+
+      end
+
+      if args.empty?
+        puts opts
+        nil
+      else
+        opts.parse! args
+        default_options[:cmd] = args.join(" ")
+
+        options = default_options.merge(options)
+
+        options
+      end
+    end
+
+  end
+end

data/lib/rerun/runner.rb

@@ -1,334 +1,375 @@
-require 'timeout'
-require 'io/wait'
-
-module Rerun
-  class Runner
-
-    def self.keep_running(cmd, options)
-      runner = new(cmd, options)
-      runner.start
-      runner.join
-      # apparently runner doesn't keep running anymore (as of Listen 2) so we have to sleep forever :-(
-      sleep 10000 while true  # :-(
-    end
-
-    include System
-
-    def initialize(run_command, options = {})
-      @run_command, @options = run_command, options
-      @run_command = "ruby #{@run_command}" if @run_command.split(' ').first =~ /\.rb$/
-    end
-
-    def start_keypress_thread
-      return if @options[:background]
-
-      @keypress_thread = Thread.new do
-        while true
-          if c = key_pressed
-            case c.downcase
-            when 'c'
-              say "Clearing screen"
-              clear_screen
-            when 'r'
-              say "Restarting"
-              restart
-            when 'p'
-              toggle_pause if watcher_running?
-            when 'x', 'q'
-              die
-              break  # the break will stop this thread, in case the 'die' doesn't
-            else
-              puts "\n#{c.inspect} pressed inside rerun"
-              puts [["c", "clear screen"],
-               ["r", "restart"],
-               ["p", "toggle pause"],
-               ["x or q", "stop and exit"]
-              ].map{|key, description| "  #{key} -- #{description}"}.join("\n")
-              puts
-            end
-          end
-          sleep 1  # todo: use select instead of polling somehow?
-        end
-      end
-      @keypress_thread.run
-    end
-
-    def stop_keypress_thread
-      @keypress_thread.kill if @keypress_thread
-      @keypress_thread = nil
-    end
-
-    def restart
-      @restarting = true
-      if @options[:restart]
-        restart_with_signal(@options[:signal])
-      else
-        stop
-        start
-      end
-      @restarting = false
-    end
-
-    def watcher_running?
-      @watcher && @watcher.running?
-    end
-
-    def toggle_pause
-      unless @pausing
-        say "Pausing.  Press 'p' again to resume."
-        @watcher.pause
-        @pausing = true
-      else
-        say "Resuming."
-        @watcher.unpause
-        @pausing = false
-      end
-    end
-
-    def unpause
-      @watcher.unpause
-    end
-
-    def dir
-      @options[:dir]
-    end
-
-    def dirs
-      @options[:dir] || "."
-    end
-
-    def pattern
-      @options[:pattern]
-    end
-
-    def ignore
-      @options[:ignore] || []
-    end
-
-    def clear?
-      @options[:clear]
-    end
-
-    def exit?
-      @options[:exit]
-    end
-
-    def app_name
-      @options[:name]
-    end
-
-    def restart_with_signal(restart_signal)
-      if @pid && (@pid != 0)
-        notify "restarting", "We will be with you shortly."
-        signal(restart_signal)
-      end
-    end
-
-    def start
-      if windows?
-        raise "Sorry, Rerun does not work on Windows."
-      end
-
-      if @already_running
-        taglines = [
-          "Here we go again!",
-          "Keep on trucking.",
-          "Once more unto the breach, dear friends, once more!",
-          "The road goes ever on and on, down from the door where it began.",
-        ]
-        notify "restarted", taglines[rand(taglines.size)]
-      else
-        taglines = [
-          "To infinity... and beyond!",
-          "Charge!",
-        ]
-        notify "launched", taglines[rand(taglines.size)]
-        @already_running = true
-      end
-
-      clear_screen if clear?
-      start_keypress_thread unless @keypress_thread
-
-      @pid = Kernel.fork do
-        begin
-          exec(@run_command)
-        rescue => e
-          puts "#{e.class}: #{e.message}"
-          exit
-        end
-      end
-      status_thread = Process.detach(@pid) # so if the child exits, it dies
-
-      Signal.trap("INT") do # INT = control-C -- allows user to stop the top-level rerun process
-        die
-      end
-
-      Signal.trap("TERM") do  # TERM is the polite way of terminating a process
-        die
-      end
-
-      begin
-        sleep 2
-      rescue Interrupt => e
-        # in case someone hits control-C immediately ("oops!")
-        die
-      end
-
-      if exit?
-        status = status_thread.value
-        if status.success?
-          notify "succeeded", ""
-        else
-          notify "failed", "Exit status #{status.exitstatus}"
-        end
-      else
-        if !running?
-          notify "Launch Failed", "See console for error output"
-          @already_running = false
-        end
-      end
-
-      unless @watcher
-
-        watcher = Watcher.new(:directory => dirs, :pattern => pattern, :ignore => ignore) do |changes|
-
-          message = change_message(changes)
-
-          say "Change detected: #{message}"
-          restart unless @restarting
-        end
-        watcher.start
-        @watcher = watcher
-        say "Watching #{dir.join(', ')} for #{pattern}" +
-                (ignore.empty? ? "" : " (ignoring #{ignore.join(',')})")
-      end
-    end
-
-    def change_message(changes)
-      message = [:modified, :added, :removed].map do |change|
-        count = changes[change] ? changes[change].size : 0
-        if count > 0
-          "#{count} #{change}"
-        end
-      end.compact.join(", ")
-
-      changed_files = changes.values.flatten
-      if changed_files.count > 0
-        message += ": "
-        message += changes.values.flatten[0..3].map { |path| path.split('/').last }.join(', ')
-        if changed_files.count > 3
-          message += ", ..."
-        end
-      end
-      message
-    end
-
-    def die
-      #stop_keypress_thread   # don't do this since we're probably *in* the keypress thread
-      stop # stop the child process if it exists
-      exit 0  # todo: status code param
-    end
-
-    def join
-      @watcher.join
-    end
-
-    def running?
-      signal(0)
-    end
-
-    def signal(signal)
-      say "Sending signal #{signal} to #{@pid}" unless signal == 0
-      Process.kill(signal, @pid)
-      true
-    rescue
-      false
-    end
-
-    # todo: test escalation
-    def stop
-      default_signal = @options[:signal] || "TERM"
-      if @pid && (@pid != 0)
-        notify "stopping", "All good things must come to an end." unless @restarting
-        begin
-          timeout(5) do  # todo: escalation timeout setting
-            # start with a polite SIGTERM
-            signal(default_signal) && Process.wait(@pid)
-          end
-        rescue Timeout::Error
-          begin
-            timeout(5) do
-              # escalate to SIGINT aka control-C since some foolish process may be ignoring SIGTERM
-              signal("INT") && Process.wait(@pid)
-            end
-          rescue Timeout::Error
-            # escalate to SIGKILL aka "kill -9" which cannot be ignored
-            signal("KILL") && Process.wait(@pid)
-          end
-        end
-      end
-    rescue => e
-      false
-    end
-
-    def git_head_changed?
-      old_git_head = @git_head
-      read_git_head
-      @git_head and old_git_head and @git_head != old_git_head
-    end
-
-    def read_git_head
-      git_head_file = File.join(dir, '.git', 'HEAD')
-      @git_head = File.exists?(git_head_file) && File.read(git_head_file)
-    end
-
-    def notify(title, body, background = true)
-      Notification.new(title, body, @options).send(background) if @options[:notify]
-      puts
-      say "#{app_name} #{title}"
-    end
-
-    def say msg
-      puts "#{Time.now.strftime("%T")} [rerun] #{msg}"
-    end
-
-    # non-blocking stdin reader.
-    # returns a 1-char string if a key was pressed; otherwise nil
-    #
-    def key_pressed
-      begin
-        # this "raw input" nonsense is because unix likes waiting for linefeeds before sending stdin
-
-        # 'raw' means turn raw input on
-
-        # restore proper output newline handling -- see stty.rb and "man stty" and /usr/include/sys/termios.h
-        # looks like "raw" flips off the OPOST bit 0x00000001 /* enable following output processing */
-        # which disables #define ONLCR		0x00000002	/* map NL to CR-NL (ala CRMOD) */
-        # so this sets it back on again since all we care about is raw input, not raw output
-        system("stty raw opost")
-
-        c = nil
-        if $stdin.ready?
-          c = $stdin.getc
-        end
-        c.chr if c
-      ensure
-        system "stty -raw" # turn raw input off
-      end
-
-      # note: according to 'man tty' the proper way restore the settings is
-      # tty_state=`stty -g`
-      # ensure
-      #   system 'stty "#{tty_state}'
-      # end
-      # but this way seems fine and less confusing
-
-    end
-
-    def clear_screen
-      # see http://ascii-table.com/ansi-escape-sequences-vt-100.php
-      $stdout.print "\033[H\033[2J"
-    end
-
-  end
-end
+require 'timeout'
+require 'io/wait'
+
+module Rerun
+  class Runner
+
+    def self.keep_running(cmd, options)
+      runner = new(cmd, options)
+      runner.start
+      runner.join
+      # apparently runner doesn't keep running anymore (as of Listen 2) so we have to sleep forever :-(
+      sleep 10000 while true # :-(
+    end
+
+    include System
+    include ::Timeout
+
+    def initialize(run_command, options = {})
+      @run_command, @options = run_command, options
+      @run_command = "ruby #{@run_command}" if @run_command.split(' ').first =~ /\.rb$/
+    end
+
+    def start_keypress_thread
+      return if @options[:background]
+
+      @keypress_thread = Thread.new do
+        while true
+          if c = key_pressed
+            case c.downcase
+            when 'c'
+              say "Clearing screen"
+              clear_screen
+            when 'r'
+              say "Restarting"
+              restart
+            when 'f'
+              say "Stopping and starting"
+              restart(false)
+            when 'p'
+              toggle_pause if watcher_running?
+            when 'x', 'q'
+              die
+              break # the break will stop this thread, in case the 'die' doesn't
+            else
+              puts "\n#{c.inspect} pressed inside rerun"
+              puts [["c", "clear screen"],
+                    ["r", "restart"],
+                    ["f", "forced restart (stop and start)"],
+                    ["p", "toggle pause"],
+                    ["x or q", "stop and exit"]
+                   ].map {|key, description| "  #{key} -- #{description}"}.join("\n")
+              puts
+            end
+          end
+          sleep 1 # todo: use select instead of polling somehow?
+        end
+      end
+      @keypress_thread.run
+    end
+
+    def stop_keypress_thread
+      @keypress_thread.kill if @keypress_thread
+      @keypress_thread = nil
+    end
+
+    def restart(with_signal = true)
+      @restarting = true
+      if @options[:restart] && with_signal
+        restart_with_signal(@options[:signal])
+      else
+        stop
+        start
+      end
+      @restarting = false
+    end
+
+    def watcher_running?
+      @watcher && @watcher.running?
+    end
+
+    def toggle_pause
+      unless @pausing
+        say "Pausing.  Press 'p' again to resume."
+        @watcher.pause
+        @pausing = true
+      else
+        say "Resuming."
+        @watcher.unpause
+        @pausing = false
+      end
+    end
+
+    def unpause
+      @watcher.unpause
+    end
+
+    def dir
+      @options[:dir]
+    end
+
+    def dirs
+      @options[:dir] || "."
+    end
+
+    def pattern
+      @options[:pattern]
+    end
+
+    def ignore
+      @options[:ignore] || []
+    end
+
+    def clear?
+      @options[:clear]
+    end
+
+    def quiet?
+      @options[:quiet]
+    end
+
+    def verbose?
+      @options[:verbose]
+    end
+
+    def exit?
+      @options[:exit]
+    end
+
+    def app_name
+      @options[:name]
+    end
+
+    def restart_with_signal(restart_signal)
+      if @pid && (@pid != 0)
+        notify "restarting", "We will be with you shortly."
+        send_signal(restart_signal)
+      end
+    end
+
+    def force_polling
+      @options[:force_polling]
+    end
+
+    def start
+      if @already_running
+        taglines = [
+          "Here we go again!",
+          "Keep on trucking.",
+          "Once more unto the breach, dear friends, once more!",
+          "The road goes ever on and on, down from the door where it began.",
+        ]
+        notify "restarted", taglines[rand(taglines.size)]
+      else
+        taglines = [
+          "To infinity... and beyond!",
+          "Charge!",
+        ]
+        notify "launched", taglines[rand(taglines.size)]
+        @already_running = true
+      end
+
+      clear_screen if clear?
+      start_keypress_thread unless @keypress_thread
+
+      begin
+        @pid = run @run_command
+        say "Rerun (#{$PID}) running #{app_name} (#{@pid})"
+      rescue => e
+        puts "#{e.class}: #{e.message}"
+        exit
+      end
+
+      status_thread = Process.detach(@pid) # so if the child exits, it dies
+
+      Signal.trap("INT") do # INT = control-C -- allows user to stop the top-level rerun process
+        die
+      end
+
+      Signal.trap("TERM") do # TERM is the polite way of terminating a process
+        die
+      end
+
+      begin
+        sleep 2
+      rescue Interrupt => e
+        # in case someone hits control-C immediately ("oops!")
+        die
+      end
+
+      if exit?
+        status = status_thread.value
+        if status.success?
+          notify "succeeded", ""
+        else
+          notify "failed", "Exit status #{status.exitstatus}"
+        end
+      else
+        if !running?
+          notify "Launch Failed", "See console for error output"
+          @already_running = false
+        end
+      end
+
+      unless @watcher
+
+        watcher = Watcher.new(:directory => dirs, :pattern => pattern, :ignore => ignore, :force_polling => force_polling) do |changes|
+
+          message = change_message(changes)
+
+          say "Change detected: #{message}"
+          restart unless @restarting
+        end
+        watcher.start
+        @watcher = watcher
+        say "Watching #{dir.join(', ')} for #{pattern}" +
+              (ignore.empty? ? "" : " (ignoring #{ignore.join(',')})") +
+              (watcher.adapter.nil? ? "" : " with #{watcher.adapter_name} adapter")
+      end
+    end
+
+    def run command
+      Kernel.spawn command
+    end
+
+    def change_message(changes)
+      message = [:modified, :added, :removed].map do |change|
+        count = changes[change] ? changes[change].size : 0
+        if count > 0
+          "#{count} #{change}"
+        end
+      end.compact.join(", ")
+
+      changed_files = changes.values.flatten
+      if changed_files.count > 0
+        message += ": "
+        message += changes.values.flatten[0..3].map {|path| path.split('/').last}.join(', ')
+        if changed_files.count > 3
+          message += ", ..."
+        end
+      end
+      message
+    end
+
+    def die
+      #stop_keypress_thread   # don't do this since we're probably *in* the keypress thread
+      stop # stop the child process if it exists
+      exit 0 # todo: status code param
+    end
+
+    def join
+      @watcher.join
+    end
+
+    def running?
+      send_signal(0)
+    end
+
+    # Send the signal to process @pid and wait for it to die.
+    # @returns true if the process dies
+    # @returns false if either sending the signal fails or the process fails to die
+    def signal_and_wait(signal)
+
+      signal_sent = if windows?
+                      force_kill = (signal == 'KILL')
+                      system("taskkill /T #{'/F' if force_kill} /PID #{@pid}")
+                    else
+                      send_signal(signal)
+                    end
+
+      if signal_sent
+        # the signal was successfully sent, so wait for the process to die
+        begin
+          timeout(@options[:wait]) do
+            Process.wait(@pid)
+          end
+          process_status = $?
+          say "Process ended: #{process_status}" if verbose?
+          true
+        rescue Timeout::Error
+          false
+        end
+      else
+        false
+      end
+    end
+
+    # Send the signal to process @pid.
+    # @returns true if the signal is sent
+    # @returns false if sending the signal fails
+    # If sending the signal fails, the exception will be swallowed
+    # (and logged if verbose is true) and this method will return false.
+    #
+    def send_signal(signal)
+      say "Sending signal #{signal} to #{@pid}" unless signal == 0 if verbose?
+      Process.kill(signal, @pid)
+      true
+    rescue => e
+      say "Signal #{signal} failed: #{e.class}: #{e.message}" if verbose?
+      false
+    end
+
+    # todo: test escalation
+    def stop
+      if @pid && (@pid != 0)
+        notify "stopping", "All good things must come to an end." unless @restarting
+        @options[:signal].split(',').each do |signal|
+          success = signal_and_wait(signal)
+          return true if success
+        end
+      end
+    rescue => e
+      false
+    end
+
+    def git_head_changed?
+      old_git_head = @git_head
+      read_git_head
+      @git_head and old_git_head and @git_head != old_git_head
+    end
+
+    def read_git_head
+      git_head_file = File.join(dir, '.git', 'HEAD')
+      @git_head = File.exists?(git_head_file) && File.read(git_head_file)
+    end
+
+    def notify(title, body, background = true)
+      Notification.new(title, body, @options).send(background) if @options[:notify]
+      puts
+      say "#{app_name} #{title}"
+    end
+
+    def say msg
+      puts "#{Time.now.strftime("%T")} [rerun] #{msg}" unless quiet?
+    end
+
+    # non-blocking stdin reader.
+    # returns a 1-char string if a key was pressed; otherwise nil
+    #
+    def key_pressed
+      begin
+        # this "raw input" nonsense is because unix likes waiting for linefeeds before sending stdin
+
+        # 'raw' means turn raw input on
+
+        # restore proper output newline handling -- see stty.rb and "man stty" and /usr/include/sys/termios.h
+        # looks like "raw" flips off the OPOST bit 0x00000001 /* enable following output processing */
+        # which disables #define ONLCR		0x00000002	/* map NL to CR-NL (ala CRMOD) */
+        # so this sets it back on again since all we care about is raw input, not raw output
+        system("stty raw opost")
+
+        c = nil
+        if $stdin.ready?
+          c = $stdin.getc
+        end
+        c.chr if c
+      ensure
+        system "stty -raw" # turn raw input off
+      end
+
+      # note: according to 'man tty' the proper way restore the settings is
+      # tty_state=`stty -g`
+      # ensure
+      #   system 'stty "#{tty_state}'
+      # end
+      # but this way seems fine and less confusing
+
+    end
+
+    def clear_screen
+      # see http://ascii-table.com/ansi-escape-sequences-vt-100.php
+      $stdout.print "\033[H\033[2J"
+    end
+
+  end
+end