rerun-cj 0.10.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 27c6fa79f508fe873f0c236c273ea18346eadd9e
+  data.tar.gz: d79d590d3158eb9182b7790d040cb5598a58a6b4
+SHA512:
+  metadata.gz: 4dddd98b58c3b26fcf6a3aebd2e7b965b2f827ad847f22ed5505e779355e08af7a4e5eb5ab79521fc7ff9a3dc1af7532ef6b8785eca95dd2c0bc38e10970f197
+  data.tar.gz: d437f2c29d6cba96f88d41aad99004b964b4e7f8c14b3c880cb77785ff39c4ed20410631cf464d1a9d607b6e843b2d37514514f762f60b0c479515c5a5dbe641

data/LICENSE

@@ -0,0 +1,34 @@
+Rerun
+Copyright (c) 2009 Alex Chaffee <alex@stinky.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to
+deal in the Software without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+---
+
+rerun partially based on code from Rspactor
+Copyright (c) 2009 Mislav Marohnić
+License as above (MIT open source).
+
+rerun partially based on code from FileSystemWatcher
+http://paulhorman.com/filesystemwatcher/
+No license provided; assumed public domain.
+
+rerun partially based on code from Shotgun
+Copyright (c) 2009 Ryan Tomayko <tomayko.com/about>
+License as above (MIT open source).
+

data/README.md

@@ -0,0 +1,330 @@
+# Rerun
+
+<http://github.com/alexch/rerun>
+
+Rerun launches your program, then watches the filesystem. If a relevant file
+changes, then it restarts your program.
+
+Rerun works for both long-running processes (e.g. apps) and short-running ones
+(e.g. tests). It's basically a no-frills command-line alternative to Guard,
+Shotgun, Autotest, etc. that doesn't require config files and works on any
+command, not just Ruby programs.
+
+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,coffee,scss,sass,erb,html,haml,ru,slim,md}` files are watched.
+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".
+
+# Installation:
+
+        gem install rerun
+
+("sudo" may be required on older systems, but try it without sudo first.)
+
+If you are using RVM you might want to put this in your global gemset so it's
+available to all your apps. (There really should be a better way to distinguish
+gems-as-libraries from gems-as-tools.)
+
+        rvm @global do gem install rerun
+
+The Listen gem looks for certain platform-dependent gems, and will complain if
+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
+
+        gem install rb-fsevent
+
+# Usage:
+
+        rerun [options] [--] cmd
+
+For example, if you're running a Sinatra app whose main file is `app.rb`:
+
+        rerun ruby app.rb
+
+If the first part of the command is a `.rb` filename, then `ruby` is
+optional, so the above can also be accomplished like this:
+
+        rerun app.rb
+
+Rails doesn't automatically notice all config file changes, so you can force it
+to restart when you change a config file like this:
+
+        rerun --dir config rails s
+
+Or if you're using Thin to run a Rack app that's configured in config.ru
+but you want it on port 4000 and in debug mode, and only want to watch
+the `app` and `web` subdirectories:
+
+        rerun --dir app,web -- thin start --debug --port=4000 -R config.ru
+
+The `--` is to separate rerun options from cmd options. You can also
+use a quoted string for the command, e.g.
+
+        rerun --dir app "thin start --debug --port=4000 -R config.ru"
+
+Rackup can also be used to launch a Rack server, so let's try that:
+
+        rerun -- rackup --port 4000 config.ru
+
+Want to mimic [autotest](https://github.com/grosser/autotest)? Try
+
+        rerun -x rake
+
+or
+
+        rerun -cx rspec
+
+And if you're using [Spork](https://github.com/sporkrb/spork) with Rails, you
+need to [restart your spork server](https://github.com/sporkrb/spork/issues/201)
+whenever certain Rails environment files change, so why not put this in your
+Rakefile...
+
+    desc "run spork (via rerun)"
+    task :spork do
+      sh "rerun --pattern '{Gemfile,Gemfile.lock,spec/spec_helper.rb,.rspec,spec/factories/**,config/environment.rb,config/environments/test.rb,config/initializers/*.rb,lib/**/*.rb}' -- spork"
+    end
+
+and start using `rake spork` to launch your spork server?
+
+(If you're using Guard instead of Rerun, check out
+[guard-spork](https://github.com/guard/guard-spork)
+for a similar solution.)
+
+How about regenerating your HTML files after every change to your
+[Erector](http://erector.rubyforge.org) widgets?
+
+        rerun -x erector --to-html my_site.rb
+
+Use Heroku Cedar? `rerun` is now compatible with `foreman`. Run all your
+Procfile processes locally and restart them all when necessary.
+
+        rerun foreman start
+
+# Options:
+
+`--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,coffee,scss,sass,erb,html,haml,ru,slim,md`.
+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/*'`.
+
+  *On top of --pattern and --ignore, we ignore any changes to files and dirs starting with a dot.*
+
+`--signal` (or -s) use specified signal (instead of the default SIGTERM) to terminate the previous process.
+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
+
+`--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.
+
+`--background` (or -b) disable on-the-fly commands, allowing the process to be backgrounded
+
+`--no-growl` don't use growl
+
+`--name` set the app name (for display)
+
+Also `--version` and `--help`, naturally.
+
+# Growl 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.
+
+Download [growlnotify here](http://growl.info/downloads.php#generaldownloads)
+now that Growl has moved to the App Store.
+
+# 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)
+* **c** -- clear the screen
+* **x** or **q** -- exit (just like control-C)
+* **p** -- pause/unpause filesystem watching
+
+If you're backgrounding or using Pry or a debugger, you might not want these
+keys to be trapped, so use the `--background` option.
+
+# Signals
+
+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 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
+restart.
+
+# To Do:
+
+## Must have for v1.0
+* ".rerun" file to specify options per project or in $HOME.
+* 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
+* Smarter --signal option (specifying signal to try and a timeout to wait, repeated)
+* If the last element of the command is a `.ru` file and there's no other command then use `rackup`
+* 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
+
+## Wacky Ideas
+* Make it work on Windows, like Guard now does. See
+  * https://github.com/guard/guard/issues/59
+  * https://github.com/guard/guard/issues/27
+* 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
+
+* 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?
+
+Shotgun does a "fork" after the web framework has loaded but before
+your application is loaded. It then loads your app, processes a
+single request in the child process, then exits the child process.
+
+Rerun launches the whole app, then when it's time to restart, uses
+"kill" to shut it down and starts the whole thing up again from
+scratch.
+
+So rerun takes somewhat longer than Shotgun to restart the app, but
+does it much less frequently. And once it's running it behaves more
+normally and consistently with your production app.
+
+Also, Shotgun reloads the app on every request, even if it doesn't
+need to. This is fine if you're loading a single file, but if your web
+pages all load other files (CSS, JS, media) then that adds up quickly.
+(I can only assume that the developers of shotgun are using caching or a
+front web server so this isn't a pain point for them.)
+
+And hey, does Shotgun reload your Worker processes if you're using Foreman and
+a Procfile? I'm pretty sure it doesn't.
+
+YMMV!
+
+# Why would I use this instead of Rack::Reloader?
+
+Rack::Reloader is certifiably beautiful code, and is a very elegant use
+of Rack's middleware architecture. But because it relies on the
+LOADED_FEATURES variable, it only reloads .rb files that were 'require'd,
+not 'load'ed. That leaves out (non-Erector) template files, and also,
+at least the way I was doing it, sub-actions (see
+[this thread](http://groups.google.com/group/sinatrarb/browse_thread/thread/7329727a9296e96a#
+)).
+
+Rack::Reloader also doesn't reload configuration changes or redo other
+things that happen during app startup. Rerun takes the attitude that if
+you want to restart an app, you should just restart the whole app. You know?
+
+# Why would I use this instead of Guard?
+
+Guard is very powerful but requires some up-front configuration.
+Rerun is meant as a no-frills command-line alternative requiring no knowledge
+of Ruby nor config file syntax.
+
+# Why did you write this?
+
+I've been using [Sinatra](http://sinatrarb.com) and loving it. In order
+to simplify their system, the Rat Pack removed auto-reloading from
+Sinatra proper. I approve of this: a web application framework should be
+focused on serving requests, not on munging Ruby ObjectSpace for
+dev-time convenience. But I still wanted automatic reloading during
+development. Shotgun wasn't working for me (see above) so I spliced
+Rerun together out of code from Rspactor, FileSystemWatcher, and Shotgun
+-- with a heavy amount of refactoring and rewriting. In late 2012 I
+migrated the backend to the Listen gem, which was extracted from Guard,
+so it should be more reliable and performant on multiple platforms.
+
+# Credits
+
+Rerun: [Alex Chaffee](http://alexchaffee.com), <mailto:alex@stinky.com>, <http://github.com/alexch/>
+
+Based upon and/or inspired by:
+
+* Shotgun: <http://github.com/rtomayko/shotgun>
+* Rspactor: <http://github.com/mislav/rspactor>
+  * (In turn based on http://rails.aizatto.com/2007/11/28/taming-the-autotest-beast-with-fsevents/ )
+* FileSystemWatcher: <http://paulhorman.com/filesystemwatcher/>
+
+## Patches by:
+
+* David Billskog <billskog@gmail.com>
+* Jens B <https://github.com/dpree>
+* Andrés Botero <https://github.com/anbotero>
+* Dreamcat4
+* <https://github.com/FND>
+* Barry Sia <https://github.com/bsia>
+* Paul Rangel <https://github.com/ismell>
+
+# Version History
+
+* ?
+  * better 'changed' message
+
+* 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
+  * bugfix, forcing Rerun to use Listen v1.0.3 while we work out the troubles we're having with Listen 1.3 and 2.1
+
+* v0.8.1
+  * bugfix release (#30 and #34)
+
+* v0.8.0
+  * --background option (thanks FND!) to disable the keyboard listener
+  * --signal option (thanks FND!)
+  * --no-growl option
+  * --dir supports multiple directories (thanks Barry!)
+
+* v0.7.1
+  * bugfix: make rails icon work again
+
+* v0.7.0
+  * uses Listen gem (which uses rb-fsevent for lightweight filesystem snooping)
+
+# License
+
+Open Source MIT License. See "LICENSE" file.

data/Rakefile

@@ -0,0 +1,82 @@
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'rspec/core/rake_task'
+
+task :default => [:spec]
+task :test => :spec
+
+desc "Run all specs"
+RSpec::Core::RakeTask.new('spec') do |t|
+  ENV['ENV'] = "test"
+  t.pattern = 'spec/**/*_spec.rb'
+  t.rspec_opts = ['--color']
+end
+
+$rubyforge_project = 'pivotalrb'
+
+$spec =
+  begin
+    require 'rubygems/specification'
+    data = File.read('rerun.gemspec')
+    spec = nil
+    #Thread.new { spec = eval("$SAFE = 3\n#{data}") }.join
+    spec = eval data
+    spec
+  end
+
+def package(ext='')
+  "pkg/#{$spec.name}-#{$spec.version}" + ext
+end
+
+desc 'Exit if git is dirty'
+task :check_git do
+  state = `git status 2> /dev/null | tail -n1`
+  clean = (state =~ /working directory clean/)
+  unless clean
+    warn "can't do that on an unclean git dir"
+    exit 1
+  end
+end
+
+desc 'Build packages'
+task :package => %w[.gem .tar.gz].map { |e| package(e) }
+
+desc 'Build and install as local gem'
+task :install => package('.gem') do
+  sh "gem install #{package('.gem')}"
+end
+
+directory 'pkg/'
+CLOBBER.include('pkg')
+
+file package('.gem') => %W[pkg/ #{$spec.name}.gemspec] + $spec.files do |f|
+  sh "gem build #{$spec.name}.gemspec"
+  mv File.basename(f.name), f.name
+end
+
+file package('.tar.gz') => %w[pkg/] + $spec.files do |f|
+  cmd = <<-SH
+    git archive \
+      --prefix=#{$spec.name}-#{$spec.version}/ \
+      --format=tar \
+      HEAD | gzip > #{f.name}
+  SH
+  sh cmd.gsub(/ +/, ' ')
+end
+
+desc 'Publish gem and tarball to rubyforge'
+task 'release' => [:check_git, package('.gem'), package('.tar.gz')] do |t|
+  puts "Releasing #{$spec.version}"
+  sh "gem push #{package('.gem')}"
+  puts "Tagging and pushing"
+  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

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+libdir = "#{File.expand_path(File.dirname(File.dirname(__FILE__)))}/lib"
+$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)

data/lib/rerun/glob.rb

@@ -0,0 +1,85 @@
+# based on http://cpan.uwinnipeg.ca/htdocs/Text-Glob/Text/Glob.pm.html#glob_to_regex_string-
+
+# todo: release as separate gem
+#
+module Rerun
+  class Glob
+    NO_LEADING_DOT = '(?=[^\.])'   # todo
+    START_OF_FILENAME = '(\A|\/)'  # beginning of string or a slash
+    END_OF_STRING = '\z'
+
+    def initialize glob_string
+      @glob_string = glob_string
+    end
+
+    def to_regexp_string
+      chars = @glob_string.split('')
+
+      chars = smoosh(chars)
+
+      curlies = 0
+      escaping = false
+      string = chars.map do |char|
+        if escaping
+          escaping = false
+          char
+        else
+          case char
+            when '**'
+              "([^/]+/)*"
+            when '*'
+              ".*"
+            when "?"
+              "."
+            when "."
+              "\\."
+
+            when "{"
+              curlies += 1
+              "("
+            when "}"
+              if curlies > 0
+                curlies -= 1
+                ")"
+              else
+                char
+              end
+            when ","
+              if curlies > 0
+                "|"
+              else
+                char
+              end
+            when "\\"
+              escaping = true
+              "\\"
+
+            else
+              char
+
+          end
+        end
+      end.join
+      START_OF_FILENAME + string + END_OF_STRING
+    end
+
+    def to_regexp
+      Regexp.new(to_regexp_string)
+    end
+
+    def smoosh chars
+      out = []
+      until chars.empty?
+        char = chars.shift
+        if char == "*" and chars.first == "*"
+          chars.shift
+          chars.shift if chars.first == "/"
+          out.push("**")
+        else
+          out.push(char)
+        end
+      end
+      out
+    end
+  end
+end

data/lib/rerun/options.rb

@@ -0,0 +1,99 @@
+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}"
+    DEFAULT_DIRS = ["."]
+
+    DEFAULTS = {
+        :pattern => DEFAULT_PATTERN,
+        :signal => "TERM",
+        :growl => true,
+        :name => Pathname.getwd.basename.to_s.capitalize,
+        :ignore => []
+    }
+
+    def self.parse args = ARGV
+      options = DEFAULTS.dup
+      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("-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") do
+          options[:growl] = false
+        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
+        options[:cmd] = args.join(" ")
+        options[:dir] ||= DEFAULT_DIRS
+        options
+      end
+    end
+
+  end
+end

data/lib/rerun/runner.rb

@@ -0,0 +1,324 @@
+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
+      stop
+      start
+      @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 start
+      if windows?
+        raise "Sorry, Rerun does not work on Windows."
+      end
+
+      if (!@already_running)
+        taglines = [
+          "To infinity... and beyond!",
+          "Charge!",
+        ]
+        notify "launched", taglines[rand(taglines.size)]
+        @already_running = true
+      else
+        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)]
+      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(',')})") +
+                " using #{watcher.adapter.class.name.split('::').last} adapter"
+      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)
+      growl title, body if @options[:growl]
+      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

data/lib/rerun/system.rb

@@ -0,0 +1,44 @@
+module Rerun
+  module System
+
+    def mac?
+      RUBY_PLATFORM =~ /darwin/i
+    end
+
+    def windows?
+       RUBY_PLATFORM =~ /mswin/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")
+      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
+    end
+
+  end
+end

data/lib/rerun/watcher.rb

@@ -0,0 +1,127 @@
+require 'listen'
+
+Thread.abort_on_exception = true
+
+# This class will watch a directory and alert you of
+# new files, modified files, deleted files.
+#
+# Now uses the Listen gem, but spawns its own thread on top.
+# We should probably be accessing the Listen thread directly.
+#
+# Author: Alex Chaffee
+#
+module Rerun
+  class Watcher
+    InvalidDirectoryError = Class.new(RuntimeError)
+
+    #def self.default_ignore
+    #  Listen::Silencer.new(Listen::Listener.new).send :_default_ignore_patterns
+    #end
+
+    attr_reader :directory, :pattern, :priority
+
+    # Create a file system watcher. Start it by calling #start.
+    #
+    # @param options[:directory] the directory to watch (default ".")
+    # @param options[:pattern] the glob pattern to search under the watched directory (default "**/*")
+    # @param options[:priority] the priority of the watcher thread (default 0)
+    #
+    def initialize(options = {}, &client_callback)
+      @client_callback = client_callback
+
+      options = {
+          :directory => ".",
+          :pattern => "**/*",
+          :priority => 0,
+      }.merge(options)
+
+      @pattern = options[:pattern]
+      @directories = options[:directory]
+      @directories = sanitize_dirs(@directories)
+      @priority = options[:priority]
+      @ignore = [options[:ignore]].flatten.compact
+      @thread = nil
+    end
+
+    def sanitize_dirs(dirs)
+      dirs = [*dirs]
+      dirs.map do |d|
+        d.chomp!("/")
+        unless FileTest.exists?(d) && FileTest.readable?(d) && FileTest.directory?(d)
+          raise InvalidDirectoryError, "Directory '#{d}' either doesnt exist or isn't readable"
+        end
+        File.expand_path(d)
+      end
+    end
+
+    def start
+      if @thread then
+        raise RuntimeError, "already started"
+      end
+
+      @thread = Thread.new do
+        @listener = Listen.to(*@directories, only: watching, ignore: ignoring, wait_for_delay: 1) do |modified, added, removed|
+          if((modified.size + added.size + removed.size) > 0)
+            @client_callback.call(:modified => modified, :added => added, :removed => removed)
+          end
+        end
+        @listener.start
+      end
+
+      @thread.priority = @priority
+
+      sleep 0.1 until @listener
+
+      at_exit { stop } # try really hard to clean up after ourselves
+    end
+
+    def watching
+      Rerun::Glob.new(@pattern).to_regexp
+    end
+
+    def ignoring
+      # todo: --no-ignore-dotfiles
+      # dotfiles = /^\.[^.]/ # at beginning of string, a real dot followed by any other character
+      # [dotfiles] + @ignore.map { |x| Rerun::Glob.new(x).to_regexp }
+      @ignore.map { |x| Rerun::Glob.new(x).to_regexp }
+    end
+
+    def adapter
+      @listener.registry[:adapter] || (timeout(4) do
+        sleep 1 until adapter = @listener.registry[:adapter]
+        adapter
+      end)
+    end
+
+    # kill the file watcher thread
+    def stop
+      @thread.wakeup rescue ThreadError
+      begin
+        @listener.stop
+      rescue Exception => e
+        puts "#{e.class}: #{e.message} stopping listener"
+      end
+      @thread.kill rescue ThreadError
+    end
+
+    # wait for the file watcher to finish
+    def join
+      @thread.join if @thread
+    rescue Interrupt => e
+      # don't care
+    end
+
+    def pause
+      @listener.pause if @listener
+    end
+
+    def unpause
+      @listener.unpause if @listener
+    end
+
+    def running?
+      @listener && @listener.instance_variable_get(:@adapter)
+    end
+
+  end
+end

data/lib/rerun.rb

@@ -0,0 +1,14 @@
+here = File.expand_path(File.dirname(__FILE__))
+$: << here unless $:.include?(here)
+
+require "listen"  # pull in the Listen gem
+require "rerun/options"
+require "rerun/system"
+require "rerun/runner"
+require "rerun/watcher"
+require "rerun/glob"
+
+module Rerun
+
+end
+

data/rerun.gemspec

@@ -0,0 +1,34 @@
+$spec = Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+
+  s.name = 'rerun-cj'
+  s.version = '0.10.0'
+
+  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."
+
+  s.authors = ["Alex Chaffee"]
+  s.email = "alex@stinky.com"
+
+  s.files = %w[
+    README.md
+    LICENSE
+    Rakefile
+    rerun.gemspec
+    bin/rerun
+    icons/rails_grn_sml.png
+    icons/rails_red_sml.png] +
+      Dir['lib/**/*.rb']
+  s.executables = ['rerun']
+  s.test_files = s.files.select {|path| path =~ /^spec\/.*_spec.rb/}
+
+  s.extra_rdoc_files = %w[README.md]
+
+  s.add_runtime_dependency 'listen', '~> 2.7', '>= 2.7.3'
+
+  s.homepage = "http://github.com/alexch/rerun/"
+  s.require_paths = %w[lib]
+
+  s.license = 'MIT'
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: rerun-cj
+version: !ruby/object:Gem::Version
+  version: 0.10.0
+platform: ruby
+authors:
+- Alex Chaffee
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: listen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.7.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.7.3
+description: Restarts your app when a file changes. A no-frills, command-line alternative
+  to Guard, Shotgun, Autotest, etc.
+email: alex@stinky.com
+executables:
+- rerun
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- LICENSE
+- README.md
+- Rakefile
+- bin/rerun
+- icons/rails_grn_sml.png
+- icons/rails_red_sml.png
+- lib/rerun.rb
+- lib/rerun/glob.rb
+- lib/rerun/options.rb
+- lib/rerun/runner.rb
+- lib/rerun/system.rb
+- lib/rerun/watcher.rb
+- rerun.gemspec
+homepage: http://github.com/alexch/rerun/
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.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.
+test_files: []