poll-rerun 0.11.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: afdc9586c6a6101dea11606085d1d10fc0887d60
+  data.tar.gz: c8129748d4c63516fd44e28c2ff8c728515c788c
+SHA512:
+  metadata.gz: 4c33ce48a27db3773cd195621f3682d0b3e395d494f939bac3cfcb84155cfa414a2d87f180f7ef82a655f6e26347b93a3a29db387702b79ee798fe7a8a18bca2
+  data.tar.gz: 9b74cab2dae5b506441edfeb8f88b12f3b5768cab495a0b66a108a98fa8d989224fd473c9a9acda0a1678a0394539d61a7423d738313eaa9847888496116b0e7

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,377 @@
+# Rerun
+
+This is a fork of the original rerun available here:
+<http://github.com/alexch/rerun>
+
+The only difference between this version and the original is the versioning that also includes the `--force-polling` flag.
+
+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 it watches files ending in: `rb,js,coffee,css,scss,sass,erb,html,haml,ru,yml,slim,md,feature`.
+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,coffee,css,scss,sass,erb,html,haml,ru,yml,slim,md,feature`.
+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`)
+
+`--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)
+
+`--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
+
+`--notify NOTIFIER` use `growl` or `osx` for notifications (see below)
+
+`--no-notify` don't use growl (or osx) notifications
+
+`--name` set the app name (for display)
+
+`--force-polling` use polling instead of a native filesystem scan (useful for Vagrant)
+
+Also `--version` and `--help`, naturally.
+
+# Notifications
+
+If you have `growlnotify` available on the `PATH`, it sends notifications to
+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 both, Rerun will pick one, or you can choose between them using `--notify growl` or `--notify osx` respectively.
+
+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-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.
+
+# 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
+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:
+
+## 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
+* see also [todo.md](todo.md)
+
+## 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
+    * "Failed" icon for notifications
+* 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>
+* 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>
+
+# Version History
+
+*
+  * `--force-polling` option (thanks ajduncan)
+
+* 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
+  * 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/goo.rb

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

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/notification.rb

@@ -0,0 +1,64 @@
+# 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
+      return unless mac?
+
+      # 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
+
+      s
+    end
+
+    def command_named(name)
+      path = `which #{name}`.chomp
+      path.empty? ? nil : path
+    end
+
+    def send(background = true)
+      return unless command
+      `#{command}#{" &" if background}`
+    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
+
+  end
+end