sum 0.1.1 → 0.1.2

data/vendor/fetcher/gemspec.rb

@@ -0,0 +1,17 @@
+GEM_NAME = 'fetcher'
+GEM_FILES = FileList['**/*'] - FileList['coverage', 'coverage/**/*', 'pkg', 'pkg/**/*']
+GEM_SPEC = Gem::Specification.new do |s|
+  # == CONFIGURE ==
+  s.author = "Luke Francl"
+  s.email = "look@recursion.org"
+  s.homepage = "http://github.com/winton/#{GEM_NAME}"
+  s.summary = "download email from POP3 or IMAP and do stuff with it. gemified fork"
+  # == CONFIGURE ==
+  s.extra_rdoc_files = [ "README.rdoc" ]
+  s.files = GEM_FILES.to_a
+  s.has_rdoc = false
+  s.name = GEM_NAME
+  s.platform = Gem::Platform::RUBY
+  s.require_path = "lib"
+  s.version = "0.1.2"
+end

data/vendor/fetcher/lib/fetcher.rb

@@ -0,0 +1,23 @@
+module Fetcher
+  # Use factory-style initialization or insantiate directly from a subclass
+  #
+  # Options:
+  # * <tt>:type</tt> - Name of class as a symbol to instantiate
+  #
+  # Other options are the same as Fetcher::Base.new
+  # 
+  # Example:
+  # 
+  # Fetcher.create(:type => :pop) is equivalent to
+  # Fetcher::Pop.new()
+  def self.create(options={})
+    options = options.dup
+    klass = options.delete(:type)
+    raise ArgumentError, 'Must supply a type' unless klass
+    module_eval "#{klass.to_s.capitalize}.new(options)"
+  end
+end
+
+require 'fetcher/base'
+require 'fetcher/pop'
+require 'fetcher/imap'

data/vendor/fetcher/lib/fetcher/base.rb

@@ -0,0 +1,63 @@
+module Fetcher
+  class Base
+    # Options:
+    # * <tt>:server</tt> - Server to connect to.
+    # * <tt>:username</tt> - Username to use when connecting to server.
+    # * <tt>:password</tt> - Password to use when connecting to server.
+    # * <tt>:receiver</tt> - Receiver object to pass messages to. Assumes the
+    # receiver object has a receive method that takes a message as it's argument
+    #
+    # Additional protocol-specific options implimented by sub-classes
+    #
+    # Example: 
+    #   Fetcher::Base.new(:server => 'mail.example.com',
+    #                     :username => 'pam',
+    #                     :password => 'test',
+    #                     :receiver => IncomingMailHandler)
+    def initialize(options={})
+      %w(server username password receiver).each do |opt|
+        raise ArgumentError, "#{opt} is required" unless options[opt.to_sym]
+        # convert receiver to a Class if it isn't already.
+        if opt == "receiver" && options[:receiver].is_a?(String)
+          options[:receiver] = Kernel.const_get(options[:receiver])
+        end
+          
+        instance_eval("@#{opt} = options[:#{opt}]")
+      end
+    end
+    
+    # Run the fetching process
+    def fetch
+      establish_connection
+      get_messages
+      close_connection
+    end
+    
+    protected
+    
+    # Stub. Should be overridden by subclass.
+    def establish_connection #:nodoc:
+      raise NotImplementedError, "This method should be overridden by subclass"
+    end
+    
+    # Stub. Should be overridden by subclass.
+    def get_messages #:nodoc:
+      raise NotImplementedError, "This method should be overridden by subclass"
+    end
+    
+    # Stub. Should be overridden by subclass.
+    def close_connection #:nodoc:
+      raise NotImplementedError, "This method should be overridden by subclass"
+    end
+    
+    # Send message to receiver object
+    def process_message(message)
+      @receiver.receive(message)
+    end
+    
+    # Stub. Should be overridden by subclass.
+    def handle_bogus_message(message) #:nodoc:
+      raise NotImplementedError, "This method should be overridden by subclass"
+    end
+  end
+end

data/vendor/fetcher/lib/fetcher/imap.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + '/../vendor/plain_imap'
+
+module Fetcher
+  class Imap < Base
+    
+    PORT = 143
+    
+    protected
+    
+    # Additional Options:
+    # * <tt>:authentication</tt> - authentication type to use, defaults to PLAIN
+    # * <tt>:port</tt> - port to use (defaults to 143)
+    # * <tt>:ssl</tt> - use SSL to connect
+    # * <tt>:use_login</tt> - use LOGIN instead of AUTHENTICATE to connect (some IMAP servers, like GMail, do not support AUTHENTICATE)
+    # * <tt>:processed_folder</tt> - if set to the name of a mailbox, messages will be moved to that mailbox instead of deleted after processing. The mailbox will be created if it does not exist.
+    # * <tt>:error_folder:</tt> - the name of a mailbox where messages that cannot be processed (i.e., your receiver throws an exception) will be moved. Defaults to "bogus". The mailbox will be created if it does not exist.
+    def initialize(options={})
+      @authentication = options.delete(:authentication) || 'PLAIN'
+      @port = options.delete(:port) || PORT
+      @ssl = options.delete(:ssl)
+      @use_login = options.delete(:use_login)
+      @processed_folder = options.delete(:processed_folder)
+      @error_folder = options.delete(:error_folder) || 'bogus'
+      super(options)
+    end
+    
+    # Open connection and login to server
+    def establish_connection
+      @connection = Net::IMAP.new(@server, @port, @ssl)
+      if @use_login
+        @connection.login(@username, @password)
+      else
+        @connection.authenticate(@authentication, @username, @password)
+      end
+    end
+    
+    # Retrieve messages from server
+    def get_messages
+      @connection.select('INBOX')
+      @connection.uid_search(['ALL']).each do |uid|
+        msg = @connection.uid_fetch(uid,'RFC822').first.attr['RFC822']
+        begin
+          process_message(msg)
+          add_to_processed_folder(uid) if @processed_folder
+        rescue
+          handle_bogus_message(msg)
+        end
+        # Mark message as deleted 
+        @connection.uid_store(uid, "+FLAGS", [:Seen, :Deleted])
+      end
+    end
+    
+    # Store the message for inspection if the receiver errors
+    def handle_bogus_message(message)
+      create_mailbox(@error_folder)
+      @connection.append(@error_folder, message)
+    end
+    
+    # Delete messages and log out
+    def close_connection
+      @connection.expunge
+      @connection.logout
+      @connection.disconnect
+    rescue
+    end
+    
+    def add_to_processed_folder(uid)
+      create_mailbox(@processed_folder)
+      @connection.uid_copy(uid, @processed_folder)
+    end
+    
+    def create_mailbox(mailbox)
+      unless @connection.list("", mailbox)
+        @connection.create(mailbox)
+      end
+    end
+    
+  end
+end

data/vendor/fetcher/lib/fetcher/pop.rb

@@ -0,0 +1,50 @@
+require File.dirname(__FILE__) + '/../vendor/secure_pop'
+
+module Fetcher
+  class Pop < Base
+
+    protected
+    
+    # Additional Options:
+    # * <tt>:ssl</tt> - whether or not to use ssl encryption
+    # * <tt>:port</tt> - port to use (defaults to 110)
+    def initialize(options={})
+      @ssl = options.delete(:ssl)
+      @port = options.delete(:port) || Net::POP3.default_port
+      super(options)
+    end
+    
+    # Open connection and login to server
+    def establish_connection
+      @connection = Net::POP3.new(@server, @port)
+      @connection.enable_ssl(OpenSSL::SSL::VERIFY_NONE) if @ssl
+      @connection.start(@username, @password)
+    end
+    
+    # Retrieve messages from server
+    def get_messages
+      unless @connection.mails.empty?
+        @connection.each_mail do |msg|
+          begin
+            process_message(msg.pop)
+          rescue
+            handle_bogus_message(msg.pop)
+          end
+          # Delete message from server
+          msg.delete
+        end
+      end
+    end
+    
+    # Store the message for inspection if the receiver errors
+    def handle_bogus_message(message)
+      # This needs a good solution
+    end
+    
+    # Close connection to server
+    def close_connection
+      @connection.finish
+    end
+    
+  end
+end

data/vendor/fetcher/lib/vendor/plain_imap.rb

@@ -0,0 +1,21 @@
+require 'net/imap'
+# add plain as an authentication type...
+# This is taken from:
+# http://svn.ruby-lang.org/cgi-bin/viewvc.cgi/trunk/lib/net/imap.rb?revision=7657&view=markup&pathrev=10966
+
+# Authenticator for the "PLAIN" authentication type.  See
+# #authenticate().
+class PlainAuthenticator
+  def process(data)
+    return "\0#{@user}\0#{@password}"
+  end
+
+  private
+
+  def initialize(user, password)
+    @user = user
+    @password = password
+  end
+end
+
+Net::IMAP.add_authenticator "PLAIN", PlainAuthenticator

data/vendor/fetcher/lib/vendor/secure_pop.rb

@@ -0,0 +1,125 @@
+require 'socket'
+require 'net/pop'
+require 'net/protocol'
+require 'openssl/ssl'
+
+# Backport of ruby 1.9's POP3 SSL support
+class Net::POP3
+  @@usessl = nil
+  @@verify = nil
+  @@certs = nil
+  PORT = 110
+  SSL_PORT = 995
+  
+  def self.default_port
+    PORT
+  end
+  
+  def self.default_ssl_port
+    SSL_PORT
+  end
+  
+  # Enable SSL for all new instances.
+  # +verify+ is the type of verification to do on the Server Cert; Defaults
+  # to OpenSSL::SSL::VERIFY_PEER.
+  # +certs+ is a file or directory holding CA certs to use to verify the 
+  # server cert; Defaults to nil.
+  def self.enable_ssl( verify = OpenSSL::SSL::VERIFY_PEER, certs = nil )
+    @@usessl = true
+    @@verify = verify
+    @@certs = certs  
+  end
+  
+  # Disable SSL for all new instances.
+  def self.disable_ssl
+    @@usessl = nil
+    @@verify = nil
+    @@certs = nil
+  end
+  
+  # Creates a new POP3 object.
+  # +addr+ is the hostname or ip address of your POP3 server.
+  # The optional +port+ is the port to connect to.
+  # The optional +isapop+ specifies whether this connection is going
+  # to use APOP authentication; it defaults to +false+.
+  # This method does *not* open the TCP connection.
+  def initialize(addr, port = nil, isapop = false)
+    @address = addr
+    @usessl = @@usessl
+    if @usessl
+      @port = port || SSL_PORT
+    else
+      @port = port || PORT
+    end
+    @apop = isapop
+    
+    @certs = @@certs
+    @verify = @@verify
+    
+    @command = nil
+    @socket = nil
+    @started = false
+    @open_timeout = 30
+    @read_timeout = 60
+    @debug_output = nil
+
+    @mails = nil
+    @n_mails = nil
+    @n_bytes = nil
+  end
+  
+  # does this instance use SSL?
+  def usessl?
+    @usessl
+  end
+  
+  # Enables SSL for this instance.  Must be called before the connection is
+  # established to have any effect.
+  # +verify+ is the type of verification to do on the Server Cert; Defaults
+  # to OpenSSL::SSL::VERIFY_PEER.
+  # +certs+ is a file or directory holding CA certs to use to verify the 
+  # server cert; Defaults to nil.
+  # +port+ is port to establish the SSL conection on; Defaults to 995.
+  def enable_ssl(verify = OpenSSL::SSL::VERIFY_PEER, certs = nil, 
+                 port = SSL_PORT)
+    @usessl = true
+    @verify = verify
+    @certs = certs
+    @port = port
+  end
+  
+  def disable_ssl
+    @usessl = nil
+    @verify = nil
+    @certs = nil
+  end
+  
+  def do_start( account, password )
+    s = timeout(@open_timeout) { TCPSocket.open(@address, @port) }
+    if @usessl
+      unless defined?(OpenSSL)
+        raise "SSL extension not installed"
+      end
+      sslctx = OpenSSL::SSL::SSLContext.new
+      sslctx.verify_mode = @verify
+      sslctx.ca_file = @certs if @certs && FileTest::file?(@certs)
+      sslctx.ca_path = @certs if @certs && FileTest::directory?(@certs)
+      s = OpenSSL::SSL::SSLSocket.new(s, sslctx)
+      s.sync_close = true
+      s.connect
+    end
+    
+    @socket = Net::InternetMessageIO.new(s)
+    on_connect
+    @command = Net::POP3Command.new(@socket)
+    if apop?
+      @command.apop account, password
+    else
+      @command.auth account, password
+    end
+    @started = true
+  ensure
+    do_finish if not @started
+  end
+  private :do_start
+end

data/vendor/fetcher/test/fetcher_test.rb

@@ -0,0 +1,74 @@
+# require File.dirname(__FILE__) + '/../../../../config/boot'
+require 'rubygems'
+require 'test/unit'
+require 'mocha'
+require 'fetcher'
+
+class FetcherTest < Test::Unit::TestCase
+  
+  def setup
+    @receiver = mock()
+  end
+  
+  def test_should_set_configuration_instance_variables
+    create_fetcher
+    assert_equal 'test.host', @fetcher.instance_variable_get(:@server)
+    assert_equal 'name', @fetcher.instance_variable_get(:@username)
+    assert_equal 'password', @fetcher.instance_variable_get(:@password)
+    assert_equal @receiver, @fetcher.instance_variable_get(:@receiver)
+  end
+  
+  def test_should_require_subclass
+    create_fetcher
+    assert_raise(NotImplementedError) { @fetcher.fetch }
+  end
+  
+  def test_should_require_server
+    assert_raise(ArgumentError) { create_fetcher(:server => nil) }
+  end
+  
+  def test_should_require_username
+    assert_raise(ArgumentError) { create_fetcher(:username => nil) }
+  end
+  
+  def test_should_require_password
+    assert_raise(ArgumentError) { create_fetcher(:password => nil) }
+  end
+  
+  def test_should_require_receiver
+    assert_raise(ArgumentError) { create_fetcher(:receiver => nil) }
+  end
+  
+  def create_fetcher(options={})
+    @fetcher = Fetcher::Base.new({:server => 'test.host', :username => 'name', :password => 'password', :receiver => @receiver}.merge(options))
+  end
+  
+end
+
+class FactoryFetcherTest < Test::Unit::TestCase
+  
+  def setup
+    @receiver = mock()
+    @pop_fetcher = Fetcher.create(:type => :pop, :server => 'test.host',
+                               :username => 'name',
+                               :password => 'password',
+                               :receiver => @receiver)
+    
+  @imap_fetcher = Fetcher.create(:type => :imap, :server => 'test.host',
+                              :username => 'name',
+                              :password => 'password',
+                              :receiver => @receiver)
+  end
+  
+  def test_should_be_sublcass
+    assert_equal Fetcher::Pop, @pop_fetcher.class
+    assert_equal Fetcher::Imap, @imap_fetcher.class
+  end
+  
+  def test_should_require_type
+    assert_raise(ArgumentError) { Fetcher.create({}) }
+  end
+  
+end
+
+# Write tests for sub-classes