rerun 0.13.0 → 0.13.1

data/lib/rerun/options.rb

@@ -1,145 +1,146 @@
-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,
-      :background => false,
-      :name => Pathname.getwd.basename.to_s.capitalize,
-      :ignore => [],
-      :dir => DEFAULT_DIRS,
-      :force_polling => false,
-    }
-
-    def self.parse args: ARGV, config_file: nil
-
-      default_options = DEFAULTS.dup
-      options = {
-        ignore: []
-      }
-
-      if config_file && File.exist?(config_file)
-        require 'shellwords'
-        config_args = File.read(config_file).shellsplit
-        args = config_args + args
-      end
-
-      option_parser = OptionParser.new("", 24, '  ') do |o|
-        o.banner = "Usage: rerun [options] [--] cmd"
-
-        o.separator ""
-        o.separator "Launches an app, and restarts it when the filesystem changes."
-        o.separator "See http://github.com/alexch/rerun for more info."
-        o.separator "Version: #{$spec.version}"
-        o.separator ""
-        o.separator "Options:"
-
-        o.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"
-        o.on("-p pattern", "--pattern pattern", "file glob to watch, default = \"#{DEFAULTS[:pattern]}\"") do |pattern|
-          options[:pattern] = pattern
-        end
-
-        o.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
-
-        o.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
-
-        o.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")
-
-        o.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
-
-        o.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 |value|
-          options[:exit] = value
-        end
-
-        o.on("-c", "--clear", "clear screen before each run") do |value|
-          options[:clear] = value
-        end
-
-        o.on("-b", "--background", "disable on-the-fly commands, allowing the process to be backgrounded") do |value|
-          options[:background] = value
-        end
-
-        o.on("-n name", "--name name", "name of app used in logs and notifications, default = \"#{DEFAULTS[:name]}\"") do |name|
-          options[:name] = name
-        end
-
-        o.on("--[no-]force-polling", "use polling instead of a native filesystem scan (useful for Vagrant)") do |value|
-          options[:force_polling] = value
-        end
-
-        o.on("--no-growl", "don't use growl [OBSOLETE]") do
-          options[:growl] = false
-          $stderr.puts "--no-growl is obsolete; use --no-notify instead"
-          return
-        end
-
-        o.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
-
-        o.on("-q", "--[no-]quiet", "don't output any logs") do |value|
-          options[:quiet] = value
-        end
-
-        o.on("--[no-]verbose", "log extra stuff like PIDs (unless you also specified `--quiet`") do |value|
-          options[:verbose] = value
-        end
-
-        o.on_tail("-h", "--help", "--usage", "show this message and immediately exit") do
-          puts o
-          return
-        end
-
-        o.on_tail("--version", "show version and immediately exit") do
-          puts $spec.version
-          return
-        end
-
-        o.on_tail ""
-        o.on_tail "On top of --pattern and --ignore, we ignore any changes to files and dirs starting with a dot."
-
-      end
-
-      option_parser.parse! args
-      options = default_options.merge(options)
-      options[:cmd] = args.join(" ").strip # todo: better arg word handling
-
-      puts option_parser if args.empty?
-
-      options
-    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 = {
+      :background => false,
+      :dir => DEFAULT_DIRS,
+      :force_polling => false,
+      :ignore => [],
+      :ignore_dotfiles => true,
+      :name => Pathname.getwd.basename.to_s.capitalize,
+      :notify => true,
+      :pattern => DEFAULT_PATTERN,
+      :quiet => false,
+      :signal => (windows? ? "TERM,KILL" : "TERM,INT,KILL"),
+      :verbose => false,
+      :wait => 2,
+    }
+
+    def self.parse args: ARGV, config_file: nil
+
+      default_options = DEFAULTS.dup
+      options = {
+        ignore: []
+      }
+
+      if config_file && File.exist?(config_file)
+        require 'shellwords'
+        config_args = File.read(config_file).shellsplit
+        args = config_args + args
+      end
+
+      option_parser = OptionParser.new("", 24, '  ') do |o|
+        o.banner = "Usage: rerun [options] [--] cmd"
+
+        o.separator ""
+        o.separator "Launches an app, and restarts it when the filesystem changes."
+        o.separator "See http://github.com/alexch/rerun for more info."
+        o.separator "Version: #{$spec.version}"
+        o.separator ""
+        o.separator "Options:"
+
+        o.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"
+        o.on("-p pattern", "--pattern pattern", "file glob to watch, default = \"#{DEFAULTS[:pattern]}\"") do |pattern|
+          options[:pattern] = pattern
+        end
+
+        o.on("-i pattern", "--ignore pattern", "file glob(s) to ignore. Can be set many times. To ignore a directory, you must append '/*' e.g. --ignore 'coverage/*' . Globs do not match dotfiles by default.") do |pattern|
+          options[:ignore] += [pattern]
+        end
+
+        o.on("--[no-]ignore-dotfiles", "by default, file globs do not match files that begin with a dot. Setting --no-ignore-dotfiles allows you to monitor a relevant file like .env, but you may also have to explicitly --ignore more dotfiles and dotdirs.") do |value|
+          options[:ignore_dotfiles] = value
+        end
+
+        o.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
+
+        o.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")
+
+        o.on("-r", "--restart", "expect process to restart itself, so just send a signal and continue watching. Sends the HUP signal unless overridden using --signal") do |signal|
+          options[:restart] = true
+          default_options[:signal] = "HUP"
+        end
+
+        o.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 |value|
+          options[:exit] = value
+        end
+
+        o.on("-c", "--clear", "clear screen before each run") do |value|
+          options[:clear] = value
+        end
+
+        o.on("-b", "--background", "disable on-the-fly keypress commands, allowing the process to be backgrounded") do |value|
+          options[:background] = value
+        end
+
+        o.on("-n name", "--name name", "name of app used in logs and notifications, default = \"#{DEFAULTS[:name]}\"") do |name|
+          options[:name] = name
+        end
+
+        o.on("--[no-]force-polling", "use polling instead of a native filesystem scan (useful for Vagrant)") do |value|
+          options[:force_polling] = value
+        end
+
+        o.on("--no-growl", "don't use growl [OBSOLETE]") do
+          options[:growl] = false
+          $stderr.puts "--no-growl is obsolete; use --no-notify instead"
+          return
+        end
+
+        o.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
+
+        o.on("-q", "--[no-]quiet", "don't output any logs") do |value|
+          options[:quiet] = value
+        end
+
+        o.on("--[no-]verbose", "log extra stuff like PIDs (unless you also specified `--quiet`") do |value|
+          options[:verbose] = value
+        end
+
+        o.on_tail("-h", "--help", "--usage", "show this message and immediately exit") do
+          puts o
+          return
+        end
+
+        o.on_tail("--version", "show version and immediately exit") do
+          puts $spec.version
+          return
+        end
+
+      end
+
+      puts option_parser if args.empty?
+      option_parser.parse! args
+      options = default_options.merge(options)
+      options[:cmd] = args.join(" ").strip # todo: better arg word handling
+
+      options
+    end
+  end
+
+end

data/lib/rerun/runner.rb

@@ -1,376 +1,374 @@
-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
-            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 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
-
-    def stty(args)
-      system "stty #{args}"
-    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
-        stty "raw opost"
-
-        c = nil
-        if $stdin.ready?
-          c = $stdin.getc
-        end
-        c.chr if c
-      ensure
-        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
+
+    # The watcher instance that wait for changes
+    attr_reader :watcher
+
+    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$/
+      @options[:directory] ||= options.delete(:dir) || '.'
+      @options[:ignore] ||= []
+    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
+            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 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[:directory]
+    end
+
+    def pattern
+      @options[:pattern]
+    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(@options) do |changes|
+          message = change_message(changes)
+          say "Change detected: #{message}"
+          restart unless @restarting
+        end
+        watcher.start
+        @watcher = watcher
+        ignore = @options[:ignore]
+        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
+      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
+
+    def stty(args)
+      system "stty #{args}"
+    end
+
+    # non-blocking stdin reader.
+    # returns a 1-char string if a key was pressed; otherwise nil
+    #
+    def key_pressed
+      return one_char if windows?
+      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
+        stty "raw opost"
+        one_char
+      ensure
+        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
+
+    private
+    def one_char
+      c = nil
+      if $stdin.ready?
+        c = $stdin.getc
+      end
+      c.chr if c
+    end
+
+  end
+end