hermes-rails 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f9071b7e4a8721889e58bd6c4c197b19435190a6
+  data.tar.gz: e812e7eb39709a33c11cf6b78f20aced40b5fc58
+SHA512:
+  metadata.gz: 34d64a8a92cdad335b5b4bdb9660f178c4d98163065209102befe8a86299116b14dd59a83254b202b4d7d4ebbf2cb9c7191316cbfd03a04dffdf34775ecdc9e0
+  data.tar.gz: e3fa78be6f7ec3b0c703d06e7e871ca2048c4c584aee63403c5c20f201310e5bae1ecf2a8e07b9365c28d813c3353a3f95c1e2448297bbb8ece0ef97ddc7e0d8

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 Dogwood Labs, Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,3 @@
+= MailgunRails
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,32 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'hermes'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/lib/hermes.rb

@@ -0,0 +1,16 @@
+require 'action_mailer'
+require 'json'
+require 'httparty'
+
+# all of the Hermes support files
+Dir[File.dirname(__FILE__) + '/support/*.rb'].each {|file| require file }
+Dir[File.dirname(__FILE__) + '/hermes/*.rb'].each {|file| require file }
+
+# all of the generic (abstract) provider support files
+Dir[File.dirname(__FILE__) + '/providers/*.rb'].each {|file| require file }
+
+# all of the actual provider support files
+Dir[File.dirname(__FILE__) + '/providers/**/*.rb'].each {|file| require file }
+
+module Hermes
+end

data/lib/hermes/deliverer.rb

@@ -0,0 +1,121 @@
+require 'digest/md5'
+
+module Hermes
+  class Deliverer
+    include Extractors
+
+    attr_reader :providers, :config
+
+    def initialize(settings)
+      @providers = {}
+      
+      @config = settings[:config]
+
+      # this will most likely come back as [:email, :sms, :tweet, :webhook]
+      provider_types = @config.keys.reject{|key| key == :config}
+      
+      # loop through each and construct a workable array
+      provider_types.each do |provider_type|
+        @providers[provider_type] ||= []
+        providers = settings[provider_type]
+        next unless providers.try(:any?)
+
+        # go through all of the providers and initialize each
+        providers.each do |provider_name, options|
+          # check to see that the provider class exists
+          provider_proper_name = "#{provider_name}_provider".camelize.to_sym
+          raise(ProviderNotFoundError, "Could not find provider class Hermes::#{provider_proper_name}") unless Hermes.constants.include?(provider_proper_name)
+
+          # initialize the provider with the given weight, defaults, and credentials
+          provider = Hermes.const_get(provider_proper_name).new(self, options)
+          @providers[provider_type] << provider
+        end
+
+        # make sure the provider type has an aggregate weight of more than 1
+        aweight = aggregate_weight_for_type(provider_type)
+        unless aweight > 0
+          raise(InvalidWeightError, "Provider type:#{provider_type} has aggregate weight:#{aweight}")
+        end
+      end
+    end
+
+    def test_mode?
+      !!@config[:test]
+    end
+
+    def handle_success(provider_name)
+      @config[:stats]
+    end
+
+    def handle_failure(provider_name, exception)
+
+    end
+
+    def should_deliver?
+      !self.test_mode? && ActionMailer::Base.perform_deliveries
+    end
+
+    def aggregate_weight_for_type(type)
+      providers = @providers[type]
+      return 0 if providers.empty?
+
+      providers.map(&:weight).inject(0, :+)
+    end
+
+    def weighted_provider_for_type(type)
+      providers = @providers[type]
+      return nil if providers.empty?
+
+      # get the aggregate weight, and do a rand based on it
+      random_index = rand(aggregate_weight_for_type(type))
+      # puts "random_index:#{random_index}"
+
+      # loop through each, exclusive range, and find the one that it falls on
+      running_total = 0
+      providers.each do |provider|
+        # puts "running_total:#{running_total}"
+        left_index = running_total
+        right_index = running_total + provider.weight
+        # puts "left_index:#{left_index} right_index:#{right_index}"
+
+        if (left_index...right_index).include?(random_index)
+          return provider
+        else
+          running_total += provider.weight
+        end
+      end
+    end
+
+    def delivery_type_for(rails_message)
+      to = extract_to(rails_message, format: :address)
+
+      if to.is_a?(Hash) && to[:twitter_username]
+        :tweet
+      elsif rails_message.to.first.include?('@')
+        :email
+      elsif to.is_a?(Phone)
+        :sms
+      elsif to.is_a?(URI)
+        :webhook
+      else
+        raise UnknownDeliveryTypeError, "Cannot determine provider type from provided to:#{to}"
+      end
+    end
+
+    def deliver!(rails_message)
+      # figure out what we're delivering
+      delivery_type = delivery_type_for(rails_message)
+
+      # set this on the message so it's available throughout
+      rails_message.hermes_type = delivery_type
+
+      # find a provider, weight matters here
+      provider = weighted_provider_for_type(delivery_type)
+
+      # and then send the message
+      provider.send_message(rails_message)
+    end
+  end
+end
+
+ActionMailer::Base.add_delivery_method :hermes, Hermes::Deliverer

data/lib/hermes/exceptions.rb

@@ -0,0 +1,13 @@
+module Hermes
+  # if provider is listed in settings, but no provider class is available
+  class ProviderNotFoundError < StandardError; end
+
+  # thrown if provider weight goes below 1
+  class InvalidWeightError < StandardError; end
+
+  # thrown if configuration does not provide all required credentials 
+  class InsufficientCredentialsError < StandardError; end
+
+  # thrown if deliverer cannot figure out what type of provider to use for provided rails message
+  class UnknownDeliveryTypeError < StandardError; end
+end

data/lib/hermes/mail_ext.rb

@@ -0,0 +1,5 @@
+module Mail
+  class Message
+    attr_accessor :hermes_type
+  end
+end

data/lib/hermes/version.rb

@@ -0,0 +1,3 @@
+module Hermes
+  VERSION = "0.0.1"
+end

data/lib/providers/mailgun/mail_ext.rb

@@ -0,0 +1,9 @@
+module Mail
+  class Message
+    attr_accessor :mailgun_variables
+    attr_accessor :mailgun_options
+    attr_accessor :mailgun_recipient_variables
+    attr_accessor :mailgun_headers
+    attr_accessor :mailgun_domain
+  end
+end

data/lib/providers/mailgun/mailgun_attachment.rb

@@ -0,0 +1,16 @@
+module Hermes
+  class MailgunAttachment < StringIO
+    attr_reader :original_filename, :content_type, :path
+
+    def initialize (attachment, *rest)
+      @path = ''
+      if rest.detect {|opt| opt[:inline] }
+        basename = @original_filename = attachment.cid
+      else
+        basename = @original_filename = attachment.filename
+      end
+      @content_type = attachment.content_type.split(';')[0]
+      super attachment.body.decoded
+    end
+  end
+end

data/lib/providers/mailgun/mailgun_provider.rb

@@ -0,0 +1,42 @@
+module Hermes
+  class MailgunProvider < Provider
+    required_credentials :api_key
+
+    def send_message(rails_message)
+      domain = rails_message.mailgun_domain || self.defaults[:domain]
+      message = self.mailgun_message(rails_message)
+
+      if self.deliverer.should_deliver?
+        self.client.send_message(domain, message)
+      end
+
+      self.message_success(rails_message)
+    end
+
+    def mailgun_message(rails_message)
+      message = Mailgun::MessageBuilder.new
+
+      # basics
+      message.set_from_address(extract_from(rails_message))
+      message.add_recipient(:to, extract_to(rails_message))
+      message.set_subject(rails_message[:subject])
+      message.set_html_body(extract_html(rails_message))
+      message.set_text_body(extract_text(rails_message))
+      message.set_message_id(rails_message.message_id)
+
+      # optionals
+      message.set_from_address('h:reply-to', rails_message[:reply_to].formatted.first) if rails_message[:reply_to]
+
+      # and any attachments
+      rails_message.attachments.try(:each) do |attachment|
+        message.add_attachment(Hermes::EmailAttachment.new(attachment))
+      end
+
+      return message
+    end
+
+    def client
+      Mailgun::Client.new(self.credentials[:api_key])
+    end
+  end
+end

data/lib/providers/outbound_webhook/outbound_webhook_provider.rb

@@ -0,0 +1,30 @@
+module Hermes
+  class OutboundWebhookProvider < Provider
+
+    def send_message(rails_message)
+      payload = payload(rails_message)
+      outbound_webhook = OutboundWebhook.create!(payload)
+      rails_message[:message_id] = outbound_webhook.id
+
+      byebug
+
+      if self.deliverer.should_deliver?
+        outbound_webhook.deliver_async
+      end
+
+      self.message_success(rails_message)
+    rescue Exception => e
+      self.message_failure(rails_message, e)
+    end
+
+    def payload(rails_message)
+      {
+        :endpoint => extract_to(rails_message),
+        :headers => {
+          'Content-Type' => 'application/json'
+        },
+        :body => extract_text(rails_message)
+      }
+    end
+  end
+end

data/lib/providers/plivo/mail_ext.rb

@@ -0,0 +1,5 @@
+module Mail
+  class Message
+    attr_accessor :plivo_url
+  end
+end

data/lib/providers/plivo/plivo_provider.rb

@@ -0,0 +1,33 @@
+module Hermes
+  class PlivoProvider < Provider
+    required_credentials :auth_id, :auth_token
+    
+    def send_message(rails_message)
+      payload = payload(rails_message)
+      
+      if self.deliverer.should_deliver?
+        result = self.client.send_message(payload)
+        rails_message[:message_id] = result["api_id"]
+      else
+        # rails message still needs a fake sid as if it succeeded
+        rails_message[:message_id] = SecureRandom.uuid
+      end
+
+      self.message_success(rails_message)
+    end
+
+    def payload(rails_message)
+      {
+        src:  extract_from(rails_message).full_number,
+        dst:  extract_to(rails_message),
+        text: extract_text(rails_message),
+        type: :sms,
+        url:  rails_message.plivo_url || self.defaults[:url]
+      }
+    end
+
+    def client
+      Plivo::RestAPI.new(self.credentials[:auth_id], self.credentials[:auth_token])
+    end
+  end
+end

data/lib/providers/provider.rb

@@ -0,0 +1,58 @@
+module Hermes
+  class Provider
+    include Extractors 
+
+    class << self
+      attr_accessor :_required_credentials
+
+      def required_credentials(*args)
+        self._required_credentials  = args.to_a
+      end
+    end
+
+    attr_reader :deliverer, :defaults, :credentials, :weight
+
+    def initialize(deliverer, options = {})
+      options.symbolize_keys!
+
+      @deliverer = deliverer
+      @defaults = options[:defaults]
+      @credentials = (options[:credentials] || {}).symbolize_keys
+      @weight = options[:weight].to_i
+
+      if self.class._required_credentials.try(:any?)
+        # provider defines required credentials, let's make sure to check we have everything we need
+        if !((@credentials.keys & self.class._required_credentials) == self.class._required_credentials)
+          # we're missing something, raise here for hard failure
+          raise(InsufficientCredentialsError, "Credentials passed:#{@credentials.keys} do not satisfy all required:#{self.class._required_credentials}")
+        end
+      end
+
+      unless @weight >= 0
+        # provider weights need to be 0 (disabled), or greater than 0 to show as active
+        raise(InvalidWeightError, "Provider name:#{provider_name} has invalid weight:#{@weight}")
+      end
+    end
+
+    def provider_name
+      self.class.name.demodulize.underscore.gsub('_provider', '')
+    end
+
+    def send_message(rails_message)
+      raise "this is an abstract method and must be defined in the subclass"
+    end
+
+    def message_success(rails_message)
+      ActionMailer::Base.deliveries << rails_message if self.deliverer.test_mode?
+      self.deliverer.handle_success(self.class.name)
+    end
+
+    def message_failure(rails_message, exception)
+      Utils.log_and_puts "--- MESSAGE SEND FAILURE ---"
+      Utils.log_and_puts exception.message
+      Utils.log_and_puts exception.backtrace.join("\n")
+      Utils.log_and_puts "--- MESSAGE SEND FAILURE ---"
+      self.deliverer.handle_failure(self.class)
+    end
+  end
+end

data/lib/providers/sendgrid/sendgrid_provider.rb

@@ -0,0 +1,46 @@
+module Hermes
+  class SendgridProvider < Provider
+    required_credentials :api_user, :api_key
+    
+    def send_message(rails_message)
+      payload = payload(rails_message)
+
+      if self.deliverer.should_deliver?
+        client.send(payload)
+      end
+
+      self.message_success(message_success)
+    end
+
+    def payload(rails_message)
+      # requireds
+      message = SendGrid::Mail.new({
+        from: extract_from(rails_message, :address),
+        from_name: extract_from(rails_message, :name),
+        to: extract_to(rails_message, :address),
+        to_name: extract_to(rails_message, :name),
+        subject: rails_message.subject,
+        html: extract_html(rails_message),
+        text: extract_text(rails_message),
+      })
+
+      # optionals
+      message.reply_to = rails_message[:reply_to].formatted.first if rails_message[:reply_to]
+      message.message_id = rails_message[:message_id].value if rails_message.message_id
+
+      # and any attachments
+      rails_message.attachments.try(:each) do |attachment|
+        message.add_attachment_file(Hermes::EmailAttachment.new(attachment))
+      end
+
+      return message
+    end
+
+    def client
+      SendGrid::Client.new({
+        api_user: self.credentials[:api_user], 
+        api_key: self.credentials[:api_key]
+      })
+    end
+  end
+end

data/lib/providers/twilio/mail_ext.rb

@@ -0,0 +1,5 @@
+module Mail
+  class Message
+    attr_accessor :twilio_status_callback
+  end
+end

data/lib/providers/twilio/twilio_provider.rb

@@ -0,0 +1,39 @@
+module Hermes
+  class TwilioProvider < Provider
+    required_credentials :account_sid, :auth_token
+
+    def send_message(rails_message)
+      payload = payload(rails_message)
+
+      if self.deliverer.should_deliver?
+        result = self.client.account.messages.create(payload)
+
+        # set the sid onto the rails message as the message id, used for tracking
+        rails_message[:message_id] = result.sid
+      else
+        # rails message still needs a fake sid as if it succeeded
+        rails_message[:message_id] = SecureRandom.uuid
+      end
+
+      self.message_success(rails_message)
+    rescue Exception => e
+      self.message_failure(rails_message, e)
+    end
+
+    def payload(rails_message)
+      payload = {
+        to: extract_to(rails_message).full_number,
+        from: extract_from(rails_message),
+        body: extract_text(rails_message),
+      }
+
+      payload[:status_callback] = rails_message.twilio_status_callback if rails_message.twilio_status_callback
+
+      return payload
+    end
+
+    def client
+      Twilio::REST::Client.new(self.credentials[:account_sid], self.credentials[:auth_token])
+    end
+  end
+end

data/lib/providers/twitter/mail_ext.rb

@@ -0,0 +1,6 @@
+module Mail
+  class Message
+    attr_accessor :twitter_oauth_token
+    attr_accessor :twitter_oauth_token_secret
+  end
+end

data/lib/providers/twitter/twitter_provider.rb

@@ -0,0 +1,21 @@
+module Hermes
+  class TwitterProvider < Provider
+    required_credentials :consumer_key, :consumer_secret
+    
+    def send_message(rails_message)
+      self.client(rails_message).update(extract_text(rails_message))
+    end
+
+    def client(rails_message)
+      # this will already be an instance of Twitter::client
+      client = extract_to(rails_message)
+
+      # just need to set the consumer key and secret and
+      # then we'll be ready for liftoff
+      client.consumer_key = self.credentials[:consumer_key]
+      client.consumer_secret = self.credentials[:consumer_secret]
+
+      return client
+    end
+  end
+end

data/lib/support/b64y.rb

@@ -0,0 +1,23 @@
+module Hermes
+  class B64Y
+    def self.encode(payload)
+      Base64.strict_encode64(YAML.dump(payload))
+    end
+
+    def self.decode(payload)
+      YAML.load(Base64.strict_decode64(payload))
+    rescue Exception => e
+      Utils.log_and_puts "--- DECODE FAILURE ---"
+      Utils.log_and_puts payload
+      Utils.log_and_puts "--- DECODE FAILURE ---"
+      raise e
+    end
+
+    def self.decodable?(payload)
+      # check to make sure when we decode that it's going to look like a YAML object
+      Base64.strict_decode64(payload)[0..2] == '---'
+    rescue
+      false
+    end
+  end
+end

data/lib/support/email_attachment.rb

@@ -0,0 +1,16 @@
+module Hermes
+  class EmailAttachment < StringIO
+    attr_reader :original_filename, :content_type, :path
+
+    def initialize (attachment, *rest)
+      @path = ''
+      if rest.detect {|opt| opt[:inline] }
+        basename = @original_filename = attachment.cid
+      else
+        basename = @original_filename = attachment.filename
+      end
+      @content_type = attachment.content_type.split(';')[0]
+      super attachment.body.decoded
+    end
+  end
+end

data/lib/support/extractors.rb

@@ -0,0 +1,68 @@
+module Hermes
+  module Extractors
+    # @see http://stackoverflow.com/questions/4868205/rails-mail-getting-the-body-as-plain-text
+    def extract_html(rails_message)
+      if rails_message.html_part
+        rails_message.html_part.body.decoded
+      else
+        rails_message.content_type =~ /text\/html/ ? rails_message.body.decoded : nil
+      end
+    end
+
+    def extract_text(rails_message)
+      if rails_message.multipart?
+        rails_message.text_part ? rails_message.text_part.body.decoded.strip : nil
+      else
+        rails_message.content_type =~ /text\/plain/ ? rails_message.body.decoded.strip : nil
+      end
+    end
+
+    # format can be full|name|address
+    def extract_from(rails_message, format: :full)
+      from = complex_extract(rails_message.from.first)
+      return from[:value] if from[:decoded]
+
+      case format
+      when :full
+        rails_message[:from].formatted.first
+      when :name
+        rails_message[:from].address_list.addresses.first.name
+      when :address
+        rails_message[:from].address_list.addresses.first.address
+      end
+    end
+
+    # format can be full|name|address
+    def extract_to(rails_message, format: :full)
+      to = complex_extract(rails_message.to.first)
+      return to[:value] if to[:decoded]
+
+      case format
+      when :full
+        rails_message[:to].formatted.first
+      when :name
+        rails_message[:to].address_list.addresses.first.name
+      when :address
+        rails_message[:to].address_list.addresses.first.address
+      end
+    end
+
+    # when passing in to/from addresses that are complex objects
+    # like a Hash or Twitter::Client instance, they will be YAMLed
+    # and then Base64ed since Mail::Message really only wants
+    # to play with strings for these fields
+    def complex_extract(address_container)
+      if B64Y.decodable?(address_container)
+        {
+          decoded: true,
+          value: B64Y.decode(address_container)
+        }
+      else
+        {
+          decoded: false,
+          value: address_container
+        }
+      end
+    end
+  end
+end

data/lib/support/phone.rb

@@ -0,0 +1,235 @@
+module Hermes
+  class Phone
+
+    attr_accessor :country, :number
+
+    @@countries = {
+      :af => ['+93', 'Afghanistan'],
+      :al => ['+355', 'Albania'],
+      :dz => ['+213', 'Algeria'],
+      :as => ['+1684', 'American Samoa', :ws],
+      :ad => ['+376', 'Andorra'],
+      :ao => ['+244', 'Angola'],
+      :ai => ['+1264', 'Anguilla'],
+      :ag => ['+1268', 'Antigua and Barbuda'],
+      :ar => ['+54', 'Argentina'],
+      :am => ['+374', 'Armenia'],
+      :aw => ['+297', 'Aruba'],
+      :au => ['+61', 'Australia/Cocos/Christmas Island'],
+      :at => ['+43', 'Austria'],
+      :az => ['+994', 'Azerbaijan'],
+      :bs => ['+1', 'Bahamas'],
+      :bh => ['+973', 'Bahrain'],
+      :bd => ['+880', 'Bangladesh'],
+      :bb => ['+1246', 'Barbados'],
+      :by => ['+375', 'Belarus'],
+      :be => ['+32', 'Belgium'],
+      :bz => ['+501', 'Belize'],
+      :bj => ['+229', 'Benin'],
+      :bm => ['+1441', 'Bermuda'],
+      :bo => ['+591', 'Bolivia'],
+      :ba => ['+387', 'Bosnia and Herzegovina'],
+      :bw => ['+267', 'Botswana'],
+      :br => ['+55', 'Brazil'],
+      :bn => ['+673', 'Brunei'],
+      :bg => ['+359', 'Bulgaria'],
+      :bf => ['+226', 'Burkina Faso'],
+      :bi => ['+257', 'Burundi'],
+      :kh => ['+855', 'Cambodia'],
+      :cm => ['+237', 'Cameroon'],
+      :ca => ['+1', 'Canada'],
+      :cv => ['+238', 'Cape Verde'],
+      :ky => ['+1345', 'Cayman Islands'],
+      :cf => ['+236', 'Central Africa'],
+      :td => ['+235', 'Chad'],
+      :cl => ['+56', 'Chile'],
+      :cn => ['+86', 'China'],
+      :co => ['+57', 'Colombia'],
+      :km => ['+269', 'Comoros'],
+      :cg => ['+242', 'Congo'],
+      :cd => ['+243', 'Congo, Dem Rep'],
+      :cr => ['+506', 'Costa Rica'],
+      :hr => ['+385', 'Croatia'],
+      :cy => ['+357', 'Cyprus'],
+      :cz => ['+420', 'Czech Republic'],
+      :dk => ['+45', 'Denmark'],
+      :dj => ['+253', 'Djibouti'],
+      :dm => ['+1767', 'Dominica'],
+      :do => ['+1809', 'Dominican Republic'],
+      :eg => ['+20', 'Egypt'],
+      :sv => ['+503', 'El Salvador'],
+      :gq => ['+240', 'Equatorial Guinea'],
+      :ee => ['+372', 'Estonia'],
+      :et => ['+251', 'Ethiopia'],
+      :fo => ['+298', 'Faroe Islands'],
+      :fj => ['+679', 'Fiji'],
+      :fi => ['+358', 'Finland/Aland Islands'],
+      :fr => ['+33', 'France'],
+      :gf => ['+594', 'French Guiana'],
+      :pf => ['+689', 'French Polynesia'],
+      :ga => ['+241', 'Gabon'],
+      :gm => ['+220', 'Gambia'],
+      :ge => ['+995', 'Georgia'],
+      :de => ['+49', 'Germany'],
+      :gh => ['+233', 'Ghana'],
+      :gi => ['+350', 'Gibraltar'],
+      :gr => ['+30', 'Greece'],
+      :gl => ['+299', 'Greenland'],
+      :gd => ['+1473', 'Grenada'],
+      :gp => ['+590', 'Guadeloupe'],
+      :gu => ['+1671', 'Guam'],
+      :gt => ['+502', 'Guatemala'],
+      :gn => ['+224', 'Guinea'],
+      :gy => ['+592', 'Guyana'],
+      :ht => ['+509', 'Haiti'],
+      :hn => ['+504', 'Honduras'],
+      :hk => ['+852', 'Hong Kong'],
+      :hu => ['+36', 'Hungary'],
+      :is => ['+354', 'Iceland'],
+      :in => ['+91', 'India'],
+      :id => ['+62', 'Indonesia'],
+      :ir => ['+98', 'Iran'],
+      :iq => ['+964', 'Iraq'],
+      :ie => ['+353', 'Ireland'],
+      :il => ['+972', 'Israel'],
+      :it => ['+39', 'Italy'],
+      :jm => ['+1876', 'Jamaica'],
+      :jp => ['+81', 'Japan'],
+      :jo => ['+962', 'Jordan'],
+      :ke => ['+254', 'Kenya'],
+      :kr => ['+82', 'Korea, Republic of'],
+      :kw => ['+965', 'Kuwait'],
+      :kg => ['+996', 'Kyrgyzstan'],
+      :la => ['+856', 'Laos'],
+      :lv => ['+371', 'Latvia'],
+      :lb => ['+961', 'Lebanon'],
+      :ls => ['+266', 'Lesotho'],
+      :lr => ['+231', 'Liberia'],
+      :ly => ['+218', 'Libya'],
+      :li => ['+423', 'Liechtenstein'],
+      :lt => ['+370', 'Lithuania'],
+      :lu => ['+352', 'Luxembourg'],
+      :mo => ['+853', 'Macao'],
+      :mk => ['+389', 'Macedonia'],
+      :mg => ['+261', 'Madagascar'],
+      :mw => ['+265', 'Malawi'],
+      :my => ['+60', 'Malaysia'],
+      :mv => ['+960', 'Maldives'],
+      :ml => ['+223', 'Mali'],
+      :mt => ['+356', 'Malta'],
+      :mq => ['+596', 'Martinique'],
+      :mr => ['+222', 'Mauritania'],
+      :mu => ['+230', 'Mauritius'],
+      :mx => ['+52', 'Mexico'],
+      :mc => ['+377', 'Monaco'],
+      :mn => ['+976', 'Mongolia'],
+      :me => ['+382', 'Montenegro'],
+      :ms => ['+1664', 'Montserrat'],
+      :ma => ['+212', 'Morocco/Western Sahara'],
+      :mz => ['+258', 'Mozambique'],
+      :na => ['+264', 'Namibia'],
+      :np => ['+977', 'Nepal'],
+      :nl => ['+31', 'Netherlands'],
+      :nz => ['+64', 'New Zealand'],
+      :ni => ['+505', 'Nicaragua'],
+      :ne => ['+227', 'Niger'],
+      :ng => ['+234', 'Nigeria'],
+      :no => ['+47', 'Norway'],
+      :om => ['+968', 'Oman'],
+      :pk => ['+92', 'Pakistan'],
+      :ps => ['+970', 'Palestinian Territory'],
+      :pa => ['+507', 'Panama'],
+      :py => ['+595', 'Paraguay'],
+      :pe => ['+51', 'Peru'],
+      :ph => ['+63', 'Philippines'],
+      :pl => ['+48', 'Poland'],
+      :pt => ['+351', 'Portugal'],
+      :pr => ['+1787', 'Puerto Rico'],
+      :qa => ['+974', 'Qatar'],
+      :re => ['+262', 'Reunion/Mayotte'],
+      :ro => ['+40', 'Romania'],
+      :ru => ['+7', 'Russia/Kazakhstan'],
+      :rw => ['+250', 'Rwanda'],
+      :ws => ['+685', 'Samoa'],
+      :sm => ['+378', 'San Marino'],
+      :sa => ['+966', 'Saudi Arabia'],
+      :sn => ['+221', 'Senegal'],
+      :rs => ['+381', 'Serbia'],
+      :sc => ['+248', 'Seychelles'],
+      :sl => ['+232', 'Sierra Leone'],
+      :sg => ['+65', 'Singapore'],
+      :sk => ['+421', 'Slovakia'],
+      :si => ['+386', 'Slovenia'],
+      :za => ['+27', 'South Africa'],
+      :es => ['+34', 'Spain'],
+      :lk => ['+94', 'Sri Lanka'],
+      :kn => ['+1869', 'St Kitts and Nevis'],
+      :lc => ['+1758', 'St Lucia'],
+      :vc => ['+1784', 'St Vincent Grenadines'],
+      :sd => ['+249', 'Sudan'],
+      :sr => ['+597', 'Suriname'],
+      :sz => ['+268', 'Swaziland'],
+      :se => ['+46', 'Sweden'],
+      :ch => ['+41', 'Switzerland'],
+      :sy => ['+963', 'Syria'],
+      :tw => ['+886', 'Taiwan'],
+      :tj => ['+992', 'Tajikistan'],
+      :tz => ['+255', 'Tanzania'],
+      :th => ['+66', 'Thailand'],
+      :tg => ['+228', 'Togo'],
+      :to => ['+676', 'Tonga'],
+      :tt => ['+1868', 'Trinidad and Tobago'],
+      :tn => ['+216', 'Tunisia'],
+      :tr => ['+90', 'Turkey'],
+      :tc => ['+1649', 'Turks and Caicos Islands'],
+      :ug => ['+256', 'Uganda'],
+      :ua => ['+380', 'Ukraine'],
+      :ae => ['+971', 'United Arab Emirates'],
+      :gb => ['+44', 'United Kingdom'],
+      :us => ['+1', 'United States'],
+      :uy => ['+598', 'Uruguay'],
+      :uz => ['+998', 'Uzbekistan'],
+      :ve => ['+58', 'Venezuela'],
+      :vn => ['+84', 'Vietnam'],
+      :vg => ['+1284', 'Virgin Islands, British'],
+      :vi => ['+1340', 'Virgin Islands, U.S.'],
+      :ye => ['+967', 'Yemen'],
+      :zm => ['+260', 'Zambia'],
+      :zw => ['+263', 'Zimbabwe']
+    }.with_indifferent_access
+
+    def self.countries
+      @@countries
+    end
+
+    def ==(other_phone)
+      self.country == other_phone.country && self.number == other_phone.number
+    end
+
+    def to_s
+      self.full_number
+    end
+
+    def initialize(country, number)
+      @country = country
+      @number = number
+    end
+
+    def country_prefix
+      self.class.prefix_for_country(@country)
+    end
+
+    def country_name
+      self.class.name_for_country(@country)
+    end
+
+    def full_number
+      self.class.prefix_for_country(self.country) + self.number
+    end
+
+    def self.prefix_for_country(country)
+      return @@countries[country.to_s.downcase][0] unless @@countries[country.to_s.downcase].nil? || @@countries[country.to_s.downcase][0].nil?
+      return nil
+    end
+  end
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: hermes-rails
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Scott Klein
+- Tyler Davis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.12'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Rails Action Mailer adapter for balancing multiple providers across email,
+  SMS, and webhook
+email:
+- scott@statuspage.io
+- tyler@statuspage.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- lib/hermes.rb
+- lib/hermes/deliverer.rb
+- lib/hermes/exceptions.rb
+- lib/hermes/mail_ext.rb
+- lib/hermes/version.rb
+- lib/providers/mailgun/mail_ext.rb
+- lib/providers/mailgun/mailgun_attachment.rb
+- lib/providers/mailgun/mailgun_provider.rb
+- lib/providers/outbound_webhook/outbound_webhook_provider.rb
+- lib/providers/plivo/mail_ext.rb
+- lib/providers/plivo/plivo_provider.rb
+- lib/providers/provider.rb
+- lib/providers/sendgrid/sendgrid_provider.rb
+- lib/providers/twilio/mail_ext.rb
+- lib/providers/twilio/twilio_provider.rb
+- lib/providers/twitter/mail_ext.rb
+- lib/providers/twitter/twitter_provider.rb
+- lib/support/b64y.rb
+- lib/support/email_attachment.rb
+- lib/support/extractors.rb
+- lib/support/phone.rb
+homepage: https://github.com/StatusPage/hermes
+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.4.2
+signing_key: 
+specification_version: 4
+summary: Rails Action Mailer adapter for balancing multiple providers across email,
+  SMS, and webhook
+test_files: []