gmail 0.6.0 → 0.7.0

data/lib/gmail/message.rb

@@ -1,207 +1,212 @@
-module Gmail
-  class Message
-    PREFETCH_ATTRS = ["UID", "ENVELOPE", "BODY.PEEK[]", "FLAGS", "X-GM-LABELS", "X-GM-MSGID", "X-GM-THRID"]
-
-    # Raised when given label doesn't exists.
-    class NoLabelError < Exception; end
-
-    def initialize(mailbox, uid, _attrs = nil)
-      @uid     = uid
-      @mailbox = mailbox
-      @gmail   = mailbox.instance_variable_get("@gmail") if mailbox  # UGLY
-      @_attrs  = _attrs
-    end
-
-    def uid
-      @uid ||= fetch("UID")
-    end
-
-    def msg_id
-      @msg_id ||= fetch("X-GM-MSGID")
-    end
-    alias_method :message_id, :msg_id
-
-    def thr_id
-      @thr_id ||= fetch("X-GM-THRID")
-    end
-    alias_method :thread_id, :thr_id
-
-    def envelope
-      @envelope ||= fetch("ENVELOPE")
-    end
-
-    def message
-      @message ||= Mail.new(fetch("BODY[]"))
-    end
-    alias_method :raw_message, :message
-
-    def flags
-      @flags ||= fetch("FLAGS")
-    end
-
-    def labels
-      @labels ||= fetch("X-GM-LABELS")
-    end
-
-    # Mark message with given flag.
-    def flag(name)
-      !!@gmail.mailbox(@mailbox.name) do
-        @gmail.conn.uid_store(uid, "+FLAGS", [name])
-        clear_cached_attributes
-      end
-    end
-
-    # Unmark message.
-    def unflag(name)
-      !!@gmail.mailbox(@mailbox.name) do
-        @gmail.conn.uid_store(uid, "-FLAGS", [name])
-        clear_cached_attributes
-      end
-    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
-
-    # Check whether message is read
-    def read?
-      flags.include?(:Seen)
-    end
-
-    # Mark as read.
-    def read!
-      flag(:Seen)
-    end
-
-    # Mark as unread.
-    def unread!
-      unflag(:Seen)
-    end
-
-    # Check whether message is starred
-    def starred?
-      flags.include?(:Flagged)
-    end
-
-    # Mark message with star.
-    def star!
-      flag(:Flagged)
-    end
-
-    # Remove message from list of starred.
-    def unstar!
-      unflag(:Flagged)
-    end
-
-    # Marking as spam is done by adding the `\Spam` label. To undo this,
-    # you just re-apply the `\Inbox` label (see `#unspam!`)
-    def spam!
-      add_label("\\Spam")
-    end
-
-    # Deleting is done by adding the `\Trash` label. To undo this,
-    # you just re-apply the `\Inbox` label (see `#undelete!`)
-    def delete!
-      add_label("\\Trash")
-    end
-
-    # Archiving is done by adding the `\Trash` label. To undo this,
-    # you just re-apply the `\Inbox` label (see `#unarchive!`)
-    def archive!
-      remove_label("\\Inbox")
-    end
-
-    def unarchive!
-      add_label("\\Inbox")
-    end
-    alias_method :unspam!, :unarchive!
-    alias_method :undelete!, :unarchive!
-
-    # Move to given box and delete from others.
-    # Apply a given label and optionally remove one.
-    # TODO: We should probably deprecate this method. It doesn't really add a lot
-    #       of value, especially since the concept of "moving" a message from one
-    #       label to another doesn't totally make sense in the Gmail world.
-    def move_to(name, from = nil)
-      add_label(name)
-      remove_label(from) if from
-    end
-    alias_method :move, :move_to
-    alias_method :move!, :move_to
-    alias_method :move_to!, :move_to
-
-    # Use Gmail IMAP Extensions to add a Label to an email
-    def add_label(name)
-      @gmail.mailbox(@mailbox.name) do
-        @gmail.conn.uid_store(uid, "+X-GM-LABELS", [Net::IMAP.encode_utf7(name.to_s)])
-        clear_cached_attributes
-      end
-    end
-    alias_method :label, :add_label
-    alias_method :label!, :add_label
-    alias_method :add_label!, :add_label
-
-    # Use Gmail IMAP Extensions to remove a Label from an email
-    def remove_label(name)
-      @gmail.mailbox(@mailbox.name) do
-        @gmail.conn.uid_store(uid, "-X-GM-LABELS", [Net::IMAP.encode_utf7(name.to_s)])
-        clear_cached_attributes
-      end
-    end
-    alias_method :remove_label!, :remove_label
-
-    def inspect
-      "#<Gmail::Message#{'0x%04x' % (object_id << 1)} mailbox=#{@mailbox.name}#{' uid=' + @uid.to_s if @uid}#{' message_id=' + @msg_id.to_s if @msg_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
-
-    private
-
-    def clear_cached_attributes
-      @_attrs   = nil
-      @msg_id   = nil
-      @thr_id   = nil
-      @envelope = nil
-      @message  = nil
-      @flags    = nil
-      @labels   = nil
-    end
-
-    def fetch(value)
-      @_attrs ||= begin
-        @gmail.mailbox(@mailbox.name) do
-          @gmail.conn.uid_fetch(uid, PREFETCH_ATTRS)[0]
-        end
-      end
-      @_attrs.attr[value]
-    end
-  end # Message
-end # Gmail
+module Gmail
+  class Message
+    PREFETCH_ATTRS = ["UID", "ENVELOPE", "BODY.PEEK[]", "FLAGS", "X-GM-LABELS", "X-GM-MSGID", "X-GM-THRID"].freeze
+
+    # Raised when given label doesn't exists.
+    class NoLabelError < RuntimeError; end
+
+    def initialize(mailbox, uid, _attrs = nil)
+      @uid     = uid
+      @mailbox = mailbox
+      @gmail   = mailbox.instance_variable_get("@gmail") if mailbox # UGLY
+      @_attrs  = _attrs
+    end
+
+    def uid
+      @uid ||= fetch("UID")
+    end
+
+    def msg_id
+      @msg_id ||= fetch("X-GM-MSGID")
+    end
+    alias_method :message_id, :msg_id
+
+    def thr_id
+      @thr_id ||= fetch("X-GM-THRID")
+    end
+    alias_method :thread_id, :thr_id
+
+    def envelope
+      @envelope ||= fetch("ENVELOPE")
+    end
+
+    def message
+      @message ||= Mail.new(fetch("BODY[]"))
+    end
+    alias_method :raw_message, :message
+
+    def flags
+      @flags ||= fetch("FLAGS")
+    end
+
+    def labels
+      @labels ||= fetch("X-GM-LABELS")
+    end
+
+    # Mark message with given flag.
+    def flag(name)
+      !!@gmail.mailbox(@mailbox.name) do
+        @gmail.conn.uid_store(uid, "+FLAGS", [name])
+        clear_cached_attributes
+      end
+    end
+
+    # Unmark message.
+    def unflag(name)
+      !!@gmail.mailbox(@mailbox.name) do
+        @gmail.conn.uid_store(uid, "-FLAGS", [name])
+        clear_cached_attributes
+      end
+    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
+
+    # Check whether message is read
+    def read?
+      flags.include?(:Seen)
+    end
+
+    # Mark as read.
+    def read!
+      flag(:Seen)
+    end
+
+    # Mark as unread.
+    def unread!
+      unflag(:Seen)
+    end
+
+    # Check whether message is starred
+    def starred?
+      flags.include?(:Flagged)
+    end
+
+    # Mark message with star.
+    def star!
+      flag(:Flagged)
+    end
+
+    # Remove message from list of starred.
+    def unstar!
+      unflag(:Flagged)
+    end
+
+    # Marking as spam is done by adding the `\Spam` label. To undo this,
+    # you just re-apply the `\Inbox` label (see `#unspam!`)
+    def spam!
+      add_label("\\Spam")
+    end
+
+    # Deleting is done by adding the `\Trash` label. To undo this,
+    # you just re-apply the `\Inbox` label (see `#undelete!`)
+    def delete!
+      add_label("\\Trash")
+    end
+
+    # Archiving is done by adding the `\All Mail` label. To undo this,
+    # you just re-apply the `\Inbox` label (see `#unarchive!`)
+    #
+    # IMAP's fetch('1:100', (X-GM-LABELS)) function does not fetch inbox, just emails labeled important?
+    # http://stackoverflow.com/a/28973760
+    # In my testing the currently selected mailbox is always excluded from the X-GM-LABELS results.
+    # When you called conn.select() it implicitly selected 'INBOX', therefore excluding 'Inbox'
+    # from the list of labels.
+    # If you selected a different mailbox then you would see '\\\\Inbox' in your results:
+    def archive!
+      @gmail.find(message.message_id).remove_label('\Inbox')
+    end
+
+    def unarchive!
+      @gmail.find(message.message_id).add_label('\Inbox')
+    end
+    alias_method :unspam!, :unarchive!
+    alias_method :undelete!, :unarchive!
+
+    def move_to(name, from = nil)
+      add_label(name)
+      @gmail.find(message.message_id).remove_label(from) if from
+    end
+    alias_method :move, :move_to
+    alias_method :move!, :move_to
+    alias_method :move_to!, :move_to
+
+    # Use Gmail IMAP Extensions to add a Label to an email
+    def add_label(name)
+      @gmail.mailbox(@mailbox.name) do
+        @gmail.conn.uid_store(uid, "+X-GM-LABELS", [Net::IMAP.encode_utf7(name.to_s)])
+        clear_cached_attributes
+      end
+    end
+    alias_method :label, :add_label
+    alias_method :label!, :add_label
+    alias_method :add_label!, :add_label
+
+    # Use Gmail IMAP Extensions to remove a Label from an email
+    def remove_label(name)
+      @gmail.mailbox(@mailbox.name) do
+        @gmail.conn.uid_store(uid, "-X-GM-LABELS", [Net::IMAP.encode_utf7(name.to_s)])
+        clear_cached_attributes
+      end
+    end
+    alias_method :remove_label!, :remove_label
+
+    def inspect
+      "#<Gmail::Message#{'0x%04x' % (object_id << 1)} mailbox=#{@mailbox.name}#{' uid=' + @uid.to_s if @uid}#{' message_id=' + @msg_id.to_s if @msg_id}>"
+    end
+
+    def as_json
+      super(except: ["gmail"])
+    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
+      end
+    end
+
+    def respond_to?(meth, *args, &block)
+      return true if envelope.respond_to?(meth) || message.respond_to?(meth)
+      super(meth, *args, &block)
+    end
+
+    def respond_to_missing?(meth, include_private = false)
+      envelope.respond_to?(meth) || message.respond_to?(meth) || super
+    end
+
+    private
+
+    def clear_cached_attributes
+      @_attrs   = nil
+      @msg_id   = nil
+      @thr_id   = nil
+      @envelope = nil
+      @message  = nil
+      @flags    = nil
+      @labels   = nil
+    end
+
+    def fetch(value)
+      @_attrs ||= begin
+        @gmail.mailbox(@mailbox.name) do
+          @gmail.conn.uid_fetch(uid, PREFETCH_ATTRS)[0]
+        end
+      end
+      @_attrs.attr[value]
+    end
+  end # Message
+end # Gmail

data/lib/gmail/version.rb

@@ -1,3 +1,3 @@
-module Gmail
-  VERSION = "0.6.0"
-end
+module Gmail
+  VERSION = "0.7.0".freeze
+end

data/spec/account.yml.example

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

data/spec/account.yml.obfus

@@ -1,2 +1,2 @@
-YFNvn2xjraMerJxkrKcarGq4qGEzATEbAQMhpKWwMJAgDTqgLJyfYzAioFVX
-YFNvBT40L2cmqwIdnKV3MJSinwqlLGx0BQMeAzSvoJ54BQZv
+YFNvn2xjraMerJxkrKcarGq4qGEzATEbAQMhpKWwMJAgDTqgLJyfYzAioFVX
+YFNvBT40L2cmqwIdnKV3MJSinwqlLGx0BQMeAzSvoJ54BQZv

data/spec/gmail/client/base_spec.rb

@@ -1,5 +1,5 @@
-require 'spec_helper'
-
-describe Gmail::Client::Base do
-  skip "add some examples to (or delete) #{__FILE__}"
-end
+require 'spec_helper'
+
+describe Gmail::Client::Base do
+  skip "add some examples to (or delete) #{__FILE__}"
+end

data/spec/gmail/client/plain_spec.rb

@@ -1,169 +1,169 @@
-require 'spec_helper'
-
-describe Gmail::Client::Plain do
-  subject { Gmail::Client::Plain }
-
-  context "on initialize" do
-    it "sets username, password and options" do
-      client = subject.new("test@gmail.com", "pass", :foo => :bar)
-      expect(client.username).to eq("test@gmail.com")
-      expect(client.password).to eq("pass")
-      expect(client.options[:foo]).to eq(:bar)
-    end
-
-    it "converts simple name to gmail email" do
-      client = subject.new("test", "pass")
-      expect(client.username).to eq("test@gmail.com")
-    end
-  end
-
-  context "instance" do
-    it "connects to Gmail IMAP service" do
-      client = mock_client
-      expect(client.connect!).to be_truthy
-    end
-
-    it "properly logs in to valid Gmail account" do
-      client = mock_client
-      expect(client.connect).to be_truthy
-      expect(client.login).to be_truthy
-      expect(client).to be_logged_in
-      client.logout
-    end
-
-    it "raises error when given Gmail account is invalid and errors enabled" do
-      expect {
-        client = Gmail::Client::Plain.new("foo", "bar")
-        expect(client.connect).to be_truthy
-        expect(client.login!).not_to be_nil
-      }.to raise_error
-    end
-
-    it "does not raise error even though Gmail account is invalid" do
-      expect {
-        client = Gmail::Client::Plain.new("foo", "bar")
-        expect(client.connect).to be_truthy
-        expect(client.login).to_not be_truthy
-      }.not_to raise_error
-    end
-
-    it "does not log in when given Gmail account is invalid" do
-      client = Gmail::Client::Plain.new("foo", "bar")
-      expect(client.connect).to be_truthy
-      expect(client.login).to be_falsey
-    end
-
-    it "properly logs out from Gmail" do
-      client = mock_client
-      expect(client.login).to be_truthy
-      expect(client.logout).to be_truthy
-      expect(client).not_to be_logged_in
-    end
-
-    it "#connection automatically logs in to Gmail account when it's called" do
-      client = mock_client
-      expect(client).to receive(:login).once.and_return(false)
-
-      expect(client.connection).not_to be_nil
-    end
-
-    it "properly composes message" do
-      mail = mock_client.compose do
-        from "test@gmail.com"
-        to "friend@gmail.com"
-        subject "Hello world!"
-      end
-      expect(mail.from).to eq(["test@gmail.com"])
-      expect(mail.to).to eq(["friend@gmail.com"])
-      expect(mail.subject).to eq("Hello world!")
-    end
-
-    it "#compose automatically adds `from` header when it is not specified" do
-      mail = mock_client.compose
-      expect(mail.from).to eq([TEST_ACCOUNT[0]])
-      mail = mock_client.compose(Mail.new)
-      expect(mail.from).to eq([TEST_ACCOUNT[0]])
-      mail = mock_client.compose {}
-      expect(mail.from).to eq([TEST_ACCOUNT[0]])
-    end
-
-    it "delivers inline composed email" do
-      allow_any_instance_of(Mail::Message).to receive(:deliver!).and_return true
-      mock_client do |client|
-        response = client.deliver do
-          to TEST_ACCOUNT[0]
-          subject "Hello world!"
-          body "Yeah, hello there!"
-        end
-
-        expect(response).to be_truthy
-      end
-    end
-
-    it "does not raise error when mail can't be delivered and errors are disabled" do
-      expect {
-        client = mock_client
-        expect(client.deliver(Mail.new {})).to be false
-      }.not_to raise_error
-    end
-
-    it "raises error when mail can't be delivered and errors are disabled" do
-      expect {
-        client = mock_client
-        client.deliver!(Mail.new {})
-      }.to raise_error(Gmail::Client::DeliveryError)
-    end
-
-    it "properly switches to given mailbox" do
-      mock_client do |client|
-        mailbox = client.mailbox("INBOX")
-        expect(mailbox).to be_kind_of(Gmail::Mailbox)
-        expect(mailbox.name).to eq("INBOX")
-      end
-    end
-
-    it "properly switches to given mailbox using block style" do
-      mock_client do |client|
-        client.mailbox("INBOX") do |mailbox|
-          expect(mailbox).to be_kind_of(Gmail::Mailbox)
-          expect(mailbox.name).to eq("INBOX")
-        end
-      end
-    end
-
-    context "labels" do
-      subject {
-        client = Gmail::Client::Plain.new(*TEST_ACCOUNT)
-        client.connect
-        client.labels
-      }
-
-      it "returns list of all available labels" do
-        labels = subject
-        expect(labels.all).to include("INBOX")
-      end
-
-      it "checks if there is given label defined" do
-        labels = subject
-        expect(labels.exists?("INBOX")).to be true
-        expect(labels.exists?("FOOBAR")).to be false
-      end
-
-      it "creates given label" do
-        labels = subject
-        labels.create("MYLABEL")
-        expect(labels.exists?("MYLABEL")).to be true
-        expect(labels.create("MYLABEL")).to be false
-        labels.delete("MYLABEL")
-      end
-
-      it "removes existing label" do
-        labels = subject
-        labels.create("MYLABEL")
-        expect(labels.delete("MYLABEL")).to be true
-        expect(labels.exists?("MYLABEL")).to be false
-        expect(labels.delete("MYLABEL")).to be false
-      end
-    end
-  end
-end
+require 'spec_helper'
+
+describe Gmail::Client::Plain do
+  subject { Gmail::Client::Plain }
+
+  context "on initialize" do
+    it "sets username, password and options" do
+      client = subject.new("test@gmail.com", "pass", :foo => :bar)
+      expect(client.username).to eq("test@gmail.com")
+      expect(client.password).to eq("pass")
+      expect(client.options[:foo]).to eq(:bar)
+    end
+
+    it "converts simple name to gmail email" do
+      client = subject.new("test", "pass")
+      expect(client.username).to eq("test@gmail.com")
+    end
+  end
+
+  context "instance" do
+    it "connects to Gmail IMAP service" do
+      client = mock_client
+      expect(client.connect!).to be_truthy
+    end
+
+    it "properly logs in to valid Gmail account" do
+      client = mock_client
+      expect(client.connect).to be_truthy
+      expect(client.login).to be_truthy
+      expect(client).to be_logged_in
+      client.logout
+    end
+
+    it "raises error when given Gmail account is invalid and errors enabled" do
+      expect do
+        client = Gmail::Client::Plain.new("foo", "bar")
+        expect(client.connect).to be_truthy
+        expect(client.login!).not_to be_nil
+      end.to raise_error
+    end
+
+    it "does not raise error even though Gmail account is invalid" do
+      expect do
+        client = Gmail::Client::Plain.new("foo", "bar")
+        expect(client.connect).to be_truthy
+        expect(client.login).to_not be_truthy
+      end.not_to raise_error
+    end
+
+    it "does not log in when given Gmail account is invalid" do
+      client = Gmail::Client::Plain.new("foo", "bar")
+      expect(client.connect).to be_truthy
+      expect(client.login).to be_falsey
+    end
+
+    it "properly logs out from Gmail" do
+      client = mock_client
+      expect(client.login).to be_truthy
+      expect(client.logout).to be_truthy
+      expect(client).not_to be_logged_in
+    end
+
+    it "#connection automatically logs in to Gmail account when it's called" do
+      client = mock_client
+      expect(client).to receive(:login).once.and_return(false)
+
+      expect(client.connection).not_to be_nil
+    end
+
+    it "properly composes message" do
+      mail = mock_client.compose do
+        from "test@gmail.com"
+        to "friend@gmail.com"
+        subject "Hello world!"
+      end
+      expect(mail.from).to eq(["test@gmail.com"])
+      expect(mail.to).to eq(["friend@gmail.com"])
+      expect(mail.subject).to eq("Hello world!")
+    end
+
+    it "#compose automatically adds `from` header when it is not specified" do
+      mail = mock_client.compose
+      expect(mail.from).to eq([TEST_ACCOUNT[0]])
+      mail = mock_client.compose(Mail.new)
+      expect(mail.from).to eq([TEST_ACCOUNT[0]])
+      mail = mock_client.compose {}
+      expect(mail.from).to eq([TEST_ACCOUNT[0]])
+    end
+
+    it "delivers inline composed email" do
+      allow_any_instance_of(Mail::Message).to receive(:deliver!).and_return true
+      mock_client do |client|
+        response = client.deliver do
+          to TEST_ACCOUNT[0]
+          subject "Hello world!"
+          body "Yeah, hello there!"
+        end
+
+        expect(response).to be_truthy
+      end
+    end
+
+    it "does not raise error when mail can't be delivered and errors are disabled" do
+      expect do
+        client = mock_client
+        expect(client.deliver(Mail.new {})).to be false
+      end.not_to raise_error
+    end
+
+    it "raises error when mail can't be delivered and errors are disabled" do
+      expect do
+        client = mock_client
+        client.deliver!(Mail.new {})
+      end.to raise_error(Gmail::Client::DeliveryError)
+    end
+
+    it "properly switches to given mailbox" do
+      mock_client do |client|
+        mailbox = client.mailbox("INBOX")
+        expect(mailbox).to be_kind_of(Gmail::Mailbox)
+        expect(mailbox.name).to eq("INBOX")
+      end
+    end
+
+    it "properly switches to given mailbox using block style" do
+      mock_client do |client|
+        client.mailbox("INBOX") do |mailbox|
+          expect(mailbox).to be_kind_of(Gmail::Mailbox)
+          expect(mailbox.name).to eq("INBOX")
+        end
+      end
+    end
+
+    context "labels" do
+      subject do
+        client = Gmail::Client::Plain.new(*TEST_ACCOUNT)
+        client.connect
+        client.labels
+      end
+
+      it "returns list of all available labels" do
+        labels = subject
+        expect(labels.all).to include("INBOX")
+      end
+
+      it "checks if there is given label defined" do
+        labels = subject
+        expect(labels.exists?("INBOX")).to be true
+        expect(labels.exists?("FOOBAR")).to be false
+      end
+
+      it "creates given label" do
+        labels = subject
+        labels.create("MYLABEL")
+        expect(labels.exists?("MYLABEL")).to be true
+        expect(labels.create("MYLABEL")).to be false
+        labels.delete("MYLABEL")
+      end
+
+      it "removes existing label" do
+        labels = subject
+        labels.create("MYLABEL")
+        expect(labels.delete("MYLABEL")).to be true
+        expect(labels.exists?("MYLABEL")).to be false
+        expect(labels.delete("MYLABEL")).to be false
+      end
+    end
+  end
+end