alexch-rerun 0.2.1

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,109 @@
+# Rerun
+
+<http://github.com/alexch/rerun>
+
+Launches your app, then watches the filesystem. If a relevant file
+changes, then it restarts your app.
+
+Currently only *.rb files are watched, anywhere under the current
+directory (.). This is pretty lame so it will change soon.
+
+If you're on Mac OS X, it uses the built-in facilities for monitoring
+the filesystem, so CPU use is very light.
+
+If you have "growlcmd" available on the PATH, it sends notifications
+to growl in addition to the console.
+
+# Installation:
+
+        sudo gem install rerun
+
+If you want to use the latest version, grab it off Github:
+
+        gem sources -a http://gems.github.com/
+        sudo gem install alexch-rerun
+
+I'll bump the version on Github for release candidates, and deploy to
+Rubyforge only when it's had some time to bake.
+
+# Usage: 
+
+        rerun [options] cmd
+
+For example, if you're running a Sinatra app whose main file is
+app.rb:
+
+        rerun app.rb
+        
+Or if you're running a Rack app that's configured in config.ru
+but you want it on port 4000 and in debug mode:
+
+        rerun "thin start --debug --port=4000 -R config.ru"        
+
+# Options:
+
+Only --version and --help so far.
+
+# To Do:
+
+* If the cmd is, or starts with, a ".rb" file, then run it with ruby
+* Allow arbitrary sets of directories and file types, possibly with "include" and "exclude" sets
+* ".rerun" file to specify options per project or in $HOME.
+* Test on Windows and Linux.
+
+# 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>
+
+# 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 my web
+pages all load other files (CSS, JS, media) and that adds up quickly.
+The developers of shotgun are probably using caching or a front web
+server so this doesn't affect them too much.
+
+YMMV!
+
+# 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 just 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.
+
+# Credits
+
+Rerun: Alex Chaffee, <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>
+
+FileSystemWatcher: <http://paulhorman.com/filesystemwatcher/>
+
+# License
+
+Open Source MIT License. See "LICENSE" file.

data/Rakefile

@@ -0,0 +1,64 @@
+require 'rake'
+require 'rake/clean'
+require 'rake/testtask'
+require 'spec/rake/spectask'
+
+task :default => [:spec]
+task :test => :spec
+
+desc "Run all specs"
+Spec::Rake::SpecTask.new('spec') do |t|
+  ENV['ENV'] = "test"
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.ruby_opts = ['-rubygems'] if defined? Gem
+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
+  end
+
+def package(ext='')
+  "pkg/#{$spec.name}-#{$spec.version}" + ext
+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' => [package('.gem'), package('.tar.gz')] do |t|
+  sh <<-end
+    rubyforge add_release #{$rubyforge_project} #{$spec.name} #{$spec.version} #{package('.gem')} &&
+    rubyforge add_file    #{$rubyforge_project} #{$spec.name} #{$spec.version} #{package('.tar.gz')}
+  end
+end
+5

data/bin/rerun

@@ -0,0 +1,52 @@
+#!/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)
+
+load "#{libdir}/../rerun.gemspec" # defines "$spec" variable, which we read the version from
+
+require 'optparse'
+
+options = {}
+
+opts = OptionParser.new("", 24, '  ') { |opts|
+  opts.banner = "Usage: rerun 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 ""
+  opts.separator "Options:"
+
+  opts.on_tail("-h", "--help", "--usage", "show this message") do
+    puts opts
+    exit
+  end
+
+  opts.on_tail("--version", "show version") do
+    puts $spec.version
+    exit
+  end
+
+  opts.parse! ARGV
+}
+
+#config = ARGV[0] || "config.ru"
+#abort "configuration #{config} not found"  unless File.exist? config
+#
+#if config =~ /\.ru$/ && File.read(config)[/^#\\(.*)/]
+#  opts.parse! $1.split(/\s+/)
+#end
+
+if ARGV.empty?
+  puts opts
+  exit
+end
+
+require 'rerun'
+cmd = ARGV.join(" ")
+runner = Rerun::Runner.new(cmd, options)
+runner.start
+runner.join

data/lib/fswatcher.rb

@@ -0,0 +1,6 @@
+require 'watcher'
+
+module Rerun
+  class FSWatcher < Watcher
+  end
+end

data/lib/osxwatcher.rb

@@ -0,0 +1,105 @@
+require "system"
+require "watcher"
+
+begin
+  require 'osx/foundation'
+  OSX.require_framework '/System/Library/Frameworks/CoreServices.framework/Frameworks/CarbonCore.framework'
+rescue MissingSourceFile
+  # this is to not fail when running on a non-Mac
+end
+
+# stolen from RSpactor, http://github.com/mislav/rspactor
+# based on http://rails.aizatto.com/2007/11/28/taming-the-autotest-beast-with-fsevents/
+
+#TODO: make it notice deleted files
+require "watcher"
+module Rerun
+  class OSXWatcher < Rerun::Watcher
+    attr_reader :last_check, :valid_extensions
+    attr_reader :stream
+    
+    def start
+      prime
+      timestamp_checked
+
+      dirs = Array(directories.map{|d| d.dir})
+      
+      mac_callback = lambda do |stream, ctx, num_events, paths, marks, event_ids|
+        examine
+        # changed_files = extract_changed_files_from_paths(split_paths(paths, num_events))
+        # timestamp_checked
+        # puts "changed files:"
+        # p changed_files
+        # yield changed_files unless changed_files.empty?
+      end
+
+      @stream = OSX::FSEventStreamCreate(OSX::KCFAllocatorDefault, mac_callback, nil, dirs, OSX::KFSEventStreamEventIdSinceNow, @sleep_time, 0)
+      raise "Failed to create stream" unless stream
+
+      OSX::FSEventStreamScheduleWithRunLoop(stream, OSX::CFRunLoopGetCurrent(), OSX::KCFRunLoopDefaultMode)
+      unless OSX::FSEventStreamStart(stream)
+        raise "Failed to start stream"
+      end
+
+      @thread = Thread.new do
+        begin
+          OSX::CFRunLoopRun()
+        rescue Interrupt
+          OSX::FSEventStreamStop(stream)
+          OSX::FSEventStreamInvalidate(stream)
+          OSX::FSEventStreamRelease(stream)
+          @stream = nil
+        end
+      end
+
+      @thread.priority = @priority
+    end
+
+    def stop
+      @thread.kill
+    end
+
+    def timestamp_checked
+      @last_check = Time.now
+    end
+
+    def split_paths(paths, num_events)
+      paths.regard_as('*')
+      rpaths = []
+      num_events.times { |i| rpaths << paths[i] }
+      rpaths
+    end
+
+    def extract_changed_files_from_paths(paths)
+      changed_files = []
+      paths.each do |path|
+        next if ignore_path?(path)
+        Dir.glob(path + "*").each do |file|
+          next if ignore_file?(file)
+          changed_files << file if file_changed?(file)
+        end
+      end
+      changed_files
+    end
+
+    def file_changed?(file)
+      File.stat(file).mtime > last_check
+    end
+
+    def ignore_path?(path)
+      path =~ /(?:^|\/)\.(git|svn)/
+    end
+
+    def ignore_file?(file)
+      File.basename(file).index('.') == 0 or not valid_extension?(file)
+    end
+
+    def file_extension(file)
+      file =~ /\.(\w+)$/ and $1
+    end
+
+    def valid_extension?(file)
+      valid_extensions.nil? or valid_extensions.include?(file_extension(file))
+    end
+  end
+end

data/lib/rerun.rb

@@ -0,0 +1,121 @@
+require "system"
+require "watcher"
+require "osxwatcher"
+require "fswatcher"
+
+# todo: make this work in non-Mac and non-Unix environments (also Macs without growlnotify) 
+module Rerun
+  class Runner
+
+    include System
+
+    def initialize(run_command, options = {})
+      @run_command, @options = run_command, options
+    end
+    
+    def restart
+      @restarting = true
+      stop
+      start
+      @restarting = false
+    end
+
+    def start
+      if (!@already_running)
+        taglines = [
+          "To infinity... and beyond!",
+          "Charge!",
+          ]
+        notify "Launched", taglines[rand(taglines.size)]
+        @already_running = true
+      else
+        taglines = [
+          "Here we go again!",
+          "Once more unto the breach, dear friends, once more!", 
+        ]
+        notify "Restarted", taglines[rand(taglines.size)]
+      end
+
+      @pid = Kernel.fork do
+        # Signal.trap("INT") { exit }
+        exec(@run_command)
+      end
+
+      Signal.trap("INT") { stop; exit }
+
+      # Process.detach(@pid)
+
+      begin
+        sleep 2
+      rescue Interrupt => e
+        # in case someone hits control-C immediately
+        stop
+        exit
+      end
+
+      unless running?
+        notify "Launch Failed", "See console for error output"
+        @already_running = false
+      end
+
+      unless @watcher
+        watcher_class = osx? ? OSXWatcher : FSWatcher
+        # watcher_class = FSWatcher
+      
+        watcher = watcher_class.new do
+          restart unless @restarting
+        end
+        watcher.add_directory(".", "**/*.rb")
+        watcher.sleep_time = 1
+        watcher.start
+        
+        @watcher = watcher
+      end
+
+    end
+    
+    def join
+      @watcher.join
+    end
+
+    def running?
+      signal(0)
+    end
+
+    def signal(signal)
+      Process.kill(signal, @pid)
+      true
+    rescue
+      false
+    end
+
+    def stop
+      if @pid && (@pid != 0)
+        notify "Stopped", "All good things must come to an end." unless @restarting
+        signal("KILL") && Process.wait(@pid)
+      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 has_growl?
+      puts
+      puts "#{Time.now.strftime("%T")} - #{app_name} #{title}"
+    end
+    
+  end
+
+end  
+

data/lib/system.rb

@@ -0,0 +1,38 @@
+
+# are we on OSX or not?
+begin
+  require 'osx/foundation'
+  OSX.require_framework '/System/Library/Frameworks/CoreServices.framework/Frameworks/CarbonCore.framework'
+  $osx = true
+rescue MissingSourceFile
+  # this is to not fail when running on a non-Mac
+end
+
+module Rerun
+  module System
+    def osx?
+      $osx
+    end
+    
+    # do we have growl or not?
+    def has_growl?
+      growlcmd != ""
+    end
+
+    def growlcmd
+      `which growlnotify`.chomp
+    end
+    
+    def app_name
+      # todo: make sure this works in non-Mac and non-Unix environments
+      File.expand_path(".").gsub(/^.*\//, '').capitalize
+    end
+
+    def growl(title, body, background = true)
+      s = "#{growlcmd} -n \"#{app_name}\" -m \"#{body}\" \"#{app_name} #{title}\""
+      s += " &" if background
+      `#{s}`
+    end
+    
+  end
+end

data/lib/watcher.rb

@@ -0,0 +1,203 @@
+
+Thread.abort_on_exception = true
+
+# This class will watch a directory or a set of directories and alert you of
+# new files, modified files, deleted files.
+#
+# Author: Paul Horman, http://paulhorman.com/filesystemwatcher/
+# Author: Alex Chaffee
+module Rerun
+  class Watcher
+    CREATED = 0
+    MODIFIED = 1
+    DELETED = 2
+
+    attr_accessor :sleep_time, :priority
+    attr_reader :directories
+
+    def initialize(&client_callback)
+      @client_callback = client_callback
+
+      @sleep_time = 1
+      @priority = 0
+
+      @directories = []
+      @files = []
+
+      @found = nil
+      @first_time = true
+      @thread = nil
+      
+    end
+
+    # add a directory to be watched
+    # @param dir the directory to watch
+    # @param expression the glob pattern to search under the watched directory
+    def add_directory(dir, expression="**/*")
+      if FileTest.exists?(dir) && FileTest.readable?(dir) then
+        @directories << Directory.new(dir, expression)
+      else
+        raise InvalidDirectoryError, "Dir '#{dir}' either doesnt exist or isnt readable"
+      end
+    end
+
+    def remove_directory(dir)
+      @directories.delete(dir)
+    end
+
+    # add a specific file to the watch list
+    # @param file the file to watch
+    def add_file(file)
+      if FileTest.exists?(file) && FileTest.readable?(file) then
+        @files << file
+      else
+        raise InvalidFileError, "File '#{file}' either doesnt exist or isnt readable"
+      end
+    end
+
+    def remove_file(file)
+      @files.delete(file)
+    end
+    
+    def prime
+      @first_time = true
+      @found = Hash.new()
+      examine
+      @first_time = false
+    end
+
+    def start
+      if @thread then
+        raise RuntimeError, "already started"
+      end
+
+      prime
+      
+      @thread = Thread.new do
+        while true do
+          examine
+          sleep(@sleep_time)
+        end
+      end
+
+      @thread.priority = @priority
+      
+      at_exit { stop } #?
+
+    end
+
+    # kill the filewatcher thread
+    def stop
+      begin
+        @thread.wakeup
+      rescue ThreadError => e
+        # ignore
+      end
+      begin
+        @thread.kill
+      rescue ThreadError => e
+        # ignore
+      end
+    end
+
+    # wait for the filewatcher to finish
+    def join
+      @thread.join() if @thread
+    rescue Interrupt => e
+      # don't care
+    end
+
+    private
+
+    def examine
+      already_examined = Hash.new()
+
+      @directories.each do |directory|
+        examine_files(directory.files(), already_examined)
+      end
+
+      examine_files(@files, already_examined) if not @files.empty?
+
+      # now diff the found files and the examined files to see if
+      # something has been deleted
+      all_found_files = @found.keys()
+      all_examined_files = already_examined.keys()
+      intersection = all_found_files - all_examined_files
+      intersection.each do |file_name|
+        @client_callback.call(DELETED, file_name)
+        @found.delete(file_name)
+      end
+
+    end
+
+    # loops over the file list check for new or modified files
+    def examine_files(files, already_examined)
+      files.each do |file_name|
+        # expand the file name to the fully qual path
+        full_file_name = File.expand_path(file_name)
+
+        # we cant do much if the file isnt readable anyway
+        if File.readable?(full_file_name) then
+          already_examined[full_file_name] = true
+          stat = File.stat(full_file_name)
+          mod_time = stat.mtime
+          size = stat.size
+
+          # on the first iteration just load all of the files into the foundList
+          if @first_time then
+            @found[full_file_name] = FoundFile.new(full_file_name, mod_time, size)
+          else
+            # see if we have found this file already
+            found_file = @found[full_file_name]
+            @found[full_file_name] = FoundFile.new(full_file_name, mod_time, size)
+
+            if found_file
+              if mod_time > found_file.mod_time || size != found_file.size then
+                @client_callback.call(MODIFIED, full_file_name)
+              end
+            else
+              @client_callback.call(CREATED, full_file_name)
+            end
+          end
+        end
+      end
+    end
+
+    class Directory
+      attr_reader :dir, :expression
+
+      def initialize(dir, expression)
+        @dir, @expression = dir, expression
+        @dir.chop! if @dir =~ %r{/$}
+      end
+
+      def files()
+        return Dir[@dir + "/" + @expression]
+      end
+    end
+
+    class FoundFile
+      attr_reader :status, :file_name, :mod_time, :size
+
+      def initialize(file_name, mod_time, size)
+        @file_name, @mod_time, @size = file_name, mod_time, size
+      end
+
+      def modified(mod_time)
+        @mod_time = mod_time
+      end
+
+      def to_s
+        "FoundFile[file_name=#{file_name}, mod_time=#{mod_time.to_i}, size=#{size}]"
+      end
+    end
+
+    # if the directory you want to watch doesnt exist or isn't readable this is thrown
+    class InvalidDirectoryError < StandardError;
+    end
+
+    # if the file you want to watch doesnt exist or isn't readable this is thrown
+    class InvalidFileError < StandardError;
+    end
+  end
+end

data/rerun.gemspec

@@ -0,0 +1,38 @@
+$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'
+  s.version = '0.2.1'
+  s.date = '2009-06-16'
+
+  s.description = "Restarts your app when a file changes"
+  s.summary     = "Launches an app, and restarts it whenever the filesystem changes."
+
+  s.authors = ["Alex Chaffee"]
+  s.email = "alex@stinky.com"
+
+  s.files = %w[
+    README.md
+    LICENSE
+    Rakefile
+    rerun.gemspec
+    bin/rerun
+    lib/rerun.rb
+    lib/fswatcher.rb
+    lib/osxwatcher.rb
+    lib/system.rb
+    lib/watcher.rb
+  ]
+  s.executables = ['rerun']
+  s.test_files = s.files.select {|path| path =~ /^spec\/.*_spec.rb/}
+
+  s.extra_rdoc_files = %w[README.md]
+  #s.add_dependency 'rack',    '>= 0.9.1'
+  #s.add_dependency 'launchy', '>= 0.3.3', '< 1.0'
+
+  s.homepage = "http://github.com/alexch/rerun/"
+  s.require_paths = %w[lib]
+  s.rubyforge_project = 'pivotalrb'
+  s.rubygems_version = '1.1.1'
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: alexch-rerun
+version: !ruby/object:Gem::Version 
+  version: 0.2.1
+platform: ruby
+authors: 
+- Alex Chaffee
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-16 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Restarts your app when a file changes
+email: alex@stinky.com
+executables: 
+- rerun
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- README.md
+- LICENSE
+- Rakefile
+- rerun.gemspec
+- bin/rerun
+- lib/rerun.rb
+- lib/fswatcher.rb
+- lib/osxwatcher.rb
+- lib/system.rb
+- lib/watcher.rb
+has_rdoc: false
+homepage: http://github.com/alexch/rerun/
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: pivotalrb
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Launches an app, and restarts it whenever the filesystem changes.
+test_files: []
+