rubymail 0.11

data/lib/multimap/spec/spec_helper.rb

@@ -0,0 +1,67 @@
+require 'multiset'
+require 'multimap'
+require 'nested_multimap'
+
+require 'enumerable_examples'
+require 'hash_examples'
+require 'set_examples'
+
+# Rubinius Hash isn't ordered by insert order
+Spec::Matchers.define :sorted_eql do |expected|
+  if defined? Rubinius
+    sorter = lambda { |a, b| a.hash <=> b.hash }
+    match do |actual|
+      expect(actual.sort(&sorter)).to eql(expected.sort(&sorter))
+    end
+  else
+    match do |actual|
+      expect(actual).to eql(expected)
+    end
+  end
+end
+
+require 'set'
+
+if defined? Rubinius
+  class Set
+    def <=>(other)
+      to_a <=> other.to_a
+    end
+  end
+end
+
+require 'forwardable'
+
+class MiniArray
+  extend Forwardable
+
+  attr_accessor :data
+
+  def initialize(data = [])
+    @data = data
+  end
+
+  def initialize_copy(orig)
+    @data = orig.data.dup
+  end
+
+  def_delegators :@data, :<<, :each, :delete, :delete_if
+
+  def ==(other)
+    other.is_a?(self.class) && @data == other.data
+  end
+
+  def eql?(other)
+    other.is_a?(self.class) && @data.eql?(other.data)
+  end
+
+  if defined? Rubinius
+    def hash
+      @data.hash
+    end
+
+    def <=>(other)
+      @data <=> other.data
+    end
+  end
+end

data/lib/rubymail/address.rb

@@ -0,0 +1,17 @@
+module Rubymail
+    class Address
+      def initialize(rubymail)
+        @rubymail = rubymail
+      end
+  
+      def validate(email)
+        Rubymail.submit :get, address_url('validate'), {:address => email}
+      end
+  
+      private
+  
+      def address_url(action)
+        "#{@rubymail.public_base_url}/address/#{action}"
+      end
+    end
+  end

data/lib/rubymail/base.rb

@@ -0,0 +1,118 @@
+module Rubymail
+    class Base
+
+      def initialize(options)
+        Rubymail.rubymail_host    = options.fetch(:rubymail_host)    { "api.rubymail.net" }
+        Rubymail.protocol        = options.fetch(:protocol)        { "https" }
+        Rubymail.api_version     = options.fetch(:api_version)     { "v3" }
+        Rubymail.test_mode       = options.fetch(:test_mode)       { false }
+        Rubymail.api_key         = options.fetch(:api_key)         { raise ArgumentError.new(":api_key is a required argument to initialize Rubymail") if Rubymail.api_key.nil? }
+        Rubymail.domain          = options.fetch(:domain)          { nil }
+        Rubymail.webhook_url     = options.fetch(:webhook_url)     { nil }
+        Rubymail.public_api_key  = options.fetch(:public_api_key)  { nil }
+      end
+  
+      def base_url
+        "#{Rubymail.protocol}://api:#{Rubymail.api_key}@#{Rubymail.rubymail_host}/#{Rubymail.api_version}"
+      end
+  
+      def public_base_url
+        "#{Rubymail.protocol}://api:#{Rubymail.public_api_key}@#{Rubymail.rubymail_host}/#{Rubymail.api_version}"
+      end
+  
+      def mailboxes(domain = Rubymail.domain)
+        Rubymail::Mailbox.new(self, domain)
+      end
+  
+      def messages(domain = Rubymail.domain)
+        @messages ||= Rubymail::Message.new(self, domain)
+      end
+  
+      def routes
+        @routes ||= Rubymail::Route.new(self)
+      end
+  
+      def bounces(domain = Rubymail.domain)
+        Rubymail::Bounce.new(self, domain)
+      end
+  
+      def domains
+        Rubymail::Domain.new(self)
+      end
+  
+      def unsubscribes(domain = Rubymail.domain)
+        Rubymail::Unsubscribe.new(self, domain)
+      end
+  
+      def webhooks(domain = Rubymail.domain, webhook_url = Rubymail.webhook_url)
+        Rubymail::Webhook.new(self, domain, webhook_url)
+      end
+  
+      def addresses(domain = Rubymail.domain)
+        if Rubymail.public_api_key.nil?
+          raise ArgumentError.new(":public_api_key is a required argument to validate addresses")
+        end
+        Rubymail::Address.new(self)
+      end
+  
+      def complaints(domain = Rubymail.domain)
+        Rubymail::Complaint.new(self, domain)
+      end
+  
+      def log(domain=Rubymail.domain)
+        Rubymail::Log.new(self, domain)
+      end
+  
+      def lists
+        @lists ||= Rubymail::MailingList.new(self)
+      end
+  
+      def list_members(address)
+        Rubymail::MailingList::Member.new(self, address)
+      end
+  
+      def secure
+        Rubymail::Secure.new(self)
+      end
+    end
+  
+  
+    def self.submit(method, url, parameters={})
+      begin
+        JSON.parse(Client.new(url).send(method, parameters))
+      rescue => e
+        error_code = e.http_code
+        error_message = begin
+          JSON(e.http_body)["message"]
+        rescue JSON::ParserError
+          ''
+        end
+        error = Rubymail::Error.new(
+          :code => error_code || nil,
+          :message => error_message || nil
+        )
+        if error.handle.kind_of? Rubymail::ErrorBase
+          raise error.handle
+        else
+          raise error
+        end
+      end
+    end
+  
+    class << self
+      attr_accessor :api_key,
+                    :api_version,
+                    :protocol,
+                    :rubymail_host,
+                    :test_mode,
+                    :domain,
+                    :webhook_url,
+                    :public_api_key
+  
+      def configure
+        yield self
+        true
+      end
+      alias :config :configure
+    end
+  end

data/lib/rubymail/bounce.rb

@@ -0,0 +1,31 @@
+module Rubymail
+    class Bounce
+      def initialize(rubymail, domain)
+        @rubymail = rubymail
+        @domain  = domain
+      end
+      
+      def list(options={})
+        Rubymail.submit(:get, bounce_url, options)["items"] || []
+      end
+
+      def find(email)
+        Rubymail.submit :get, bounce_url(email)
+      end
+  
+      def add(email, options={})
+        Rubymail.submit :post, bounce_url, {:address => email}.merge(options)
+      end
+      
+      def destroy(email)
+        Rubymail.submit :delete, bounce_url(email)  
+      end
+  
+      private
+  
+      def bounce_url(address=nil)
+        "#{@rubymail.base_url}/#{@domain}/bounces#{'/' + address if address}"
+      end
+      
+    end
+  end

data/lib/rubymail/client.rb

@@ -0,0 +1,87 @@
+module Rubymail
+    class Client
+      attr_reader :url
+  
+      def initialize(url)
+        @url = url
+      end
+  
+      def get(params = {})
+        request_path = path
+        request_path += "?#{URI.encode_www_form(params)}" if params.any?
+  
+        request = Net::HTTP::Get.new(request_path)
+  
+        make_request(request)
+      end
+  
+      def post(params = {})
+        request = Net::HTTP::Post.new(path)
+        request.set_form_data(params)
+  
+        make_request(request)
+      end
+  
+      def put(params = {})
+        request = Net::HTTP::Put.new(path)
+        request.set_form_data(params)
+  
+        make_request(request)
+      end
+  
+      def delete(params = {})
+        request = Net::HTTP::Delete.new(path)
+        request.set_form_data(params)
+  
+        make_request(request)
+      end
+  
+      private
+  
+      def make_request(request)
+        set_auth(request)
+        response = http_client.request(request)
+  
+        check_for_errors(response)
+  
+        response.body
+      end
+  
+      def check_for_errors(response)
+        return if response.code == '200'
+  
+        error = ClientError.new
+        error.http_code = response.code.to_i
+        error.http_body = response.body
+        raise error
+      end
+  
+      def path
+        parsed_url.path
+      end
+  
+      def parsed_url
+        @parsed_url ||= URI.parse url
+      end
+  
+      def http_client
+        http = Net::HTTP.new(rubymail_url.host, rubymail_url.port)
+        http.use_ssl = true
+        http
+      end
+  
+      def rubymail_url
+        URI.parse Rubymail().base_url
+      end
+  
+      def set_auth(request)
+        request.basic_auth(parsed_url.user, parsed_url.password)
+      end
+    end
+  end
+  
+  module Rubymail
+    class ClientError < StandardError
+      attr_accessor :http_code, :http_body
+    end
+  end

data/lib/rubymail/complaint.rb

@@ -0,0 +1,31 @@
+module Rubymail
+    class Complaint
+      def initialize(rubymail, domain)
+        @rubymail = rubymail
+        @domain  = domain
+      end
+      
+      def list(options={})
+        Rubymail.submit(:get, complaint_url, options)["items"] || []
+      end
+  
+      def find(email)
+        Rubymail.submit :get, complaint_url(email)
+      end
+  
+      def add(email)
+        Rubymail.submit :post, complaint_url, {:address => email}
+      end
+  
+      def destroy(email)
+        Rubymail.submit :delete, complaint_url(email)
+      end
+  
+      private
+  
+      def complaint_url(address=nil)
+        "#{@rubymail.base_url}/#{@domain}/complaints#{'/' + address if address}"
+      end
+  
+    end
+  end

data/lib/rubymail/domain.rb

@@ -0,0 +1,34 @@
+module Rubymail
+    class Domain
+      def initialize(rubymail)
+        @rubymail = rubymail
+      end
+
+      def list(options={})
+        Rubymail.submit(:get, domain_url, options)["items"] || []
+      end
+  
+      def find(domain)
+        Rubymail.submit :get, domain_url(domain)
+      end
+  
+      def create(domain, opts = {})
+        opts = {name: domain}.merge(opts)
+        Rubymail.submit :post, domain_url, opts
+      end
+  
+      def delete(domain)
+        Rubymail.submit :delete, domain_url(domain)
+      end
+  
+      def verify(domain)
+        Rubymail.submit :put, "#{domain_url(domain)}/verify"
+      end
+  
+      private
+  
+      def domain_url(domain = nil)
+        "#{@rubymail.base_url}/domains#{'/' + domain if domain}"
+      end
+    end
+  end

data/lib/rubymail/list.rb

@@ -0,0 +1,37 @@
+module Rubymail
+    class MailingList
+      def initialize(rubymail)
+        @rubymail = rubymail
+      end
+  
+      def list(options={})
+        response = Rubymail.submit(:get, list_url, options)["items"] || []
+      end
+  
+      def find(address)
+        Rubymail.submit :get, list_url(address)
+      end
+  
+      def create(address, options={})
+          params = {:address => address}
+        Rubymail.submit :post, list_url, params.merge(options)
+      end
+  
+      def update(address, new_address, options={})
+        params = {:address => new_address}
+        Rubymail.submit :put, list_url(address), params.merge(options)
+      end		
+  
+      def delete(address)
+          Rubymail.submit :delete, list_url(address)
+      end
+  
+  
+      private
+  
+      def list_url(address=nil)
+        "#{@rubymail.base_url}/lists#{'/' + address if address}"
+      end
+      
+    end
+  end

data/lib/rubymail/log.rb

@@ -0,0 +1,19 @@
+module Rubymail
+	class Log
+        def initialize(rubymail, domain)
+        @rubymail = rubymail
+        @domain = domain
+        end
+        
+        def list(options={})
+        Rubymail.submit(:get, log_url, options)
+        end
+        
+        private
+
+        
+        def log_url
+        "#{@rubymail.base_url}/#{@domain}/log"
+        end
+    end
+end

data/lib/rubymail/mailbox.rb

@@ -0,0 +1,41 @@
+module Rubymail
+    class Mailbox
+  
+      def initialize(rubymail, domain)
+        @rubymail = rubymail
+        @domain  = domain
+      end
+      
+      def list(options={})
+        Rubymail.submit(:get, mailbox_url, options)["items"]
+      end
+      
+      def create(mailbox_name, password)
+        address = "#{mailbox_name}@#{@domain}"
+        Rubymail.submit(
+          :post,
+          mailbox_url,
+          {
+            :mailbox => address,
+            :password => password
+          }
+        )
+      end
+  
+      def update_password(mailbox_name, password)
+        Rubymail.submit :put, mailbox_url(mailbox_name), :password => password
+      end
+  
+      def destroy(mailbox_name)
+        Rubymail.submit :delete, mailbox_url(mailbox_name)
+      end
+  
+  
+      private
+
+      def mailbox_url(mailbox_name=nil)
+        "#{@rubymail.base_url}/#{@domain}/mailboxes#{'/' + mailbox_name if mailbox_name}"
+      end
+  
+    end
+  end

data/lib/rubymail/message.rb

@@ -0,0 +1,16 @@
+module Rubymail
+    class Message
+      def initialize(rubymail, domain)
+        @rubymail = rubymail
+        @domain  = domain
+      end
+  
+      def send_email(parameters={})
+        Rubymail.submit(:post, messages_url, parameters)
+      end
+  
+      def messages_url
+        "#{@rubymail.base_url}/#{@domain}/messages"
+      end
+    end
+  end

data/lib/rubymail/route.rb

@@ -0,0 +1,99 @@
+module Rubymail
+    class Route
+      def initialize(rubymail)
+        @rubymail = rubymail
+      end
+  
+      def list(options={})
+        Rubymail.submit(:get, route_url, options)["items"] || []
+      end
+  
+      def find(route_id)
+        Rubymail.submit(:get, route_url(route_id))["route"]
+      end
+  
+      def create(description, priority, filter, actions)
+        data = ::Multimap.new
+  
+        data['priority']    = priority
+        data['description'] = description
+        data['expression']  = build_filter(filter)
+  
+        actions = build_actions(actions)
+  
+        actions.each do |action|
+          data['action'] = action
+        end
+  
+        data = data.to_hash
+  
+        # TODO: Raise an error or return false if unable to create route
+        Rubymail.submit(:post, route_url, data)["route"]["id"]
+      end
+  
+      def update(route_id, params)
+        data = ::Multimap.new
+  
+        params = Hash[params.map{ |k, v| [k.to_s, v] }]
+  
+        ['priority', 'description'].each do |key|
+          data[key] = params[key] if params.has_key?(key)
+        end
+  
+        data['expression'] = build_filter(params['expression']) if params.has_key?('expression')
+  
+        if params.has_key?('actions')
+          actions = build_actions(params['actions'])
+  
+          actions.each do |action|
+            data['action'] = action
+          end
+        end
+  
+        data = data.to_hash
+  
+        Rubymail.submit(:put, route_url(route_id), data)
+      end
+  
+      def destroy(route_id)
+        Rubymail.submit(:delete, route_url(route_id))["id"]
+      end
+  
+      private
+  
+      def route_url(route_id=nil)
+        "#{@rubymail.base_url}/routes#{'/' + route_id if route_id}"
+      end
+  
+      def build_actions(actions)
+        _actions = []
+  
+        actions.each do |action|
+          case action.first.to_sym
+          when :forward
+            _actions << "forward(\"#{action.last}\")"
+          when :stop
+            _actions << "stop()"
+          else
+            raise Rubymail::Error.new("Unsupported action requested, see http://documentation.rubymail.net/user_manual.html#routes for a list of allowed actions")
+          end
+        end
+  
+        _actions
+      end
+  
+  
+      def build_filter(filter)
+        case filter.first.to_sym
+        when :match_recipient
+          return "match_recipient('#{filter.last}')"
+        when :match_header
+          return "match_header('#{filter[1]}', '#{filter.last}')"
+        when :catch_all
+          return "catch_all()"
+        else
+          raise Rubymail::Error.new("Unsupported filter requested, see http://documentation.rubymail.net/user_manual.html#routes for a list of allowed filters")
+        end
+      end
+    end
+  end

data/lib/rubymail/rubymail_error.rb

@@ -0,0 +1,53 @@
+module Rubymail
+    class Error
+      attr_accessor :error
+  
+      def initialize(options={})
+        @error =
+          case options[:code]
+          when 200
+            # 200 status code [success code]
+          when 404
+            Rubymail::NotFound.new(options[:message])
+          when 400
+            Rubymail::BadRequest.new(options[:message])
+          when 401
+            Rubymail::Unauthorized.new(options[:message])
+          when 402
+            Rubymail::ResquestFailed.new(options[:message])
+          when 500, 502, 503, 504
+            Rubymail::ServerError.new(options[:message])
+          else
+            Rubymail::ErrorBase.new(options[:message])
+          end
+      end
+  
+      def handle
+        return error.handle
+      end
+    end
+  
+    class ErrorBase < StandardError
+      def handle
+        return self
+      end
+    end
+  
+    class NotFound < ErrorBase
+      def handle
+        return nil
+      end
+    end
+  
+    class BadRequest < ErrorBase
+    end
+  
+    class Unauthorized < ErrorBase
+    end
+  
+    class ResquestFailed < ErrorBase
+    end
+  
+    class ServerError < ErrorBase
+    end
+  end

data/lib/rubymail/secure.rb

@@ -0,0 +1,19 @@
+module Rubymail
+    class Secure
+      def initialize(rubymail)
+        @rubymail = rubymail
+      end
+      
+      def check_request_auth(timestamp, token, signature, offset=-5)
+        if offset != 0
+          offset = Time.now.to_i + offset * 60
+          return false if timestamp < offset
+        end
+        
+        return signature == OpenSSL::HMAC.hexdigest(
+          OpenSSL::Digest::Digest.new('sha256'),
+          Rubymail.api_key,
+          '%s%s' % [timestamp, token])
+      end
+    end
+  end