gmail_oauth 0.1.1

data/.gitignore

@@ -0,0 +1,25 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC
+*.rdb
+
+## Test Account details
+spec/account.yml

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# gmail_oauth gem changelog
+
+## 0.1 / 2010-12-13
+
+* Birthday of OAuth version from https://github.com/nu7hatch/gmail

data/LICENSE

@@ -0,0 +1,21 @@
+Copyrignt (c) 2010 Kriss 'nu7hatch' Kowalik
+Copyright (c) 2009-2010 BehindLogic
+
+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/README.md

@@ -0,0 +1,257 @@
+# GMail for Ruby
+
+I changed the auth method to Oauth, using Nicolas Fouché's [gmail_xoauth](https://github.com/nfo/gmail_xoauth).
+
+To use it you must produce your own token and secret. You can follow an example of how to do it by [Nicolas Fouché](https://github.com/nfo/gmail-oauth-sinatra).
+
+THIS IS NOT TESTED.
+
+###To Do
+* Write specs (I know, I know)
+
+A Rubyesque interface to Google's GMail with Oauth, with all the tools you'll need. Search, 
+read and send multipart emails, archive, mark as read/unread, delete emails, 
+and manage labels.
+
+It's based on Kriss 'nu7hatch' Kowalik gmail gem. This version has oauth login and does not require username and password from users.  
+
+## Author(s)
+
+* [Kriss 'nu7hatch' Kowalik](http://github.com/nu7hatch)
+* [Daniel Parker of BehindLogic.com](http://github.com/dcparker)
+
+Extra thanks for specific feature contributions from:
+
+* [Arthur Chiu](http://github.com/achiu)
+* [Justin Perkins](http://github.com/justinperkins)
+* [Mikkel Malmberg](http://github.com/mikker)
+* [Julien Blanchard](http://github.com/julienXX)
+* [Federico Galassi](http://github.com/fgalassi)
+
+## Installation
+
+You can install it easy using rubygems:
+
+    sudo gem install gmail_oauth
+    
+Or install it manualy:
+
+    git clone git://github.com/stefanobernardi/gmail_oauth.git
+    cd gmail
+    rake install
+
+To install gmail gem you have to met following requirements (with rubygems all 
+will be installed automatically):
+
+* mail
+* mime
+* gmail_xoauth
+* smpt_tls (Ruby < 1.8.7)
+
+## Features
+
+* Search emails
+* Read emails (handles attachments)
+* Emails: label, archive, delete, mark as read/unread/spam, star
+* Manage labels
+* Create and send multipart email messages in plaintext and/or html, with inline 
+  images and attachments
+* Utilizes Gmail's IMAP & SMTP, MIME-type detection and parses and generates 
+  MIME properly.
+
+## Basic usage
+
+First of all require the `gmail-oauth` library.
+
+    require 'gmail_oauth'
+    
+### Authenticating gmail sessions
+
+This will you automatically log in to your account. 
+
+    gmail = Gmail.connect(email, token, secret, consumer_key, consumer_secret)
+    # play with your gmail...
+    gmail.logout
+
+If you pass a block, the session will be passed into the block, and the session 
+will be logged out after the block is executed.
+
+    Gmail.connect(email, token, secret, consumer_key, consumer_secret) do |gmail|
+      # play with your gmail...
+    end
+    
+Examples above are "quiet", it means that it will not raise any errors when 
+session couldn't be started (eg. because of connection error or invalid 
+authorization data). You can use connection which handles errors raising:
+
+    Gmail.connect!(email, token, secret, consumer_key, consumer_secret)
+    Gmail.connect!(email, token, secret, consumer_key, consumer_secret) {|gmail| ... play with gmail ... }
+    
+You can also check if you are logged in at any time:
+
+    Gmail.connect(email, token, secret, consumer_key, consumer_secret) do |gmail|
+      gmail.logged_in?
+    end
+
+### Counting and gathering emails
+    
+Get counts for messages in the inbox:
+
+    gmail.inbox.count
+    gmail.inbox.count(:unread)
+    gmail.inbox.count(:read)
+
+Count with some criteria:
+
+    gmail.inbox.count(:after => Date.parse("2010-02-20"), :before => Date.parse("2010-03-20"))
+    gmail.inbox.count(:on => Date.parse("2010-04-15"))
+    gmail.inbox.count(:from => "myfriend@gmail.com")
+    gmail.inbox.count(:to => "directlytome@gmail.com")
+
+Combine flags and options:
+
+    gmail.inbox.count(:unread, :from => "myboss@gmail.com")
+    
+Browsing labeled emails is similar to work with inbox.
+
+    gmail.mailbox('Urgent').count
+    
+Getting messages works the same way as counting: Remember that every message in a 
+conversation/thread will come as a separate message.
+
+    gmail.inbox.emails(:unread, :before => Date.parse("2010-04-20"), :from => "myboss@gmail.com")
+
+You can use also one of aliases:
+
+    gmail.inbox.find(...)
+    gmail.inbox.search(...)
+    gmail.inbox.mails(...)    
+    
+Also you can manipulate each message using block style:
+
+    gmail.inbox.find(:unread) do |email|
+      email.read!
+    end
+    
+### Working with emails!
+
+Any news older than 4-20, mark as read and archive it:
+
+    gmail.inbox.find(:before => Date.parse("2010-04-20"), :from => "news@nbcnews.com") do |email|
+      email.read! # can also unread!, spam! or star!
+      email.archive!
+    end
+
+Delete emails from X:
+
+    gmail.inbox.find(:from => "x-fiance@gmail.com").each do |email|
+      email.delete!
+    end
+
+Save all attachments in the "Faxes" label to a local folder:
+
+    folder = "/where/ever"
+    gmail.mailbox("Faxes").emails do |email|
+      if !email.message.attachments.empty?
+        email.message.save_attachments_to(folder)
+      end
+    end
+     
+You can use also `#label` method instead of `#mailbox`: 
+
+    gmail.label("Faxes").emails {|email| ... }
+
+Save just the first attachment from the newest unread email (assuming pdf):
+
+    email = gmail.inbox.find(:unread).first
+    email.attachments[0].save_to_file("/path/to/location")
+
+Add a label to a message:
+
+    email.label("Faxes")
+    
+Example above will raise error when you don't have the `Faxes` label. You can 
+avoid this using:
+
+    email.label!("Faxes") # The `Faxes` label will be automatically created now
+
+You can also move message to a label/mailbox:
+ 
+    email.move_to("Faxes")
+    email.move_to!("NewLabel")
+    
+There is also few shortcuts to mark messages quickly:
+
+    email.read!
+    email.unread!
+    email.spam!
+    email.star!
+    email.unstar!
+
+### Managing labels
+
+With Gmail gem you can also manage your labels. You can get list of defined 
+labels:
+
+    gmail.labels.all
+
+Create new label:
+  
+    gmail.labels.new("Uregent")
+    gmail.labels.add("AnotherOne")
+    
+Remove labels:
+
+    gmail.labels.delete("Uregent")
+    
+Or check if given label exists:
+
+    gmail.labels.exists?("Uregent") # => false
+    gmail.labels.exists?("AnotherOne") # => true
+
+### Composing and sending emails
+
+Creating emails now uses the amazing [Mail](http://rubygems.org/gems/mail) rubygem. 
+See its [documentation here](http://github.com/mikel/mail). The Ruby Gmail will 
+automatically configure your Mail emails to be sent via your Gmail account's SMTP, 
+so they will be in your Gmail's "Sent" folder. Also, no need to specify the "From" 
+email either, because ruby-gmail will set it for you.
+
+    gmail.deliver do
+      to "email@example.com"
+      subject "Having fun in Puerto Rico!"
+      text_part do
+        body "Text of plaintext message."
+      end
+      html_part do
+        body "<p>Text of <em>html</em> message.</p>"
+      end
+      add_file "/path/to/some_image.jpg"
+    end
+
+Or, generate the message first and send it later
+
+    email = gmail.generate_message do
+      to "email@example.com"
+      subject "Having fun in Puerto Rico!"
+      body "Spent the day on the road..."
+    end
+    email.deliver! # or: gmail.deliver(email)
+
+## Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+## Copyright
+
+* Copyrignt (c) 2010 Kriss 'nu7hatch' Kowalik
+* Copyright (c) 2009-2010 BehindLogic
+
+See LICENSE for details.
+

data/Rakefile

@@ -0,0 +1,45 @@
+# -*- ruby -*-
+$:.unshift(File.expand_path('../lib', __FILE__))
+require 'gmail/version'
+require 'rspec/core/rake_task'
+require 'rake/rdoctask'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = 'spec/**/*_spec.rb'
+  t.rspec_opts = %q[-c -b]
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |t|
+  t.rcov = true
+  t.rspec_opts = %q[-c -b]
+  t.rcov_opts = %q[-T -x "spec"]
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "Gmail #{Gmail.version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+task :default => :spec
+
+desc "Build current version as a rubygem"
+task :build do
+  `gem build gmail-oauth.gemspec`
+  `mkdir -p pkg`
+  `mv gmail_oauth-*.gem pkg/`
+end
+
+desc "Relase current version to rubygems.org"
+task :release => :build do
+  `git tag -am "Version bump to #{Gmail.version}" v#{Gmail.version}`
+  `git push origin master`
+  `git push origin master --tags`
+  `gem push pkg/gmail_oauth-#{Gmail.version}.gem`
+end
+
+desc "Perform installation via rubygems"
+task :install => :build do
+  `gem install pkg/gmail_oauth-#{Gmail.version}.gem`
+end

data/TODO.md

@@ -0,0 +1,3 @@
+# TODO
+
+* Specs

data/lib/gmail/client.rb

@@ -0,0 +1,236 @@
+module Gmail
+  class 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
+  
+    # 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 :email
+    attr_reader :token
+    attr_reader :secret
+    attr_reader :options
+  
+    def initialize(email, token, secret, consumer_key, consumer_secret, options={})
+      defaults  = {}
+      @email = email
+      @username = email
+      @token = token
+      @secret = secret
+      @consumer_key = consumer_key
+      @consumer_secret = consumer_secret
+      @options  = defaults.merge(options)
+    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(raise_errors=false)
+      @imap and @logged_in = (login = @imap.authenticate('XOAUTH', email,
+        :consumer_key => consumer_key,
+        :consumer_secret => consumer_secret,
+        :token => token,
+        :token_secret => secret
+      )) && login.name == 'OK'
+    rescue Net::IMAP::NoResponseError
+      raise_errors and raise AuthorizationError, "Couldn't login to given GMail account"
+    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 = @email 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)
+      name = Net::IMAP.encode_utf7(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
+      mailbox
+    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)} (#{@email}) #{'dis' if !logged_in?}connected>"
+    end
+    
+    #def fill_username(username)
+    #  username =~ /@/ ? username : "#{username}@gmail.com"
+    #end
+
+    def mail_domain
+      @email.split('@')[0]
+    end
+    
+    private
+    
+    def switch_to_mailbox(mailbox)
+      conn.select(mailbox) if mailbox
+      @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 => {
+          :consumer_key => 'anonymous',
+          :consumer_secret => 'anonymous',
+          :token => '4/nM2QAaunKUINb4RrXPC55F-mix_k',
+          :token_secret => '41r18IyXjIvuyabS/NDyW6+m'
+        }
+        :authentication => 'xoauth',
+        :enable_starttls_auto => true
+      }]
+    end
+  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?(Net::IMAP.encode_utf7(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

data/lib/gmail/mailbox.rb

@@ -0,0 +1,115 @@
+module Gmail
+  class Mailbox
+    MAILBOX_ALIASES = {
+      :all       => ['ALL'],
+      :seen      => ['SEEN'],
+      :unseen    => ['UNSEEN'],
+      :read      => ['SEEN'],
+      :unread    => ['UNSEEN'],
+      :flagged   => ['FLAGGED'],
+      :unflagged => ['UNFLAGGED'],
+      :starred   => ['FLAGGED'],
+      :unstarred => ['UNFLAGGED'], 
+      :deleted   => ['DELETED'],
+      :undeleted => ['UNDELETED'],
+      :draft     => ['DRAFT'],
+      :undrafted => ['UNDRAFT']
+    }
+  
+    attr_reader :name
+    attr_reader :external_name
+
+    def initialize(gmail, name="INBOX")
+      @name  = name
+      @external_name = Net::IMAP.decode_utf7(name)
+      @gmail = gmail
+    end
+
+    # Returns list of emails which meets given criteria. 
+    #
+    # ==== Examples
+    #
+    #   gmail.inbox.emails(:all)
+    #   gmail.inbox.emails(:unread, :from => "friend@gmail.com")
+    #   gmail.inbox.emails(:all, :after => Time.now-(20*24*3600))
+    #   gmail.mailbox("Test").emails(:read)
+    #
+    #   gmail.mailbox("Test") do |box| 
+    #     box.emails(:read)
+    #     box.emails(:unread) do |email|
+    #       ... do something with each email...
+    #     end
+    #   end
+    def emails(*args, &block)
+      args << :all if args.size == 0
+
+      if args.first.is_a?(Symbol) 
+        search = MAILBOX_ALIASES[args.shift].dup
+        opts = args.first.is_a?(Hash) ? args.first : {}
+        
+        opts[:after]      and search.concat ['SINCE', opts[:after].to_imap_date]
+        opts[:before]     and search.concat ['BEFORE', opts[:before].to_imap_date]
+        opts[:on]         and search.concat ['ON', opts[:on].to_imap_date]
+        opts[:from]       and search.concat ['FROM', opts[:from]]
+        opts[:to]         and search.concat ['TO', opts[:to]]
+        opts[:subject]    and search.concat ['SUBJECT', opts[:subject]]
+        opts[:label]      and search.concat ['LABEL', opts[:label]]
+        opts[:attachment] and search.concat ['HAS', 'attachment']
+        opts[:search]     and search.concat [opts[:search]]
+        
+        @gmail.mailbox(name) do
+          @gmail.conn.uid_search(search).collect do |uid| 
+            message = (messages[uid] ||= Message.new(self, uid))
+            block.call(message) if block_given?
+            message
+          end
+        end
+      elsif args.first.is_a?(Hash)
+        emails(:all, args.first)
+      else
+        raise ArgumentError, "Invalid search criteria"
+      end
+    end
+    alias :mails :emails
+    alias :search :emails
+    alias :find :emails
+    alias :filter :emails
+
+    # This is a convenience method that really probably shouldn't need to exist, 
+    # but it does make code more readable, if seriously all you want is the count 
+    # of messages.
+    #
+    # ==== Examples
+    #
+    #   gmail.inbox.count(:all)
+    #   gmail.inbox.count(:unread, :from => "friend@gmail.com")
+    #   gmail.mailbox("Test").count(:all, :after => Time.now-(20*24*3600))
+    def count(*args)
+      emails(*args).size
+    end
+
+    # This permanently removes messages which are marked as deleted
+    def expunge
+      @gmail.mailbox(name) { @gmail.conn.expunge }
+    end
+
+    # Cached messages. 
+    def messages
+      @messages ||= {}
+    end
+    
+    def inspect
+      "#<Gmail::Mailbox#{'0x%04x' % (object_id << 1)} name=#{external_name}>"
+    end
+
+    def to_s
+      name
+    end
+
+    MAILBOX_ALIASES.each_key { |mailbox|
+      define_method(mailbox) do |*args, &block|
+        emails(mailbox, *args, &block)
+      end
+    }
+  end # Message
+end # Gmail

data/lib/gmail/message.rb

@@ -0,0 +1,164 @@
+require 'mime/message'
+
+module Gmail
+  class Message
+    # Raised when given label doesn't exists.
+    class NoLabelError < Exception; end 
+  
+    attr_reader :uid
+    
+    def initialize(mailbox, uid)
+      @uid     = uid
+      @mailbox = mailbox
+      @gmail   = mailbox.instance_variable_get("@gmail") if mailbox
+    end
+    
+    def uid
+      @uid ||= @gmail.conn.uid_search(['HEADER', 'Message-ID', message_id])[0]
+    end
+    
+    # Mark message with given flag.
+    def flag(name)
+      !!@gmail.mailbox(@mailbox.name) { @gmail.conn.uid_store(uid, "+FLAGS", [name]) }
+    end
+    
+    # Unmark message. 
+    def unflag(name)
+      !!@gmail.mailbox(@mailbox.name) { @gmail.conn.uid_store(uid, "-FLAGS", [name]) }
+    end
+    
+    # Do commonly used operations on message. 
+    def mark(flag)
+      case flag
+        when :read    then read!
+        when :unread  then unread!
+        when :deleted then delete!
+        when :spam    then spam!
+      else
+        flag(flag)
+      end
+    end
+    
+    # Mark this message as a spam.
+    def spam!
+      move_to('[Gmail]/Spam')
+    end
+    
+    # Mark as read.
+    def read!
+      flag(:Seen)
+    end
+    
+    # Mark as unread.
+    def unread!
+      unflag(:Seen)
+    end
+    
+    # Mark message with star.
+    def star!
+      flag('[Gmail]/Starred')
+    end
+    
+    # Remove message from list of starred.
+    def unstar!
+      unflag('[Gmail]/Starred')
+    end
+    
+    # Move to trash / bin.
+    def delete!
+      @mailbox.messages.delete(uid)
+      flag(:deleted)
+
+      # For some, it's called "Trash", for others, it's called "Bin". Support both.
+      trash =  @gmail.labels.exist?('[Gmail]/Bin') ? '[Gmail]/Bin' : '[Gmail]/Trash'
+      move_to(trash) unless %w[[Gmail]/Spam [Gmail]/Bin [Gmail]/Trash].include?(@mailbox.name)
+    end
+
+    # Archive this message.
+    def archive!
+      move_to('[Gmail]/All Mail')
+    end
+    
+    # Move to given box and delete from others.  
+    def move_to(name, from=nil)
+      label(name, from)
+      delete! if !%w[[Gmail]/Bin [Gmail]/Trash].include?(name)
+    end
+    alias :move :move_to
+    
+    # Move message to given and delete from others. When given mailbox doesn't 
+    # exist then it will be automaticaly created. 
+    def move_to!(name, from=nil)
+      label!(name, from) && delete!
+    end
+    alias :move! :move_to!
+    
+    # Mark this message with given label. When given label doesn't exist then
+    # it will raise <tt>NoLabelError</tt>. 
+    #
+    # See also <tt>Gmail::Message#label!</tt>.
+    def label(name, from=nil)
+      @gmail.mailbox(Net::IMAP.encode_utf7(from || @mailbox.external_name)) { @gmail.conn.uid_copy(uid, Net::IMAP.encode_utf7(name)) }
+    rescue Net::IMAP::NoResponseError
+      raise NoLabelError, "Label '#{name}' doesn't exist!"
+    end
+
+    # Mark this message with given label. When given label doesn't exist then
+    # it will be automaticaly created. 
+    #
+    # See also <tt>Gmail::Message#label</tt>.
+    def label!(name, from=nil)
+      label(name, from) 
+    rescue NoLabelError
+      @gmail.labels.add(Net::IMAP.encode_utf7(name))
+      label(name, from)
+    end
+    alias :add_label :label!
+    alias :add_label! :label!
+    
+    # Remove given label from this message. 
+    def remove_label!(name)
+      move_to('[Gmail]/All Mail', name)
+    end
+    alias :delete_label! :remove_label!
+    
+    def inspect
+      "#<Gmail::Message#{'0x%04x' % (object_id << 1)} mailbox=#{@mailbox.external_name}#{' uid='+@uid.to_s if @uid}#{' message_id='+@message_id.to_s if @message_id}>"
+    end
+    
+    def method_missing(meth, *args, &block)
+      # Delegate rest directly to the message.
+      if envelope.respond_to?(meth)
+        envelope.send(meth, *args, &block)
+      elsif message.respond_to?(meth)
+        message.send(meth, *args, &block)
+      else
+        super(meth, *args, &block)
+      end
+    end
+
+    def respond_to?(meth, *args, &block)
+      if envelope.respond_to?(meth)
+        return true
+      elsif message.respond_to?(meth)
+        return true
+      else
+        super(meth, *args, &block)
+      end
+    end
+
+    def envelope
+      @envelope ||= @gmail.mailbox(@mailbox.name) {
+        @gmail.conn.uid_fetch(uid, "ENVELOPE")[0].attr["ENVELOPE"]
+      }
+    end
+
+    private
+    
+    def message
+      @message ||= Mail.new(@gmail.mailbox(@mailbox.name) { 
+        @gmail.conn.uid_fetch(uid, "RFC822")[0].attr["RFC822"] # RFC822
+      })
+    end
+  end # Message
+end # Gmail

data/lib/gmail/version.rb

@@ -0,0 +1,12 @@
+module Gmail
+  class Version #:nodoc:
+    MAJOR  = 0
+    MINOR  = 1
+    PATCH  = 1
+    STRING = [MAJOR, MINOR, PATCH].join('.')
+  end # Version
+  
+  def self.version # :nodoc:
+    Version::STRING
+  end 
+end # Gmail

data/lib/gmail.rb

@@ -0,0 +1,48 @@
+require 'net/imap'
+require 'net/smtp'
+require 'mail'
+require 'date'
+require 'time'
+require 'gmail_xoauth'
+
+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
+    def new(email, token, secret, consumer_key, consumer_secret, options={}, &block)
+      client = Client.new(email, token, secret, consumer_key, consumer_secret, options)
+      client.connect and client.login
+      if block_given?
+        yield client
+        client.logout
+      end
+      client
+    end
+    alias :connect :new
+    
+    def new!(email, token, secret, consumer_key, consumer_secret, options={}, &block)
+      client = Client.new(email, token, secret, consumer_key, consumer_secret, options)
+      client.connect! and client.login!
+      if block_given?
+        yield client
+        client.logout
+      end
+      client
+    end
+    alias :connect! :new!
+  end # << self
+end # Gmail

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification 
+name: gmail_oauth
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- BehindLogic
+- Chris Kowalik
+- Stefano Bernardi
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-12-14 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: mime
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 1
+        version: "0.1"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: mail
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 2
+        - 1
+        version: 2.2.1
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: gmail_xoauth
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 3
+        version: "0.3"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 0
+        version: "2.0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 9
+        version: "0.9"
+  type: :development
+  version_requirements: *id005
+description: A Rubyesque interface to Gmail with Oauth, with all the tools you will need. Search, read and send multipart emails; archive, mark as read/unread, delete emails; and manage labels.
+email: 
+- hello@stefanobernardi.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+- CHANGELOG.md
+- TODO.md
+files: 
+- .gitignore
+- CHANGELOG.md
+- LICENSE
+- README.md
+- Rakefile
+- TODO.md
+- lib/gmail.rb
+- lib/gmail/client.rb
+- lib/gmail/labels.rb
+- lib/gmail/mailbox.rb
+- lib/gmail/message.rb
+- lib/gmail/version.rb
+has_rdoc: true
+homepage: http://github.com/stefanobernardi/gmail_oauth
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A Rubyesque interface to Gmail with Oauth, with all the tools you will need.
+test_files: []
+