snailgun-rr 1.1.1.3

data/README-snowleopard

@@ -0,0 +1,15 @@
+If you use ruby-1.9.2-p0 on Snow Leopard snailgun won't work out of the Box!
+
+I have included a small patch to the ruby-sources that make it work:
+
+(this is assuming you use rvm)
+
+cd $HOME/.rvm/src/ruby-1.9.2-p0/ext/socket
+patch -p1 < wherever_snailgun_was_installed/ruby-1.9.2-p0.patch
+ruby extconf.rb
+make clean
+make clean install
+
+Patch was taken from http://redmine.ruby-lang.org/repositories/revision/ruby-19?rev=29242
+
+thieso@gmail.com 20101024

data/README-textmate

@@ -0,0 +1,26 @@
+To get ultra fast CMD-R results in textmate you need to patch the run_script.rb that comes with textmate:
+
+cd /Applications/TextMate.app/Contents/SharedSupport/Bundles/Ruby.tmbundle/Support/RubyMate/
+
+patch -p0 < wherever_snailgun_was_installed/textmate.patch
+
+To run test in never before seen speed simply cd into your rails-app (tested with rails 3) and say:
+
+> snailgun
+
+the output should read something like:
+Now entering subshell for RAILS_ENV=test. Use 'exit' to terminate snailgun
+Server starting for RAILS_ENV=test
+.. some seconds later ...
+Server ready for RAILS_ENV=test
+
+Now you can either use fruby instead of ruby to start tests "by hand":
+
+fruby -Itest test/unit/your_test.rb
+
+or - in TextMate - simply navigate to your_test.rb and hit CMD-R
+
+enjoy!
+
+thieso@gmail.com 20101024 at #rchh
+

data/README.markdown

@@ -0,0 +1,216 @@
+Snailgun
+========
+
+Snailgun accelerates the startup of Ruby applications which require large
+numbers of libraries.  It does this by preparing a Ruby process with your
+chosen libraries preloaded, and then forking that process whenever a new
+command-line Ruby interpreter is required.
+
+Installation
+------------
+
+    sudo gem install mysql_retry_lost_connection
+    sudo gem install snailgun-rr
+
+Case 1: standalone
+------------------
+
+    # WITHOUT SNAILGUN
+    $ time ruby -rubygems -e 'require "active_support"' -e 'puts "".blank?'
+    true
+
+    real	0m2.123s
+    user	0m1.424s
+    sys 	0m0.168s
+
+    # WITH SNAILGUN
+    $ snailgun -rubygems -ractive_support
+    Snailgun starting on /home/brian/.snailgun/14781 - 'exit' to end
+    $ time fruby -e 'puts "".blank?'
+    true
+
+    real	0m0.064s
+    user	0m0.020s
+    sys 	0m0.004s
+
+    $ exit
+    logout
+    Snailgun ended
+    $ 
+
+Case 2: Rails app
+-----------------
+
+When using Rails or Merb, snailgun will start a process preloaded for the
+`test` environment only unless told otherwise.
+
+You need to edit `config/environments/test.rb` and set
+`config.cache_classes = false`. This is so that your application classes
+are loaded each time you run a test, rather than being preloaded into
+the test environment.
+
+Snailgun will take several seconds to be ready to process requests. Start
+with `snailgun -v` if you wish to be notified when it is ready.
+
+    $ rails testapp
+    $ cd testapp
+    $ vi config/environments/test.rb
+    ... set config.cache_classes = false
+    $ snailgun -I test
+    Now entering subshell. Use 'exit' to terminate snailgun
+
+    $ time RAILS_ENV=test fruby script/runner 'puts 1+2'
+    3
+
+    real	0m0.169s
+    user	0m0.040s
+    sys 	0m0.008s
+
+    # To run your test suite
+    $ frake test       # or frake spec
+
+Your preloaded process will remain around until you type `exit` to terminate
+it.
+
+Note that any attempt by `fruby` or `frake` to perform an action in an
+environment other than 'test' will fail.  See below for how to run multiple
+snailgun environments.
+
+Merb support has been contributed (using MERB_ENV), but it is untested by
+me.
+
+Case 3: Rails with multiple environments
+----------------------------------------
+
+After reading the warnings below, you may choose to start multiple snailgun
+processes each configured for a different environment, as follows:
+
+    $ snailgun --rails test,development
+
+This gives the potential for faster startup of rake tasks which involve
+the development environment (such as migrations) and the console. The
+utility `fconsole` is provided for this.
+
+However, beware that frake and fruby need to decide which of the preloaded
+environments to dispatch the command to.  The safest way is to force the
+correct one explicitly:
+
+    RAILS_ENV=test frake test:units
+    RAILS_ENV=development fruby script/server
+    RAILS_ENV=test fruby script/runner 'puts "".blank?'
+
+If you do not specify the environment, then a simple heuristic is used:
+
+* `fruby` always defaults to the 'development' environment.
+
+* `frake` honours any `RAILS_ENV=xxx` setting on the command line. If
+missing, `frake` defaults to the 'test' environment if no args are given or
+if an arg containing the word 'test' or 'spec' is given; otherwise it falls
+back to the 'development' environment.
+
+WARNING: The decision as to which of the preloaded environments to use is
+made *before* actually running the command.  If the wrong choice is made, it
+can lead to problems.
+
+In the worst case, you may have a 'test'-type task, but find that it is
+wrongly dispatched to your 'development' environment - and possibly ends up
+blowing away your development database.  This actually happened to me while
+developing snailgun.  SO IF YOUR DEVELOPMENT DATABASE CONTAINS USEFUL DATA,
+KEEP IT BACKED UP.
+
+If you run test files individually, it is especially critical that you set
+the correct environment. e.g.
+
+    RAILS_ENV=test fruby -Ilib -Itest test/unit/some_test.rb
+
+Case 4: Rails with cucumber
+---------------------------
+
+Cucumber creates its own Rails environment called "cucumber", so you can
+setup snailgun like this:
+
+    $ snailgun --rails test,cucumber
+
+Then use `frake cucumber` to exercise the features. frake selects the
+"cucumber" environment if run with "cucumber" as an argument.
+
+NOTE: to make your model classes be loaded on each run you need to set
+`config.cache_classes = false` in `config/environments/cucumber.rb`.
+Cucumber will give a big warning saying that this is known to be a
+problem with transactional fixtures. I don't use transactional fixtures
+so this isn't a problem for me.
+
+For a substantial performance boost, remove `:lib=>false` lines from
+`config/environments/cucumber.rb` so that cucumber, webrat, nokogiri etc
+are preloaded.
+
+Smaller performance boosts can be had from further preloading.  For example,
+cucumber makes use of some rspec libraries for diffing even if you're not
+using rspec, so you can preload those. Add something like this to the end of
+`config/environments/cucumber.rb`
+
+    begin
+      require 'spec/expectations'
+      require 'spec/runner/differs/default'
+    rescue LoadError
+    end
+    require 'test_help'
+    require 'test/unit/testresult'
+    require 'active_support/secure_random'
+    require 'active_support/time_with_zone'
+
+autotest
+--------
+
+There is some simple support for autotest (from the ZenTest package).
+Just type `fautotest` instead of `autotest` after snailgun has been started.
+This hasn't been tested for a while.
+
+Bypassing rubygems
+------------------
+
+You can get noticeably faster startup if you don't use rubygems to invoke
+the programs.  To do this, you can add the binary directory directly into
+the front of your PATH, e.g. for Ubuntu
+
+    PATH=/var/lib/gems/1.8/gems/snailgun-1.0.3/bin:$PATH
+
+Alternatively, create a file called `fruby` somewhere early on in your PATH
+(e.g. under `$HOME/bin`), like this:
+
+    #!/usr/bin/env ruby
+    load '/path/to/the/real/fruby'
+
+Repeat for `frake` etc.
+
+Other bugs and limitations
+--------------------------
+Only works with Linux/BSD systems, due to use of passing open file
+descriptors across a socket.
+
+Ctrl-C doesn't terminate frake processes.
+
+`fruby script/console` doesn't give any speedup, because script/console uses
+exec to invoke irb.  Use the supplied `fconsole` instead.
+
+The environment is not currently passed across the socket to the ruby
+process. This means it's not usable as a fast CGI replacement.
+
+In Rails, you need to beware that any changes to your `config/environment*`
+will not be reflected until you stop and restart snailgun.
+
+Licence
+-------
+This code is released under the same licence as Ruby itself.
+
+Author
+------
+Brian Candler <B.Candler@pobox.com>
+
+Credits:
+
+* Jan X <jan.h.xie@gmail.com>
+* George Ogata <george.ogata@gmail.com>
+* Niklas Hofer <niklas+dev@lanpartei.de>
+* Thies C. Arntzen <thieso@gmail.com>
+* Scott Herrimn <schalias-snailgun@yahoo.com>

data/bin/fautotest

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# Copyright (C) Brian Candler 2009. Released under the Ruby licence.
+
+# shortcut for: RAILS_ENV=test fruby /path/to/autotest
+
+ENV["RAILS_ENV"] = "test"
+Test::Unit.run = true if defined?(Test::Unit) && Test::Unit.respond_to?(:run=)
+ARGV[0,0] = ["-e","gem 'ZenTest'","-e","load Gem.bin_path('ZenTest', 'autotest')","--"]
+load File.join(File.dirname(__FILE__), "fruby")

data/bin/fconsole

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# Copyright (C) Brian Candler 2009. Released under the Ruby licence.
+
+ENV['RAILS_ENV'] = ARGV.shift if ARGV[0] =~ /^\w/
+
+ARGV[0,0] = [
+  "-rirb",
+  "-rirb/completion",
+  "-rconsole_app",
+  "-rconsole_with_helpers",
+  "-eIRB.start", "--", "--simple-prompt"
+]
+load File.join(File.dirname(__FILE__), "fruby")

data/bin/fcucumber

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# Copyright (C) Brian Candler 2009. Released under the Ruby licence.
+
+$DEFAULT_ENV='cucumber'
+ARGV[0,0] = ['cucumber']
+load File.join(File.dirname(__FILE__), 'fruby')

data/bin/frake

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+# Copyright (C) Brian Candler 2009. Released under the Ruby licence.
+# Here we run rake within a pre-forked ruby process
+
+# Pre-parse environment - see collect_tasks in rake/lib/rake.rb
+ARGV.each do |arg|
+  if arg =~ /^(\w+)=(.*)$/
+    ENV[$1] = $2
+  end
+end
+
+# Rails/Merb: make a guess at the correct environment
+if File.exist?("config/boot.rb") || File.exist?("config/init.rb")
+  if ARGV.find { |arg| arg =~ /\bcucumber\b/ }
+    $DEFAULT_ENV='cucumber'
+  elsif ARGV.find { |arg| arg =~ /\b(test|spec)\b/ } || !ARGV.find { |arg| arg !~ /^-/ }
+    $DEFAULT_ENV='test'
+  end
+end
+
+ARGV[0,0] = ["-rrake", "-eRake.application.run", "--"]
+load File.join(File.dirname(__FILE__), "fruby")

data/bin/fruby

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+# Copyright (C) Brian Candler 2009. Released under the Ruby licence.
+# This could be rewritten in C for even faster startup
+
+require 'socket'
+if ENV['SNAILGUN_SOCK']
+  sockname = ENV['SNAILGUN_SOCK']
+elsif File.directory?('tmp/sockets/snailgun')
+  env = ENV['RAILS_ENV'] || ENV['MERB_ENV']
+  unless env
+    # Normally default to development: see railties/lib/tasks/misc.rake
+    env = $DEFAULT_ENV || 'development'
+    STDERR.puts "Snailgun assuming environment '#{env}'"
+  end
+  sockname = "tmp/sockets/snailgun/#{env}"
+end
+
+unless sockname and File.exists? sockname
+  STDERR.puts <<EOS
+Unable to find path to snailgun socket.
+- did you run this in a session with a snailgun parent?
+- you can do 'SNAILGUN_SOCK=/path/to/sock #{$0} ...'
+EOS
+  exit 1
+end
+
+server = UNIXSocket.open(sockname)
+server.send_io(STDIN)
+server.send_io(STDOUT)
+server.send_io(STDERR)
+args = Marshal.dump([ARGV, ENV.to_hash, Dir.pwd, Process.getpgrp])
+server.write [args.size].pack("N")
+server.write args
+begin
+  rc = (server.read(1) || "\000").unpack("C").first
+  exit rc
+rescue Interrupt
+  server.write('X')
+  exit 1
+end

data/bin/snailgun

@@ -0,0 +1,155 @@
+#!/usr/bin/env ruby
+# Copyright (C) Brian Candler 2009. Released under the Ruby licence.
+# Turn on copy-on-write garbage collection in REE: see
+# http://www.rubyenterpriseedition.com/documentation.html#_copy_on_write_friendliness
+begin
+  GC.copy_on_write_friendly = true
+rescue NoMethodError
+end
+
+$:.unshift File.expand_path(File.join(File.dirname(__FILE__), "..", "lib"))
+require 'snailgun/server'
+require 'optparse'
+
+sockpath = nil
+mode = nil
+envs = "test"
+rake = false
+verbose = false
+
+def fix_rake
+  require 'rbconfig'
+  Config::CONFIG['bindir'] = File.expand_path(File.dirname(__FILE__))
+  Config::CONFIG['ruby_install_name'] = 'fruby'
+  require 'rubygems'
+  require 'rake'
+  require 'rake/testtask'
+  require 'rake/rdoctask'
+end
+
+OptionParser.new do |opts|
+  opts.on("-I DIR", "add to load path")		{ |v| $:.unshift v }
+  opts.on("-r LIB", "require library")		{ |v| require v }
+  opts.on("--rails [ENVS]", "rails mode")	{ |v| mode = :rails; envs = v }
+  opts.on("--ruby [SOCKPATH]", "ruby mode")	{ |v| mode = :ruby; sockpath = v }
+  opts.on("--rake", "add rake support")		{ rake = true }
+  opts.on("-v", "--verbose", "show progress")	{ verbose = true }
+end.parse!
+
+mode ||= if File.exist?("config/boot.rb")
+           :rails
+         elsif File.exist?("config/init.rb")
+           :merb
+         else
+           :ruby
+         end
+
+STDERR.puts "Starting in #{mode} mode" if verbose
+case mode
+when :ruby
+  unless sockpath
+    dir = File.join(ENV['HOME'], '.snailgun')
+    begin
+      Dir.mkdir dir, 0700
+    rescue Errno::EEXIST
+      File.chmod 0700, dir
+    end
+    sockpath = File.join dir, $$.to_s
+  end
+  fix_rake if rake
+  server = Snailgun::Server.new(sockpath)
+  server.interactive!
+
+when :rails
+  conf = File.expand_path('config/boot.rb')
+  unless File.exist?(conf)
+    raise "#{conf} does not exist, cannot continue"
+  end
+  sockdir = File.expand_path('tmp/sockets/snailgun')
+  begin
+    Dir.mkdir sockdir, 0700
+  rescue Errno::EEXIST
+    File.chmod 0700, sockdir
+  end
+  pids = {}
+  fix_rake   # TODO: separate process for rake (but then need to choose right RAILS_ENV)
+  
+  start_for_envs = envs.split(/[\s,]+/).uniq
+  start_for_envs.each do |env|
+    pids[env] = fork do
+      STDERR.puts "Server starting for RAILS_ENV=#{env}"
+      server = Snailgun::Server.new("#{sockdir}/#{env}")
+      ENV['SNAILGUN'] = 'yes'
+      ENV['RAILS_ENV'] = env
+      load conf
+      # We can get some drastic test speedups by preloading test frameworks
+      # (although user could do that in config/environments/test.rb)
+      if env != 'test'
+        if File.exist?('./config/environment.rb')
+          require './config/environment.rb'
+        end
+      elsif File.exist?('./test/test_helper.rb')
+        require './test/test_helper'
+      elsif File.exist?('spec/spec_helper.rb')
+        require 'spec'
+        require 'spec/rails'
+      end
+      if Rails.respond_to?(:configuration) && Rails.configuration.cache_classes
+        STDERR.puts <<-EOS
+WARNING: Snailgun doesn't work well with `cache_classes`. Strongly recommend
+`config.cache_classes = false` in config/environments/#{env}.rb
+EOS
+      end
+      STDERR.puts "Server ready for RAILS_ENV=#{env}"
+      server.run
+    end
+  end
+  if start_for_envs.size == 1
+    ENV['RAILS_ENV'] = start_for_envs.first
+    STDERR.puts "Now entering subshell for RAILS_ENV=#{ENV['RAILS_ENV']}. Use 'exit' to terminate snailgun"
+  else
+    STDERR.puts "Now entering subshell Don't forget to set your RAILS_ENV!. Use 'exit' to terminate snailgun"
+  end
+  Snailgun::Server.shell
+  pids.each do |env,pid|
+    Process.kill('TERM',pid)
+  end
+  # TODO: wait a few secs for them to die, 'KILL' if required
+  STDERR.puts "Snailgun ended"
+
+when :merb
+  conf = File.expand_path('config/init.rb')
+  unless File.exist?(conf)
+    raise '#{conf} does not exist, cannot continue'
+  end
+  sockdir = File.expand_path('tmp/sockets/snailgun')
+  begin
+    require 'fileutils'
+    FileUtils.mkdir_p sockdir
+  ensure
+    File.chmod 0700, sockdir
+  end
+  pids = {}
+  fix_rake   # TODO: separate process for rake (but then need to choose right RAILS_ENV)
+  envs.split(/\s*,\s*/).uniq.each do |env|
+    pids[env] = fork do
+      server = Snailgun::Server.new("#{sockdir}/#{env}")
+      ENV['MERB_ENV'] = env
+
+      require 'rubygems'
+      gem 'merb-core'
+      require 'merb'
+      Merb.start_environment([env])
+
+      STDERR.puts "Started server for #{env}" if verbose
+      server.run
+    end
+  end
+  STDERR.puts "Use 'exit' to terminate snailgun"
+  Snailgun::Server.shell
+  pids.each do |env,pid|
+    Process.kill('TERM',pid)
+  end
+  # TODO: wait a few secs for them to die, 'KILL' if required
+  STDERR.puts "Snailgun ended"
+end

data/lib/snailgun/server.rb

@@ -0,0 +1,129 @@
+# Copyright (C) Brian Candler 2009. Released under the Ruby licence.
+
+# Our at_exit handler must be called *last*, so register it first
+at_exit { $SNAILGUN_EXIT.call if $SNAILGUN_EXIT }
+
+# Fix truncation of $0. See http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/336743
+$progname = $0
+alias $PROGRAM_NAME $0
+alias $0 $progname
+trace_var(:$0) {|val| $PROGRAM_NAME = val} # update for ps
+
+require 'socket'
+require 'optparse'
+require 'shellwords'
+
+module Snailgun
+  class Server
+    attr_accessor :sockname
+
+    def initialize(sockname = nil)
+      @sockname = sockname || "/tmp/snailgun#{$$}"
+      File.delete(@sockname) rescue nil
+      @socket = UNIXServer.open(@sockname)
+      yield self if block_given?
+    end
+
+    def run
+      while client = @socket.accept
+        pid = fork do
+          rubylib = nil
+          begin
+            STDIN.reopen(client.recv_io)
+            STDOUT.reopen(client.recv_io)
+            STDERR.reopen(client.recv_io)
+            nbytes = client.read(4).unpack("N").first
+            args, env, cwd, pgid = Marshal.load(client.read(nbytes))
+            Dir.chdir(cwd)
+            $LOAD_PATH.unshift rubylib if (rubylib = env['RUBYLIB'])
+            begin
+              Process.setpgid(0, pgid)
+            rescue Errno::EPERM
+            end
+            exit_status = 0
+            $SNAILGUN_EXIT = lambda {
+              begin
+                client.write [exit_status].pack("C")
+              rescue Errno::EPIPE
+              end
+            }
+            #This doesn't work in 1.8.6:
+            #Thread.new { client.read(1); Thread.main.raise Interrupt }
+            Thread.new { client.read(1); exit 1 }
+            Dispatcher.cleanup_application
+            Dispatcher.reload_application
+            start_ruby(args)
+          rescue SystemExit => e
+            exit_status = e.status
+            raise  # for the benefit of Test::Unit
+          rescue Exception => e
+            STDERR.puts "#{e}\n\t#{e.backtrace.join("\n\t")}"
+            exit 1
+          ensure
+            $LOAD_PATH.shift if rubylib
+          end
+        end
+        Process.detach(pid) if pid && pid > 0
+        client.close
+      end
+    ensure
+      File.delete(@sockname) rescue nil
+    end
+
+    # Process the received ruby command line. (TODO: implement more options)
+    def start_ruby(args)
+      e = []
+      OptionParser.new do |opts|
+        opts.on("-e EXPR") do |v|
+          e << v
+        end
+        opts.on("-I DIR") do |v|
+          v.split(':').each do |value|
+            $:.unshift value
+          end
+        end
+        opts.on("-r LIB") do |v|
+          require v
+        end
+        # opts.on("-rcatch_exception") do |v|
+        # end
+        opts.on("-KU") do |v|
+          $KCODE = 'u' if RUBY_VERSION < "1.9"
+        end
+      end.order!(args)
+
+      ARGV.replace(args)
+      if !e.empty?
+        $0 = '-e'
+        e.each { |expr| eval(expr, TOPLEVEL_BINDING) }
+      elsif ARGV.empty?
+        $0 = '-'
+        eval(STDIN.read, TOPLEVEL_BINDING)
+      else
+        cmd = ARGV.shift
+        $0 = cmd
+        load(cmd)
+      end
+    end
+    
+    def self.shell
+      shell_opts = ENV['SNAILGUN_SHELL_OPTS'] || "-i"
+      args = shell_opts ? Shellwords.shellwords(shell_opts) : []
+      system(ENV['SHELL'] || 'bash', *args)
+    end
+
+    # Interactive mode (start a subshell with SNAILGUN_SOCK set up,
+    # and terminate the snailgun server when the subshell exits)
+    def interactive!
+      ENV['SNAILGUN_SOCK'] = @sockname
+      pid = Process.fork {
+        STDERR.puts "Snailgun starting on #{sockname} - 'exit' to end"
+        run
+      }
+      self.class.shell
+      Process.kill('TERM',pid)
+      # TODO: wait a few secs for it to die, 'KILL' if required
+      STDERR.puts "Snailgun ended"
+    end
+  end
+end

data/ruby-1.9.2-p0.patch

@@ -0,0 +1,54 @@
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: Makefile
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: ancdata.o
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: basicsocket.o
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: constants.o
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: constdefs.c
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: constdefs.h
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: extconf.h
+diff -u socket/extconf.rb /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket/extconf.rb
+--- socket/extconf.rb	2010-05-19 15:48:50.000000000 +0200
++++ /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket/extconf.rb	2010-10-24 10:44:17.000000000 +0200
+@@ -117,7 +117,7 @@
+   }
+ end
+ 
+-if (have_func("sendmsg") | have_func("recvmsg")) && /64-darwin/ !~ RUBY_PLATFORM
++if have_func("sendmsg") | have_func("recvmsg")
+   # CMSG_ macros are broken on 64bit darwin, because of use of __DARWIN_ALIGN.
+   have_struct_member('struct msghdr', 'msg_control', ['sys/types.h', 'sys/socket.h'])
+   have_struct_member('struct msghdr', 'msg_accrights', ['sys/types.h', 'sys/socket.h'])
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: init.o
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: ipsocket.o
+Common subdirectories: socket/lib and /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket/lib
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: mkmf.log
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: option.o
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: raddrinfo.o
+diff -u socket/rubysocket.h /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket/rubysocket.h
+--- socket/rubysocket.h	2010-04-28 09:16:30.000000000 +0200
++++ /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket/rubysocket.h	2010-10-24 10:43:51.000000000 +0200
+@@ -138,6 +138,17 @@
+ };
+ #endif
+ 
++#if defined __APPLE__ && defined __MACH__
++/*
++ * CMSG_ macros are broken on 64bit darwin, because __DARWIN_ALIGN
++ * aligns up to __darwin_size_t which is 64bit, but CMSG_DATA is
++ * 32bit-aligned.
++ */
++#undef __DARWIN_ALIGNBYTES
++#define __DARWIN_ALIGNBYTES (sizeof(unsigned int) - 1)
++#endif
++
++
+ #if defined(_AIX)
+ #ifndef CMSG_SPACE
+ # define CMSG_SPACE(len) (_CMSG_ALIGN(sizeof(struct cmsghdr)) + _CMSG_ALIGN(len))
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: socket.bundle
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: socket.o
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: sockssocket.o
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: tcpserver.o
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: tcpsocket.o
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: udpsocket.o
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: unixserver.o
+Only in /Users/thieso/.rvm/src/ruby-1.9.2-p0/ext/socket: unixsocket.o

data/textmate.patch

@@ -0,0 +1,25 @@
+--- run_script.rb.orig	2010-10-25 09:23:45.000000000 +0200
++++ run_script.rb	2010-10-25 09:24:06.000000000 +0200
+@@ -90,6 +90,22 @@
+   return path, '', path
+ end
+ 
++def snailgun_socket
++  Pathname.new(Dir.pwd).ascend do |path|
++    if File.exists?(path.join("config", "boot.rb"))
++      if File.exists?(path.join("tmp", "sockets", "snailgun", "test"))
++        return path.join("tmp", "sockets", "snailgun", "test").to_s
++      end
++    end
++  end
++  nil
++end
++
++if socket = snailgun_socket
++  ENV['SNAILGUN_SOCK'] = socket
++  cmd[0] = 'fruby'
++end
++
+ TextMate::Executor.run( cmd, :version_args => ["--version"],
+                              :script_args  => args ) do |line, type|
+   if is_test_script and type == :out

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: snailgun-rr
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 1
+  - 1
+  - 3
+  version: 1.1.1.3
+platform: ruby
+authors: 
+- Brian Candler
+- Scott Herriman
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-16 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mysql_retry_lost_connection
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+description: Snailgun accelerates the startup of Ruby applications which require large numbers of libraries
+email: schalias-snailgun@yahoo.com
+executables: 
+- fautotest
+- fconsole
+- fcucumber
+- frake
+- fruby
+- snailgun
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- bin/fautotest
+- bin/fconsole
+- bin/fcucumber
+- bin/frake
+- bin/fruby
+- bin/snailgun
+- lib/snailgun/server.rb
+- README.markdown
+- README-snowleopard
+- ruby-1.9.2-p0.patch
+- textmate.patch
+- README-textmate
+has_rdoc: true
+homepage: http://github.com/sherriman/snailgun
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: snailgun
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 2
+summary: Command-line startup accelerator
+test_files: []
+