rerun 0.9.0 → 0.13.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: dfeb631293e3c084bb49fe63e960edd9ec01a7bc
-  data.tar.gz: dfacf8cd2c638cc518b3021d3267f09b0f9df91a
+SHA256:
+  metadata.gz: 12916c529d417f7435294064c61ab8bc9b3e4811e61ab162725b84dc42730212
+  data.tar.gz: 2d32573a380ae73f845564580eced58064271d3347a09da7c5e13ad72882a8c5
 SHA512:
-  metadata.gz: 15d53a73449cc4755ca91ebf2c59c5f21b64d9ac97c43c3af3f47c9404e0fea33ba02f6e2b3ab9fe021043fbc60bb9fa0b4f81d2af1363a8bc151136462c53df
-  data.tar.gz: 74e2275e507e39b77ca9f01358178639f2f65154b4255518e550371f5c78fb95a84d90b34e11236bc0db9ea3ba579d21fc38c68edb1368803ac44beb4c4a2574
+  metadata.gz: a3d9ed3d68053c23b3c9665abc33cde89d4fd5893fa1d9930fbcb93113459450810ced0d3d0cd7e83c2bc4dc9da27446228f1104dc2a46cdb01ef53dc8bc5f48
+  data.tar.gz: 1df642c255cd253271015b111f2b0fa4b9023c0fd697b1bd03405b2fccb9d716658f840a82884dfa7b042395c07664205f6427c08a9b432f8742ce58413792cd

data/README.md

@@ -14,14 +14,18 @@ Rerun's advantage is its simple design. Since it uses `exec` and the standard
 Unix `SIGINT` and `SIGKILL` signals, you're sure the restarted app is really
 acting just like it was when you ran it from the command line the first time.
 
-By default only `*.{rb,js,css,scss,sass,erb,html,haml,ru}` files are watched.
+By default it watches files ending in: `rb,js,coffee,css,scss,sass,erb,html,haml,ru,yml,slim,md,feature,c,h`.
 Use the `--pattern` option if you want to change this.
 
 As of version 0.7.0, we use the Listen gem, which tries to use your OS's
 built-in facilities for monitoring the filesystem, so CPU use is very light.
 
-Rerun does not work on Windows. Sorry, but you can't do much relaunching
-without "fork".
+**UPDATE**: Now Rerun *does* work on Windows! Caveats:
+  * not well-tested
+  * you need to press Enter after keypress input
+  * you may need to install the `wdm` gem manually: `gem install wdm`
+  * You may see this persistent `INFO` error message; to remove it, use`--no-notify`:
+    * `INFO: Could not find files for the given pattern(s)`
 
 # Installation:
 
@@ -40,10 +44,39 @@ they're not available. Unfortunately, Rubygems doesn't understand optional
 dependencies very well, so you may have to install extra gems (and/or put them
 in your Gemfile) to make Rerun work more smoothly on your system.
 (Learn more at <https://github.com/guard/listen#listen-adapters>.)
-For example, on Mac OS X, use
+
+On Mac OS X, use
 
         gem install rb-fsevent
 
+On Windows, use
+
+        gem install wdm
+
+On *BSD, use
+
+        gem install rb-kqueue
+
+## Installation via Gemfile / Bundler
+
+If you are using rerun inside an existing Ruby application (like a Rails or Sinatra app), you can add it to your Gemfile:
+
+``` ruby
+group :development, :test do
+  gem "rerun"
+end
+```
+
+Using a Gemfile is also an easy way to use the pre-release branch, which may have bugfixes or features you want:
+
+``` ruby
+group :development, :test do
+  gem "rerun", git: "https://github.com/alexch/rerun.git"
+end
+```
+
+When using a Gemfile, install with `bundle install` or `bundle update`, and run using `bundle exec rerun`, to guarantee you are using the rerun version specified in the Gemfile, and not a different version in a system-wide gemset.
+
 # Usage:
 
         rerun [options] [--] cmd
@@ -113,42 +146,95 @@ Procfile processes locally and restart them all when necessary.
 
 # Options:
 
+These options can be specified on the command line and/or inside a `.rerun` config file (see below).
+
 `--dir` directory (or directories) to watch (default = "."). Separate multiple paths with ',' and/or use multiple `-d` options.
 
 `--pattern` glob to match inside directory. This uses the Ruby Dir glob style -- see <http://www.ruby-doc.org/core/classes/Dir.html#M002322> for details.
-By default it watches files ending in: `rb,js,css,scss,sass,erb,html,haml,ru`.
-On top of this, it also ignores dotfiles, `.tmp` files, and some other files and directories (like `.git .hg .rbx .svn bundle log tmp`) -- run `rerun --help` for the full list.
+By default it watches files ending in: `rb,js,coffee,css,scss,sass,erb,html,haml,ru,yml,slim,md,feature,c,h`.
+On top of this, it also ignores dotfiles, `.tmp` files, and some other files and directories (like `.git` and `log`).
+Run `rerun --help` to see the actual list.
+
+`--ignore pattern` file glob to ignore (can be set many times). To ignore a directory, you must append `'/*'` e.g.
+  `--ignore 'coverage/*'`.
 
-`--signal` (or -s) use specified signal (instead of the default SIGTERM) to terminate the previous process.
+`--[no-]ignore-dotfiles` By default, on top of --pattern and --ignore, we ignore any changes to files and dirs starting 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. 
+
+`--signal` (or `-s`) use specified signal(s) (instead of the default `TERM,INT,KILL`) to terminate the previous process. You can use a comma-delimited list if you want to try a signal, wait up to 5 seconds for the process to die, then try again with a different signal, and so on. 
 This may be useful for forcing the respective process to terminate as quickly as possible.
 (`--signal KILL` is the equivalent of `kill -9`)
 
-`--clear` (or -c) clear the screen before each run
+`--wait sec` (or `-w`)           after asking the process to terminate, wait this long (in seconds) before either aborting, or trying the next signal in series. Default: 2 sec
+
+`--restart` (or `-r`) expect process to restart itself, using signal HUP by default
+(e.g. `-r -s INT` will send a INT and then resume watching for changes)
 
 `--exit` (or -x) expect the program to exit. With this option, rerun checks the return value; without it, rerun checks that the launched process is still running.
 
+`--clear` (or -c) clear the screen before each run
+
 `--background` (or -b) disable on-the-fly commands, allowing the process to be backgrounded
 
-`--no-growl` don't use growl
+`--notify NOTIFIER` use `growl` or `osx` or `notify-send` for notifications (see below)
+
+`--no-notify` disable notifications
 
 `--name` set the app name (for display)
 
-Also --version and --help, naturally.
+`--force-polling` use polling instead of a native filesystem scan (useful for Vagrant)
+
+`--quiet` silences most messages
+
+`--verbose` enables even more messages (unless you also specified `--quiet`, which overrides `--verbose`)
+
+Also `--version` and `--help`, naturally.
+
+## Config file
+
+If the current directory contains a file named `.rerun`, it will be parsed with the same rules as command-line arguments. Newlines are the same as any other whitespace, so you can stack options vertically, like this:
+
+```
+--quiet
+--pattern **/*.{rb,js,scss,sass,html,md}
+```
 
-# Growl Notifications
+Options specified on the command line will override those in the config file. You can negate boolean options with `--no-`, so for example, with the above config file, to re-enable logging, you could say:
+
+```sh
+rerun --no-quiet rackup
+```
+
+If you're not sure what options are being overwritten, use `--verbose` and rerun will show you the final result of the parsing.
+
+# Notifications
 
 If you have `growlnotify` available on the `PATH`, it sends notifications to
-growl in addition to the console. If you have growl but don't want rerun to use it,
-set the `--no-growl` option.
+growl in addition to the console.
+
+If you have `terminal-notifier`, it sends notifications to
+the OS X notification center in addition to the console.
+
+If you have `notify-send`, it sends notifications to Freedesktop-compatible
+desktops in addition to the console.
+
+If you have more than one available notification program, Rerun will pick one, or you can choose between them using `--notify growl`, `--notify osx`, `--notify notify-send`, etc.
+
+If you have a notifier installed but don't want rerun to use it,
+set the `--no-notify` option.
 
 Download [growlnotify here](http://growl.info/downloads.php#generaldownloads)
 now that Growl has moved to the App Store.
 
+Install [terminal-notifier](https://github.com/julienXX/terminal-notifier) using `gem install terminal-notifier`. (You may have to put it in your system gemset and/or use `sudo` too.) Using Homebrew to install terminal-notifier is not recommended.
+
+On Debian/Ubuntu, `notify-send` is availble in the `libnotify-bin` package. On other GNU/Linux systems, it might be in a package with a different name.
+
 # On-The-Fly Commands
 
 While the app is (re)running, you can make things happen by pressing keys:
 
 * **r** -- restart (as if a file had changed)
+* **f** -- force restart (stop and start)
 * **c** -- clear the screen
 * **x** or **q** -- exit (just like control-C)
 * **p** -- pause/unpause filesystem watching
@@ -161,44 +247,66 @@ keys to be trapped, so use the `--background` option.
 The current algorithm for killing the process is:
 
 * send [SIGTERM](http://en.wikipedia.org/wiki/SIGTERM) (or the value of the `--signal` option)
-* if that doesn't work after 4 seconds, send SIGINT (aka control-C)
+* if that doesn't work after 2 seconds, send SIGINT (aka control-C)
 * if that doesn't work after 2 more seconds, send SIGKILL (aka kill -9)
 
 This seems like the most gentle and unixy way of doing things, but it does
-mean that if your program ignores SIGTERM, it takes an extra 4 to 6 seconds to
+mean that if your program ignores SIGTERM, it takes an extra 2 to 4 seconds to
 restart.
 
+If you want to use your own series of signals, use the `--signal` option. If you want to change the delay before attempting the next signal, use the `--wait` option.
+
+# Vagrant and VirtualBox
+
+If running inside a shared directory using Vagrant and VirtualBox, you must pass the `--force-polling` option. You may also have to pass some extra `--ignore` options too; otherwise each scan can take 10 or more seconds on directories with a large number of files or subdirectories underneath it.
+
+# Troubleshooting
+
+## zsh ##
+
+If you are using `zsh` as your shell, and you are specifying your `--pattern` as `**/*.rb`, you may face this error
+```
+Errno::EACCES: Permission denied - <filename>
+```
+This is because `**/*.rb` gets expanded into the command by `zsh` instead of passing it through to rerun. The solution is to simply quote ('' or "") the pattern.
+i.e
+```
+rerun -p **/*.rb rake test
+```
+becomes
+```
+rerun -p "**/*.rb" rake test
+```
+
 # To Do:
 
-* Cooldown (so if a dozen files appear in a burst, say from 'git pull', it only restarts once)
+## Must have for v1.0
+* Make sure to pass through quoted options correctly to target process [bug]
+* Optionally do "bundle install" before and "bundle exec" during launch
+
+## Nice to have
+* ".rerun" file in $HOME
 * If the last element of the command is a `.ru` file and there's no other command then use `rackup`
-* --ignore pattern (currently we're using Listen's default list plus dotfiles)
-* ".rerun" file to specify options per project or in $HOME.
 * Figure out an algorithm so "-x" is not needed (if possible) -- maybe by accepting a "--port" option or reading `config.ru`
 * Specify (or deduce) port to listen for to determine success of a web server launch
-* Make sure to pass through quoted options correctly to target process [bug]
-* Make it work on Windows, like Guard now does. See
-  * https://github.com/guard/guard/issues/59
-  * https://github.com/guard/guard/issues/27
-* Optionally do "bundle install" before and "bundle exec" during launch
+* see also [todo.md](todo.md)
+
+## Wacky Ideas
+
 * On OS X:
     * use a C library using growl's developer API <http://growl.info/developer/>
     * Use growl's AppleScript or SDK instead of relying on growlnotify
-    * Use OS X notifications
     * "Failed" icon for notifications
-* On Linux:
-    * Test on Linux.
-    * Use libnotify or notify-send http://www.linuxjournal.com/content/tech-tip-get-notifications-your-scripts-notify-send
 
 # Other projects that do similar things
 
+* Guard: <http://github.com/guard/guard>
 * Restartomatic: <http://github.com/adammck/restartomatic>
 * Shotgun: <http://github.com/rtomayko/shotgun>
 * Rack::Reloader middleware: <http://github.com/rack/rack/blob/5ca8f82fb59f0bf0e8fd438e8e91c5acf3d98e44/lib/rack/reloader.rb>
 * The Sinatra FAQ has a discussion at <http://www.sinatrarb.com/faq.html#reloading>
 * Kicker: <http://github.com/alloy/kicker/>
 * Watchr: <https://github.com/mynyml/watchr>
-* Guard: <http://github.com/guard/guard>
 * Autotest: <https://github.com/grosser/autotest>
 
 # Why would I use this instead of Shotgun?
@@ -279,14 +387,53 @@ Based upon and/or inspired by:
 * <https://github.com/FND>
 * Barry Sia <https://github.com/bsia>
 * Paul Rangel <https://github.com/ismell>
+* James Edward Gray II <https://github.com/JEG2>
+* Raul E Rangel <https://github.com/ismell> and Antonio Terceiro <https://github.com/terceiro>
+* Mike Pastore <https://github.com/mwpastore>
+* Andy Duncan <https://github.com/ajduncan>
+* Brent Van Minnen
+* Matthew O'Riordan <https://github.com/mattheworiordan>
+* Antonio Terceiro <https://github.com/terceiro>
+* <https://github.com/mattbrictson>
+* <https://github.com/krissi>
 
 # Version History
 
-* v0.9.0
+* 
+  * --no-ignore-dotfiles option
+
+* v0.13.0   26 January 2018
+  * bugfix: pause/unpause works again (thanks Barry!)
+  * `.rerun` config file
+
+* v0.12.0   23 January 2018
+  * smarter `--signal` option, allowing you to specify a series of signals to try in order; also `--wait` to change how long between tries
+  * `--force-polling` option (thanks ajduncan)
+  * `f` key to force stop and start (thanks mwpastore)
+  * add `.c` and `.h` files to default ignore list
+  * support for Windows
+     * use `Kernel.spawn` instead of `fork`
+     * use `wdm` gem for Windows Directory Monitor
+  * support for notifications on GNU/Linux using [notify-send](http://www.linuxjournal.com/content/tech-tip-get-notifications-your-scripts-notify-send) (thanks terceiro)
+  * fix `Gem::LoadError - terminal-notifier is not part of the bundle` [bug](https://github.com/alexch/rerun/issues/108) (thanks 	mattheworiordan)
+
+* 0.11.0    7 October 2015
+  * better 'changed' message
+  * `--notify osx` option
+  * `--restart` option (with bugfix by Mike Pastore)
+  * use Listen 3 gem
+  * add `.feature` files to default watchlist (thanks @jmuheim)
+
+* v0.10.0   4 May 2014
+  * add '.coffee,.slim,.md' to default pattern (thanks @xylinq)
+  * --ignore option
+
+* v0.9.0    6 March 2014
   * --dir (or -d) can be specified more than once, for multiple directories (thanks again Barry!)
   * --name option
   * press 'p' to pause/unpause filesystem watching (Barry is the man!)
   * works with Listen 2 (note: needs 2.3 or higher)
+  * cooldown works, thanks to patches to underlying Listen gem
   * ignore all dotfiles, and add actual list of ignored dirs and files
 
 * v0.8.2

data/Rakefile

@@ -32,7 +32,7 @@ end
 desc 'Exit if git is dirty'
 task :check_git do
   state = `git status 2> /dev/null | tail -n1`
-  clean = (state =~ /working directory clean/)
+  clean = (state =~ /working (directory|tree) clean/)
   unless clean
     warn "can't do that on an unclean git dir"
     exit 1
@@ -73,3 +73,10 @@ task 'release' => [:check_git, package('.gem'), package('.tar.gz')] do |t|
   sh "git tag v#{$spec.version}"
   sh "git push && git push --tags"
 end
+
+desc 'download github issues and pull requests'
+task 'github' do
+  %w(issues pulls).each do |type|
+    sh "curl -o #{type}.json https://api.github.com/repos/alexch/rerun/#{type}"
+  end
+end

data/bin/rerun

@@ -7,6 +7,12 @@ $LOAD_PATH.unshift libdir unless $LOAD_PATH.include?(libdir)
 require 'rerun'
 require 'optparse'
 
-options = Rerun::Options.parse
-exit if options.nil?
-runner = Rerun::Runner.keep_running(options[:cmd], options)
+options = Rerun::Options.parse config_file: ".rerun"
+
+if options and options[:verbose]
+  puts "\nrerun options:\n\t#{options}"
+end
+
+exit if options.nil? or options[:cmd].nil? or options[:cmd].empty?
+
+Rerun::Runner.keep_running(options[:cmd], options)

data/lib/goo.rb

@@ -0,0 +1,3 @@
+goooo
+goooo
+goooo

data/lib/rerun.rb

@@ -4,13 +4,12 @@ $: << here unless $:.include?(here)
 require "listen"  # pull in the Listen gem
 require "rerun/options"
 require "rerun/system"
+require "rerun/notification"
 require "rerun/runner"
 require "rerun/watcher"
 require "rerun/glob"
 
 module Rerun
 
-  DEFAULT_PATTERN = "**/*.{rb,js,css,scss,sass,erb,html,haml,ru}"
-
 end
 

data/lib/rerun/notification.rb

@@ -0,0 +1,82 @@
+# todo: unit tests
+
+module Rerun
+  class Notification
+    include System
+
+    attr_reader :title, :body, :options
+
+    def initialize(title, body, options = Options::DEFAULTS.dup)
+      @title = title
+      @body = body
+      @options = options
+    end
+
+    def command
+      # todo: strategy or subclass
+
+      s = nil
+
+      if options[:notify] == true or options[:notify] == "growl"
+        if (cmd = command_named("growlnotify"))
+          # todo: check version of growlnotify and warn if it's too old
+          icon_str = ("--image \"#{icon}\"" if icon)
+          s = "#{cmd} -n \"#{app_name}\" -m \"#{body}\" \"#{app_name} #{title}\" #{icon_str}"
+        end
+      end
+
+      if s.nil? and options[:notify] == true or options[:notify] == "osx"
+        if (cmd = command_named("terminal-notifier"))
+          icon_str = ("-appIcon \"#{icon}\"" if icon)
+          s = "#{cmd} -title \"#{app_name}\" -message \"#{body}\" \"#{app_name} #{title}\" #{icon_str}"
+        end
+      end
+
+      if s.nil? and options[:notify] == true or options[:notify] == "notify-send"
+        if (cmd = command_named('notify-send'))
+          icon_str = "--icon #{icon}" if icon
+          s = "#{cmd} -t 500 --hint=int:transient:1 #{icon_str} \"#{app_name}: #{title}\" \"#{body}\""
+        end
+      end
+
+      s
+    end
+
+    def command_named(name)
+      which_command = windows? ? 'where.exe %{cmd}' : 'which %{cmd} 2> /dev/null'
+      # TODO: remove 'INFO' error message
+      path = `#{which_command % {cmd: name}}`.chomp
+      path.empty? ? nil : path
+    end
+
+    def send(background = true)
+      return unless command
+      with_clean_env do
+        `#{command}#{" &" if background}`
+      end
+    end
+
+    def app_name
+      options[:name]
+    end
+
+    def icon
+      "#{icon_dir}/rails_red_sml.png" if rails?
+    end
+
+    def icon_dir
+      here = File.expand_path(File.dirname(__FILE__))
+      File.expand_path("#{here}/../../icons")
+    end
+
+    def with_clean_env
+      if defined?(Bundler)
+        Bundler.with_clean_env do
+          yield
+        end
+      else
+        yield
+      end
+    end
+  end
+end

data/lib/rerun/options.rb

@@ -1,5 +1,7 @@
 require 'optparse'
 require 'pathname'
+require 'rerun/watcher'
+require 'rerun/system'
 
 libdir = "#{File.expand_path(File.dirname(File.dirname(__FILE__)))}"
 
@@ -7,86 +9,138 @@ $spec = Gem::Specification.load(File.join(libdir, "..", "rerun.gemspec"))
 
 module Rerun
   class Options
-    DEFAULT_PATTERN = "**/*.{rb,js,css,scss,sass,erb,html,haml,ru}"
+
+    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 => "TERM",
-        :growl => true,
-        :name => Pathname.getwd.basename.to_s.capitalize
+      :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
-      options = DEFAULTS.dup
-      opts = OptionParser.new("", 24, '  ') do |opts|
-        opts.banner = "Usage: rerun [options] [--] cmd"
+    def self.parse args: ARGV, config_file: nil
 
-        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:"
+      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
 
-        opts.on("-d dir", "--dir dir", "directory to watch, default = \"#{DEFAULT_DIRS}\".  Specify multiple paths with ',' or separate '-d dir' option pairs.") do |dir|
+      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
 
-        opts.on("-p pattern", "--pattern pattern", "file glob, default = \"#{DEFAULTS[:pattern]}\"") do |pattern|
+        # todo: rename to "--watch"
+        o.on("-p pattern", "--pattern pattern", "file glob to watch, default = \"#{DEFAULTS[:pattern]}\"") do |pattern|
           options[:pattern] = pattern
         end
 
-        opts.on("-s", "--signal signal", "terminate process using this signal, default = \"#{DEFAULTS[:signal]}\"") do |signal|
+        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
 
-        opts.on("-c", "--clear", "clear screen before each run") do
-          options[:clear] = true
+        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
 
-        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
+        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
 
-        opts.on("-b", "--background", "disable on-the-fly commands, allowing the process to be backgrounded") do
-          options[:background] = true
+        o.on("-c", "--clear", "clear screen before each run") do |value|
+          options[:clear] = value
         end
 
-        opts.on("-n name", "--name name", "name of app used in logs and notifications, default = \"#{DEFAULTS[:name]}\"") do |name|
+        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
 
-        opts.on("--no-growl", "don't use growl") do
+        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
 
-        opts.on_tail("-h", "--help", "--usage", "show this message") do
-          puts opts
+        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
 
-        opts.on_tail("--version", "show version") do
+        o.on_tail("--version", "show version and immediately exit") do
           puts $spec.version
           return
         end
 
-        opts.on_tail ""
-        opts.on_tail "On top of --pattern, we ignore any changes to files and dirs starting with a dot, ending with [#{Listen::Silencer::DEFAULT_IGNORED_EXTENSIONS.join(',')}], or named [#{Listen::Silencer::DEFAULT_IGNORED_DIRECTORIES.join(',')}]."
-
       end
 
-      if args.empty?
-        puts opts
-        nil
-      else
-        opts.parse! args
-        options[:cmd] = args.join(" ")
-        options[:dir] ||= DEFAULT_DIRS
-        options
-      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

@@ -4,19 +4,25 @@ 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  # :-(
+      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
@@ -32,22 +38,26 @@ module Rerun
             when 'r'
               say "Restarting"
               restart
+            when 'f'
+              say "Stopping and starting"
+              restart(false)
             when 'p'
-              toggle_pause if watcher_running?
+              toggle_pause
             when 'x', 'q'
               die
-              break  # the break will stop this thread, in case the 'die' doesn't
+              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")
+                    ["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?
+          sleep 1 # todo: use select instead of polling somehow?
         end
       end
       @keypress_thread.run
@@ -58,24 +68,24 @@ module Rerun
       @keypress_thread = nil
     end
 
-    def restart
+    def restart(with_signal = true)
       @restarting = true
-      stop
-      start
+      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"
+        say "Resuming."
         @watcher.unpause
         @pausing = false
       end
@@ -86,11 +96,7 @@ module Rerun
     end
 
     def dir
-      @options[:dir]
-    end
-
-    def dirs
-      @options[:dir] || "."
+      @options[:directory]
     end
 
     def pattern
@@ -101,6 +107,14 @@ module Rerun
       @options[:clear]
     end
 
+    def quiet?
+      @options[:quiet]
+    end
+
+    def verbose?
+      @options[:verbose]
+    end
+
     def exit?
       @options[:exit]
     end
@@ -109,19 +123,19 @@ module Rerun
       @options[:name]
     end
 
-    def start
-      if windows?
-        raise "Sorry, Rerun does not work on Windows."
+    def restart_with_signal(restart_signal)
+      if @pid && (@pid != 0)
+        notify "restarting", "We will be with you shortly."
+        send_signal(restart_signal)
       end
+    end
 
-      if (!@already_running)
-        taglines = [
-          "To infinity... and beyond!",
-          "Charge!",
-        ]
-        notify "launched", taglines[rand(taglines.size)]
-        @already_running = true
-      else
+    def force_polling
+      @options[:force_polling]
+    end
+
+    def start
+      if @already_running
         taglines = [
           "Here we go again!",
           "Keep on trucking.",
@@ -129,26 +143,33 @@ module Rerun
           "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
+      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
+      Signal.trap("TERM") do # TERM is the polite way of terminating a process
         die
       end
 
@@ -174,28 +195,47 @@ module Rerun
       end
 
       unless @watcher
-
-        watcher = Watcher.new(:directory => dirs, :pattern => pattern) do |changes|
-
-          message = [:modified, :added, :removed].map do |change|
-            count = changes[change].size
-            if count and count > 0
-              "#{count} #{change}"
-            end
-          end.compact.join(", ")
+        watcher = Watcher.new(@options) do |changes|
+          message = change_message(changes)
           say "Change detected: #{message}"
           restart unless @restarting
         end
         watcher.start
         @watcher = watcher
-        say "Watching #{dir.join(', ')} for #{pattern} using #{watcher.adapter.class.name.split('::').last} adapter"
+        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
+      exit 0 # todo: status code param
     end
 
     def join
@@ -203,40 +243,63 @@ module Rerun
     end
 
     def running?
-      signal(0)
+      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
 
-    def signal(signal)
-      say "Sending signal #{signal} to #{@pid}" unless signal == 0
+    # 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
+    rescue => e
+      say "Signal #{signal} failed: #{e.class}: #{e.message}" if verbose?
       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(4) do  # todo: escalation timeout setting
-            # start with a polite SIGTERM
-            signal(default_signal) && Process.wait(@pid)
-          end
-        rescue Timeout::Error
-          begin
-            timeout(2) 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
+        @options[:signal].split(',').each do |signal|
+          success = signal_and_wait(signal)
+          return true if success
         end
       end
-    rescue => e
+    rescue
       false
     end
 
@@ -251,20 +314,25 @@ module Rerun
       @git_head = File.exists?(git_head_file) && File.read(git_head_file)
     end
 
-    def notify(title, body)
-      growl title, body if @options[:growl]
+    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}"
+      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
 
@@ -274,15 +342,10 @@ module Rerun
         # 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
+        stty "raw opost"
+        one_char
       ensure
-        system "stty -raw" # turn raw input off
+        stty "-raw" # turn raw input off
       end
 
       # note: according to 'man tty' the proper way restore the settings is
@@ -291,7 +354,6 @@ module Rerun
       #   system 'stty "#{tty_state}'
       # end
       # but this way seems fine and less confusing
-
     end
 
     def clear_screen
@@ -299,5 +361,14 @@ module Rerun
       $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

data/lib/rerun/system.rb

@@ -6,38 +6,16 @@ module Rerun
     end
 
     def windows?
-       RUBY_PLATFORM =~ /mswin/i
+       RUBY_PLATFORM =~ /(mswin|mingw32)/i
     end
 
     def linux?
        RUBY_PLATFORM =~ /linux/i
     end
 
-    # do we have growl or not?
-    def growl_available?
-      mac? && (growlcmd != "")
-    end
-
-    def growlcmd
-      growlnotify = `which growlnotify`.chomp
-      # todo: check version of growlnotify and warn if it's too old
-      growlnotify
-    end
-
-    def icon
-      here = File.expand_path(File.dirname(__FILE__))
-      icondir = File.expand_path("#{here}/../../icons")
+    def rails?
       rails_sig_file = File.expand_path(".")+"/config/boot.rb"
-      "#{icondir}/rails_red_sml.png" if File.exists? rails_sig_file
-    end
-
-    def growl(title, body, background = true)
-      if growl_available?
-        icon_str = ("--image \"#{icon}\"" if icon)
-        s = "#{growlcmd} -n \"#{app_name}\" -m \"#{body}\" \"#{app_name} #{title}\" #{icon_str}"
-        s += " &" if background
-        `#{s}`
-      end
+      File.exists? rails_sig_file
     end
 
   end

data/lib/rerun/watcher.rb

@@ -14,7 +14,11 @@ module Rerun
   class Watcher
     InvalidDirectoryError = Class.new(RuntimeError)
 
-    attr_reader :directory, :pattern, :priority
+    #def self.default_ignore
+    #  Listen::Silencer.new(Listen::Listener.new).send :_default_ignore_patterns
+    #end
+
+    attr_reader :directory, :pattern, :priority, :ignore_dotfiles
 
     # Create a file system watcher. Start it by calling #start.
     #
@@ -29,12 +33,16 @@ module Rerun
           :directory => ".",
           :pattern => "**/*",
           :priority => 0,
+          :ignore_dotfiles => true,
       }.merge(options)
 
       @pattern = options[:pattern]
       @directories = options[:directory]
       @directories = sanitize_dirs(@directories)
       @priority = options[:priority]
+      @force_polling = options[:force_polling]
+      @ignore = [options[:ignore]].flatten.compact
+      @ignore_dotfiles = options[:ignore_dotfiles]
       @thread = nil
     end
 
@@ -55,10 +63,9 @@ module Rerun
       end
 
       @thread = Thread.new do
-        regexp = Rerun::Glob.new(@pattern).to_regexp
-        dotfiles = /^\.[^.]/  # at beginning of string, a real dot followed by any other character
-        @listener = Listen.to(*@directories, only: regexp, ignore: dotfiles, wait_for_delay: 1) do |modified, added, removed|
-          if((modified.size + added.size + removed.size) > 0)
+        @listener = Listen.to(*@directories, only: watching, ignore: ignoring, wait_for_delay: 1, force_polling: @force_polling) do |modified, added, removed|
+          count = modified.size + added.size + removed.size
+          if count > 0
             @client_callback.call(:modified => modified, :added => added, :removed => removed)
           end
         end
@@ -72,11 +79,16 @@ module Rerun
       at_exit { stop } # try really hard to clean up after ourselves
     end
 
-    def adapter
-      @listener.registry[:adapter] || (timeout(4) do
-        sleep 1 until adapter = @listener.registry[:adapter]
-        adapter
-      end)
+    def watching
+      Rerun::Glob.new(@pattern).to_regexp
+    end
+
+    def ignoring
+      patterns = []
+      if ignore_dotfiles
+        patterns << /^\.[^.]/ # at beginning of string, a real dot followed by any other character
+      end
+      patterns + @ignore.map { |x| Rerun::Glob.new(x).to_regexp }
     end
 
     # kill the file watcher thread
@@ -93,7 +105,7 @@ module Rerun
     # wait for the file watcher to finish
     def join
       @thread.join if @thread
-    rescue Interrupt => e
+    rescue Interrupt
       # don't care
     end
 
@@ -102,12 +114,21 @@ module Rerun
     end
 
     def unpause
-      @listener.unpause if @listener
+      @listener.start if @listener
     end
 
     def running?
-      @listener && @listener.instance_variable_get(:@adapter)
+      @listener && @listener.processing?
     end
 
+    def adapter
+      @listener &&
+          (backend = @listener.instance_variable_get(:@backend)) &&
+          backend.instance_variable_get(:@adapter)
+    end
+
+    def adapter_name
+      adapter && adapter.class.name.split('::').last
+    end
   end
 end

data/rerun.gemspec

@@ -3,7 +3,7 @@ $spec = Gem::Specification.new do |s|
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
 
   s.name = 'rerun'
-  s.version = '0.9.0'
+  s.version = '0.13.1'
 
   s.description = "Restarts your app when a file changes. A no-frills, command-line alternative to Guard, Shotgun, Autotest, etc."
   s.summary     = "Launches an app, and restarts it whenever the filesystem changes. A no-frills, command-line alternative to Guard, Shotgun, Autotest, etc."
@@ -25,7 +25,7 @@ $spec = Gem::Specification.new do |s|
 
   s.extra_rdoc_files = %w[README.md]
 
-  s.add_dependency 'listen', '~> 2.7'
+  s.add_runtime_dependency 'listen', '~> 3.0'
 
   s.homepage = "http://github.com/alexch/rerun/"
   s.require_paths = %w[lib]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rerun
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.13.1
 platform: ruby
 authors:
 - Alex Chaffee
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-03-06 00:00:00.000000000 Z
+date: 2020-12-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: listen
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.7'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.7'
+        version: '3.0'
 description: Restarts your app when a file changes. A no-frills, command-line alternative
   to Guard, Shotgun, Autotest, etc.
 email: alex@stinky.com
@@ -39,8 +39,10 @@ files:
 - bin/rerun
 - icons/rails_grn_sml.png
 - icons/rails_red_sml.png
+- lib/goo.rb
 - lib/rerun.rb
 - lib/rerun/glob.rb
+- lib/rerun/notification.rb
 - lib/rerun/options.rb
 - lib/rerun/runner.rb
 - lib/rerun/system.rb
@@ -50,7 +52,7 @@ homepage: http://github.com/alexch/rerun/
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -65,9 +67,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 2
 summary: Launches an app, and restarts it whenever the filesystem changes. A no-frills,
   command-line alternative to Guard, Shotgun, Autotest, etc.