postal-ruby 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: decfbd216e5711fdb213bd6896c656f608e252b7
+  data.tar.gz: f7696e1e19fbca0f46a6f9ba0475b5b7f124decb
+SHA512:
+  metadata.gz: 5d2a13891fdd768c6fa07d819fb2fe702e599888aebfccac0a47e37171b0bafae9cf4d46afdab61694dbefe76340062724d8f3c16d7ed3c1df9555787ea6f7d3
+  data.tar.gz: 9583d073dbcaee6ae0a1ff1f8d9203b3e325645c66e9b986de38d54b8ee0f8ae4c0e25282a44f19b9babc4031e508271daaba44838cd0e25b27cea76a75439e7

data/lib/postal.rb

@@ -0,0 +1,22 @@
+require 'postal/client'
+require 'postal/config'
+
+module Postal
+
+  def self.config
+    @config ||= Config.new
+  end
+
+  def self.configure(&block)
+    block.call(config)
+  end
+
+  def self.send_message(&block)
+    Postal::Client.instance.send_message(&block)
+  end
+
+  def self.send_raw_message(&block)
+    Postal::Client.instance.send_raw_message(&block)
+  end
+
+end

data/lib/postal/attachment.rb

@@ -0,0 +1,31 @@
+require 'base64'
+
+module Postal
+  class Attachment
+
+    def initialize(attributes)
+      @attributes = attributes
+    end
+
+    def filename
+      @attributes['filename']
+    end
+
+    def content_type
+      @attributes['content_type']
+    end
+
+    def size
+      @attributes['size']
+    end
+
+    def hash
+      @attributes['hash']
+    end
+
+    def data
+      @data ||= Base64.decode64(@attributes['data'])
+    end
+
+  end
+end

data/lib/postal/client.rb

@@ -0,0 +1,61 @@
+require 'moonrope_client'
+require 'postal/message_scope'
+require 'postal/send_message'
+require 'postal/send_raw_message'
+
+module Postal
+  class Client
+
+    #
+    # Create and cache a global instance of client based on the environment variables
+    # which can be provided. In 90% of cases, Postal will be accessed through this.
+    #
+    def self.instance
+      @instance ||= Client.new(Postal.config.host, Postal.config.server_key)
+    end
+
+    #
+    # Initialize a new client with the host and API key
+    #
+    def initialize(host, server_key)
+      @host = host
+      @server_key = server_key
+    end
+
+    #
+    # Provide a scope to access messages
+    #
+    def messages
+      MessageScope.new(self)
+    end
+
+    #
+    # Send a message
+    #
+    def send_message(&block)
+      message = SendMessage.new(self)
+      block.call(message)
+      message.send!
+    end
+
+    #
+    # Send a raw message
+    #
+    def send_raw_message(&block)
+      message = SendRawMessage.new(self)
+      block.call(message)
+      message.send!
+    end
+
+    #
+    # Return the backend moonrope instance for this client
+    #
+    def moonrope
+      @moonrope ||= begin
+        headers= {'X-Server-API-Key' => @server_key}
+        MoonropeClient::Connection.new(@host, :headers => headers, :ssl => true)
+      end
+    end
+
+  end
+end

data/lib/postal/config.rb

@@ -0,0 +1,15 @@
+module Postal
+  class Config
+
+    def host
+      @host || ENV['POSTAL_HOST'] || raise(Error, "Host has not been configured. Set it using the `Postal.configure` block or use `POSTAL_HOST` environment variable.")
+    end
+    attr_writer :host
+
+    def server_key
+      @server_key || ENV['POSTAL_KEY'] || raise(Error, "Server key has not been configured. Set it using the `Postal.configure` block or use `POSTAL_KEY` environment variable.")
+    end
+    attr_writer :server_key
+
+  end
+end

data/lib/postal/error.rb

@@ -0,0 +1,47 @@
+module Postal
+
+  #
+  # A generic error that all errors will inherit from
+  #
+  class Error < StandardError
+  end
+
+  #
+  # Raised when a message cannot be found by its ID
+  #
+  class MessageNotFound < Error
+    def initialize(id)
+      @id = id
+    end
+
+    def message
+      "No message found matching ID '#{@id}'"
+    end
+
+    def to_s
+      message
+    end
+  end
+
+  #
+  # Raised when a message cannot be found by its ID
+  #
+  class SendError < Error
+    def initialize(code, error_message)
+      @code = code
+      @error_message = error_message
+    end
+
+    attr_reader :code
+    attr_reader :error_message
+
+    def message
+      "[#{@code}] #{@error_message}"
+    end
+
+    def to_s
+      message
+    end
+  end
+
+end

data/lib/postal/header_set.rb

@@ -0,0 +1,21 @@
+module Postal
+  class HeaderSet
+
+    def initialize(headers)
+      @headers = headers
+    end
+
+    def [](name)
+      @headers[name.to_s.downcase]
+    end
+
+    def has_key?(key)
+      @headers.has_key?(name.to_s.downcase)
+    end
+
+    def method_missing(*args, &block)
+      @headers.send(*args, &block)
+    end
+
+  end
+end

data/lib/postal/message.rb

@@ -0,0 +1,156 @@
+require 'postal/error'
+require 'postal/header_set'
+require 'postal/attachment'
+
+module Postal
+  class Message
+
+    #
+    # Find a specific messsage with the given scope
+    #
+    def self.find_with_scope(scope, id)
+      api = scope.client.moonrope.messages.message(:id => id.to_i, :_expansions => scope.expansions)
+      if api.success?
+        Message.new(scope.client, api.data)
+      elsif api.status == 'error' && api.data['code'] == 'MessageNotFound'
+        raise MessageNotFound.new(id)
+      else
+        raise Error, "Couldn't load message from API (#{api.data})"
+      end
+    end
+
+    #
+    # If methods are called directly on the Message class, we likely want to see if we can
+    # run them through the global client message scope.
+    #
+    def self.method_missing(name, *args, &block)
+      if MessageScope.instance_methods(false).include?(name)
+        Postal::Client.instance.messages.send(name, *args, &block)
+      else
+        super
+      end
+    end
+
+    #
+    # Initialize a new message object with the client and a set of initial attributes.
+    #
+    def initialize(client, attributes)
+      @client = client
+      @attributes = attributes
+    end
+
+    #
+    # Return the message ID
+    #
+    def id
+      @attributes['id']
+    end
+
+    #
+    # Return the message token
+    #
+    def token
+      @attributes['token']
+    end
+
+    #
+    # Set a has of all the attributes from the API that should be exposed through
+    # the Message class.
+    #
+    ATTRIBUTES = {
+      :status => [:status, :status],
+      :last_delivery_attempt => [:status, :last_delivery_attempt, :timestamp],
+      :held? => [:status, :held, :boolean],
+      :hold_expiry => [:status, :hold_expiry, :timestamp],
+      :rcpt_to => [:details, :rcpt_to],
+      :mail_from => [:details, :mail_from],
+      :subject => [:details, :subject],
+      :message_id => [:details, :message_id],
+      :timestamp => [:details, :timestamp, :timestamp],
+      :direction => [:details, :direction],
+      :size => [:details, :size],
+      :bounce? => [:details, :bounce, :boolean],
+      :bounce_for_id => [:details, :bounce],
+      :tag => [:details, :tag],
+      :received_with_ssl? => [:details, :received_with_ssl, :boolean],
+      :inspected? => [:inspection, :inspected, :boolean],
+      :spam? => [:inspection, :spam, :boolean],
+      :spam_score => [:inspection, :spam_score],
+      :threat? => [:inspection, :thret, :boolean],
+      :threat_details => [:inspection, :threat_details],
+      :plain_body => [:plain_body],
+      :html_body => [:html_body],
+    }
+
+    #
+    # Catch calls to any of the default attributes for a message and return the
+    # data however we'd like it
+    #
+    def method_missing(name, *args, &block)
+      if mapping = ATTRIBUTES[name.to_sym]
+        expansion, attribute, type = mapping
+        value = from_expansion(expansion, attribute)
+        case type
+        when :timestamp
+          value ? Time.at(value) : nil
+        when :boolean
+          value == 1
+        else
+          value
+        end
+      else
+        super
+      end
+    end
+
+    #
+    # Return a set of headers which can be queried like a hash however looking up
+    # values using [] will be case-insensitive.
+    #
+    def headers
+      @headers ||= HeaderSet.new(from_expansion(:headers))
+    end
+
+    #
+    # Return an array of attachment objects
+    #
+    def attachments
+      @attachments ||= from_expansion(:attachments).map do |a|
+        Attachment.new(a)
+      end
+    end
+
+    #
+    # Return the full raw message
+    #
+    def raw_message
+      @raw_message ||= Base64.decode64(from_expansion(:raw_message))
+    end
+
+    private
+
+    def from_expansion(expansion, attribute = nil, loaded = false)
+      if @attributes.has_key?(expansion.to_s) || loaded
+        attribute ? @attributes[expansion.to_s][attribute.to_s] : @attributes[expansion.to_s]
+      else
+        load_expansions(expansion)
+        from_expansion(expansion, attribute, true)
+      end
+    end
+
+    def load_expansions(*names)
+      puts "\e[31mLoading expansion #{names}\e[0m"
+      api = @client.moonrope.messages.message(:id => self.id, :_expansions => names)
+      if api.success?
+        names.each do |expansion_name|
+          if api.data.has_key?(expansion_name.to_s)
+            @attributes[expansion_name.to_s] = api.data[expansion_name.to_s]
+          end
+        end
+      else
+        raise Postal::Error, "Couldn't load expansion data (#{names.join(', ')}) for message ID '#{self.id}'"
+      end
+    end
+
+  end
+end

data/lib/postal/message_scope.rb

@@ -0,0 +1,40 @@
+require 'postal/message'
+
+module Postal
+  class MessageScope
+
+    attr_reader :client
+
+    def initialize(client)
+      @client = client
+      @includes = []
+    end
+
+    #
+    # Add includes to the scope
+    #
+    def includes(*includes)
+      @includes.push(*includes)
+      self
+    end
+
+    #
+    # Return the current includes
+    #
+    def expansions
+      if @includes.include?(:all)
+        true
+      else
+        @includes.map(&:to_s)
+      end
+    end
+
+    #
+    # Find a given message by its ID
+    #
+    def find_by_id(id)
+      Message.find_with_scope(self, id)
+    end
+
+  end
+end

data/lib/postal/send_message.rb

@@ -0,0 +1,81 @@
+require 'base64'
+require 'postal/send_result'
+
+module Postal
+  class SendMessage
+
+    def initialize(client)
+      @client = client
+      @attributes = {}
+    end
+
+    def send!
+      api = @client.moonrope.request(:send, :message, @attributes)
+      if api.success?
+        SendResult.new(@client, api.data)
+      elsif api.status == 'error'
+        raise SendError.new(api.data['code'], api.data['message'])
+      else
+        raise Error, "Couldn't send message"
+      end
+    end
+
+    def from(address)
+      @attributes[:from] = address
+    end
+
+    def sender(address)
+      @attributes[:sender] = address
+    end
+
+    def to(*addresses)
+      @attributes[:to] ||= []
+      @attributes[:to] += addresses
+    end
+
+    def cc(*addresses)
+      @attributes[:cc] ||= []
+      @attributes[:cc] += addresses
+    end
+
+    def bcc(*addresses)
+      @attributes[:bcc] ||= []
+      @attributes[:bcc] += addresses
+    end
+
+    def subject(subject)
+      @attributes[:subject] = subject
+    end
+
+    def tag(tag)
+      @attributes[:tag] = subject
+    end
+
+    def reply_to(reply_to)
+      @attributes[:reply_to] = subject
+    end
+
+    def plain_body(content)
+      @attributes[:plain_body] = content
+    end
+
+    def html_body(content)
+      @attributes[:html_body] = content
+    end
+
+    def header(key, value)
+      @attributes[:headers] ||= {}
+      @attributes[:headers][key.to_s] = value
+    end
+
+    def attach(filename, content_type, data)
+      @attributes[:attachments] ||= []
+      @attributes[:attachments] << {
+        :name => filename,
+        :content_type => content_type,
+        :data => Base64.encode64(data)
+      }
+    end
+
+  end
+end

data/lib/postal/send_raw_message.rb

@@ -0,0 +1,37 @@
+require 'base64'
+require 'postal/send_result'
+
+module Postal
+  class SendRawMessage
+
+    def initialize(client)
+      @client = client
+      @attributes = {}
+    end
+
+    def send!
+      api = @client.moonrope.request(:send, :raw, @attributes)
+      if api.success?
+        SendResult.new(@client, api.data)
+      elsif api.status == 'error'
+        raise SendError.new(api.data['code'], api.data['message'])
+      else
+        raise Error, "Couldn't send message"
+      end
+    end
+
+    def mail_from(address)
+      @attributes[:mail_from] = address
+    end
+
+    def rcpt_to(*addresses)
+      @attributes[:rcpt_to] ||= []
+      @attributes[:rcpt_to] += addresses
+    end
+
+    def data(data)
+      @attributes[:data] = Base64.encode64(data)
+    end
+
+  end
+end

data/lib/postal/send_result.rb

@@ -0,0 +1,30 @@
+module Postal
+  class SendResult
+
+    def initialize(client, result)
+      @client = client
+      @result = result
+    end
+
+    def message_id
+      @result['message_id']
+    end
+
+    def recipients
+      @recipients ||= begin
+        @result['messages'].each_with_object({}) do |(recipient, message_details), hash|
+          hash[recipient.to_s.downcase] = Message.new(@client, message_details)
+        end
+      end
+    end
+
+    def [](recipient)
+      recipients[recipient.to_s.downcase]
+    end
+
+    def size
+      recipients.size
+    end
+
+  end
+end

data/lib/postal/version.rb

@@ -0,0 +1,3 @@
+module Postal
+  VERSION = '1.0.0'
+end

metadata

@@ -0,0 +1,77 @@
+--- !ruby/object:Gem::Specification
+name: postal-ruby
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Adam Cooke
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-04-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: moonrope-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.2
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: Ruby library for the Postal e-mail platform
+email:
+- me@adamcooke.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/postal.rb
+- lib/postal/attachment.rb
+- lib/postal/client.rb
+- lib/postal/config.rb
+- lib/postal/error.rb
+- lib/postal/header_set.rb
+- lib/postal/message.rb
+- lib/postal/message_scope.rb
+- lib/postal/send_message.rb
+- lib/postal/send_raw_message.rb
+- lib/postal/send_result.rb
+- lib/postal/version.rb
+homepage: https://github.com/atech/postal
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Ruby library for the Postal e-mail platform
+test_files: []
+has_rdoc: