remailer 0.1.0 → 0.2.1

data/.gitignore

@@ -1,5 +1,7 @@
 *.gem
 
+config.rb
+
 ## MAC OS
 .DS_Store
 

data/README.rdoc

@@ -76,6 +76,20 @@ exhausted:
       STDERR.puts "Sending complete."
     end
 
+The call to send a message can also take a callback method which must receive
+one parameter that will be the numerical status code returned by the SMTP
+server. Success is defined as 250, errors vary:
+
+    connection.send_email(
+      'from@example.net',
+      'to@example.com',
+      email_content
+    ) do |status_code|
+      puts "Message finished with status #{status_code}"
+    end
+
+A status code of nil is sent if the server timed out or the connection failed.
+
 == Status
 
 This software is currently experimental and is not recommended for production

data/VERSION

@@ -1 +1 @@
-0.1.0
+0.2.1

data/lib/remailer/connection.rb

@@ -2,12 +2,55 @@ require 'socket'
 require 'eventmachine'
 
 class Remailer::Connection < EventMachine::Connection
+  # == Exceptions ===========================================================
+  
+  class CallbackArgumentsRequired < Exception; end
+
   # == Constants ============================================================
   
   DEFAULT_TIMEOUT = 5
-  SMTP_PORT = 25
   CRLF = "\r\n".freeze
   CRLF_LENGTH = CRLF.length
+
+  SMTP_PORT = 25
+  SOCKS5_PORT = 1080
+  
+  SOCKS5_VERSION = 5
+
+  SOCKS5_METHOD = {
+    :no_auth => 0,
+    :gssapi => 1,
+    :username_password => 2
+  }.freeze
+  
+  SOCKS5_COMMAND = {
+    :connect => 1,
+    :bind => 2
+  }.freeze
+  
+  SOCKS5_REPLY = {
+    0 => 'Succeeded',
+    1 => 'General SOCKS server failure',
+    2 => 'Connection not allowed',
+    3 => 'Network unreachable',
+    4 => 'Host unreachable',
+    5 => 'Connection refused',
+    6 => 'TTL expired',
+    7 => 'Command not supported',
+    8 => 'Address type not supported'
+  }.freeze
+  
+  SOCKS5_ADDRESS_TYPE = {
+    :ipv4 => 1,
+    :domainname => 3,
+    :ipv6 => 4
+  }.freeze
+  
+  NOTIFICATIONS = [
+    :debug,
+    :error,
+    :connect
+  ].freeze
   
   # == Properties ===========================================================
   
@@ -29,40 +72,65 @@ class Remailer::Connection < EventMachine::Connection
   # * use_tls => Will use TLS if availble (default is true)
   def self.open(smtp_server, options = nil)
     options ||= { }
+    options[:host] = smtp_server
     options[:port] ||= 25
     options[:use_tls] = true unless (options.key?(:use_tls))
     
-    EventMachine.connect(smtp_server, options[:port], self, options)
+    host_name = smtp_server
+    host_port = options[:port]
+    
+    if (proxy_options = options[:proxy])
+      host_name = proxy_options[:host]
+      host_port = proxy_options[:port] || SOCKS5_PORT
+    end
+
+    EventMachine.connect(host_name, host_port, self, options)
   end
   
-  # EHLO address
-  # MAIL FROM:<reverse-path> [SP <mail-parameters> ] <CRLF>
-  # RCPT TO:<forward-path> [ SP <rcpt-parameters> ] <CRLF>
-  # DATA <CRLF>
-  # NOOP
-  # QUIT
-  
-  # 250-mx.google.com at your service, [99.231.152.248]
-  # 250-SIZE 35651584
-  # 250-8BITMIME
-  # 250-STARTTLS
-  # 250 ENHANCEDSTATUSCODES
-  
   def self.encode_data(data)
     data.gsub(/((?:\r\n|\n)\.)/m, '\\1.')
   end
+  
+  def self.base64(string)
+    [ string ].pack('m').chomp
+  end
+  
+  def self.encode_authentication(username, password)
+    base64("\0#{username}\0#{password}")
+  end
+  
+  def self.warn_about_arguments(proc, range)
+    unless (range.include?(proc.arity) or proc.arity == -1)
+      STDERR.puts "Callback must accept #{[ range.min, range.max ].uniq.join(' to ')} arguments but accepts #{proc.arity}"
+    end
+  end
 
   # == Instance Methods =====================================================
   
   def initialize(options)
-    @options = options
+    # Throwing exceptions inside this block is going to cause EventMachine
+    # to malfunction in a spectacular way and hide the actual exception. To
+    # allow for debugging, exceptions are dumped to STDERR as a last resort.
+    begin
+      @options = options
 
-    @options[:hostname] ||= Socket.gethostname
-    @messages = [ ]
+      @options[:hostname] ||= Socket.gethostname
+      @messages = [ ]
     
-    debug_notification(:options, @options.inspect)
+      NOTIFICATIONS.each do |type|
+        callback = @options[type]
+
+        if (callback.is_a?(Proc))
+          self.class.warn_about_arguments(callback, (2..2))
+        end
+      end
     
-    @timeout_at = Time.now + (@timeout || DEFAULT_TIMEOUT)
+      debug_notification(:options, @options.inspect)
+    
+      reset_timeout!
+    rescue Object => e
+      STDERR.puts "#{e.class}: #{e}"
+    end
   end
   
   # Returns true if the connection has advertised TLS support, or false if
@@ -71,6 +139,18 @@ class Remailer::Connection < EventMachine::Connection
   def tls_support?
     !!@tls_support
   end
+  
+  # Returns true if the connection will be using a proxy to connect, false
+  # otherwise.
+  def using_proxy?
+    !!@options[:proxy]
+  end
+  
+  # Returns true if the connection will require authentication to complete,
+  # that is a username has been supplied in the options, or false otherwise.
+  def requires_authentication?
+    @options[:username] and !@options[:username].empty?
+  end
 
   # This is used to create a callback that will be called if no more messages
   # are schedueld to be sent.
@@ -78,11 +158,19 @@ class Remailer::Connection < EventMachine::Connection
     @options[:after_complete] = block
   end
   
+  # Closes the connection after all of the queued messages have been sent.
   def close_when_complete!
     @options[:close] = true
   end
 
+  # Sends an email message through the connection at the earliest opportunity.
+  # A callback block can be supplied that will be executed when the message
+  # has been sent, an unexpected result occurred, or the send timed out.
   def send_email(from, to, data, &block)
+    if (block_given?)
+      self.class.warn_about_arguments(block, 1..2)
+    end
+    
     message = {
       :from => from,
       :to => to,
@@ -92,7 +180,9 @@ class Remailer::Connection < EventMachine::Connection
     
     @messages << message
     
+    # If the connection is ready to send...
     if (@state == :ready)
+      # ...send the message right away.
       send_queued_message!
     end
   end
@@ -114,7 +204,14 @@ class Remailer::Connection < EventMachine::Connection
   # flagging the connection as estasblished.
   def connection_completed
     @timeout_at = nil
-    @state = :connected
+    
+    if (using_proxy?)
+      enter_proxy_init_state!
+    else
+      connect_notification(true, "Connection completed")
+      @state = :connected
+      @connected = true
+    end
   end
   
   # This implements the EventMachine::Connection#unbind method to capture
@@ -130,17 +227,48 @@ class Remailer::Connection < EventMachine::Connection
   end
 
   def receive_data(data)
-    # Data is received in arbitrary sized chunks, so there is no guarantee
-    # a whole line will be ready to process, or that there is only one line.
-    @buffer ||= ''
-    @buffer << data
+    # FIX: Buffer the data anyway.
     
-    while (line_index = @buffer.index(CRLF))
-      if (line_index > 0)
-        receive_reply(@buffer[0, line_index])
+    case (state)
+    when :proxy_init
+      version, method = data.unpack('CC')
+      
+      if (method == SOCKS5_METHOD[:username_password])
+        enter_proxy_authentication_state!
+      else
+        enter_proxy_connecting_state!
+      end
+    when :proxy_connecting
+      version, reply, reserved, address_type, address, port = data.unpack('CCCCNn')
+      
+      case (reply)
+      when 0
+        @state = :connected
+        @connected = true
+        connect_notification(true, "Connection completed")
+      else
+        debug(:error, "Proxy server returned error code #{reply}: #{SOCKS5_REPLY[reply]}")
+        connect_notification(false, "Proxy server returned error code #{reply}: #{SOCKS5_REPLY[reply]}")
+        close_connection
+        @state = :failed
       end
+    when :proxy_authenticating
+      # Decode response of authentication request...
+      
+      # ...
+    else
+      # Data is received in arbitrary sized chunks, so there is no guarantee
+      # a whole line will be ready to process, or that there is only one line.
+      @buffer ||= ''
+      @buffer << data
+    
+      while (line_index = @buffer.index(CRLF))
+        if (line_index > 0)
+          receive_reply(@buffer[0, line_index])
+        end
 
-      @buffer = (@buffer[line_index + CRLF_LENGTH, @buffer.length] || '')
+        @buffer = (@buffer[line_index + CRLF_LENGTH, @buffer.length] || '')
+      end
     end
   end
 
@@ -152,6 +280,7 @@ class Remailer::Connection < EventMachine::Connection
     end
   end
 
+protected
   def send_line(line = '')
     send_data(line + CRLF)
 
@@ -164,6 +293,18 @@ class Remailer::Connection < EventMachine::Connection
     !!@reply_complete
   end
   
+  def resolve_hostname(hostname)
+    # FIXME: Elminitate this potentially blocking call by using an async
+    #        resolver if available.
+    record = Socket.gethostbyname(hostname)
+    
+    debug_notification(:resolved, record && record.last)
+
+    record and record.last
+  rescue
+    nil
+  end
+
   def receive_reply(reply)
     debug_notification(:reply, reply.inspect)
 
@@ -173,8 +314,11 @@ class Remailer::Connection < EventMachine::Connection
       reply_code = $1.to_i
       @reply_complete = $2 != '-'
       reply_message = $3
+      
+      debug_notification(:recv, reply)
     end
     
+    # The connection itself will be in a particular state.
     case (state)
     when :connected
       case (reply_code)
@@ -192,7 +336,7 @@ class Remailer::Connection < EventMachine::Connection
           send_line("HELO #{@options[:hostname]}")
         end
       else
-        fail_unanticipated_response!(reply)
+        fail_unanticipated_response!(reply_code, reply_message)
       end
     when :sent_ehlo
       case (reply_code)
@@ -206,27 +350,46 @@ class Remailer::Connection < EventMachine::Connection
         when 'STARTTLS'
           @tls_support = true
         end
-      
-        # FIX: Add TLS support
-        #        if (@tls_support and @options[:use_tls])
-        #          @state = :tls_init
-        #        end
 
         if (@reply_complete)
-          # Add authentication hook
-          @state = :ready
-
-          send_queued_message!
+          if (@options[:use_tls])
+            send_line("STARTTLS")
+            @state = :sent_starttls
+          elsif (requires_authentication?)
+            enter_sent_auth_state!
+          else
+            enter_ready_state!
+          end
         end
       else
-        fail_unanticipated_response!(reply)
+        fail_unanticipated_response!(reply_code, reply_message)
       end
     when :sent_helo
       case (reply_code)
       when 250
-        @state = :ready
+        enter_ready_state!
       else
-        fail_unanticipated_response!(reply)
+        fail_unanticipated_response!(reply_code, reply_message)
+      end
+    when :sent_starttls
+      case (reply_code)
+      when 220
+        start_tls
+        
+        if (requires_authentication?)
+          enter_sent_auth_state!
+        else
+          enter_ready_state!
+        end
+      else
+        fail_unanticipated_response!(reply_code, reply_message)
+      end
+    when :sent_auth
+      case (reply_code)
+      when 235
+        enter_ready_state!
+      else
+        fail_unanticipated_response!(reply_code, reply_message)
       end
     when :sent_mail_from
       case (reply_code)
@@ -234,7 +397,7 @@ class Remailer::Connection < EventMachine::Connection
         @state = :sent_rcpt_to
         send_line("RCPT TO:#{@active_message[:to]}")
       else
-        fail_unanticipated_response!(reply)
+        fail_unanticipated_response!(reply_code, reply_message)
       end
     when :sent_rcpt_to
       case (reply_code)
@@ -244,48 +407,121 @@ class Remailer::Connection < EventMachine::Connection
         
         @data_offset = 0
       else
-        fail_unanticipated_response!(reply)
+        fail_unanticipated_response!(reply_code, reply_message)
       end
     when :sent_data
       case (reply_code)
       when 354
         @state = :data_sending
         
-        transmit_data_chunk!
+        transmit_data!
       else
-        fail_unanticipated_response!(reply)
+        fail_unanticipated_response!(reply_code, reply_message)
       end
     when :sent_data_content
-      if (callback = @active_message[:callback])
-        callback.call(reply_code)
-      end
-      
-      @state = :ready
+      send_callback(reply_code, reply_message)
       
-      send_queued_message!
+      enter_ready_state!
     when :sent_quit
       case (reply_code)
       when 221
         @state = :closed
         close_connection
       else
-        fail_unanticipated_response!(reply)
+        fail_unanticipated_response!(reply_code, reply_message)
       end
     when :sent_reset
       case (reply_code)
       when 250
-        @state = :ready
-        
-        
-        send_queued_message!
+        enter_ready_state!
       end
     end
   end
   
-  def transmit_data_chunk!(chunk_size = nil)
+  def enter_proxy_init_state!
+    debug_notification(:proxy, "Initiating proxy connection through #{@options[:proxy][:host]}")
+
+    socks_methods = [ ]
+    
+    if (@options[:proxy][:username])
+      socks_methods << SOCKS5_METHOD[:username_password]
+    end
+    
+    send_data(
+      [
+        SOCKS5_VERSION,
+        socks_methods.length,
+        socks_methods
+      ].flatten.pack('CCC*')
+    )
+
+    @state = :proxy_init
+  end
+  
+  def enter_proxy_connecting_state!
+    # REFACTOR: Move the resolution of the hostname to an earlier point to
+    #           avoid connecting needlessly.
+    
+    debug_notification(:proxy, "Sending proxy connection request to #{@options[:host]}:#{@options[:port]}")
+    
+    if (ip_address = resolve_hostname(@options[:host]))
+      send_data(
+        [
+          SOCKS5_VERSION,
+          SOCKS5_COMMAND[:connect],
+          0,
+          SOCKS5_ADDRESS_TYPE[:ipv4],
+          ip_address,
+          @options[:port]
+        ].pack('CCCCA4n')
+      )
+      
+      @state = :proxy_connecting
+    else
+      send_callback(:error_connecting, "Could not resolve hostname #{@options[:host]}")
+      
+      @state = :failed
+      close_connection
+    end
+  end
+  
+  def enter_proxy_authenticating_state!
+    debug_notification(:proxy, "Sending proxy authentication")
+
+    proxy_options = @options[:proxy]
+    username = proxy_options[:username]
+    password = proxy_options[:password]
+    
+    send_data(
+      [
+        SOCKS5_VERSION,
+        username.length,
+        username,
+        password.length,
+        password
+      ].pack('CCA*CA*')
+    )
+    
+    @state = :proxy_authenticating
+  end
+  
+  def enter_ready_state!
+    @state = :ready
+    
+    send_queued_message!
+  end
+  
+  def enter_sent_auth_state!
+    send_line("AUTH PLAIN #{self.class.encode_authentication(@options[:username], @options[:password])}")
+    @state = :sent_auth
+  end
+  
+  def transmit_data!(chunk_size = nil)
     data = @active_message[:data]
     chunk_size ||= data.length
     
+    # This chunk-based sending will work better when/if EventMachine can be
+    # configured to support 'writable' notifications on the active socket.
     chunk = data[@data_offset, chunk_size]
     debug_notification(:send, chunk.inspect)
     send_data(self.class.encode_data(data))
@@ -301,12 +537,14 @@ class Remailer::Connection < EventMachine::Connection
     end
   end
   
-  def notify_writable
-    # FIXME: Get EventMachine to trigger this
+  def reset_timeout!
+    @timeout_at = Time.now + (@options[:timeout] || DEFAULT_TIMEOUT)
   end
 
   def send_queued_message!
     return if (@active_message)
+    
+    reset_timeout!
       
     if (@active_message = @messages.shift)
       @state = :sent_mail_from
@@ -324,30 +562,61 @@ class Remailer::Connection < EventMachine::Connection
   def check_for_timeouts!
     return if (!@timeout_at or Time.now < @timeout_at)
 
-    callback(nil)
+    error_notification(:timeout, "Connection timed out")
+    debug_notification(:timeout, "Connection timed out")
+    send_callback(:timeout, "Connection timed out before send could complete")
+
     @state = :timeout
+
+    unless (@connected)
+      connect_notification(false, "Connection timed out")
+    end
+
     close_connection
   end
   
-  def debug_notification(type, message)
-    case (@options[:debug])
+  def send_notification(type, code, message)
+    case (callback = @options[type])
     when nil, false
-      # No debugging in this case
+      # No notification in this case
     when Proc
-      @options[:debug].call(type, message)
+      callback.call(code, message)
     when IO
-      @options[:debug].puts("%s: %s" % [ type, message ])
+      callback.puts("%s: %s" % [ code.to_s, message ])
     else
-      STDERR.puts("%s: %s" % [ type, message ])
+      STDERR.puts("%s: %s" % [ code.to_s, message ])
     end
   end
   
-  def fail_unanticipated_response!(reply)
-    if (@active_message)
-      if (callback = @active_message[:callback])
-        callback.call(nil)
+  def connect_notification(code, message)
+    send_notification(:connect, code, message)
+  end
+
+  def error_notification(code, message)
+    send_notification(:error, code, message)
+  end
+
+  def debug_notification(code, message)
+    send_notification(:debug, code, message)
+  end
+
+  def send_callback(reply_code, reply_message)
+    if (callback = (@active_message and @active_message[:callback]))
+      # The callback is screened in advance when assigned to ensure that it
+      # has only 1 or 2 arguments. There should be no else here.
+      case (callback.arity)
+      when 2
+        callback.call(reply_code, reply_message)
+      when 1
+        callback.call(reply_code)
       end
     end
+  end
+  
+  def fail_unanticipated_response!(reply_code, reply_message)
+    send_callback(reply_code, reply_message)
+    debug_notification(:error, "[#{@state}] #{reply_code} #{reply_message}")
+    error_notification(reply_code, reply_message)
     
     @active_message = nil
     

data/remailer.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{remailer}
-  s.version = "0.1.0"
+  s.version = "0.2.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Scott Tadman"]
-  s.date = %q{2010-11-17}
+  s.date = %q{2010-11-22}
   s.description = %q{EventMachine capable SMTP engine}
   s.email = %q{scott@twg.ca}
   s.extra_rdoc_files = [

data/test/helper.rb

@@ -62,3 +62,15 @@ class Test::Unit::TestCase
     end
   end
 end
+
+require 'ostruct'
+
+TestConfig = OpenStruct.new
+
+config_file = File.expand_path("config.rb", File.dirname(__FILE__))
+
+if (File.exist?(config_file))
+  require config_file
+else
+  raise "No test/config.rb file found. Copy and modify test/config.example.rb"
+end

data/test/unit/remailer_test.rb

@@ -1,8 +1,6 @@
 require File.expand_path(File.join(*%w[ .. helper ]), File.dirname(__FILE__))
 
 class RemailerTest < Test::Unit::TestCase
-  TEST_SMTP_SERVER = 'mail.postageapp.com'.freeze
-  
   def test_encode_data
     sample_data = "Line 1\r\nLine 2\r\n.\r\nLine 3\r\n.Line 4\r\n"
     
@@ -14,7 +12,7 @@ class RemailerTest < Test::Unit::TestCase
       debug = { }
       
       connection = Remailer::Connection.open(
-        TEST_SMTP_SERVER,
+        TestConfig.smtp_server[:host],
         :debug => STDERR
       )
 
@@ -32,10 +30,104 @@ class RemailerTest < Test::Unit::TestCase
         connection.state == :closed
       end
       
-      assert_equal TEST_SMTP_SERVER, connection.remote
+      assert_equal TestConfig.smtp_server[:host], connection.remote
+      
+      assert_equal true, after_complete_trigger
+      
+      assert_equal 52428800, connection.max_size
+      assert_equal :esmtp, connection.protocol
+      assert_equal true, connection.tls_support?
+    end
+  end
+  
+  def test_failed_connect
+    engine do
+      error_received = nil
+      
+      connection = Remailer::Connection.open(
+        'example.com',
+        :debug => STDERR,
+        :error => lambda { |code, message|
+          error_received = [ code, message ]
+        },
+        :timeout => 1
+      )
+      
+      assert_eventually(3) do
+        error_received
+      end
+      
+      assert_equal :timeout, error_received[0]
+    end
+  end
+
+  def test_connect_with_auth
+    engine do
+      debug = { }
+      
+      connection = Remailer::Connection.open(
+        TestConfig.public_smtp_server[:host],
+        :port => 587,
+        :debug => STDERR,
+        :username => TestConfig.public_smtp_server[:username],
+        :password => TestConfig.public_smtp_server[:password]
+      )
+
+      after_complete_trigger = false
+      
+      connection.close_when_complete!
+      connection.after_complete do
+        after_complete_trigger = true
+      end
+      
+      assert_equal :connecting, connection.state
+      assert !connection.error?
+
+      assert_eventually(15) do
+        connection.state == :closed
+      end
+      
+      assert_equal TestConfig.public_smtp_server[:identifier], connection.remote
       
       assert_equal true, after_complete_trigger
       
+      assert_equal 35651584, connection.max_size
+      assert_equal :esmtp, connection.protocol
+      assert_equal true, connection.tls_support?
+    end
+  end
+  
+  def test_connect_via_proxy
+    engine do
+      debug = { }
+
+      connection = Remailer::Connection.open(
+        TestConfig.smtp_server[:host],
+        :debug => STDERR,
+        :proxy => {
+          :proto => :socks5,
+          :host => TestConfig.proxy_server
+        }
+      )
+
+      after_complete_trigger = false
+
+      connection.close_when_complete!
+      connection.after_complete do
+        after_complete_trigger = true
+      end
+
+      assert_equal :connecting, connection.state
+      assert !connection.error?
+
+      assert_eventually(15) do
+        connection.state == :closed
+      end
+
+      assert_equal TestConfig.smtp_server[:identifier], connection.remote
+
+      assert_equal true, after_complete_trigger
+
       assert_equal 52428800, connection.max_size
       assert_equal :esmtp, connection.protocol
       assert_equal true, connection.tls_support?
@@ -45,7 +137,7 @@ class RemailerTest < Test::Unit::TestCase
   def test_connect_and_send_after_start
     engine do
       connection = Remailer::Connection.open(
-        TEST_SMTP_SERVER,
+        TestConfig.smtp_server[:host],
         :debug => STDERR
       )
       
@@ -73,7 +165,7 @@ class RemailerTest < Test::Unit::TestCase
   def test_connect_and_send_dotted_message
     engine do
       connection = Remailer::Connection.open(
-        TEST_SMTP_SERVER,
+        TestConfig.smtp_server[:host],
         :debug => STDERR
       )
       
@@ -97,15 +189,14 @@ class RemailerTest < Test::Unit::TestCase
 
   def test_connect_and_long_send
     engine do
-      connection = Remailer::Connection.open('twgmail.twg.ca')
+      connection = Remailer::Connection.open(TestConfig.smtp_server[:host])
       
       assert_equal :connecting, connection.state
-      assert !connection.error?
       
       result_code = nil
       connection.send_email(
-        'sender@postageapp.com',
-        'remailer+test@example.postageapp.com',
+        TestConfig.sender,
+        TestConfig.receiver,
         example_message + 'a' * 100000
       ) do |c|
         result_code = c
@@ -121,9 +212,9 @@ protected
   def example_message
     example = <<__END__
 Date: Sat, 13 Nov 2010 02:25:24 +0000
-From: sender@postageapp.com
-To: Remailer Test <remailer@twg.ca>
-Message-Id: <hfLkcIByfjYoNIxCO7DMsxBTX9svsFHikIOfAiYy@twg.ca>
+From: #{TestConfig.sender}
+To: Remailer Test <#{TestConfig.receiver}>
+Message-Id: <hfLkcIByfjYoNIxCO7DMsxBTX9svsFHikIOfAiYy@#{TestConfig.sender.split(/@/).last}>
 Subject: Example Subject
 Mime-Version: 1.0
 Content-Type: text/plain

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
+  - 2
   - 1
-  - 0
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors: 
 - Scott Tadman
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-17 00:00:00 -05:00
+date: 2010-11-22 00:00:00 -05:00
 default_executable: 
 dependencies: []