spork 0.5.6 → 0.5.7

data/README.rdoc

@@ -1,6 +1,10 @@
 = Spork
 
-* http://github.com/timcharper/spork
+* Repository: http://github.com/timcharper/spork
+* Issues: http://github.com/timcharper/spork/issues
+* Changes: http://github.com/timcharper/spork/blob/master/History.txt
+* Mailing list: http://groups.google.com/group/sporkgem
+* Wiki: http://wiki.github.com/timcharper/spork
 
 == SYNOPSIS:
 

data/features/rails_delayed_loading_workarounds.feature

@@ -62,10 +62,19 @@ Feature: Rails Delayed Work arounds
           get :index
           response.body.should include('listing users')
           puts "Controller stack is functioning"
+          response.body.should include('Here is a list of users')
+          puts "Views are not being cached"
         end
       end
       """
     When I fire up a spork instance with "spork rspec"
+    And the contents of "app/views/users/index.html.erb" are changed to:
+      """
+      <%= reverse_text('listing users'.reverse) %>
+      <p>Here is a list of users</p>
+      """
+      
     And I run spec --drb spec/controllers/users_controller_spec.rb
     Then the output should contain "Controller stack is functioning"
+    Then the output should contain "Views are not being cached"
   

data/features/steps/sandbox_steps.rb

@@ -12,6 +12,10 @@ Given /^a file named "([^\"]*)" with:$/ do |file_name, file_content|
   create_file(file_name, file_content)
 end
 
+When /^the contents of "([^\"]*)" are changed to:$/ do |file_name, file_content|
+  create_file(file_name, file_content)
+end
+
 # the following code appears in "config/environment.rb" after /Rails::Initializer.run/:
 Given /^the following code appears in "([^\"]*)" after \/([^\\\/]*)\/:$/ do |file_name, regex, content|
   # require 'ruby-debug'; Debugger.start; Debugger.start_control; debugger

data/lib/spork.rb

@@ -1,21 +1,23 @@
 $LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__))) unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
 module Spork
   class << self
-    def already_ran
-      @already_ran ||= []
-    end
-    
-    def each_run_procs
-      @each_run_procs ||= []
-    end
-    
-    def prefork(&block)
-      return if already_ran?(caller.first)
+    # Run a block, during prefork mode.  By default, if prefork is called twice in the same file and line number, the supplied block will only be ran once.
+    #
+    # == Parameters
+    #
+    # * +prevent_double_run+ - Pass false to disable double run prevention
+    def prefork(prevent_double_run = true, &block)
+      return if prevent_double_run && already_ran?(caller.first)
       yield
     end
     
-    def each_run(&block)
-      return if already_ran?(caller.first)
+    # Run a block AFTER the fork occurs.  By default, if prefork is called twice in the same file and line number, the supplied block will only be ran once.
+    #
+    # == Parameters
+    #
+    # * +prevent_double_run+ - Pass false to disable double run prevention
+    def each_run(prevent_double_run = true, &block)
+      return if prevent_double_run && already_ran?(caller.first)
       if @state == :using_spork
         each_run_procs << block
       else
@@ -23,59 +25,72 @@ module Spork
       end
     end
     
-    def already_ran?(caller_script_and_line)
-      return true if already_ran.include?(expanded_caller(caller_script_and_line))
-      already_ran << expanded_caller(caller_script_and_line)
-      false
-    end
-    
+    # Used by the server. Sets the state to activate spork. Otherwise, prefork and each_run are run in passive mode, allowing specs without a Spork server.
     def using_spork!
       @state = :using_spork
     end
     
+    # Used by the server.  Returns the current state of Spork.
     def state
       @state ||= :not_using_spork
     end
     
+    # Used by the server.  Called when loading the prefork blocks of the code.
     def exec_prefork(&block)
       using_spork!
       yield
     end
     
+    # Used by the server.  Called to run all of the prefork blocks.
     def exec_each_run(&block)
       each_run_procs.each { |p| p.call }
       each_run_procs.clear
       yield if block_given?
     end
     
-    def expanded_caller(caller_line)
-      file, line = caller_line.split(":")
-      line.gsub(/:.+/, '')
-      File.expand_path(file, Dir.pwd) + ":" + line
-    end
-    
+    # Traps an instance method of a class (or module) so any calls to it don't actually run until Spork.exec_each_run
     def trap_method(klass, method_name)
+      method_name_without_spork, method_name_with_spork = alias_method_names(method_name, :spork)
+      
       klass.class_eval <<-EOF, __FILE__, __LINE__ + 1
-        alias :#{method_name}_without_spork :#{method_name} unless method_defined?(:#{method_name}_without_spork) 
+        alias :#{method_name_without_spork} :#{method_name} unless method_defined?(:#{method_name_without_spork}) 
         def #{method_name}(*args)
-          Spork.each_run_procs << lambda do
-            #{method_name}_without_spork(*args)
+          Spork.each_run(false) do
+            #{method_name_without_spork}(*args)
           end
         end
       EOF
     end
     
+    # Same as trap_method, but for class methods instead
     def trap_class_method(klass, method_name)
-      klass.class_eval <<-EOF, __FILE__, __LINE__ + 1
-        class << self
-          alias :#{method_name}_without_spork :#{method_name} unless method_defined?(:#{method_name}_without_spork)
-          def #{method_name}(*args)
-            Spork.each_run_procs << lambda do
-              #{method_name}_without_spork(*args)
-            end
-          end
-        end
-      EOF
+      trap_method((class << klass; self; end), method_name)
     end
+    
+    private
+      def alias_method_names(method_name, feature)
+        /^(.+?)([\?\!]{0,1})$/.match(method_name.to_s)
+        ["#{$1}_without_spork#{$2}", "#{$1}_with_spork#{$2}"]
+      end
+      
+      def already_ran
+        @already_ran ||= []
+      end
+      
+      def expanded_caller(caller_line)
+        file, line = caller_line.split(":")
+        line.gsub(/:.+/, '')
+        File.expand_path(file, Dir.pwd) + ":" + line
+      end
+      
+      def already_ran?(caller_script_and_line)
+        return true if already_ran.include?(expanded_caller(caller_script_and_line))
+        already_ran << expanded_caller(caller_script_and_line)
+        false
+      end
+      
+      def each_run_procs
+        @each_run_procs ||= []
+      end
   end
 end

data/lib/spork/app_framework.rb

@@ -1,10 +1,22 @@
 class Spork::AppFramework
+  # A hash of procs where the key is the class name, and the proc takes no arguments and returns true if it detects that said application framework is being used in the project.
+  # 
+  # The key :Rails maps to Spork::AppFramework::Rails
+  #
+  # This is used to reduce the amount of code needed to be loaded - only the detected application framework's support code is loaded.
   SUPPORTED_FRAMEWORKS = {
-    :Rails => lambda do
+    :Rails => lambda {
       File.exist?("config/environment.rb") && File.read("config/environment.rb").include?('RAILS_GEM_VERSION')
-    end
+    }
   }
   
+  def self.setup_autoload
+    ([:Unknown] + SUPPORTED_FRAMEWORKS.keys).each do |name|
+      autoload name, File.join(File.dirname(__FILE__), "app_framework", name.to_s.downcase)
+    end
+  end
+  
+  # Iterates through all SUPPORTED_FRAMEWORKS and returns the symbolic name of the project application framework detected.  Otherwise, returns :Unknown
   def self.detect_framework_name
     SUPPORTED_FRAMEWORKS.each do |key, value|
       return key if value.call
@@ -12,32 +24,37 @@ class Spork::AppFramework
     :Unknown
   end
   
+  # Same as detect_framework_name, but returns an instance of the specific AppFramework class.
   def self.detect_framework
     name = detect_framework_name
     self[name]
   end
   
+  # Initializes, stores, and returns a singleton instance of the named AppFramework.
+  #
+  # == Parameters
+  #
+  # # +name+ - A symbolic name of a AppFramework subclass
+  #
+  # == Example
+  #
+  #   Spork::AppFramework[:Rails]
   def self.[](name)
-    instances[name] ||= (
-      require File.join(File.dirname(__FILE__), "app_framework", name.to_s.downcase)
-      const_get(name).new
-    )
-  end
-  
-  def self.instances
-    @instances ||= {}
+    instances[name] ||= const_get(name).new
   end
   
   def self.short_name
     name.gsub('Spork::AppFramework::', '')
   end
   
+  # If there is some stuff out of the box that the Spork can do to speed up tests without the test helper file being bootstrapped, this should return false.
   def bootstrap_required?
     entry_point.nil?
   end
   
+  # Abstract: The path to the file that loads the project environment, ie config/environment.rb.  Returns nil if there is none.
   def entry_point
-    nil
+    raise NotImplemented
   end
   
   def preload(&block)
@@ -47,4 +64,11 @@ class Spork::AppFramework
   def short_name
     self.class.short_name
   end
-end
+  
+  protected
+    def self.instances
+      @instances ||= {}
+    end
+end
+
+Spork::AppFramework.setup_autoload

data/lib/spork/app_framework/rails.rb

@@ -39,6 +39,7 @@ class Spork::AppFramework::Rails < Spork::AppFramework
       delay_app_preload
       delay_application_controller_loading
       delay_route_loading
+      delay_eager_view_loading
     end
     
     def reset_rails_env
@@ -92,6 +93,24 @@ class Spork::AppFramework::Rails < Spork::AppFramework
         Spork.trap_method(::Rails::Initializer, :initialize_routing)
       end
     end
+    
+    def delay_eager_view_loading
+      # So, in testing mode it seems it would be optimal to not eager load 
+      # views (as your may only run a test that uses one or two views).
+      # However, I decided to delay eager loading rather than force it to 
+      # disable because you may wish to eager load your views (I.E. you're 
+      # testing concurrency)
+      
+      # Rails 2.3.x +
+      if defined?(::ActionView::Template::EagerPath)
+        Spork.trap_method(::ActionView::Template::EagerPath, :load!)
+      end
+      # Rails 2.2.x
+      if defined?(::ActionView::PathSet::Path)
+        Spork.trap_method(::ActionView::PathSet::Path, :load)
+      end
+      # Rails 2.0.5 - 2.1.x don't appear to eager cache views.
+    end
   end
   
   def preload(&block)

data/lib/spork/app_framework/rails_stub_files/application.rb

@@ -1,2 +1,3 @@
+# This is a stub used to help Spork delay the loading of the real ApplicationController
 class ::ApplicationController < ActionController::Base
 end

data/lib/spork/app_framework/rails_stub_files/application_controller.rb

@@ -1,2 +1,3 @@
+# This is a stub used to help Spork delay the loading of the real ApplicationController
 class ::ApplicationController < ActionController::Base
 end

data/lib/spork/app_framework/rails_stub_files/application_helper.rb

@@ -1,2 +1,3 @@
+# This is a stub used to help Spork delay the loading of the real ApplicationHelper
 module ::ApplicationHelper
 end

data/lib/spork/app_framework/unknown.rb

@@ -1,2 +1,6 @@
+# This is used if no supported appliction framework is detected
 class Spork::AppFramework::Unknown < Spork::AppFramework
+  def entry_point
+    nil
+  end
 end

data/lib/spork/custom_io_streams.rb

@@ -1,3 +1,5 @@
+# This class is mainly used for testing.
+# When included (and used), it gives us an opportunity to stub out the output streams used for a given class
 module Spork::CustomIOStreams
   def self.included(klass)
     klass.send(:extend, ::Spork::CustomIOStreams::ClassMethods)

data/lib/spork/diagnoser.rb

@@ -1,9 +1,23 @@
+# The Diagnoser hooks into load and require and keeps track of when files are required / loaded, and who loaded them.
+# It's used when you run spork --diagnose
+#
+# = Example
+#  
+#  Spork::Diagnoser.install_hook!('/path/env.rb', '/path')
+#  require '/path/to/env.rb'
+#  Spork::Diagnoser.output_results(STDOUT)
 class Spork::Diagnoser
   class << self
     def loaded_files
       @loaded_files ||= {}
     end
     
+    # Installs the diagnoser hook into Kernel#require and Kernel#load
+    #
+    # == Parameters
+    #
+    # * +entry_file+ - The file that is used to load the project.  Used to filter the backtrace so anything that happens after it is hidden.
+    # * +dir+ - The project directory.  Any file loaded outside of this directory will not be logged.
     def install_hook!(entry_file = nil, dir = Dir.pwd)
       @dir = File.expand_path(Dir.pwd, dir)
       @entry_file = entry_file
@@ -30,6 +44,7 @@ class Spork::Diagnoser
       loaded_files[filename] = filter_callstack(caller) if subdirectory?(filename)
     end
     
+    # Uninstall the hook. Generally useful only for testing the Diagnoser.
     def remove_hook!
       return unless Kernel.private_instance_methods.include?('require_without_diagnoser')
       Kernel.class_eval do
@@ -42,6 +57,11 @@ class Spork::Diagnoser
       true
     end
     
+    # output the results of a diagnostic run.
+    #
+    # == Parameters
+    #
+    # * +stdout+ - An IO stream to output the results to.
     def output_results(stdout)
       project_prefix = Dir.pwd + "/"
       minimify = lambda { |f| f.gsub(project_prefix, '')}

data/lib/spork/forker.rb

@@ -1,4 +1,16 @@
+# A helper class that allows you to run a block inside of a fork, and then get the result from that block.
+#
+# == Example:
+#
+#   forker = Spork::Forker.new do
+#     sleep 3
+#     "success"
+#   end
+#   
+#   forker.result # => "success"
 class Spork::Forker
+  
+  # Raised if the fork died (was killed) before it sent it's response back.
   class ForkDiedException < Exception; end
   def initialize(&block)
     return unless block_given?
@@ -20,6 +32,9 @@ class Spork::Forker
     @child_io.close
   end
   
+  # Wait for the fork to finish running, and then return its return value.
+  #
+  # If the fork was aborted, then result returns nil.
   def result
     return unless running?
     result_thread = Thread.new do
@@ -36,6 +51,7 @@ class Spork::Forker
     @result
   end
   
+  # abort the current running fork
   def abort
     if running?
       Process.kill(Signal.list['TERM'], @child_pid)

data/lib/spork/runner.rb

@@ -2,6 +2,7 @@ require 'optparse'
 require 'spork/server'
 
 module Spork
+  # This is used by bin/spork. It's wrapped in a class because it's easier to test that way.
   class Runner
     attr_reader :server
     
@@ -42,6 +43,7 @@ module Spork
       text.string
     end
     
+    # Returns a server for the specified (or the detected default) testing framework.  Returns nil if none detected, or if the specified is not supported or available.
     def find_server
       if options[:server_matcher]
         @server = Spork::Server.supported_servers(options[:server_matcher]).first
@@ -96,9 +98,6 @@ Are you running me from a project directory?
       end
     end
     
-    def diagnose
-    end
-
     private
     attr_reader :options 
 

data/lib/spork/server.rb

@@ -4,7 +4,9 @@ require 'spork/forker.rb'
 require 'spork/custom_io_streams.rb'
 require 'spork/app_framework.rb'
 
-# This is based off of spec_server.rb from rspec-rails (David Chelimsky), which was based on Florian Weber's TDDMate
+# An abstract class that is implemented to create a server
+#
+# (This was originally based off of spec_server.rb from rspec-rails (David Chelimsky), which was based on Florian Weber's TDDMate)
 class Spork::Server
   @@supported_servers = []
   
@@ -13,26 +15,27 @@ class Spork::Server
   
   include Spork::CustomIOStreams
   
+  # Abstract method: returns the servers port.  Override this to return the port that should be used by the test framework.
   def self.port
     raise NotImplemented
   end
   
+  # Abstract method: returns the entry file that loads the testing environment, such as spec/spec_helper.rb.
   def self.helper_file
     raise NotImplemented
   end
   
+  # Convenience method that turns the class name without the namespace
   def self.server_name
     self.name.gsub('Spork::Server::', '')
   end
   
-  def self.inherited(subclass)
-    @@supported_servers << subclass
-  end
-  
+  # Returns a list of all testing servers that have detected their testing framework being used in the project.
   def self.available_servers
     supported_servers.select { |s| s.available? }
   end
   
+  # Returns a list of all servers that have been implemented (it keeps track of them automatically via Class.inherited)
   def self.supported_servers(starting_with = nil)
     @@supported_servers.sort! { |a,b| a.load_preference_index <=> b.load_preference_index }
     return @@supported_servers if starting_with.nil?
@@ -41,18 +44,22 @@ class Spork::Server
     end
   end
   
+  # Returns true if the testing frameworks helper file exists.  Override if this is not sufficient to detect your testing framework.
   def self.available?
     File.exist?(helper_file)
   end
   
+  # Used to specify
   def self.load_preference_index
     LOAD_PREFERENCE.index(server_name) || LOAD_PREFERENCE.length
   end
   
+  # Detects if the test helper has been bootstrapped.
   def self.bootstrapped?
     File.read(helper_file).include?("Spork.prefork")
   end
   
+  # Bootstraps the current test helper file by prepending a Spork.prefork and Spork.each_run block at the beginning.
   def self.bootstrap
     if bootstrapped?
       stderr.puts "Already bootstrapped!"
@@ -75,6 +82,7 @@ class Spork::Server
     new.listen
   end
   
+  # Sets up signals and starts the DRb service. If it's successful, it doesn't return. Not ever.  You don't need to override this.
   def listen
     trap("SIGINT") { sig_int_received }
     trap("SIGTERM") { abort; exit!(0) }
@@ -93,6 +101,14 @@ class Spork::Server
     self.class.helper_file
   end
   
+  # This is the public facing method that is served up by DRb.  To use it from the client side (in a testing framework):
+  # 
+  #   DRb.start_service("druby://localhost:0") # this allows Ruby to do some magical stuff so you can pass an output stream over DRb.
+  #                                            # see http://redmine.ruby-lang.org/issues/show/496 to see why localhost:0 is used.
+  #   spec_server = DRbObject.new_with_uri("druby://127.0.0.1:8989")
+  #   spec_server.run(options.argv, $stderr, $stdout)
+  #
+  # When implementing a test server, don't override this method: override run_tests instead.
   def run(argv, stderr, stdout)
     abort if running?
     
@@ -104,11 +120,22 @@ class Spork::Server
     @child.result
   end
   
+  # returns whether or not the child (a test run) is running right now.
   def running?
     @child && @child.running?
   end
   
+  protected
+    # Abstract method: here is where the server runs the tests.
+    def run_tests(argv, input, output)
+      raise NotImplemented
+    end
+  
   private
+    def self.inherited(subclass)
+      @@supported_servers << subclass
+    end
+    
     def self.framework
       @framework ||= Spork::AppFramework.detect_framework
     end
@@ -143,10 +170,6 @@ class Spork::Server
       true
     end
     
-    def run_tests(argv, input, output)
-      raise NotImplemented
-    end
-    
     def restart
       stderr.puts "restarting"
       stderr.flush

data/spec/spork/app_framework/rails_spec.rb

@@ -1,7 +1,5 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-Spork::AppFramework[:Rails]
-
 describe Spork::AppFramework::Rails do
   describe ".version" do
     it "detects the current version of rails" do

data/spec/spork/app_framework/unknown_spec.rb

@@ -1,7 +1,5 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
-Spork::AppFramework[:Unknown]
-
 describe Spork::AppFramework::Unknown do
   it "requires bootstrapping" do
     Spork::AppFramework::Unknown.new.bootstrap_required?.should == true

data/spec/spork/forker_spec.rb

@@ -1,36 +1,44 @@
 require File.dirname(__FILE__) + '/../spec_helper'
 
 describe Spork::Forker do
-  it "runs a block in a fork" do
-    @var = "hello world"
-    Spork::Forker.new { @var = "booyah" }.result
-    @var.should == "hello world"
+  describe ".new" do
+    it "runs a block in a fork" do
+      $var = "hello world"
+      Spork::Forker.new { $var = "booyah" }.result
+      $var.should == "hello world"
+    end
   end
   
-  it "returns the result" do
-    Spork::Forker.new { "results" }.result.should == "results"
+  describe "#result" do
+    it "returns the result" do
+      Spork::Forker.new { "results" }.result.should == "results"
+    end
   end
   
-  it "reports when the fork is running" do
-    forker = Spork::Forker.new { sleep 0.1 }
-    forker.running?.should == true
-    forker.result
-    sleep 0.1
-    forker.running?.should == false
+  describe "#running?" do
+    it "reports when the fork is running" do
+      forker = Spork::Forker.new { sleep 0.1 }
+      forker.running?.should == true
+      forker.result
+      sleep 0.1
+      forker.running?.should == false
+    end
   end
   
-  it "aborts a fork and returns nil for the result" do
-    started_at = Time.now
-    ended_at = nil
-    forker = Spork::Forker.new { sleep 5 }
-    Thread.new do
-      forker.result.should == nil
-      ended_at = Time.now
+  describe "#abort" do
+    it "aborts a fork and returns nil for the result" do
+      started_at = Time.now
+      ended_at = nil
+      forker = Spork::Forker.new { sleep 5 }
+      Thread.new do
+        forker.result.should == nil
+        ended_at = Time.now
+      end
+      sleep 0.5
+      forker.abort
+      sleep 0.1
+      (ended_at - started_at).should be_close(0.5, 0.1)
+      forker.running?.should == false
     end
-    sleep 0.5
-    forker.abort
-    sleep 0.1
-    (ended_at - started_at).should be_close(0.5, 0.1)
-    forker.running?.should == false
   end
 end

data/spec/spork/server_spec.rb

@@ -96,12 +96,12 @@ describe Spork::Server do
       File.read(FakeServer.helper_file).should include(File.read(FakeServer::BOOTSTRAP_FILE))
     end
   
-    it "prevents you from running specs twice in parallel" do
+    it "aborts the current running thread when another run is started" do
       create_helper_file
       @fake.wait_time = 0.25
-      first_run = Thread.new { @fake.run("test", STDOUT, STDIN).should == true }
+      first_run = Thread.new { @fake.run("test", STDOUT, STDIN).should == nil }
       sleep(0.05)
-      @fake.run("test", STDOUT, STDIN).should == false
+      @fake.run("test", STDOUT, STDIN).should == true
     
       # wait for the first to finish
       first_run.join

data/spec/spork_spec.rb

@@ -57,6 +57,87 @@ describe Spork do
   end
   
   it "expands a caller line, preserving the line number" do
-    Spork.expanded_caller("/boo/../yah.rb:31").should == "/yah.rb:31"
+    Spork.send(:expanded_caller, "/boo/../yah.rb:31").should == "/yah.rb:31"
+  end
+  
+  describe "#trap_method" do
+    before(:each) do
+      Spork.using_spork!
+      
+      Object.class_eval do
+        class TrapTest
+          def self.output
+            @output ||= []
+          end
+          
+          def hello
+            TrapTest.output << 'hello'
+          end
+          
+          def goodbye
+            TrapTest.output << 'goodbye'
+          end
+          
+          def say_something!
+            TrapTest.output << 'something'
+          end
+        end
+      end
+      @trap_test = TrapTest.new
+    end
+    
+    after(:each) do
+      Object.send(:remove_const, :TrapTest)
+    end
+    
+    it "delays execution of a method until after Spork.exec_each_run is called" do
+      Spork.using_spork!
+      Spork.trap_method(TrapTest, :hello)
+      @trap_test.hello
+      @trap_test.goodbye
+      Spork.exec_each_run
+      TrapTest.output.should == ['goodbye', 'hello']
+    end
+    
+    it "works with methods that have punctuation" do
+      Spork.trap_method(TrapTest, :say_something!)
+      @trap_test.say_something!
+      TrapTest.output.should == []
+      Spork.exec_each_run
+      TrapTest.output.should == ['something']
+    end
+  end
+  
+  describe "#trap_class_method" do
+    before(:each) do
+      Object.class_eval do
+        class TrapTest
+          def self.output
+            @output ||= []
+          end
+          
+          def self.hello
+            output << 'hello'
+          end
+          
+          def self.goodbye
+            output << 'goodbye'
+          end
+        end
+      end
+    end
+    
+    after(:each) do
+      Object.send(:remove_const, :TrapTest)
+    end
+    
+    it "delays execution of a method until after Spork.exec_each_run is called" do
+      Spork.using_spork!
+      Spork.trap_class_method(TrapTest, :hello)
+      TrapTest.hello
+      TrapTest.goodbye
+      Spork.exec_each_run
+      TrapTest.output.should == ['goodbye', 'hello']
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: spork
 version: !ruby/object:Gem::Version 
-  version: 0.5.6
+  version: 0.5.7
 platform: ruby
 authors: 
 - Tim Harper
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-06-10 00:00:00 -06:00
+date: 2009-06-17 00:00:00 -06:00
 default_executable: spork
 dependencies: []