poll-rerun 0.11.1

data/lib/rerun/options.rb

@@ -0,0 +1,124 @@
+require 'optparse'
+require 'pathname'
+require 'rerun/watcher'
+
+libdir = "#{File.expand_path(File.dirname(File.dirname(__FILE__)))}"
+
+$spec = Gem::Specification.load(File.join(libdir, "..", "rerun.gemspec"))
+
+module Rerun
+  class Options
+    DEFAULT_PATTERN = "**/*.{rb,js,coffee,css,scss,sass,erb,html,haml,ru,yml,slim,md,feature}"
+    DEFAULT_DIRS = ["."]
+
+    DEFAULTS = {
+        :pattern => DEFAULT_PATTERN,
+        :signal => "TERM",
+        :notify => true,
+        :name => Pathname.getwd.basename.to_s.capitalize,
+        :ignore => [],
+        :dir => DEFAULT_DIRS,
+        :force_polling => false,
+    }
+
+    def self.parse args = ARGV
+
+      default_options = DEFAULTS.dup
+      options = {
+          ignore: []
+      }
+
+      opts = OptionParser.new("", 24, '  ') do |opts|
+        opts.banner = "Usage: rerun [options] [--] cmd"
+
+        opts.separator ""
+        opts.separator "Launches an app, and restarts it when the filesystem changes."
+        opts.separator "See http://github.com/alexch/rerun for more info."
+        opts.separator "Version: #{$spec.version}"
+        opts.separator ""
+        opts.separator "Options:"
+
+        opts.on("-d dir", "--dir dir", "directory to watch, default = \"#{DEFAULT_DIRS}\".  Specify multiple paths with ',' or separate '-d dir' option pairs.") do |dir|
+          elements = dir.split(",")
+          options[:dir] = (options[:dir] || []) + elements
+        end
+
+        # todo: rename to "--watch"
+        opts.on("-p pattern", "--pattern pattern", "file glob to watch, default = \"#{DEFAULTS[:pattern]}\"") do |pattern|
+          options[:pattern] = pattern
+        end
+
+        opts.on("-i pattern", "--ignore pattern", "file glob to ignore (can be set many times). To ignore a directory, you must append '/*' e.g. --ignore 'coverage/*'") do |pattern|
+          options[:ignore] += [pattern]
+        end
+
+        opts.on("-s signal", "--signal signal", "terminate process using this signal, default = \"#{DEFAULTS[:signal]}\"") do |signal|
+          options[:signal] = signal
+        end
+
+        opts.on("-r", "--restart", "expect process to restart itself (uses the HUP signal unless overridden using --signal)") do |signal|
+          options[:restart] = true
+          default_options[:signal] = "HUP"
+        end
+
+        opts.on("-c", "--clear", "clear screen before each run") do
+          options[:clear] = true
+        end
+
+        opts.on("-x", "--exit", "expect the program to exit. With this option, rerun checks the return value; without it, rerun checks that the process is running.") do |dir|
+          options[:exit] = true
+        end
+
+        opts.on("-b", "--background", "disable on-the-fly commands, allowing the process to be backgrounded") do
+          options[:background] = true
+        end
+
+        opts.on("-n name", "--name name", "name of app used in logs and notifications, default = \"#{DEFAULTS[:name]}\"") do |name|
+          options[:name] = name
+        end
+
+        opts.on("--force-polling", "use polling instead of a native filesystem scan (useful for Vagrant)") do
+          options[:force_polling] = true
+        end
+
+        opts.on("--no-growl", "don't use growl [OBSOLETE]") do
+          options[:growl] = false
+          $stderr.puts "--no-growl is obsolete; use --no-notify instead"
+          return
+        end
+
+        opts.on("--[no-]notify [notifier]", "send messages through growl (requires growlnotify) or osx (requires terminal-notifier gem)") do |notifier|
+          notifier = true if notifier.nil?
+          options[:notify] = notifier
+        end
+
+        opts.on_tail("-h", "--help", "--usage", "show this message") do
+          puts opts
+          return
+        end
+
+        opts.on_tail("--version", "show version") do
+          puts $spec.version
+          return
+        end
+
+        opts.on_tail ""
+        opts.on_tail "On top of --pattern and --ignore, we ignore any changes to files and dirs starting with a dot."
+
+      end
+
+      if args.empty?
+        puts opts
+        nil
+      else
+        opts.parse! args
+        default_options[:cmd] = args.join(" ")
+
+        options = default_options.merge(options)
+
+        options
+      end
+    end
+
+  end
+end

data/lib/rerun/runner.rb

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

data/lib/rerun/system.rb

@@ -0,0 +1,22 @@
+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
+
+    def rails?
+      rails_sig_file = File.expand_path(".")+"/config/boot.rb"
+      File.exists? rails_sig_file
+    end
+
+  end
+end

data/lib/rerun/watcher.rb

@@ -0,0 +1,130 @@
+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]
+      @force_polling = options[:force_polling]
+      @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, force_polling: @force_polling) 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 }
+    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.start if @listener
+    end
+
+    def running?
+      @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/lib/rerun.rb

@@ -0,0 +1,15 @@
+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/notification"
+require "rerun/runner"
+require "rerun/watcher"
+require "rerun/glob"
+
+module Rerun
+
+end
+

data/poll-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 = 'poll-rerun'
+  s.version = '0.11.1'
+
+  s.description = "Fork of the original rerun gem but with a 'released' --force-polling flag available. Restarts your app when a file changes. A no-frills, command-line alternative to Guard, Shotgun, Autotest, etc."
+  s.summary     = "Fork of original rerun, but with 'released' --force-polling flag. 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
+    poll-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', '~> 3.0'
+
+  s.homepage = "http://github.com/hawry/rerun"
+  s.require_paths = %w[lib]
+
+  s.license = 'MIT'
+end