gmail 0.4.0 → 0.4.2

data/lib/gmail/message.rb

@@ -1,164 +1,166 @@
-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
+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 labels
+      @gmail.conn.uid_fetch(uid, "X-GM-LABELS")[0].attr["X-GM-LABELS"]
+    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

@@ -1,12 +1,3 @@
-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
+module Gmail
+  VERSION = "0.4.2"  
+end # Gmail

data/spec/account.yml.example

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

data/spec/client_spec.rb

@@ -1,173 +1,178 @@
-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
+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 
+      client = mock_client
+      client.connect!.should be_true
+    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_nil
+        }.should raise_error      
+        ### FIX: can someone dig to the bottom of this?  We are getting NoMethodError instead of Gmail::Client::AuthorizationError in 1.9
+    end
+    
+    it "shouldn't raise error even though GMail account is invalid" do
+      lambda {
+        client = Gmail::Client::Plain.new("foo", "bar")
+        client.connect.should be_true
+        expect(client.login).to_not be_true
+      }.should_not raise_error
+    end
+
+    it "shouldn't login when given GMail account is invalid" do
+      client = Gmail::Client::Plain.new("foo", "bar")
+      client.connect.should be_true
+      client.login.should be_false
+    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
+    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("INBOX")
+        mailbox.should be_kind_of(Gmail::Mailbox)
+        mailbox.name.should == "INBOX"
+      end 
+    end
+    
+    it "should properly switch to given mailbox using block style" do
+      mock_client do |client|
+        client.mailbox("INBOX") do |mailbox|
+          mailbox.should be_kind_of(Gmail::Mailbox)
+          mailbox.name.should == "INBOX"
+        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("INBOX")
+      end
+      
+      it "should be able to check if there is given label defined" do
+        labels = subject
+        labels.exists?("INBOX").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