gmail-afurmanov 0.1.0

data/gmail.gemspec

@@ -0,0 +1,18 @@
+# -*- ruby -*-
+
+$:.unshift(File.expand_path('../lib', __FILE__))
+require 'gmail/version'
+
+begin
+  Ore::Specification.new do |gemspec|
+    gemspec.version = Gmail.version
+  end
+rescue NameError
+  begin
+    require 'ore/specification'
+    retry
+  rescue LoadError
+    STDERR.puts "The '#{__FILE__}' file requires Ore."
+    STDERR.puts "Run `gem install ore-core` to install Ore."
+  end
+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,29 @@
+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/base'
+    require 'gmail/client/plain'
+    require 'gmail/client/xoauth'
+  end # Client
+end # Gmail

data/lib/gmail/client/base.rb

@@ -0,0 +1,223 @@
+#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)
+      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('@')[0]
+      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/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

data/lib/gmail/client/xoauth.rb

@@ -0,0 +1,51 @@
+require 'gmail_xoauth'
+
+module Gmail
+  module Client
+    class XOAuth < Base
+      attr_reader :token
+      attr_reader :secret
+      attr_reader :consumer_key
+      attr_reader :consumer_secret
+
+      def initialize(username, options={})
+        @token           = options.delete(:token)
+        @secret          = options.delete(:secret)
+        @consumer_key    = options.delete(:consumer_key)
+        @consumer_secret = options.delete(:consumer_secret)
+       
+        super(username, options)
+      end
+
+      def login(raise_errors=false)
+        @imap and @logged_in = (login = @imap.authenticate('XOAUTH', username,
+          :consumer_key    => consumer_key,
+          :consumer_secret => consumer_secret,
+          :token           => token,
+          :token_secret    => secret
+        )) && login.name == 'OK'
+      rescue
+        raise_errors and raise AuthorizationError, "Couldn't login to given GMail account: #{username}"        
+      end
+
+      def smtp_settings
+        [:smtp, {
+           :address => GMAIL_SMTP_HOST,
+           :port => GMAIL_SMTP_PORT,
+           :domain => mail_domain,
+           :user_name => username,
+           :password => {
+             :consumer_key    => consumer_key,
+             :consumer_secret => consumer_secret,
+             :token           => token,
+             :token_secret    => secret
+           },
+           :authentication => :xoauth,
+           :enable_starttls_auto => true
+         }]
+      end
+    end # XOAuth
+
+    register :xoauth, XOAuth
+  end # Client
+end # Gmail

data/lib/gmail/labels.rb

@@ -0,0 +1,48 @@
+module Gmail
+  class Labels
+    include Enumerable
+    attr_reader :connection
+    alias :conn :connection
+     
+    def initialize(connection)
+      @connection = connection
+    end
+    
+    # Get list of all defined labels.
+    def all
+      (conn.list("", "%")+conn.list("[Gmail]/", "%")).inject([]) do |labels,label|
+        label[:name].each_line {|l| labels << Net::IMAP.decode_utf7(l) }
+        labels 
+      end
+    end
+    alias :list :all
+    alias :to_a :all
+
+    def each(*args, &block)
+      all.each(*args, &block)
+    end
+    
+    # Returns +true+ when given label defined. 
+    def exists?(label)
+      all.include?(label)
+    end
+    alias :exist? :exists?
+    
+    # Creates given label in your account.
+    def create(label)
+      !!conn.create(Net::IMAP.encode_utf7(label)) rescue false
+    end
+    alias :new :create
+    alias :add :create
+    
+    # Deletes given label from your account. 
+    def delete(label)
+      !!conn.delete(Net::IMAP.encode_utf7(label)) rescue false
+    end
+    alias :remove :delete
+    
+    def inspect
+      "#<Gmail::Labels#{'0x%04x' % (object_id << 1)}>"
+    end
+  end # Labels
+end # Gmail