ruby-gmail 0.0.1

data/.autotest

@@ -0,0 +1,23 @@
+# -*- ruby -*-
+
+require 'autotest/restart'
+
+# Autotest.add_hook :initialize do |at|
+#   at.extra_files << "../some/external/dependency.rb"
+#
+#   at.libs << ":../some/external"
+#
+#   at.add_exception 'vendor'
+#
+#   at.add_mapping(/dependency.rb/) do |f, _|
+#     at.files_matching(/test_.*rb$/)
+#   end
+#
+#   %w(TestA TestB).each do |klass|
+#     at.extra_class_map[klass] = "test/test_misc.rb"
+#   end
+# end
+
+# Autotest.add_hook :run_command do |at|
+#   system "rake build"
+# end

data/History.txt

@@ -0,0 +1,6 @@
+=== 0.0.1 / 2009-11-18
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,13 @@
+.autotest
+History.txt
+lib/gmail/mailbox.rb
+lib/gmail/message.rb
+lib/gmail.rb
+lib/ietf/rfc2045.rb
+lib/ietf/rfc822.rb
+lib/mime/entity.rb
+lib/mime/message.rb
+lib/smtp_tls.rb
+Manifest.txt
+Rakefile
+README.txt

data/README.txt

@@ -0,0 +1,77 @@
+= ruby-gmail
+
+* http://github.com/dcparker/ruby-gmail
+
+== DESCRIPTION:
+
+A Rubyesque interface to Gmail. Connect to Gmail via IMAP and manipulate emails and labels. Send email with your Gmail account via SMTP. Includes full support for parsing and generating MIME messages.
+
+== FEATURES/PROBLEMS:
+
+* Read emails via IMAP
+* Full MIME parsing ability, with understanding of attachments
+* Create, rename, and delete labels
+* Label, archive, delete, mark as read/unread/spam
+* Send emails via SMTP
+* Full ability to generate MIME messages including inline images and attachments
+
+== SYNOPSIS:
+
+  gmail = Gmail.new(username, password)
+  gmail.inbox.count # => {:unread => 2, :read => 41, }
+  unread = gmail.inbox.emails(:unread)
+  unread[0].archive!
+  unread[1].delete!
+  unread[2].move_to('FunStuff') # => Labels 'FunStuff' and removes from inbox
+  unread[3].message # => a MIME::Message, parsed from the email body
+  unread[3].mark(:read)
+  unread[3].message.attachments.length
+  unread[4].label('FunStuff') # => Just adds the label 'FunStuff'
+  unread[4].message.save_attachments_to('path/to/save/into')
+  unread[5].message.attachments[0].save_to_file('path/to/save/into')
+  unread[6].mark(:spam)
+  
+  new_email = MIME::Message.generate
+  new_email.to "email@example.com"
+  new_email.subject "Having fun in Puerto Rico!"
+  plain, html = new_email.generate_multipart('text/plain', 'text/html')
+  plain.content = "Text of plain message."
+  html.content = "<p>Text of <em>html</em> message.</p>"
+  new_email.attach_file('some_image.dmg')
+  gmail.send_email(new_email)
+
+== REQUIREMENTS:
+
+* ruby
+* net/smtp
+* net/imap
+* gem shared-mime-info
+
+== INSTALL:
+
+* [sudo] gem install ruby-gmail -s http://gemcutter.org
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 BehindLogic.com
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,9 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+
+Hoe.spec 'ruby-gmail' do
+  developer 'Daniel Parker', 'gems@behindlogic.com'
+  extra_deps << ['shared-mime-info', '>= 0']
+end

data/lib/gmail.rb

@@ -0,0 +1,95 @@
+require 'net/imap'
+require 'net/smtp'
+require 'smtp_tls'
+
+class Gmail
+  VERSION = '0.0.1'
+
+  attr_reader :imap
+
+  def initialize(username, password)
+    # This is to hide the username and password, not like it REALLY needs hiding, but ... you know.
+    meta = class << self
+      class << self
+        attr_accessor :username, :password
+      end
+      self
+    end
+    meta.username = username
+    meta.password = password
+    @imap = Net::IMAP.new('imap.gmail.com',993,true)
+    @connected = true if @imap.login(username, password)
+    at_exit { logout if @connected }
+  end
+
+  # Accessors for IMAP things
+  def mailbox(name)
+    mailboxes[name] ||= Mailbox.new(self, name)
+  end
+
+  # Accessors for Gmail things
+  def inbox
+    mailbox('inbox')
+  end
+  # Log out of gmail
+  def logout
+    @connected = false if @imap.logout
+  end
+
+  def in_mailbox(mailbox, &block)
+    raise ArgumentError, "Must provide a code block" unless block_given?
+    mailbox_stack << mailbox
+    unless @selected == mailbox.name
+      @gmail.imap.select(mailbox.name)
+      @selected = mailbox.name
+    end
+    value = block.arity == 1 ? block.call(mailbox) : block.call
+    mailbox_stack.pop
+    # Select previously selected mailbox if there is one
+    if mailbox_stack.last
+      @gmail.imap.select(mailbox_stack.last.name)
+      @selected = mailbox.name
+    end
+    return value
+  end
+
+  def open_smtp(&block)
+    raise ArgumentError, "This method is to be used with a block." unless block_given?
+    meta = class << self; self end
+    puts "Opening SMTP..."
+    Net::SMTP.start('smtp.gmail.com', 587, 'localhost.localdomain', meta.username, meta.password, 'plain', true) do |smtp|
+      puts "SMTP open."
+      block.call(lambda {|to, body|
+        from = meta.username =~ /@/ ? meta.username : meta.username + '@gmail.com'
+        puts "Sending from #{from} to #{to}:\n#{body}"
+        smtp.send_message(body, from, to)
+      })
+      puts "SMTP closing."
+    end
+    puts "SMTP closed."
+  end
+  
+  def send_email(to, body=nil)
+    meta = class << self; self end
+    if to.is_a?(MIME::Message)
+      to.headers['from'] = meta.username =~ /@/ ? meta.username : meta.username + '@gmail.com'
+      body = to.to_s
+      to = to.to
+    end
+    raise ArgumentError, "Please supply (to, body) to Gmail#send_email" if body.nil?
+    open_smtp do |smtp|
+      smtp.call to, body
+    end
+  end
+  
+  private
+    def mailboxes
+      @mailboxes ||= {}
+    end
+    def mailbox_stack
+      @mailbox_stack ||= []
+    end
+end
+
+require 'gmail/mailbox'
+require 'gmail/message'

data/lib/gmail/mailbox.rb

@@ -0,0 +1,37 @@
+class Gmail
+  class Mailbox
+    attr_reader :name
+
+    def initialize(gmail, name)
+      @gmail = gmail
+      @name = name.is_a?(Symbol) ? name.to_s.upcase : name
+    end
+
+    def inspect
+      "<#Mailbox name=#{@name}>"
+    end
+
+    def to_s
+      name
+    end
+
+    # Method: emails
+    # Args: [ :all | :unread | :read ]
+    def emails(key = :all)
+      aliases = {
+        :all => ['ALL'],
+        :unread => ['UNSEEN'],
+        :read => ['SEEN']
+      }
+      # puts "Gathering #{(aliases[key] || key).inspect} messages for mailbox '#{name}'..."
+      @gmail.in_mailbox(name) do
+        @gmail.imap.uid_search(aliases[key] || key).collect { |uid| messages[uid] ||= Message.new(@gmail, self, uid) }
+      end
+    end
+
+    private
+      def messages
+        @messages ||= {}
+      end
+  end
+end

data/lib/gmail/message.rb

@@ -0,0 +1,81 @@
+require 'mime/message'
+class Gmail
+  class Message
+    def initialize(gmail, mailbox, uid)
+      @gmail = gmail
+      @mailbox = mailbox
+      @uid = uid
+    end
+    def inspect
+      "<#Message:#{object_id} mailbox=#{mailbox.name}#{' uid='+@uid if @uid}#{' message_id='+@message_id if @message_id}>"
+    end
+
+    # Auto IMAP info
+    def uid
+      @uid ||= @gmail.imap.uid_search(['HEADER', 'Message-ID', message_id])[0]
+    end
+    def message_id
+      @message_id || begin
+        @gmail.in_mailbox(@mailbox.name) do
+          @message_id = @gmail.imap.uid_fetch(@uid, ['ENVELOPE'])[0].attr['ENVELOPE'].message_id
+        end
+      end
+      @message_id
+    end
+    def body
+      @body ||= @gmail.in_mailbox(@mailbox.name) do
+        @gmail.imap.uid_fetch(uid, "RFC822")[0].attr["RFC822"]
+      end
+    end
+
+    # Parsed MIME message object
+    def message
+      @message ||= MIME::Message.new(body)
+    end
+
+    # IMAP Operations
+    def flag(flg)
+      @gmail.in_mailbox(@mailbox.name) do
+        @gmail.imap.uid_store(uid, "+FLAGS", [flg])
+      end
+    end
+    def unflag(flg)
+      @gmail.in_mailbox(@mailbox.name) do
+        @gmail.imap.uid_store(uid, "-FLAGS", [flg])
+      end
+    end
+
+    # Gmail Operations
+    def mark(flag)
+      case flag
+      when :read
+        flag(:Seen)
+      when :unread
+        unflag(:Seen)
+      when :deleted
+        flag(:Deleted)
+      when :spam
+        move_to('[Gmail]/Spam')
+      end
+    end
+    def delete!
+      @mailbox.messages.delete(uid)
+      flag(:Deleted)
+    end
+    def label(name)
+      @gmail.in_mailbox(@mailbox.name) do |m|
+        m.gmail.imap.uid_copy(uid, name)
+      end
+    end
+    # We're not sure of any 'labels' except the 'mailbox' we're in at the moment.
+    # Research whether we can find flags that tell which other labels this email is a part of.
+    # def remove_label(name)
+    # end
+    def move_to(name)
+      label(name) && delete!
+    end
+    def archive!
+      move_to('[Gmail]/All Mail')
+    end
+  end
+end

data/lib/ietf/rfc2045.rb

@@ -0,0 +1,25 @@
+require 'ietf/rfc822'
+module IETF
+  module RFC2045
+    def self.parse_rfc2045_from(raw)
+      headers, raw = IETF::RFC822.parse_rfc822_from(raw)
+
+      if headers['content-type'] =~ /multipart\/(\w+); boundary=(.*)/
+        content = {}
+        content[:type] = $1
+        content[:boundary] = $2
+        content[:content] = IETF::RFC2045.parse_rfc2045_content_from(raw, content[:boundary])
+      else
+        content = raw
+      end
+
+      return [headers, content]
+    end
+
+    def self.parse_rfc2045_content_from(raw, boundary)
+      raw.split(/#{CRLF.source}--#{boundary}(?:--)?(?:#{CRLF.source}|$)/).collect {|part|
+        IETF::RFC2045.parse_rfc2045_from(part)
+      }
+    end
+  end
+end

data/lib/ietf/rfc822.rb

@@ -0,0 +1,21 @@
+module IETF
+  CRLF = /\r\n/ # We can be a little lax about those carriage-returns.
+  TEXT = /.+?(?=#{CRLF.source}|$)/
+  HTAB = Regexp.new(11.chr)
+  LWSP_CHAR = /[ \t#{HTAB.source}]/
+  CTL = Regexp.new([(0...37).to_a,177].flatten.map {|i| i.chr}.join)
+  FIELD_BODY = /#{TEXT.source}(?:#{CRLF.source}#{LWSP_CHAR.source}#{TEXT.source})*/
+  FIELD_NAME = /^[^#{CTL.source} :]+/
+  FIELD = /(#{FIELD_NAME.source}):\s*(#{FIELD_BODY.source})/
+  module RFC822
+    def self.parse_rfc822_from(raw)
+      headers = {}
+      # Parse out rfc822 (headers)
+      head, remaining_raw = raw.split(/#{CRLF.source}#{CRLF.source}/,2)
+      head.scan(FIELD) do |field_name, field_body|
+        headers[field_name.downcase] = field_body
+      end
+      return [headers, remaining_raw]
+    end
+  end
+end

data/lib/mime/entity.rb

@@ -0,0 +1,187 @@
+String::ALPHANUMERIC_CHARACTERS = ('a'..'z').to_a + ('A'..'Z').to_a unless defined? String::ALPHANUMERIC_CHARACTERS
+def String.random(size)
+  length = String::ALPHANUMERIC_CHARACTERS.length
+  (0...size).collect { String::ALPHANUMERIC_CHARACTERS[Kernel.rand(length)] }.join
+end
+
+module MIME
+  def self.capitalize_header(header_name)
+    header_name.gsub(/^(\w)/) {|m| m.capitalize}.gsub(/-(\w)/) {|n| '-' + n[1].chr.capitalize}
+  end
+  class Entity
+    def initialize(arg=nil)
+      if arg.is_a?(String)
+        @raw = arg
+        from_parsed(IETF::RFC2045.parse_rfc2045_from(@raw))
+      elsif arg.is_a?(Hash)
+        @headers = arg
+      end
+    end
+
+    def inspect
+      "<#{self.class.name}##{object_id} Headers:{#{headers.collect {|k,v| "#{k}=#{v}"}.join(' ')}} content:#{multipart? ? 'multipart' : 'flat'}>"
+    end
+
+    def parsed
+      IETF::RFC2045.parse_rfc2045_from(@raw)
+    end
+
+    # This means we have a structure from IETF::RFC2045.
+    # Entity is: [headers, content], while content may be an array of Entities.
+    # Or, {:type, :boundary, :content}
+    def from_parsed(parsed)
+      case parsed
+      when Array
+        puts "Parsed: #{parsed[0].class.name}, #{parsed[1].class.name}"
+        if parsed[0].is_a?(Hash) && (parsed[1].is_a?(Hash) || parsed[1].is_a?(String))
+          @headers = parsed[0]
+          @content = parsed[1].is_a?(Hash) ? parsed[1][:content].collect {|p| Entity.new.from_parsed(p)} : parsed[1]
+          if parsed[1].is_a?(Hash)
+            @multipart_type = parsed[1][:type]
+            @multipart_boundary = parsed[1][:boundary]
+          end
+        else
+          puts " -> fail"
+        end
+        return self
+      when Hash
+        puts "Parsed: #{parsed.keys.sort.inspect}"
+        if parsed.has_key?(:type) && parsed.has_key?(:boundary) && parsed.has_key?(:content)
+          @content = parsed[:content].is_a?(Array) ? parsed[:content].collect {|p| Entity.new.from_parsed(p)} : parsed[:content]
+        else
+          puts " -> fail"
+        end
+        return self
+      end
+      raise ArgumentError, "Must pass in either: [an array with two elements: headers(hash) and content(string or array)] OR [a hash containing :type, :boundary, and :content(being the former or a string)]"
+    end
+
+    ##############
+    # ATTRIBUTES #
+
+    # An Entity has Headers.
+    def headers
+      @headers ||= {}
+    end
+    # An Entity has Content.
+    #   IF the Content-Type is a multipart type,
+    #   the content will be one or more Entities.
+    attr_reader :content, :multipart_type
+
+    #################
+    # Macro Methods #
+
+    def multipart?
+      !!(headers['content-type'] =~ /multipart\//)
+    end
+    def multipart_type
+      if headers['content-type'] =~ /multipart\/(\w+)/
+        $1
+      end
+    end
+    # Auto-generates a boundary if one doesn't yet exist.
+    def multipart_boundary
+      return nil unless multipart?
+      @multipart_boundary || begin
+        # Content-Type: multipart/mixed; boundary=000e0cd28d1282f4ba04788017e5
+        @multipart_boundary = String.random(25)
+        headers['content-type'] = "multipart/#{multipart_type}; boundary=#{@multipart_boundary}"
+        @multipart_boundary
+      end
+    end
+    def attachment?
+      headers['content-disposition'] =~ /^attachment(?=;|$)/
+    end
+    def attachment_filename
+      # Content-Disposition: attachment; filename="summary.txt"
+      if headers['content-disposition'] =~ /^attachment; filename=[\"\']?([^\"\']+)/
+        $1
+      end
+    end
+    attr_accessor :encoding
+    def encoding
+      @encoding ||= headers['content-transfer-encoding'] || nil
+    end
+    def find_part(options)
+      find_parts(options).first
+    end
+    def find_parts(options)
+      parts = []
+        # Do I match your search?
+        iam = true
+        iam = false if options[:content_type] && headers['content-type'] !~ /^#{options[:content_type]}(?=;|$)/
+        iam = false if options[:content_disposition] && headers['content-disposition'] !~ /^#{options[:content_disposition]}(?=;|$)/
+        parts << self if iam
+        # Do any of my children match your search?
+        content.each do |part|
+          parts.concat part.find_parts(options)
+        end if multipart?
+      return parts
+    end
+
+    def save_to_file(path=nil)
+      filename = path if path && !File.exists?(path) # If path doesn't exist, assume it's a filename
+      filename ||= path + '/' + attachment_filename if path && attachment? # If path does exist, and we're saving an attachment, use the attachment filename
+      filename ||= (attachment? ? attachment_filename : path) # If there is no path and we're saving an attachment, use the attachment filename; otherwise use path (whether it is present or not)
+      filename ||= '.' # No path supplied, and not saving an attachment. We'll just save it in the current directory.
+      if File.directory?(filename)
+        i = 0
+        begin
+          i += 1
+          filename = filename + "/attachment-#{i}"
+        end until !File.exists(filename)
+      end
+      # After all that trouble to get a filename to save to...
+      File.open(filename, 'w') do |file|
+        file << decoded_content
+      end
+    end
+
+    ##########################
+    # CONVERTING / RENDERING #
+
+    # Renders this data structure into a string, encoded
+    def to_s
+      multipart_boundary # initialize the boundary if necessary
+      headers.inject('') {|a,(k,v)| a << "#{MIME.capitalize_header(k)}: #{v}\r\n"} + "\r\n" + if content.is_a?(Array)
+        "\r\n--#{multipart_boundary}\r\n" + content.collect {|part| part.to_s }.join("\r\n--#{multipart_boundary}\r\n") + "\r\n--#{multipart_boundary}--\r\n"
+      else
+        content.to_s
+      end
+    end
+
+    # Converts this data structure into a string, but decoded if necessary
+    def decoded_content
+      return nil if @content.is_a?(Array)
+      case encoding
+      when 'quoted-printable'
+        @content.unpack('M')[0]
+      when 'base64'
+        @content.unpack('m')[0]
+      else
+        @content
+      end
+    end
+
+    # You can set new content, and it will be saved in encoded form.
+    def content=(raw)
+      @content = raw.is_a?(Array) ? raw :
+        case encoding
+        when 'quoted-printable'
+          [raw].pack('M')
+        when 'base64'
+          [raw].pack('m')
+        else
+          raw
+        end
+    end
+
+    private
+      def transfer_to(other)
+        other.instance_variable_set(:@content, @content.dup)
+        other.headers.clear
+        other.headers.merge!(Hash[*headers.dup.select {|k,v| k =~ /content/}.flatten])
+      end
+
+  end
+end

data/lib/mime/message.rb

@@ -0,0 +1,68 @@
+require 'mime/entity'
+require 'shared-mime-info'
+module MIME
+  # A Message is really a MIME::Entity,
+  # but should be used for the outermost Entity, because
+  # it includes helper methods to access common data
+  # from an email message.
+  class Message < Entity
+    def self.generate
+      Message.new('date' => Time.now.strftime("%a, %d %b %Y %H:%M:%S %z"), 'mime-version' => '1.0')
+    end
+
+    def to(addressee=nil)
+      headers['to'] = addressee if addressee
+      headers['to'].match(/([A-Z0-9._%+-]+@[A-Z0-9._%+-]+\.[A-Z]+)/i)[1]
+    end
+
+    def subject(subj=nil)
+      headers['subject'] = subj if subj
+      headers['subject']
+    end
+
+    def from
+      headers['from'].match(/([A-Z0-9._%+-]+@[A-Z0-9._%+-]+\.[A-Z]+)/i)[1]
+    end
+
+    def attachments
+      find_parts(:content_disposition => 'attachment')
+    end
+
+    def save_attachments_to(path=nil)
+      attachments.each {|a| a.save_to_file(path) }
+    end
+
+    def generate_multipart(*content_types)
+      headers['content-type'] = 'multipart/alternative'
+      @content = content_types.collect { |content_type| Entity.new('content-type' => content_type) }
+    end
+
+    def attach_file(filename)
+      short_filename = filename.match(/([^\\\/]+)$/)[1]
+
+      # Generate the attachment piece
+      attachment = Entity.new(
+        'content-type' => MIME.check(filename).type + "; \r\n  name=\"#{short_filename}\"",
+        'content-disposition' => "attachment; \r\n  filename=\"#{short_filename}\"",
+        'content-transfer-encoding' => 'base64'
+      )
+      attachment.content = File.read(filename)
+      
+      # Enclose in a top-level multipart/mixed
+      if multipart? && multipart_type == 'mixed'
+        # If already enclosed, all we have to do is add the attachment part
+        (@content ||= []) << attachment
+      else
+        # Generate the new top-level multipart, transferring what is here already into a child object
+        new_content = Entity.new
+        # Whatever it is, since it's not multipart/mixed, transfer it into a child object and add the attachment.
+        transfer_to(new_content)
+        headers.reject! {|k,v| k =~ /content/}
+        headers['content-type'] = 'multipart/mixed'
+        @content = [new_content, attachment]
+      end
+
+      attachment
+    end
+  end
+end

data/lib/smtp_tls.rb

@@ -0,0 +1,94 @@
+require "openssl"
+require "net/smtp"
+
+Net::SMTP.class_eval do
+  
+  def self.start( address, port = nil,
+                  helo = 'localhost.localdomain',
+                  user = nil, secret = nil, authtype = nil, use_tls = false,
+                  &block) # :yield: smtp
+    new(address, port).start(helo, user, secret, authtype, use_tls, &block)
+  end
+
+  def start( helo = 'localhost.localdomain',
+             user = nil, secret = nil, authtype = nil, use_tls = false ) # :yield: smtp
+    start_method = use_tls ? :do_tls_start : :do_start
+    if block_given?
+      begin
+        send start_method, helo, user, secret, authtype
+        return yield(self)
+      ensure
+        do_finish
+      end
+    else
+      send start_method helo, user, secret, authtype
+      return self
+    end
+  end
+
+  private
+  
+  def do_tls_start(helodomain, user, secret, authtype)
+    raise IOError, 'SMTP session already started' if @started
+    if RUBY_VERSION == '1.8.6'
+      check_auth_args user, secret, authtype if user or secret
+    else
+      check_auth_args user, secret if user or secret
+    end
+
+    sock = timeout(@open_timeout) { TCPSocket.open(@address, @port) }
+    @socket = Net::InternetMessageIO.new(sock)
+    @socket.read_timeout = 60 #@read_timeout
+    @socket.debug_output = STDERR #@debug_output
+
+    check_response(critical { recv_response() })
+    do_helo(helodomain)
+
+    raise 'openssl library not installed' unless defined?(OpenSSL)
+    starttls
+    ssl = OpenSSL::SSL::SSLSocket.new(sock)
+    ssl.sync_close = true
+    ssl.connect
+    @socket = Net::InternetMessageIO.new(ssl)
+    @socket.read_timeout = 60 #@read_timeout
+    @socket.debug_output = STDERR #@debug_output
+    do_helo(helodomain)
+
+    authenticate user, secret, authtype if user
+    @started = true
+  ensure
+    unless @started
+      # authentication failed, cancel connection.
+        @socket.close if not @started and @socket and not @socket.closed?
+      @socket = nil
+    end
+  end
+
+  def do_helo(helodomain)
+     begin
+      if @esmtp
+        ehlo helodomain
+      else
+        helo helodomain
+      end
+    rescue Net::ProtocolError
+      if @esmtp
+        @esmtp = false
+        @error_occured = false
+        retry
+      end
+      raise
+    end
+  end
+
+  def starttls
+    getok('STARTTLS')
+  end
+
+  def quit
+    begin
+      getok('QUIT')
+    rescue EOFError, OpenSSL::SSL::SSLError
+    end
+  end
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification 
+name: ruby-gmail
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Daniel Parker
+autorequire: 
+bindir: bin
+cert_chain: 
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDNjCCAh6gAwIBAgIBADANBgkqhkiG9w0BAQUFADBBMQ0wCwYDVQQDDARnZW1z
+  MRswGQYKCZImiZPyLGQBGRYLYmVoaW5kbG9naWMxEzARBgoJkiaJk/IsZAEZFgNj
+  b20wHhcNMDkxMTE5MDQ0NzIzWhcNMTAxMTE5MDQ0NzIzWjBBMQ0wCwYDVQQDDARn
+  ZW1zMRswGQYKCZImiZPyLGQBGRYLYmVoaW5kbG9naWMxEzARBgoJkiaJk/IsZAEZ
+  FgNjb20wggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIBAQDs+2PvSoBC5mCz
+  Nm95RXKOb/u+CmPA70DoG9cF0zipCie003Vm0DYL3Rtobcr32eMvHxkWoJ6xoz0I
+  h74yNKtHjTTCxj86HWBPsE6xVMxVCftClndjCyKsiMiqvvp1wDNO0FFK+6LijmL3
+  2Xkp4brWq1JO92y9vYct34R7o2X//+nwZs+sss+EYhNdvdUJfWy7tA5dghGdLvRn
+  UhJJSAtTefkBCwO7bufLEt+n7wIRbiJJ5dDCwE3NIX4wUSrNeYwXGXA/Ybki+BUl
+  3KJF9IC0XR9fY9DGF0FXBKrkfDlZRrnQOem2aIxeuln0KQLJXXJuDTQPHO+mK3EG
+  UPhR7IAHAgMBAAGjOTA3MAkGA1UdEwQCMAAwCwYDVR0PBAQDAgSwMB0GA1UdDgQW
+  BBQn32ZStKmqwFqs2vuglYzkvDzBZjANBgkqhkiG9w0BAQUFAAOCAQEAe3Z+iMmy
+  IX9ChQW4hNNb1HOpgCMc2RL+vUwku9WE95dZ+BE4A6mOYTj5JXdYf4R4Z2vavr+d
+  nwJWtXPeIBWxireb8gUU0DwqodYTpsmkj5LD1zIaZ59rXlwDA9O0V4fwE1iRG5MD
+  mB7m8fT8WNOeg4AfjH4aSiHI1+HX1RQkc7KFdLotKnCevzYU6Jza5VUbXyJ+yCEH
+  DFARN3mkfGI+18MRDEi39nK2O/bBd6Wf0cYPEKsGQjNNAIBtv9belepSMd1KKfQ2
+  L7j8CnNDCrsHDe7/251D85wSvTH4Q/41NE5ahdCkkHwzDJeyhXpmNuUSswdn7woz
+  teST6sOe8lUhZQ==
+  -----END CERTIFICATE-----
+
+date: 2009-11-19 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: shared-mime-info
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.3
+    version: 
+description: A Rubyesque interface to Gmail. Connect to Gmail via IMAP and manipulate emails and labels. Send email with your Gmail account via SMTP. Includes full support for parsing and generating MIME messages.
+email: 
+- gems@behindlogic.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- .autotest
+- History.txt
+- lib/gmail/mailbox.rb
+- lib/gmail/message.rb
+- lib/gmail.rb
+- lib/ietf/rfc2045.rb
+- lib/ietf/rfc822.rb
+- lib/mime/entity.rb
+- lib/mime/message.rb
+- lib/smtp_tls.rb
+- Manifest.txt
+- Rakefile
+- README.txt
+has_rdoc: true
+homepage: http://github.com/dcparker/ruby-gmail
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: ruby-gmail
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A Rubyesque interface to Gmail
+test_files: []
+