outbox 0.0.1 → 0.1.0

data/lib/outbox/message_types.rb

@@ -0,0 +1,62 @@
+module Outbox
+  module MessageTypes
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      # Registers a message type for sending & creates accessors.
+      #
+      #   Message.register_message_type :telepathy, TelepathyMessage
+      #   message = Message.new do
+      #     telepathy do
+      #       thought 'Hello world.'
+      #     end
+      #   end
+      #   message.telepathy.thought #=> 'Hello world.'
+      #
+      # Upon deliver the audience object will be checked for the registered
+      # message type.
+      #
+      #   message.deliver telepathy: 'Bob'
+      def register_message_type(name, message_type)
+        message_types[name.to_sym] = message_type
+        define_message_type_reader(name, message_type)
+        define_message_type_writer(name)
+      end
+
+      # Returns a hash of the registred message types, where the key is the name
+      # of the message type and the value is the message type class.
+      def message_types
+        @message_types ||= {}
+      end
+
+      protected
+
+      def define_message_type_reader(name, message_type)
+        ivar_name = "@#{name}"
+        define_method(name) do |options = nil, &block|
+          if options || block
+            instance_variable_set(ivar_name, message_type.new(options, &block))
+          else
+            instance_variable_get(ivar_name)
+          end
+        end
+      end
+
+      def define_message_type_writer(name)
+        define_method("#{name}=") do |value|
+          instance_variable_set("@#{name}", value)
+        end
+      end
+    end
+
+    protected
+
+    def assign_message_type_values(values)
+      values.each do |key, value|
+        self.public_send(key, value) if self.respond_to?(key)
+      end
+    end
+  end
+end

data/lib/outbox/messages/base.rb

@@ -0,0 +1,46 @@
+module Outbox
+  module Messages
+    class Base
+      include MessageClients
+      include MessageFields
+
+      # Make a new message. Every message type can be created using a hash,
+      # block, or direct assignment.
+      #
+      #   message = Email.new to: 'someone@example.com', from: 'company@example.com'
+      #   message = Email.new do
+      #     to 'someone@example.com'
+      #     from 'company@example.com'
+      #   end
+      #   message = Email.new
+      #   message.to = 'someone@example.com'
+      #   message.from = 'company@example.com'
+      def initialize(fields = nil, &block)
+        @fields = {}
+        @client = self.class.default_client and self.class.default_client.dup
+
+        self.fields = self.class.defaults
+
+        if block_given?
+          instance_eval(&block)
+        else
+          self.fields = fields unless fields.nil?
+        end
+      end
+
+      # Sets the 'audience' for this message. All message types must implement
+      # this method. By default, this is an alias for a 'to' field if present.
+      def audience=(audience)
+        self.to = audience if self.respond_to?(:to=)
+      end
+
+      # Validates the current message and delivers the message using the
+      # defined client.
+      def deliver(audience = nil)
+        self.audience = audience if audience
+        validate_fields
+        client.deliver(self)
+      end
+    end
+  end
+end

data/lib/outbox/messages/email.rb

@@ -0,0 +1,77 @@
+require 'mail'
+
+module Outbox
+  module Messages
+    # Email messages use the same interface for composing emails as
+    # Mail::Message from the mail gem. The only difference is the abstraction
+    # of the client interface, which allows you to send the email using
+    # whatever client you wish.
+    #
+    #   email = Outbox::Messages::Email.new do
+    #     to 'nicolas@test.lindsaar.net.au'
+    #     from 'Mikel Lindsaar <mikel@test.lindsaar.net.au>'
+    #     subject 'First multipart email sent with Mail'
+    #
+    #     text_part do
+    #       body 'This is plain text'
+    #     end
+    #
+    #     html_part do
+    #       content_type 'text/html; charset=UTF-8'
+    #       body '<h1>This is HTML</h1>'
+    #     end
+    #   end
+    #   email.client :mandrill, api_key: '...'
+    #   email.deliver
+    class Email < Base
+      register_client_alias :mail, Outbox::Clients::MailClient
+
+      default_client :mail
+
+      required_fields :smtp_envelope_from, :smtp_envelope_to,
+                      :encoded, accessor: false
+
+      fields :bcc, :cc, :content_description, :content_disposition,
+             :content_id, :content_location, :content_transfer_encoding,
+             :content_type, :date, :from, :in_reply_to, :keywords,
+             :message_id, :mime_version, :received, :references, :reply_to,
+             :resent_bcc, :resent_cc, :resent_date, :resent_from,
+             :resent_message_id, :resent_sender, :resent_to, :return_path,
+             :sender, :to, :comments, :subject, accessor: false
+
+      def initialize(fields = nil, &block)
+        @message = ::Mail::Message.new
+        super
+      end
+
+      # Returns the internal Mail::Message instance
+      def message_object
+        @message
+      end
+
+      def audience=(audience)
+        case audience
+        when String, Array
+          self.to = audience
+        else
+          audience = Outbox::Accessor.new(audience)
+          self.to = audience[:to]
+          self.cc = audience[:cc]
+          self.bcc = audience[:bcc]
+        end
+      end
+
+      def method_missing(method, *args, &block)
+        if @message.respond_to?(method)
+          @message.public_send(method, *args, &block)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        @message.respond_to?(method, include_private) || super
+      end
+    end
+  end
+end

data/lib/outbox/version.rb

@@ -1,3 +1,3 @@
 module Outbox
-  VERSION = '0.0.1'
+  VERSION = '0.1.0'
 end

data/outbox.gemspec

@@ -8,8 +8,8 @@ Gem::Specification.new do |spec|
   spec.version       = Outbox::VERSION
   spec.authors       = ['Pete Browne']
   spec.email         = ['pete.browne@localmed.com']
-  spec.description   = %q{A Rails engine and generic interface for sending email, SMS, & push notifications.}
-  spec.summary       = %q{Outbox is a Rails engine and generic interface for sending notifications using a variety of delivery methods, with built-in support for the most popular SaaS solutions.}
+  spec.description   = %q{A generic interface for sending email, SMS, & push notifications.}
+  spec.summary       = %q{Outbox is a generic interface for sending notifications using a variety of protocols, with built-in support for the most popular SaaS solutions.}
   spec.homepage      = 'https://github.com/localmed/outbox'
   spec.license       = 'MIT'
 
@@ -18,6 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
+  spec.add_runtime_dependency 'mail', '~> 2.5.3'
   spec.add_development_dependency 'bundler', '~> 1.3'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec'

data/spec/outbox/accessor_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe Outbox::Accessor do
+  context 'with a hash' do
+    it 'reads properties via symbol' do
+      hash = { 'a' => 1, :b => 2 }
+      hash_accessor = Outbox::Accessor.new(hash)
+      expect(hash_accessor[:a]).to eq(1)
+      expect(hash_accessor[:b]).to eq(2)
+      expect(hash_accessor[:c]).to be_nil
+    end
+
+    it 'reads properties via string' do
+      hash = { 'a' => 1, :b => 2 }
+      hash_accessor = Outbox::Accessor.new(hash)
+      expect(hash_accessor['a']).to eq(1)
+      expect(hash_accessor['b']).to eq(2)
+      expect(hash_accessor['c']).to be_nil
+    end
+
+    it 'writes arbitrary properties' do
+      hash = {}
+      hash_accessor = Outbox::Accessor.new(hash)
+      hash_accessor[:a] = 1
+      hash_accessor['b'] = 2
+      expect(hash_accessor.object[:a]).to eq(1)
+      expect(hash_accessor.object[:b]).to eq(2)
+    end
+  end
+
+  context 'with an object' do
+    class MockObj
+      attr_accessor :a, :b
+    end
+
+    it 'reads properties it responds to' do
+      object = MockObj.new
+      object.a = 1
+      object.b = 2
+      object_accessor = Outbox::Accessor.new(object)
+      expect(object_accessor[:a]).to eq(1)
+      expect(object_accessor[:b]).to eq(2)
+      expect(object_accessor[:c]).to be_nil
+    end
+
+    it 'writes properties it responds to' do
+      object = MockObj.new
+      object.a = 1
+      object_accessor = Outbox::Accessor.new(object)
+      expect(object_accessor[:a]).to eq(1)
+      object_accessor[:a] = 2
+      expect(object_accessor.object.a).to eq(2)
+      expect {
+        object_accessor[:c] = 2
+      }.not_to raise_error()
+    end
+  end
+end

data/spec/outbox/clients/base_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Outbox::Clients::Base do
+  class Client < Outbox::Clients::Base
+    defaults foo: 10
+  end
+
+  describe '.defaults' do
+    it 'defines default settings' do
+      client = Client.new
+      expect(client.settings[:foo]).to eq(10)
+    end
+  end
+
+  describe '.new' do
+    it 'initializes settings' do
+      client = Client.new foo: 1, bar: 2
+      expect(client.settings[:foo]).to eq(1)
+      expect(client.settings[:bar]).to eq(2)
+    end
+  end
+
+  describe '#deliver' do
+    it 'raises an error' do
+      client = Client.new
+      expect{client.deliver(Outbox::Messages::Base.new)}.to raise_error(NotImplementedError)
+    end
+  end
+end

data/spec/outbox/clients/mail_client_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+describe Outbox::Clients::MailClient do
+  describe '.new' do
+    it 'configures the delivery method' do
+      client = Outbox::Clients::MailClient.new delivery_method: :smtp, smtp_settings: {
+        address: 'smtp.mockup.com',
+        port: 587
+      }
+      expect(client.delivery_method).to eq(:smtp)
+      expect(client.delivery_method_settings[:address]).to eq('smtp.mockup.com')
+      expect(client.delivery_method_settings[:port]).to eq(587)
+    end
+  end
+
+  describe '#deliver' do
+    before do
+      @client = Outbox::Clients::MailClient.new delivery_method: :smtp, smtp_settings: {
+        address: 'smtp.mockup.com',
+        port: 587
+      }
+      @email = Outbox::Messages::Email.new do
+        to 'bob@gmail.com'
+        from 'john@gmail.com'
+        body 'Hello world.'
+      end
+    end
+
+    it 'configures the delivery method' do
+      message = double(:message, deliver: true)
+      expect(@email.message_object).to receive(:dup) { message }
+      expect(message).to receive(:delivery_method).with(:smtp, address: 'smtp.mockup.com', port: 587)
+      @client.deliver(@email)
+    end
+
+    it 'delivers the email' do
+      message = double(:message, delivery_method: true)
+      expect(@email.message_object).to receive(:dup) { message }
+      expect(message).to receive(:deliver)
+      @client.deliver(@email)
+    end
+  end
+end

data/spec/outbox/clients/test_client_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Outbox::Clients::TestClient do
+  class Message < Outbox::Messages::Base
+    default_client :test
+    fields :to, :body
+  end
+
+  before { Outbox::Clients::TestClient.deliveries.clear }
+
+  it 'defaults to no deliveries' do
+    expect(Outbox::Clients::TestClient.deliveries).to be_empty
+  end
+
+  it 'appends the delivery to to deliveries array' do
+    message = Message.new(to: 'Bob', body: 'Hi Bob')
+    message.deliver
+    expect(Outbox::Clients::TestClient.deliveries.length).to eq(1)
+    expect(Outbox::Clients::TestClient.deliveries.first).to be(message)
+  end
+
+  it 'saves configuration' do
+    client = Outbox::Clients::TestClient.new foo: 1, bar: 2
+    expect(client.settings).to eq(foo: 1, bar: 2)
+  end
+end

data/spec/outbox/message_spec.rb

@@ -0,0 +1,103 @@
+require 'spec_helper'
+
+describe Outbox::Message do
+  class Telepathy < Outbox::Messages::Base
+    default_client :test
+    fields :to, :from, :thought
+  end
+
+  class MessageInABottle < Outbox::Messages::Base
+    default_client :test
+    fields :to, :bottle, :message
+  end
+
+  before do
+    @original_message_types = Outbox::Message.message_types
+    Outbox::Message.register_message_type :telepathy, Telepathy
+    Outbox::Message.register_message_type :bottle, MessageInABottle
+  end
+
+  after do
+    Outbox::Message.instance_variable_set :@message_types, @original_message_types
+  end
+
+  describe '.message_types' do
+    it 'includes email' do
+      expect(Outbox::Message.message_types[:email]).to eq(Outbox::Messages::Email)
+    end
+  end
+
+  describe '.register_message_type' do
+    it 'adds a message type' do
+      expect(Outbox::Message.message_types[:telepathy]).to eq(Telepathy)
+    end
+
+    it 'defines a block accessor for that type' do
+      message = Outbox::Message.new
+      message.telepathy do
+        thought 'Hello world.'
+      end
+      expect(message.telepathy.thought).to eq('Hello world.')
+    end
+
+    it 'defines a writer for that type' do
+      message = Outbox::Message.new
+      message.telepathy = Telepathy.new thought: 'Hello world.'
+      expect(message.telepathy.thought).to eq('Hello world.')
+    end
+  end
+
+  describe '.new' do
+    it 'initializes with a block' do
+      message = Outbox::Message.new do
+        telepathy do
+          thought 'Hello world.'
+        end
+      end
+      expect(message.telepathy.thought).to eq('Hello world.')
+    end
+
+    it 'initializes with a hash' do
+      message = Outbox::Message.new telepathy: { thought: 'Hello world.' }
+      expect(message.telepathy.thought).to eq('Hello world.')
+    end
+  end
+
+  describe '#deliver' do
+    before do
+      @message = Outbox::Message.new do
+        telepathy do
+          thought 'Hello world.'
+        end
+      end
+    end
+
+    context 'with a hash' do
+      it 'deilvers the message to that audience' do
+        @message.deliver telepathy: 'Bob', bottle: 'John'
+        message = Outbox::Clients::TestClient.deliveries.last
+        expect(Outbox::Clients::TestClient.deliveries.length).to eq(1)
+        expect(message).to be(@message.telepathy)
+        expect(message.to).to eq('Bob')
+      end
+    end
+
+    context 'with an audience object' do
+      it 'delivers the messages to the audience' do
+        audience = OpenStruct.new
+        audience.telepathy = 'Bob'
+        audience.bottle = 'John'
+
+        @message.bottle do
+          bottle 'Coke'
+          message 'Hello world.'
+        end
+
+        @message.deliver(audience)
+        expect(Outbox::Clients::TestClient.deliveries.length).to eq(2)
+        expect(@message.telepathy.to).to eq('Bob')
+        expect(@message.bottle.to).to eq('John')
+      end
+    end
+  end
+end