luggage 1.0.0

data/lib/luggage/message.rb

@@ -0,0 +1,151 @@
+module Luggage
+  class Message
+    class MessageNotFoundError < ArgumentError; end
+    class DuplicateMessageError < StandardError; end
+
+    attr_accessor :flags
+    attr_reader :connection, :mailbox, :template, :date, :message_id
+
+    # Creates a local Message instance
+    #
+    # `connection` should be an authenticated Imap connection
+    # `mailbox` should be either a Mailbox or a string describing a remote mailbox
+    # `args` will be passed to Message::new.  Keys used by Message::new will be set, any
+    #   other keys will be delegated to Mail::Message.
+    #
+    # Example Usage:
+    # Message.new_local(c, 'INBOX', :template => 'base.eml', :date => 4.days.ago)
+    # Message.new_local(c, m, :subject => "VIAGRA ROCKS!", :body => "<insert phishing here>", :cc => "yourmom@gmail.com")
+    #
+    def self.new_local(connection, mailbox, args = {}, &block)
+      message = new(connection, mailbox, args)
+      message.instance_eval do
+        @mail = @template ? Mail.read(@template) : Mail.new
+        args.each do |key, value|
+          mail[key] = value if mail.respond_to?(key)
+        end
+        mail[:message_id] = message_id
+      end
+
+      message.instance_eval &block if block_given?
+      message
+    end
+
+    # Creates a Message instance
+    #
+    # `connection` should be an authenticated Imap connection
+    # `mailbox` should be either a Mailbox or a string describing a remote mailbox
+    # `args[:date]` when this message is appended to the remote server, this is the date which will be used
+    # `args[:template]` use this file as the initial raw email content.  
+    # `args[:message_id]` use this as for the Message-ID header.  This header is used to identify messages across requests
+    #
+    def initialize(connection, mailbox, args = {}, &block)
+      raise ArgumentError, "Net::IMAP connection required" unless connection.kind_of?(Net::IMAP)
+
+      @connection = connection
+      @mailbox = mailbox.kind_of?(Mailbox) ? mailbox : Mailbox.new(connection, mailbox)
+      @flags = []
+      @date = args[:date] || Time.now
+      @template = args[:template]
+      @message_id = args[:message_id] || "<#{UUIDTools::UUID.random_create}@test.oib.com>"
+
+      raise ArgumentError, "mailbox requried" unless @mailbox.present?
+
+      instance_eval &block if block_given?
+    end
+
+    # Formatted to save to file
+    #
+    # Mail::Message.new( message.to_s ).raw_source = message.to_s
+    #
+    def to_s
+      mail.encoded
+    end
+
+    # Fetch this message from the server and update all its attributes
+    #
+    def reload
+      fields = fetch_fields
+      @mail = Mail.new(fields["BODY[]"])
+      @flags = fields["FLAGS"]
+      @date = Time.parse(fields["INTERNALDATE"])
+      self
+    end
+
+    # Append this message to the remote mailbox
+    #
+    def save!
+      mailbox.select!
+      connection.append(mailbox.name, raw_message, flags.map {|f| f.to_sym.upcase}, date)
+    end
+
+    # Add the 'Deleted' flag to this message on the remote server
+    #
+    def delete!
+      mailbox.select!
+      connection.uid_store([uid], "+FLAGS", [:Deleted])
+      @mail = nil
+    end
+
+    # Returns true if a message with the same message_id exists in the remote mailbox
+    #
+    def exists?
+      mailbox.select!
+      connection.uid_search("HEADER Message-ID #{message_id}").present?
+    end
+
+    # Proxy all other methods to this instance's Mail::Message 
+    #
+    def method_missing(meth, *args, &block)
+       if mail.respond_to?(meth)
+         mail.send(meth, *args, &block)
+       else
+         super
+       end
+    end
+
+    def inspect
+      "#<Luggage::Message server: \"#{host}\", mailbox: \"#{mailbox.name}\", message_id: \"#{message_id}\">"
+    end
+
+    def host
+      connection.instance_variable_get(:@host)
+    end
+
+    private
+
+    # Formatted to upload to IMAP server
+    #
+    def raw_message
+      mail.to_s
+    end
+
+    def mail
+      reload unless @mail.present?
+      @mail
+    end
+
+    def uid
+      unless @uid.present?
+        mailbox.select!
+        @uid = fetch_uid
+      end
+      @uid
+    end
+
+    def fetch_uid
+      response = connection.uid_search("HEADER Message-ID #{message_id}")
+      raise MessageNotFoundError if response.empty?
+      raise DuplicateMessageError if response.length > 1
+      response.first
+    end
+
+    def fetch_fields
+      response = connection.uid_fetch([uid], ["FLAGS", "INTERNALDATE", "BODY.PEEK[]"])
+      raise MessageNotFoundError if response.empty?
+      raise DuplicateMessageError if response.length > 1
+      response.first[:attr]
+    end
+  end
+end
+

data/lib/luggage/version.rb

@@ -0,0 +1,3 @@
+module Luggage
+  VERSION = "1.0.0"
+end

data/lib/luggage.rb

@@ -0,0 +1,16 @@
+require 'net/imap'
+require 'mail'
+require 'uuidtools'
+
+require 'luggage/factory'
+require 'luggage/mailbox'
+require 'luggage/mailbox_array'
+require 'luggage/mailbox_query_builder'
+require 'luggage/message'
+require 'luggage/version'
+
+module Luggage
+  def self.new(*args, &block)
+    Factory.new(*args, &block)
+  end
+end

data/luggage.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+
+require File.expand_path('../lib/luggage/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = "luggage"
+  gem.version       = Luggage::VERSION
+  gem.summary       = %q{Net::IMAP DSL}
+  gem.description   = %q{Easily interact with IMAP servers}
+  gem.license       = "MIT"
+  gem.authors       = ["Ryan Michael", "Eric Pinzur"]
+  gem.email         = "ryanmichael@otherinbox.com"
+  gem.homepage      = "https://github.com/otherinbox/luggage"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ['lib']
+
+  gem.add_dependency 'mail', '~> 2.5.0'
+  gem.add_dependency 'uuidtools', '~> 2.1.3'
+
+  gem.add_development_dependency 'bundler', '~> 1.0'
+  gem.add_development_dependency 'rake', '~> 0.8'
+  gem.add_development_dependency 'rdoc', '~> 3.0'
+  gem.add_development_dependency 'rspec', '~> 2.4'
+  gem.add_development_dependency 'activesupport', '~> 3.2.9'
+  gem.add_development_dependency 'fuubar', '~> 1.1.0'
+  gem.add_development_dependency 'pry', '~> 0.9.10'
+end

data/spec/luggage/factory_spec.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Luggage::Factory do
+  include_context "factories"
+
+  describe "::new" do
+    it "accepts :connection" do
+      expect(Luggage.new(:connection => connection).connection).to eq(connection)
+    end
+
+    it "accepts :server, :authenticate and creates a connection" do
+      Net::IMAP.any_instance.stub(:authenticate).and_return(true)
+      expect(Luggage.new(:server => :foo, :authenticate => "LOGIN username password").connection).to be_a(Net::IMAP)
+    end
+
+    it "accepts :server, :xoauth and creates a connection" do
+      Net::IMAP.any_instance.stub(:send_command).and_return(true)
+      expect(Luggage.new(:server => :foo, :xoauth => "token").connection).to be_a(Net::IMAP)
+    end
+
+    it "requires a way to build a connection" do
+      expect { Luggage.new }.to raise_error(ArgumentError)
+    end
+  end
+
+  describe '#message' do
+    it "returns a Luggage::Message" do
+      expect(factory.message(:mailbox)).to be_a(Luggage::Message)
+    end
+
+    it "passes arguments to initialize" do
+      Luggage::Message.should_receive(:new).with(connection, "mailbox_name", :key => :value).and_return( double('Message').as_null_object )
+      factory.message("mailbox_name", :key => :value)
+    end
+  end
+
+  describe "#mailboxes" do
+    before(:each) do
+      connection.stub(:list).
+        and_return([ 
+          OpenStruct.new(:name => "Mailbox_1"), 
+          OpenStruct.new(:name => "Mailbox_2"), 
+          OpenStruct.new(:name => "Mailbox_3"),
+          OpenStruct.new(:name => "Mailbox_4") ])
+    end
+
+    context "with no arguments" do
+      it "returns an array of mailboxes defined on the remote server" do
+        expect(factory.mailboxes.map(&:name)).to eq(["Mailbox_1", "Mailbox_2", "Mailbox_3", "Mailbox_4"])
+      end
+    end
+
+    context "with a string argument (function-call syntax)" do
+      it "returns a mailbox with the passed name" do
+        expect(factory.mailboxes("foo").name).to eq("foo")
+      end
+    end
+
+    context "with an iteger (function-call syntax)" do
+      it "returns the nth mailbox on the remote server" do
+        expect(factory.mailboxes(1).name).to eq("Mailbox_2")
+      end
+    end
+
+    context "with a string argument (hash-index syntax)" do
+      it "returns a mailbox with the passed name" do
+        expect(factory.mailboxes["foo"].name).to eq("foo")
+      end
+    end
+
+    context "with an integer (array-index syntax)" do
+      it "returns the nth mailbox on the remote server" do
+        expect(factory.mailboxes[1].name).to eq("Mailbox_2")
+      end
+    end
+
+    context "with a range (array-slice syntax)" do
+      it "returns a subset array of mailboxes defined on the remote server" do
+        expect(factory.mailboxes[1..2].map(&:name)).to eq(["Mailbox_2", "Mailbox_3"])
+      end
+    end
+  end
+end

data/spec/luggage/mailbox_query_builder_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Luggage::MailboxQueryBuilder do
+  include_context "factories"
+
+  describe "::new" do
+    it "sets the mailbox" do
+      expect(Luggage::MailboxQueryBuilder.new(mailbox).mailbox).to eq(mailbox)
+    end
+
+    it "requires a mailbox" do
+      expect { Luggage::MailboxQueryBuilder.new(:not_a_mailbox) }.to raise_error(ArgumentError)
+    end
+
+    it "sets the connection" do
+      expect(Luggage::MailboxQueryBuilder.new(mailbox).connection).to eq(connection)
+    end
+  end
+
+  describe "#each" do
+    it "yields to each member of #messages" do
+      block = Proc.new {}
+      query_builder.stub(:message_ids).and_return(['<one@example.com>', '<two@example.com>'])
+      query_builder.messages.should_receive(:each) #.with(block)
+
+      query_builder.each(&block)
+    end
+  end
+
+  describe "::where" do
+    it "returns self" do
+      expect(query_builder.where(:foo => :bar)).to be_a(Luggage::MailboxQueryBuilder)
+    end
+
+    it "appends to the query" do
+      expect(query_builder.where(:foo => :bar).where(:baz => :qux).query).to eq([:foo, :bar, :baz, :qux])
+    end
+  end
+
+  describe "::[]" do
+    it "returns messages[]" do
+      query_builder.stub(:message_ids).and_return(['<one@example.com>', '<two@example.com>'])
+      query_builder.messages.should_receive(:[]).with((1..2))
+
+      query_builder[1..2]
+    end
+  end
+end

data/spec/luggage/mailbox_spec.rb

@@ -0,0 +1,135 @@
+require 'spec_helper'
+
+describe Luggage::Mailbox do
+  include_context "factories"
+
+  describe "::new" do
+    it "executes a passed block" do
+      m = Luggage::Mailbox.new(connection, :mailbox) do
+        @name = "woot"
+      end
+      expect(m.name).to eq("woot")
+    end
+
+    it "sets the connection" do
+      expect(Luggage::Mailbox.new(connection, :mailbox).connection).to eq(connection)
+    end
+
+    it "requires a connection" do
+      expect { Luggage::Mailbox.new(:foo, :mailbox).connection }.to raise_error(ArgumentError)
+    end
+
+    it "sets the name" do
+      expect(Luggage::Mailbox.new(connection, :mailbox).name).to eq(:mailbox)
+    end
+  end
+
+  describe "message" do
+    it "executes a passed block" do
+      m = mailbox.message do
+        subject("new subject")
+      end
+      expect(m.subject).to eq("new subject")
+    end
+
+
+    it "returns an Luggage::Message" do
+      expect(mailbox.message).to be_a(Luggage::Message)
+    end
+
+    it "instantiates with expected arguments" do
+      message = Luggage::Message.new(connection, mailbox, :foo => :bar)
+      Luggage::Message.should_receive(:new).with(connection, mailbox, :foo => :bar).and_return(message)
+
+      mailbox.message(:foo => :bar)
+    end
+  end
+
+  describe "all" do
+    it "returns a QueryBuilder" do
+      expect(mailbox.all).to be_a(Luggage::MailboxQueryBuilder)
+    end
+  end
+
+  describe "each" do
+    it "delegates to QueryBuilder instance" do
+      block = Proc.new {}
+      Luggage::MailboxQueryBuilder.any_instance.should_receive(:each).with(&block)
+
+      mailbox.each(&block)
+    end
+  end
+
+  describe "first" do
+    it "delegates to QueryBuilder instance" do
+      Luggage::MailboxQueryBuilder.any_instance.should_receive(:first)
+
+      mailbox.first
+    end
+  end
+
+  describe "where" do
+    it "delegates to QueryBuilder instance" do
+      Luggage::MailboxQueryBuilder.any_instance.should_receive(:where).with(:foo => :bar)
+
+      mailbox.where(:foo => :bar)
+    end
+  end
+
+  describe "select!" do
+    it "selects the mailbox" do
+      connection.should_receive(:select).with(:mailbox)
+
+      mailbox.select!
+    end
+  end
+
+  describe "save!" do
+    it "creates the mailbox if it doesn't exist" do
+      connection.should_receive(:create).with(:mailbox)
+
+      mailbox.save!
+    end
+
+    it "doesn't create the mailbox if the mailbox exists" do
+      mailbox.stub(:exists?).and_return(true)
+      connection.should_not_receive(:create)
+
+      mailbox.save!
+    end
+  end
+
+  describe "expunge!" do
+    it "selects the mailbox" do
+      connection.should_receive(:select).with(:mailbox)
+
+      mailbox.expunge!
+    end
+
+    it "expunges the mailbox" do
+      connection.should_receive(:expunge)
+
+      mailbox.expunge!
+    end
+  end
+
+  describe "delete!" do
+    it "deletes the mailbox" do
+      connection.should_receive(:delete)
+
+      mailbox.delete!
+    end
+  end
+
+  describe "exists?" do
+    it "returns true if list includes the mailbox name" do
+      connection.stub(:list).with("", :mailbox).and_return([:results])
+
+      expect(mailbox.exists?).to be_true
+    end
+
+    it "returns false if the list doesn't include the mailbox name" do
+      expect(mailbox.exists?).to be_false
+    end
+  end
+end

data/spec/luggage/message_spec.rb

@@ -0,0 +1,181 @@
+require 'spec_helper'
+
+describe Luggage::Message do
+  include_context "factories"
+
+  describe "::new_local" do
+    it "executes a passed block" do
+      m = Luggage::Message.new_local(connection, "Inbox") do
+        subject("new subject")
+      end
+      expect(m.subject).to eq("new subject")
+    end
+
+    it "returns an Luggage::Message" do
+      expect(Luggage::Message.new_local(connection, "Inbox")).to be_a(Luggage::Message)
+    end
+
+    it "raises ArgumentError if Luggage::Mailbox isn't passed" do
+      expect{ Luggage::Message.new_local() }.to raise_error(ArgumentError)
+    end
+
+    [:subject, :body, :to].each do |method|
+      context "with #{method} passed as argument" do
+        it "sets #{method} on Mail object" do
+          message = Luggage::Message.new_local(connection, :mailbox, method => "string")
+          expect(message.to_s).to match(/string/)
+        end
+      end
+    end
+
+    context "without template" do
+      it "instatiates a Mail object" do
+        mail = Mail.new
+        Mail.should_receive(:new).and_return(mail)
+        Luggage::Message.new_local(connection, :mailbox)
+      end
+    end
+
+    context "with a template" do
+      it "instatiates a Mail object" do
+        Mail.should_receive(:read).and_return({})
+
+        Luggage::Message.new_local(connection, :mailbox, :template =>"base")
+      end
+    end
+  end
+
+  describe "::new" do
+    it "executes a passed block" do
+      m = Luggage::Message.new(connection, "Inbox") do
+        subject("new subject")
+      end
+      expect(m.subject).to eq("new subject")
+    end
+
+    it "sets connection" do
+      expect(Luggage::Message.new(connection, :mailbox).connection).to eq(connection)
+    end
+
+    it "requires a connection" do
+      expect { Luggage::Message.new(:not_a_connection, :mailbox).connection }.to raise_error(ArgumentError)
+    end
+
+    it "sets mailbox if Mailbox passed" do
+      expect(Luggage::Message.new(connection, mailbox).mailbox).to eq(mailbox)
+    end
+
+    it "instantiates new mailbox if string passed" do
+      expect(Luggage::Message.new(connection, :mailbox).mailbox).to be_a(Luggage::Mailbox)
+    end
+
+    it "sets date if passed" do
+      date = 2.days.ago
+      expect(Luggage::Message.new(connection, :mailbox, :date => date).date).to eq(date)
+    end
+
+    it "sets date to now if not passed" do
+      expect(Luggage::Message.new(connection, :mailbox).date).to be_a(Time)
+    end
+
+    it "sets message_id if passed" do
+      message_id = "<foo@example.com>"
+      expect(Luggage::Message.new(connection, :mailbox, :message_id => message_id).message_id).to eq(message_id)
+    end
+
+    it "creates message_id if not passed" do
+      expect(Luggage::Message.new(connection, :mailbox).message_id).to match(/<\S*@\S*>/)
+    end
+  end
+
+  describe "#reload" do
+    it "selects mailbox" do
+      connection.should_receive(:select).with("Inbox")
+
+      message.reload
+    end
+
+    it "fetches raw email" do
+      connection.should_receive(:uid_fetch).
+        with([1], ["FLAGS", "INTERNALDATE", "BODY.PEEK[]"]).
+        and_return( [{:attr => {"BODY[]" => "raw_body", "FLAGS" => [], "INTERNALDATE" => 1.day.ago.to_s}}]  )
+
+      message.reload
+    end
+
+    it "fetches flags" do
+      connection.should_receive(:uid_fetch).
+        with([1], ["FLAGS", "INTERNALDATE", "BODY.PEEK[]"]).
+        and_return( [{:attr => {"BODY[]" => "raw_body", "FLAGS" => [], "INTERNALDATE" => 1.day.ago.to_s}}]  )
+
+      message.reload
+    end
+
+    it "creates new Mail instance" do
+      message # To instantiate the first one...
+
+      Mail.should_receive(:new).with("raw_body")
+
+      message.reload
+    end
+  end
+
+  describe "#save!" do
+    it "selects mailbox" do
+      connection.should_receive(:select).with("Inbox")
+
+      message.save!
+    end
+
+    it "appends message to mailbox" do
+      message_date = 2.days.ago
+      message.stub(:raw_message).and_return("Random Content")
+      message.stub(:flags).and_return([:Seen])
+      message.stub(:date).and_return(message_date)
+
+      connection.should_receive(:append).with("Inbox", "Random Content", [:SEEN], message_date)
+      message.save!
+    end
+  end
+
+  describe "#to_s" do
+    it "returns a string" do
+      expect(message.to_s).to be_a(String)
+    end
+  end
+
+
+  describe "#delete!" do
+    it "selects mailbox" do
+      connection.should_receive(:select).with("Inbox")
+
+      message.delete!
+    end
+
+    it "sets Deleted flag" do
+      connection.should_receive(:uid_store).with([1], "+FLAGS", [:Deleted])
+
+      message.delete!
+    end
+
+    it "resets cached mail instance" do
+      message.delete!
+      expect(message.instance_variable_get(:@mail)).to be_nil
+    end
+  end
+
+  describe "#exists?" do
+    it "selects mailbox" do
+      connection.should_receive(:select).with("Inbox")
+
+      message.exists?
+    end
+
+    it "searches for message with message_id" do
+      message.stub(:message_id).and_return("<foo@example.com>")
+      connection.should_receive(:uid_search).with("HEADER Message-ID <foo@example.com>").and_return([1])
+
+      message.exists?
+    end
+  end
+end

data/spec/luggage_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe Luggage do
+  it "should have a VERSION constant" do
+    subject.const_get('VERSION').should_not be_empty
+  end
+
+  include_context "factories"
+
+  describe "::new" do
+    it "proxies Luggage::Factory" do
+      Luggage::Factory.should_receive(:new).with(:server => :foo, :authenticate => :bar)
+      Luggage.new(:server => :foo, :authenticate => :bar)
+    end
+  end
+end

data/spec/net_imap.rb

@@ -0,0 +1,15 @@
+# mock Net::IMAP
+class Net::IMAP
+  def initialize(*args, &block)
+  end
+
+  def login(user, password)
+  end
+
+  def disconnect
+  end
+
+  def disconnected?
+  end
+end
+