gmail_gm_raw 0.4.3

data/TODO.md

@@ -0,0 +1,12 @@
+# TODO
+
+* Specs for xoauth 
+* Specs for message operations
+* Specs for filters in mailbox
+* Specs for current [Gmail IMAP extensions](http://code.google.com/apis/gmail/imap/)
+* Non-English accounts
+* Further implement [Gmail IMAP extensions](http://code.google.com/apis/gmail/imap/)
+  * add custom search (X-GM-RAW)
+  * add thread id (X-GM-THRID)
+* Export/Import to mbox format
+* Integration with [contacts](http://rubygems.org/gems/contacts) gem

data/gmail.gemspec

@@ -0,0 +1,34 @@
+# -*- encoding: utf-8 -*-
+
+$:.push File.expand_path('../lib', __FILE__)
+require 'gmail/version'
+
+Gem::Specification.new do |s|
+  s.name = "gmail_gm_raw"
+  s.summary = "A Rubyesque interface to Gmail, with all the tools you will need."
+  s.description = "A Rubyesque interface to Gmail, with all the tools you will need.
+  Search, read and send multipart emails; archive, mark as read/unread,
+  delete emails; and manage labels.
+  "
+  s.version = Gmail::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = ["Chris Kowalik"]
+  s.email = ["chris@nu7hat.ch"]
+  s.homepage = "http://github.com/nu7hatch/gmail"
+  
+  # runtime dependencies
+  s.add_dependency "mime", ">= 0.1"
+  s.add_dependency "mail", ">= 2.2.1"
+  s.add_dependency "gmail_xoauth", ">= 0.3.0"
+  
+  # development dependencies
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec", "~> 2.0"
+  s.add_development_dependency "mocha", ">= 0.9"
+  s.add_development_dependency "gem-release"
+  
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/gmail.rb

@@ -0,0 +1,65 @@
+require 'net/imap'
+require 'net/smtp'
+require 'mail'
+require 'date'
+require 'time'
+
+if RUBY_VERSION < "1.8.7"
+  require "smtp_tls"
+end
+
+class Object
+  def to_imap_date
+    Date.parse(to_s).strftime("%d-%B-%Y")
+  end
+end
+
+module Gmail
+  autoload :Version, "gmail/version"
+  autoload :Client,  "gmail/client"
+  autoload :Labels,  "gmail/labels"
+  autoload :Mailbox, "gmail/mailbox"
+  autoload :Message, "gmail/message"
+
+  class << self
+    # Creates new Gmail connection using given authorization options.
+    #
+    # ==== Examples
+    #
+    #   Gmail.new(:plain, "foo@gmail.com", "password")
+    #   Gmail.new(:xoauth, "foo@gmail.com", 
+    #     :consumer_key => "",
+    #     :consumer_secret => "",
+    #     :token => "",
+    #     :secret => "")
+    #
+    # To use plain authentication mehod you can also call:
+    #
+    #   Gmail.new("foo@gmail.com", "password")
+    #
+    # You can also use block-style call:
+    #
+    #   Gmail.new("foo@gmail.com", "password") do |client|
+    #     # ...
+    #   end
+    #
+
+    ['', '!'].each { |kind|
+      define_method("new#{kind}") do |*args, &block|                  # def new(*args, &block)
+        args.unshift(:plain) unless args.first.is_a?(Symbol)          #   args.unshift(:plain) unless args.first.is_a?(Symbol)  
+        client = Gmail::Client.new(*args)                             #   client = Gmail::Client.new(*args) 
+        client.send("connect#{kind}") and client.send("login#{kind}") #   client.connect and client.login
+                                                                      #  
+        if block_given?                                               #   if block_given?
+          yield client                                                #     yield client
+          client.logout                                               #     client.logout
+        end                                                           #   end
+                                                                      #   
+        client                                                        #   client
+      end                                                             # end
+    }
+
+    alias :connect :new
+    alias :connect! :new!
+  end # << self
+end # Gmail

data/lib/gmail/client.rb

@@ -0,0 +1,30 @@
+module Gmail
+  module Client
+    # Raised when connection with GMail IMAP service couldn't be established. 
+    class ConnectionError < SocketError; end
+    # Raised when given username or password are invalid.
+    class AuthorizationError < Net::IMAP::NoResponseError; end
+    # Raised when delivered email is invalid. 
+    class DeliveryError < ArgumentError; end
+    # Raised when given client is not registered
+    class UnknownClient < ArgumentError; end
+
+    def self.register(name, klass)
+      @clients ||= {}
+      @clients[name] = klass
+    end
+
+    def self.new(name, *args)
+      if client = @clients[name]
+        client.new(*args)
+      else
+        raise UnknownClient, "No such client: #{name}" 
+      end
+    end
+
+    require 'gmail/client/imap_extensions'
+    require 'gmail/client/base'
+    require 'gmail/client/plain'
+    require 'gmail/client/xoauth'
+  end # Client
+end # Gmail

data/lib/gmail/client/base.rb

@@ -0,0 +1,225 @@
+require 'thread'
+
+module Gmail
+  module Client
+    class Base
+      # GMail IMAP defaults
+      GMAIL_IMAP_HOST = 'imap.gmail.com'
+      GMAIL_IMAP_PORT = 993
+      
+      # GMail SMTP defaults
+      GMAIL_SMTP_HOST = "smtp.gmail.com"
+      GMAIL_SMTP_PORT = 587
+      
+      attr_reader :username
+      attr_reader :options
+      
+      def initialize(username, options={})
+        defaults       = {}
+        @username      = fill_username(username)
+        @options       = defaults.merge(options)
+        @mailbox_mutex = Mutex.new
+      end
+      
+      # Connect to gmail service. 
+      def connect(raise_errors=false)
+        @imap = Net::IMAP.new(GMAIL_IMAP_HOST, GMAIL_IMAP_PORT, true, nil, false)
+        GmailImapExtensions.patch_net_imap_response_parser
+        @imap
+      rescue SocketError
+        raise_errors and raise ConnectionError, "Couldn't establish connection with GMail IMAP service"
+      end
+      
+      # This version of connect will raise error on failure...
+      def connect!
+        connect(true)
+      end
+      
+      # Return current connection. Log in automaticaly to specified account if 
+      # it is necessary.
+      def connection
+        login and at_exit { logout } unless logged_in?
+        @imap
+      end
+      alias :conn :connection
+      
+      # Login to specified account.
+      def login(*args)
+        raise NotImplementedError, "The `#{self.class.name}#login` method is not implemented."
+      end
+      alias :sign_in :login
+      
+      # This version of login will raise error on failure...
+      def login!
+        login(true)
+      end
+      alias :sign_in! :login!
+      
+      # Returns +true+ when you are logged in to specified account.
+      def logged_in?
+        !!@logged_in
+      end
+      alias :signed_in? :logged_in?
+      
+      # Logout from GMail service. 
+      def logout
+        @imap && logged_in? and @imap.logout
+      ensure
+        @logged_in = false
+      end
+      alias :sign_out :logout
+      
+      # Return labels object, which helps you with managing your GMail labels.
+      # See <tt>Gmail::Labels</tt> for details.
+      def labels
+        @labels ||= Labels.new(conn)
+      end
+      
+      # Compose new e-mail.
+      #
+      # ==== Examples
+      #   
+      #   mail = gmail.compose
+      #   mail.from "test@gmail.org"
+      #   mail.to "friend@gmail.com"
+      #
+      # ... or block style:
+      #  
+      #   mail = gmail.compose do 
+      #     from "test@gmail.org"
+      #     to "friend@gmail.com"
+      #     subject "Hello!"
+      #     body "Hello my friend! long time..."
+      #   end
+      #
+      # Now you can deliver your mail:
+      #
+      #   gmail.deliver(mail)
+      def compose(mail=nil, &block)
+        if block_given?
+          mail = Mail.new(&block)
+        elsif !mail 
+          mail = Mail.new
+        end 
+
+        mail.delivery_method(*smtp_settings)
+        mail.from = username unless mail.from
+        mail
+      end
+      alias :message :compose
+      
+      # Compose (optionaly) and send given email. 
+      #
+      # ==== Examples
+      #
+      #   gmail.deliver do 
+      #     to "friend@gmail.com"
+      #     subject "Hello friend!"
+      #     body "Hi! How are you?"
+      #   end
+      #
+      # ... or with already created message:
+      #
+      #   mail = Mail.new { ... }
+      #   gmail.deliver(mail)
+      #
+      #   mail = gmail.compose { ... }
+      #   gmail.deliver(mail)
+      def deliver(mail=nil, raise_errors=false, &block)
+        mail = compose(mail, &block) if block_given?
+        mail.deliver!
+      rescue Object => ex
+        raise_errors and raise DeliveryError, "Couldn't deliver email: #{ex.to_s}"
+      end
+      
+      # This version of deliver will raise error on failure...
+      def deliver!(mail=nil, &block)
+        deliver(mail, true, &block)
+      end
+      
+      # Do something with given mailbox or within it context. 
+      #
+      # ==== Examples
+      #
+      #   mailbox = gmail.mailbox("INBOX")
+      #   mailbox.emails(:all)
+      #   mailbox.count(:unread, :before => Time.now-(20*24*3600))
+      #
+      # ... or block style:
+      #
+      #   gmail.label("Work") do |mailbox|
+      #     mailbox.emails(:unread)
+      #     mailbox.count(:all)
+      #     ...
+      #   end
+      def mailbox(name, &block)
+        @mailbox_mutex.synchronize do
+          name = name.to_s
+          mailbox = (mailboxes[name] ||= Mailbox.new(self, name))
+          switch_to_mailbox(name) if @current_mailbox != name
+
+          if block_given?
+            mailbox_stack << @current_mailbox
+            result = block.arity == 1 ? block.call(mailbox) : block.call
+            mailbox_stack.pop
+            switch_to_mailbox(mailbox_stack.last)
+            return result
+          end
+
+          return mailbox
+        end
+      end
+      alias :in_mailbox :mailbox
+      alias :in_label :mailbox
+      alias :label :mailbox
+      
+      # Alias for <tt>mailbox("INBOX")</tt>. See <tt>Gmail::Client#mailbox</tt>
+      # for details.
+      def inbox
+        mailbox("INBOX")
+      end
+      
+      def mailboxes
+        @mailboxes ||= {}
+      end
+      
+      def inspect
+        "#<Gmail::Client#{'0x%04x' % (object_id << 1)} (#{username}) #{'dis' if !logged_in?}connected>"
+      end
+      
+      def fill_username(username)
+        username =~ /@/ ? username : "#{username}@gmail.com"
+      end
+
+      def mail_domain
+        username.split('@').last
+      end
+      
+      private
+      
+      def switch_to_mailbox(mailbox)
+        if mailbox
+          mailbox = Net::IMAP.encode_utf7(mailbox)
+          conn.select(mailbox)
+        end
+        @current_mailbox = mailbox
+      end
+      
+      def mailbox_stack
+        @mailbox_stack ||= []
+      end
+      
+      def smtp_settings
+        [:smtp, {
+          :address => GMAIL_SMTP_HOST,
+          :port => GMAIL_SMTP_PORT,
+          :domain => mail_domain,
+          :user_name => username,
+          :password => password,
+          :authentication => 'plain',
+          :enable_starttls_auto => true
+        }]
+      end
+    end # Base
+  end # Client
+end # Gmail

data/lib/gmail/client/imap_extensions.rb

@@ -0,0 +1,54 @@
+# Taken from https://github.com/oxos/gmail-oauth-thread-stats/blob/master/gmail_imap_extensions_compatibility.rb
+
+module GmailImapExtensions
+
+  def self.patch_net_imap_response_parser(klass = Net::IMAP::ResponseParser)
+    klass.class_eval do
+      def msg_att
+        match(Net::IMAP::ResponseParser::T_LPAR)
+        attr = {}
+        while true
+          token = lookahead
+          case token.symbol
+          when Net::IMAP::ResponseParser::T_RPAR
+            shift_token
+            break
+          when Net::IMAP::ResponseParser::T_SPACE
+            shift_token
+            token = lookahead
+          end
+          case token.value
+          when /\A(?:ENVELOPE)\z/ni
+            name, val = envelope_data
+          when /\A(?:FLAGS)\z/ni
+            name, val = flags_data
+          when /\A(?:INTERNALDATE)\z/ni
+            name, val = internaldate_data
+          when /\A(?:RFC822(?:\.HEADER|\.TEXT)?)\z/ni
+            name, val = rfc822_text
+          when /\A(?:RFC822\.SIZE)\z/ni
+            name, val = rfc822_size
+          when /\A(?:BODY(?:STRUCTURE)?)\z/ni
+            name, val = body_data
+          when /\A(?:UID)\z/ni
+            name, val = uid_data
+      
+          # Gmail extension additions.
+          # Cargo-Cult code warning: # I have no idea why the regexp - just copying a pattern
+          when /\A(?:X-GM-LABELS)\z/ni
+            name, val = flags_data
+          when /\A(?:X-GM-MSGID)\z/ni 
+            name, val = uid_data
+          when /\A(?:X-GM-THRID)\z/ni 
+            name, val = uid_data
+          else
+            parse_error("unknown attribute `%s'", token.value)
+          end
+          attr[name] = val
+        end
+        return attr
+      end
+    end
+  end
+
+end

data/lib/gmail/client/plain.rb

@@ -0,0 +1,20 @@
+module Gmail
+  module Client
+    class Plain < Base
+      attr_reader :password
+      
+      def initialize(username, password, options={})
+        @password = password
+        super(username, options)
+      end
+
+      def login(raise_errors=false)
+        @imap and @logged_in = (login = @imap.login(username, password)) && login.name == 'OK'
+      rescue Net::IMAP::NoResponseError
+        raise_errors and raise AuthorizationError, "Couldn't login to given GMail account: #{username}"
+      end
+    end # Plain
+
+    register :plain, Plain
+  end # Client
+end # Gmail