eyemap 0.8.0

data/lib/eyemap.rb

@@ -0,0 +1,7 @@
+$:.unshift(File.dirname(File.expand_path(__FILE__)))
+require 'eyemap/eyemap'
+require 'eyemap/message'
+require 'eyemap/folder'
+require 'eyemap/exception'
+require 'eyemap/search'
+$:.shift

data/lib/eyemap/drivers/courier.rb

@@ -0,0 +1,12 @@
+require 'eyemap/drivers/courier_folder'
+
+class EyeMap::Driver::Courier < EyeMap::Driver
+    def initialize(*args)
+
+        super(args)
+
+        self[:folder_class]  = EyeMap::Folder::Courier
+        self[:delimiter]     = '.'
+
+    end
+end

data/lib/eyemap/drivers/courier_folder.rb

@@ -0,0 +1,13 @@
+class EyeMap::Folder::Courier < EyeMap::Folder
+
+    def delete
+        # courier has an interesting situation where it does not 
+        # allow the currently selected mailbox to be deleted.
+        # until I'm positive this is "normal" behavior I'm going to keep it
+        # here.
+
+        @driver.conn.select("INBOX")
+        super
+    end
+
+end

data/lib/eyemap/drivers/dovecot.rb

@@ -0,0 +1,12 @@
+require 'eyemap/drivers/dovecot_folder'
+
+class EyeMap::Driver::Dovecot < EyeMap::Driver
+    def initialize(*args)
+
+        super(args)
+
+        self[:folder_class]  = EyeMap::Folder::Dovecot
+        self[:delimiter]     = '/'
+
+    end
+end

data/lib/eyemap/drivers/dovecot_folder.rb

@@ -0,0 +1,34 @@
+class EyeMap::Folder::Dovecot < EyeMap::Folder
+
+    def create
+        raise EyeMap::Exception::DriverIncapable.new("Dovecot cannot handle inferior folders.")
+    end
+
+    def folder(folder_name)
+        raise EyeMap::Exception::DriverIncapable.new("Dovecot cannot handle inferior folders.")
+    end
+
+    def subfolders
+        list = nil
+
+        if @folder_name.length > 0
+            list = @driver.conn.list("", "#{@folder_name}#{@driver[:delimiter]}%")
+        else
+            list = @driver.conn.list("", "%")
+        end
+
+        retval = []
+
+        if list
+            list.each do |f|
+                retval.push(@driver[:folder_class].
+                            new(f.name, @driver, f.delim,
+                                # deep copy
+                                Marshal.load(Marshal.dump(f.attr))))
+            end
+        end
+
+        return retval
+    end
+
+end

data/lib/eyemap/exception.rb

@@ -0,0 +1,8 @@
+class EyeMap::Exception 
+  class EyeMap::Exception::BadCall < Exception
+  end
+  class EyeMap::Exception::InvalidDriver < Exception
+  end
+  class EyeMap::Exception::DriverIncapable < Exception
+  end
+end

data/lib/eyemap/eyemap.rb

@@ -0,0 +1,238 @@
+require 'net/imap'
+
+begin
+    require 'rubygems'
+rescue LoadError => e
+end
+
+require 'active_support'
+
+#
+# EyeMap - an Objective interface to IMAP
+#
+# Those who have worked with IMAP should know that the servers that
+# implement it have a world of hurt coming to them, and that's why
+# they don't implement every single part of the spec right. There are
+# too many SHOULD's and not enough MUST's.
+#
+# Anyways, our solution to this model is pretty simple. Provide
+# drivers for the IMAP servers, which control their quirks, and
+# present a unified interface in which the user does not have to care
+# about the nasty underpinnings and can just get work done.
+#
+# EyeMap is a part of the Re: Mail project.
+#
+# To connect to an IMAP store, use the EyeMap.connect() call.
+#
+# To figure out what to do after you've got your connection, look at
+# the methods in EyeMap::Driver.
+#
+
+class EyeMap
+
+    # 
+    # EyeMap::Driver - Top level calls for IMAP connections.
+    #
+    # <documentation about implementing a driver goes here>
+    # 
+
+    class Driver 
+        protected
+
+        #
+        # Assign a driver capability in key/value format.
+        #
+
+        def []=(key, value)
+            @capabilities[key] = value
+        end
+
+        public 
+
+        #
+        # Create a new driver object. This really shouldn't be called by
+        # itself, but as a super() method, as it just fills in defaults
+        # intended to be overridden.
+        #
+
+        def initialize(args)
+            args = args[0]
+
+            if ! args.include? :user or 
+                ! args.include? :password or
+                ! args.include? :host
+
+                raise EyeMap::Exception::BadCall.new("User, Password and Host must be provided to connect")
+
+            end
+            @capabilities        = EyeMap::Capabilities.new
+            self[:driver_class]  = args[:driver_class]
+            self[:driver]        = args[:driver]
+            self[:message_class] = EyeMap::Message
+            self[:folder_class]  = EyeMap::Folder
+            self[:delimiter]     = '/'
+            self[:user]          = args[:user]
+            self[:password]      = args[:password]
+            self[:host]          = args[:host]
+            self[:auth_mech]     = 'LOGIN' # for now
+            self[:ssl]           = !!args[:ssl]
+            self[:verify_ssl]    = args[:ssl] ? !!args[:verify_ssl] : false
+            self[:cert]          = args[:cert]
+
+            if ! args[:port]
+                args[:port] = args[:ssl] ? 993 : 143
+            end
+
+            self[:port] = args[:port] 
+
+        end
+
+        #
+        # Fetch a capability. Capabilities are a struct, but are presented
+        # in hash form. See EyeMap::Capabilities for more information.
+        #
+
+        def [](key)
+            return @capabilities[key]
+        end
+
+        #
+        # Creates a new folder with the name specified.
+        #
+
+        def create(folder_name)
+            self.conn.create(folder_name)
+            self[:folder_class].new(folder_name, self, self[:delimiter])
+        end
+
+        #
+        # Get an EyeMap::Folder (or derivative) object for the name of
+        # the folder in question. Requires the full folder name.
+        #
+
+        def folder(folder_name=nil)
+            return self[:folder_class].
+                new(folder_name,
+                    self,
+                    self[:delimiter])
+        end
+
+        #
+        # Get the underlying Net::IMAP connection.
+        #
+
+        def conn
+            @conn
+        end
+
+        #
+        # Returns true if the connection is still alive.
+        #
+
+        def connected?
+            ! @conn.disconnected?
+        end
+
+        #
+        # Initiates a connection (or reconnection) to the server.
+        #
+
+        def connect
+            if @conn and connected?
+                begin
+                    @conn.authenticate("LOGIN", self[:user], self[:password]) unless
+                    @conn.login(self[:user], self[:password]) 
+                rescue Exception => e
+                end
+
+            else
+                @conn = Net::IMAP.new(self[:host], self[:port], 
+                                      self[:ssl], self[:cert], 
+                                      self[:verify_ssl])
+                connect() # recurse
+            end
+        end
+
+        #
+        # Disconnect from the server
+        #
+
+        def disconnect
+            @conn.disconnect
+        end
+
+    end # Driver
+
+    #
+    # Use a driver to connect to an IMAP store.
+    #
+    # The arguments here are a collection of EyeMap::Capabilities
+    # items. If there are any driver-specific items, those will be noted
+    # for that driver. Please read the documentation for both.
+    #
+    # Capabilities are /driver/ capabilities and not IMAP capabilities in
+    # the traditional sense (although there are a few correlations). 
+    #
+    # You will generally not work with these directly, outside of passing
+    # them to the EyeMap.connect() call, or if you're writing a
+    # driver.
+    #
+    # All items are symbols, so while not listed here, they start with a colon:
+    #
+    # * delimiter:     The folder delimiter that the IMAP server uses.
+    # * folder_class:  The class that new folder objects are created from.
+    # * message_class: The class that new message objects are created
+    #   from.
+    # * driver_class:  Calculated from 'driver', this is the class of
+    #   the driver that is being used.
+    # * driver:        The 'text' name of the driver, used to locate the
+    #   driver.
+    # * user:          The username to connect to the IMAP store with.
+    # * password:      The password to connect to the IMAP store with.
+    # * host:          The host of the IMAP store.
+    # * ssl:           Set to true to use SSL to connect to the IMAP
+    #   store.
+    # * auth_mech:     The authentication mechanism to use.
+    # * verify_ssl:    Verify our SSL connection?
+    # * port:          The port to use in our IMAP connection.
+    # * cert:          The certificate to use (SSL only)
+    #
+
+    def EyeMap.connect(*args)
+        args = args[0]
+
+        if ! args[:driver]
+            args[:driver] = 'auto'
+        end
+
+        # require the appropriate driver from the driver/ directory
+        begin
+            require "eyemap/drivers/#{args[:driver]}"
+        rescue LoadError => e
+            throw EyeMap::Exception::InvalidDriver.new("Driver '#{args[:driver]}' doesn't exist or isn't working properly.")
+        end
+
+        # fetch the driver's class object from the symbol table (Kernel is hte root level)
+        # and store it in the :driver_class argument.
+        args[:driver_class] = EyeMap::Driver.const_get(Inflector.camelize(args[:driver]).to_sym)
+
+        # call, connect, and return the value of the constructor
+        obj = args[:driver_class].new(args)
+
+        obj.connect()
+        return obj
+
+    end
+
+    def initialize
+        throw EyeMap::Exception::BadCall.new("Use EyeMap.connect() to connect to a driver")
+    end
+
+end # EyeMap
+
+EyeMap::Capabilities = Struct.new(:delimiter,     :folder_class,
+                                  :message_class, :driver_class,
+                                  :driver, :user, :password,
+                                  :host, :ssl,    :auth_mech,
+                                  :verify_ssl,    :port,
+                                  :cert)

data/lib/eyemap/folder.rb

@@ -0,0 +1,211 @@
+class EyeMap::Folder
+
+    attr_reader :properties
+    attr_reader :folder_name
+    attr_reader :driver
+    attr_reader :delimiter
+
+    #
+    # Constructor. Inheriting drivers must implement this interface.
+    #
+
+    def initialize(folder_name, driver, delimiter, properties={ })
+        @driver = driver
+        @folder_name = (folder_name and folder_name.length > 0) ? folder_name : "INBOX"
+        @folder_name.freeze
+        @delimiter = delimiter
+        @properties = properties || Hash.new
+    end
+
+    #
+    # Get a specific folder underneath this one.
+    #
+
+    def folder(folder_name)
+        self.class.new(@folder_name + @delimiter + folder_name,
+                       @driver,
+                       @delimiter)
+    end
+
+    # return the 'short name' of the folder - the name of the folder
+    # without anything "lower" than the delimiter (including the
+    # delimiter itself).
+
+    def short_name
+        return @folder_name.sub(/.*?([^#{@delimiter}]+)$/, '\1')
+    end
+
+    #
+    # Get the list of subfolders for this folder.
+    #
+
+    def subfolders
+        list = @driver.conn.list(@folder_name, "%")
+
+        retval = []
+
+        if list
+            list.each do |f|
+                retval.push(@driver[:folder_class].
+                            new(f.name, @driver, f.delim,
+                                # deep copy
+                                Marshal.load(Marshal.dump(f.attr))))
+            end
+        end
+
+        return retval
+    end
+
+    #
+    # Returns all the folders below this folder in a series of ::Folder objects.
+    #
+
+    def folder_tree
+        skel = { :folder => nil, :children => [] }
+        retval = []
+        subfolders.each do |sub|
+            folder = skel.dup
+            folder[:folder] = sub
+            folder[:children] = folder[:folder].folder_tree
+            retval.push(folder)
+        end
+
+        return retval
+    end
+
+    def total
+        @driver.conn.status(@folder_name, ["MESSAGES"])["MESSAGES"]
+    end
+
+    def recent
+        @driver.conn.status(@folder_name, ["RECENT"])["RECENT"]
+    end
+
+    def unseen
+        @driver.conn.status(@folder_name, ["UNSEEN"])["UNSEEN"]
+    end
+
+    def find_message(message_id)
+        @driver.conn.examine(@folder_name)
+
+        if ! message_id.kind_of? Numeric
+            raise EyeMap::Exception::BadCall.new("Message ID must be numeric")
+        end
+
+        messages = @driver.conn.fetch(message_id, "UID")
+        uid = nil
+
+        uid = messages[0].attr["UID"] if messages[0]
+
+        return @driver[:message_class].new(uid, @folder_name, @driver) if uid
+
+        return nil
+    end
+
+    #
+    # Search through a range of message ids (or an array of them).
+    #
+    # pass 'nil' to search for all messages (the default)
+    #
+
+    def find_messages(message_ids=nil)
+        # this next line of code would be great for AOP
+        @driver.conn.examine(@folder_name)
+        messages = []
+
+        if message_ids.kind_of? Range
+            query = "#{message_ids.first}:#{message_ids.last}"
+        elsif message_ids.kind_of? Array
+            query = message_ids.join(",")
+        elsif ! message_ids
+            query = "ALL"
+        elsif message_ids.kind_of? Numeric
+            return [find_message(message_ids)]
+        else
+            raise EyeMap::Exception::BadCall.new("Invalid query parameters")
+        end
+
+        @driver.conn.uid_search([query]).each do |uid|
+            messages.push(@driver[:message_class].
+                          new(uid, @folder_name, @driver))
+        end
+
+        return messages
+
+    end
+
+    #
+    # Get a list of valid messages for the current folder, that contain
+    # the number of items per page and reflect the current "page" for
+    # that inbox: page = (num_per_page * 10) - 9 -> (num_per_page *
+    # 10). The reason for this is that IMAP message id's start with 1.
+    #
+
+    def paginate_headers(page, num_per_page=10)
+        @driver.conn.examine(@folder_name)
+        uids = @driver.conn.uid_search(["ALL"])
+
+        # get out now if we don't have any messages.
+        unless uids and uids.length > 0
+            return []
+        end
+
+        # for our query, the high and low mid's, respective to the array.
+        low_mid  = (page * num_per_page) - (num_per_page - 1)
+        high_mid = page * num_per_page
+
+        # no messages this high
+        if uids[low_mid].nil?
+            return []
+        end
+
+        if uids[high_mid].nil?
+            high_mid = -1
+        end
+
+        return uids[low_mid..high_mid]
+
+    end
+
+    #
+    # Permanently deletes all messages marked with the :Deleted flag
+    #
+
+    def expunge
+        @driver.conn.examine(@folder_name)
+        @driver.conn.expunge()
+    end
+
+    #
+    # Creates a new folder underneath this one with the name specified.
+    #
+    # It will prepend the current folder information and the delimiter
+    # to the folder name passed.
+    #
+
+    def create(folder_name)
+        new_folder = @folder_name + @delimiter + folder_name
+        @driver.conn.create(new_folder)
+        self.class.new(new_folder, @driver, @delimiter)
+    end
+
+    #
+    # Delete this folder.
+    #
+
+    def delete
+        @driver.conn.delete(@folder_name)
+    end
+
+    #
+    # Add a new message to this folder.
+    #
+    # Our message in this case is just a block of text. This does not use a message object.
+    #
+
+    def add_message(message_text)
+        @driver.conn.append(@folder_name, message_text.gsub(/[^\r]\n/, "\r\n"),
+                            [], Time.now)
+    end
+
+end

data/lib/eyemap/message.rb

@@ -0,0 +1,99 @@
+class EyeMap::Message
+
+    def initialize(uid, folder_name, driver)
+        @uid = uid
+        @folder_name = folder_name
+        @driver = driver 
+    end
+
+    def envelope
+        @driver.conn.uid_fetch(@uid, "ENVELOPE")[0].attr["ENVELOPE"]
+    end
+
+    def move(folder)
+        copy(folder)
+        delete
+    end
+
+    def copy(folder)
+        @driver.conn.uid_copy(@uid, folder.folder_name)
+    end
+
+    #
+    # Fetches headers and sanitizes various fields from the IMAP message.
+    # Takes an array of header names.
+    #
+
+    def headers(headers)
+        @driver.conn.examine(@folder_name)
+
+        fetch_command = "BODY.PEEK[HEADER.FIELDS ("
+
+        fetch_fields = ""
+        headers.each do |h|
+            fetch_fields << h << " "
+        end
+
+        fetch_command << fetch_fields.strip << ")]"
+
+        return_headers = Hash.new
+
+        # send the command - Net::IMAP returns the value as 
+        # BODY[HEADER.FIELDS instead of
+        # BODY.PEEK[HEADER.FIELDS, so we compensate for that.
+        body = @driver.conn.uid_fetch(@uid, fetch_command)[0].
+            attr["BODY[HEADER.FIELDS (" + fetch_fields.upcase.strip + ")]"]
+
+        # pull out the fields we just nabbed
+
+        headers.each do |h|
+            r = Regexp.new %r!(?:^|\r\n)(#{h}:.+?)\r\n!i
+            header = nil
+            while m = r.match(body)
+                match = m[1]
+                match.sub! /^#{h}:\s/, ""
+
+                if header
+                    header = [header] unless header.kind_of? Array
+                    header.push(match)
+                else
+                    header = match 
+                end
+
+                body.sub! /(?:^|\r\n)(#{h}:.+?)\r\n/i, ""
+            end
+
+            return_headers[h] = header
+        end
+
+        return return_headers
+
+    end
+
+    #
+    # Delete a message from the mail store.
+    #
+    # Unfortunately, as soon as you close this mailbox or select
+    # another, the messages that were marked deleted will be expunged
+    # due to the nature of the IMAP protocol.
+    #
+    # Instead of using this call at all, it would be wiser to move your
+    # messages to delete to a separate folder and then delete them there
+    # when you are ready.
+    #
+
+    def delete()
+        @driver.conn.select(@folder_name)
+        @driver.conn.uid_store(@uid, "+FLAGS", [:Deleted])
+    end
+
+    #
+    # This does the opposite of delete()
+    #
+
+    def undelete()
+        @driver.conn.select(@folder_name)
+        @driver.conn.uid_store(@uid, "-FLAGS", [:Deleted])
+    end
+
+end

data/lib/eyemap/search.rb

@@ -0,0 +1,2 @@
+class EyeMap::Search
+end

data/test/activeimap.rb

@@ -0,0 +1,160 @@
+require 'test/unit'
+require 'eyemap'
+
+Dir['lib/eyemap/drivers/*.rb'].each do |x|
+    load x
+end
+
+$USER         = ENV['EYEMAP_USER']
+$PASS         = ENV['EYEMAP_PASS']
+$HOST         = ENV['EYEMAP_HOST']
+$DOVECOT_PORT = ENV['EYEMAP_DOVECOT_PORT']
+$COURIER_PORT = ENV['EYEMAP_COURIER_PORT']
+
+#
+# Most of the tests just work against dovecot and courier right now.
+#
+# Ideally, we should have tests which work against each connection in their
+# own test file with a driver or something that communicates with a inner series
+# of tests. These tests would assert general functionality while maintaining their
+# specific-ness.
+#
+
+module GenericTestsMain
+
+    def test_folder
+        assert_kind_of(EyeMap::Folder, @conn.folder)
+    end
+
+    def test_capabilities
+        assert_kind_of(Class,  @conn[:driver_class])
+        assert_kind_of(Class,  @conn[:message_class])
+        assert_kind_of(Class,  @conn[:folder_class])
+        assert_kind_of(String, @conn[:driver])
+    end
+
+    def test_connections
+        assert(@conn.connected?)
+        assert_nothing_raised() { @conn.disconnect }
+        assert(!@conn.connected?)
+        assert_nothing_raised() { @conn.connect }
+        assert(@conn.connected?)
+    end
+
+end
+
+module GenericTestsFolder
+
+    def test_subfolders_and_create_and_delete
+        if @conn[:driver_class] == EyeMap::Driver::Dovecot
+            assert_nothing_raised() { @conn.folder.subfolders }
+            assert_equal([], @conn.folder.subfolders)
+            assert_raise(EyeMap::Exception::DriverIncapable) do
+                @conn.folder.folder("monkey")
+            end
+            assert_raise(EyeMap::Exception::DriverIncapable) do
+                @conn.folder.create
+            end
+        else
+            folders = nil
+            assert_nothing_raised() { folders = @conn.folder.subfolders }
+
+            if folders.collect { |f| f.short_name }.include? "monkey"
+                assert_nothing_raised() { @conn.folder.folder("monkey").delete }
+            else
+                assert_raise(Net::IMAP::NoResponseError) { @conn.folder.folder("monkey").delete }
+            end
+
+            assert_kind_of(EyeMap::Folder, @conn.folder.create("monkey"))
+            assert_nothing_raised() { @conn.folder.folder("monkey").delete }
+        end
+    end # test_subfolders_and_create_and_delete
+
+    def test_short_name
+        assert_equal(@conn.folder("INBOX").folder_name, @conn.folder("INBOX").short_name)
+
+        unless @conn[:driver_class] == EyeMap::Driver::Dovecot
+            assert_nothing_raised() { @conn.folder("INBOX").create("Monkey") }
+            assert_equal("Monkey", @conn.folder("INBOX").folder("Monkey").short_name)
+            assert_nothing_raised() { @conn.folder("INBOX").folder("Monkey").delete }
+        end
+    end # test_short_name
+
+end
+
+module GenericTestsMessage
+    def test_message
+        message = ""
+        assert_nothing_raised() do
+            f = File.open("test/test_message")
+            tmp_irs = $/
+                $/ = nil
+            message << f.readline
+            $/ = tmp_irs
+            f.close
+        end
+
+        folder = nil
+        new_message = nil
+
+        assert_nothing_raised() do
+            if @conn[:driver_class] == EyeMap::Driver::Dovecot
+                folder = @conn.create("EyeMap")
+            else
+                folder = @conn.folder.create("EyeMap")
+            end
+        end
+
+        assert_nothing_raised() do 
+            @conn.folder.add_message(message.gsub(/(?:[^\r])\n/, "\r\n")) 
+            # type change: String -> EyeMap::Message
+            message = @conn.folder.find_message(@conn.folder.total)
+            message.copy(folder)
+            new_message = @conn.folder(folder.folder_name).find_message(@conn.folder(folder.folder_name).total)
+        end
+
+        assert_equal(new_message.headers(%w(Subject)), message.headers(%w(Subject)))
+
+        assert_nothing_raised() do 
+            new_message.delete
+            message.move(folder)
+            new_message = @conn.folder(folder.folder_name).find_message(@conn.folder(folder.folder_name).total)
+        end
+
+        assert_equal(new_message.headers(%w(Subject)), message.headers(%w(Subject)))
+
+        assert_nothing_raised() do 
+            new_message.delete
+            folder.delete
+        end
+    end
+end
+
+class TestDovecotEyeMap < Test::Unit::TestCase
+
+    def setup
+        @conn = EyeMap.connect(:driver   => 'dovecot', 
+                               :user     => $USER,
+                               :password => $PASS,
+                               :port     => $DOVECOT_PORT,
+                               :host     => $HOST)
+    end
+
+    include GenericTestsMain
+    include GenericTestsFolder
+    include GenericTestsMessage
+end
+
+class TestCourierEyeMap < Test::Unit::TestCase
+    def setup
+        @conn = EyeMap.connect(:driver   => 'courier', 
+                               :port     => $COURIER_PORT,
+                               :user     => $USER,
+                               :password => $PASS,
+                               :host     => $HOST)
+    end
+
+    include GenericTestsMain
+    include GenericTestsFolder
+    include GenericTestsMessage
+end

data/test/test_message

@@ -0,0 +1,6 @@
+From: testmonkey@example.org
+To: testmonkey@example.org
+Subject: ActiveIMAP Test Message
+
+hello there
+

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: eyemap
+version: !ruby/object:Gem::Version 
+  version: 0.8.0
+date: 2007-03-26 00:00:00 -07:00
+summary: Provides a Driver Architecture and Framework for talking to IMAP servers
+require_paths: 
+- lib
+email: erik@hollensbe.org
+homepage: 
+rubyforge_project: eyemap
+description: 
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Erik Hollensbe
+files: 
+- lib/eyemap.rb
+- lib/eyemap/exception.rb
+- lib/eyemap/eyemap.rb
+- lib/eyemap/folder.rb
+- lib/eyemap/message.rb
+- lib/eyemap/search.rb
+- lib/eyemap/drivers/auto.rb
+- lib/eyemap/drivers/courier.rb
+- lib/eyemap/drivers/courier_folder.rb
+- lib/eyemap/drivers/dovecot.rb
+- lib/eyemap/drivers/dovecot_folder.rb
+- test/activeimap.rb
+- test/test_message
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: