gmail-afurmanov 0.1.0

data/lib/gmail/mailbox.rb

@@ -0,0 +1,117 @@
+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 ['BODY', opts[:search]]
+        opts[:body]       and search.concat ['BODY', opts[:body]]
+        opts[:query]      and search.concat opts[:query]
+
+        @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
+    
+    def message
+      @message ||= Mail.new(@gmail.mailbox(@mailbox.name) { 
+        @gmail.conn.uid_fetch(uid, "RFC822")[0].attr["RFC822"] # RFC822
+      })
+    end
+    alias_method :raw_message, :message
+
+  end # Message
+end # Gmail

data/lib/gmail/version.rb

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

data/spec/account.yml.example

@@ -0,0 +1,2 @@
+- "test@gmail.com"
+- "test"

data/spec/client_spec.rb

@@ -0,0 +1,173 @@
+require 'spec_helper'
+
+describe "Gmail client (Plain)" do
+  subject { Gmail::Client::Plain }
+  
+  context "on initialize" do
+    it "should set username, password and options" do
+      client = subject.new("test@gmail.com", "pass", :foo => :bar)
+      client.username.should == "test@gmail.com"
+      client.password.should == "pass"
+      client.options[:foo].should == :bar
+    end
+    
+    it "should convert simple name to gmail email" do 
+      client = subject.new("test", "pass")
+      client.username.should == "test@gmail.com"
+    end
+  end
+  
+  context "instance" do
+    def mock_client(&block) 
+      client = Gmail::Client::Plain.new(*TEST_ACCOUNT)
+      if block_given?
+        client.connect
+        yield client
+        client.logout
+      end
+      client
+    end
+   
+    it "should connect to GMail IMAP service" do 
+      lambda { 
+        client = mock_client
+        client.connect!.should be_true
+      }.should_not raise_error(Gmail::Client::ConnectionError)
+    end
+    
+    it "should properly login to valid GMail account" do
+      client = mock_client
+      client.connect.should be_true
+      client.login.should be_true
+      client.should be_logged_in
+      client.logout
+    end
+    
+    it "should raise error when given GMail account is invalid and errors enabled" do
+      lambda {
+        client = Gmail::Client::Plain.new("foo", "bar")
+        client.connect.should be_true
+        client.login!.should_not be_true
+      }.should raise_error(Gmail::Client::AuthorizationError)
+    end
+    
+    it "shouldn't login when given GMail account is invalid" do
+      lambda {
+        client = Gmail::Client::Plain.new("foo", "bar")
+        client.connect.should be_true
+        client.login.should_not be_true
+      }.should_not raise_error(Gmail::Client::AuthorizationError)
+    end
+    
+    it "should properly logout from GMail" do 
+      client = mock_client
+      client.connect
+      client.login.should be_true
+      client.logout.should be_true
+      client.should_not be_logged_in
+    end
+    
+    it "#connection should automatically log in to GMail account when it's called" do
+      mock_client do |client|
+        client.expects(:login).once.returns(false)
+        client.connection.should_not be_nil
+      end
+    end
+    
+    it "should properly compose message" do 
+      mail = mock_client.compose do
+        from "test@gmail.com"
+        to "friend@gmail.com"
+        subject "Hello world!"
+      end
+      mail.from.should == ["test@gmail.com"]
+      mail.to.should == ["friend@gmail.com"]
+      mail.subject.should == "Hello world!"
+    end
+    
+    it "#compose should automatically add `from` header when it is not specified" do
+      mail = mock_client.compose
+      mail.from.should == [TEST_ACCOUNT[0]]
+      mail = mock_client.compose(Mail.new)
+      mail.from.should == [TEST_ACCOUNT[0]]
+      mail = mock_client.compose {}
+      mail.from.should == [TEST_ACCOUNT[0]]
+    end
+    
+    it "should deliver inline composed email" do
+      mock_client do |client|
+        client.deliver do 
+          to TEST_ACCOUNT[0]
+          subject "Hello world!"
+          body "Yeah, hello there!"
+        end.should be_true
+      end
+    end
+    
+    it "should not raise error when mail can't be delivered and errors are disabled" do
+      lambda { 
+        client = mock_client
+        client.deliver(Mail.new {}).should be_false
+      }.should_not raise_error(Gmail::Client::DeliveryError)
+    end
+    
+    it "should raise error when mail can't be delivered and errors are disabled" do 
+      lambda { 
+        client = mock_client
+        client.deliver!(Mail.new {})
+      }.should raise_error(Gmail::Client::DeliveryError)
+    end
+    
+    it "should properly switch to given mailbox" do
+      mock_client do |client| 
+        mailbox = client.mailbox("TEST")
+        mailbox.should be_kind_of(Gmail::Mailbox)
+        mailbox.name.should == "TEST"
+      end 
+    end
+    
+    it "should properly switch to given mailbox using block style" do
+      mock_client do |client| 
+        client.mailbox("TEST") do |mailbox|
+          mailbox.should be_kind_of(Gmail::Mailbox)
+          mailbox.name.should == "TEST"
+        end
+      end
+    end
+    
+    context "labels" do
+      subject { 
+        client = Gmail::Client::Plain.new(*TEST_ACCOUNT)
+        client.connect
+        client.labels
+      }
+      
+      it "should get list of all available labels" do
+        labels = subject
+        labels.all.should include("TEST", "INBOX")
+      end
+      
+      it "should be able to check if there is given label defined" do
+        labels = subject
+        labels.exists?("TEST").should be_true
+        labels.exists?("FOOBAR").should be_false
+      end
+      
+      it "should be able to create given label" do
+        labels = subject
+        labels.create("MYLABEL")
+        labels.exists?("MYLABEL").should be_true
+        labels.create("MYLABEL").should be_false
+        labels.delete("MYLABEL")
+      end
+      
+      it "should be able to remove existing label" do
+        labels = subject
+        labels.create("MYLABEL")
+        labels.delete("MYLABEL").should be_true
+        labels.exists?("MYLABEL").should be_false
+        labels.delete("MYLABEL").should be_false
+      end
+    end
+  end
+end