babysms 0.5.1

data/lib/babysms/adapters/bandwidth_adapter.rb

@@ -0,0 +1,41 @@
+unless Object.const_defined?(:Bandwidth)
+  fail '`ruby-bandwidth` gem is required to use BandwidthAdapter'
+end
+
+module BabySMS
+  module Adapters
+    class BandwidthAdapter < BabySMS::Adapter
+      def initialize(user_id:, api_token:, api_secret:, from:)
+        super(from: from)
+
+        self.client = Bandwidth::Client.new(user_id: user_id,
+                                            api_token: api_token,
+                                            api_secret: api_secret)
+      end
+
+      def deliver(message)
+        response = Bandwidth::Message.create(client,
+                                             from: from,
+                                             to: message.to,
+                                             text: message.contents)
+        if response[:error]
+          raise BabySMS::FailedDelivery.new(response[:error].to_s, adapter: self)
+        end
+
+        response[:id]
+      end
+
+      class WebHook < BabySMS::WebHook
+        def process(app:, report:)
+          validate!(app.request)
+          message = BabySMS::Message.new(from: app.params['from'],
+                                         to: app.params['to'],
+                                         contents: app.params['text'],
+                                         uuid: app.params['id'])
+          report.incoming_message(message)
+          [200, { 'Content-Type' => 'text/plain' }, 'ok']
+        end
+      end
+    end
+  end
+end

data/lib/babysms/adapters/nexmo_adapter.rb

@@ -0,0 +1,39 @@
+unless Object.const_defined?(:Nexmo)
+  fail '`nexmo` gem is required to use NexmoAdapter'
+end
+
+module BabySMS
+  module Adapters
+    class NexmoAdapter < BabySMS::Adapter
+      def initialize(api_key:, api_secret:, from:)
+        super(from: from)
+
+        self.client = Nexmo::Client.new(api_key: api_key, api_secret: api_secret)
+      end
+
+      def deliver(message)
+        # Thanks for being weird, Nexmo.  Rejects numbers starting with "+"
+        response = client.sms.send(from: from.gsub(/\A\+/, ''),
+                                   to: message.to,
+                                   text: message.contents)
+        if response.messages.first.status != '0'
+          raise BabySMS::FailedDelivery.new(response.messages.first.error_text,
+                                            adapter: self)
+        end
+
+        response.messages.first.message_id
+      end
+
+      class WebHook < BabySMS::WebHook
+        def process(app:, report:)
+          message = BabySMS::Message.new(from: app.params['msisdn'],
+                                         to: app.params['to'],
+                                         contents: app.params['text'],
+                                         uuid: app.params['messageId'])
+          report.incoming_message(message)
+          [200, { 'Content-Type' => 'text/plain' }, 'ok']
+        end
+      end
+    end
+  end
+end

data/lib/babysms/adapters/plivo_adapter.rb

@@ -0,0 +1,34 @@
+unless Object.const_defined?(:Plivo)
+  fail '`plivo-ruby` gem is required to use PlivoAdapter'
+end
+
+module BabySMS
+  module Adapters
+    class PlivoAdapter < BabySMS::Adapter
+      def initialize(auth_id:, auth_token:, from:)
+        super(from: from)
+
+        self.client = Plivo::RestClient.new(auth_id, auth_token)
+      end
+
+      def deliver(message)
+        response = client.messages.create(from, [message.to], message.contents)
+        response.message_uuid
+      rescue PlivoRESTError => e
+        raise BabySMS::FailedDelivery.new(e.message, adapter: self)
+      end
+
+      class WebHook < BabySMS::WebHook
+        def process(app:, report:)
+          # 'Uuid' is the uuid.  Also of note: NumMedia, and MediaContentType0, MediaUrl0
+          message = BabySMS::Message.new(from: app.params['From'],
+                                         to: app.params['To'],
+                                         contents: app.params['Text'],
+                                         uuid: app.params['Uuid'])
+          report.incoming_message(message)
+          [200, { 'Content-Type' => 'text/plain' }, 'ok']
+        end
+      end
+    end
+  end
+end

data/lib/babysms/adapters/signalwire_adapter.rb

@@ -0,0 +1,38 @@
+unless Object.const_defined?(:Signalwire)
+  fail '`signalwire-ruby` gem is required to use SignalwireAdapter'
+end
+
+require 'signalwire/sdk'
+
+module BabySMS
+  module Adapters
+    class SignalwireAdapter < BabySMS::Adapter
+      def initialize(from:, project:, token:, space_url:)
+        super(from: from)
+        self.client = Signalwire::REST::Client.new(project, token, signalwire_space_url: space_url)
+      end
+
+      def deliver(message)
+        result = client.messages.create(from: from,
+                                        to: message.to,
+                                        body: message.contents,
+                                        status_callback: web_hook.end_point)
+        result.sid
+      rescue Signalwire::REST::SignalwireError => e
+        raise BabySMS::FailedDelivery.new(e.message, adapter: self)
+      end
+
+      class WebHook < BabySMS::WebHook
+        def process(app:, report:)
+          # Of note: NumMedia, and MediaContentType0, MediaUrl0
+          message = BabySMS::Message.new(from: app.params['from'],
+                                         to: app.params['to'],
+                                         contents: app.params['body'],
+                                         uuid: app.params['id'])
+          report.incoming_message(message)
+          [200, { 'Content-Type' => 'application/xml' }, '<Response></Response>']
+        end
+      end
+    end
+  end
+end

data/lib/babysms/adapters/test_adapter.rb

@@ -0,0 +1,61 @@
+require 'babysms/web_hook'
+
+require 'rainbow/refinement'
+require 'json'
+
+using Rainbow
+
+module BabySMS
+  module Adapters
+    class TestAdapter < BabySMS::Adapter
+      attr_accessor :verbose
+      attr_accessor :fails
+      attr_accessor :outbox
+
+      def initialize(verbose: false, fails: false, from: '+1555-555-5555')
+        super(from: from)
+
+        self.verbose = verbose
+        self.fails = fails
+        self.outbox = []
+      end
+
+      def deliver(message)
+        if fails
+          raise BabySMS::FailedDelivery.new('intentional failure', adapter: self)
+        end
+
+        outbox.push(message)
+        if verbose
+          terminal_output = <<~"MSG"
+            #{"SMS:".bright.yellow} -> #{message.to.bright.yellow}:
+              >> #{message.contents.white}
+          MSG
+          $stderr.puts terminal_output
+        end
+
+        next_message_uuid
+      end
+
+      private
+
+      def next_message_uuid
+        @message_uuid ||= 0
+        @message_uuid += 1
+        @message_uuid.to_s
+      end
+
+      class WebHook < BabySMS::WebHook
+        def process(app:, report:)
+          json = JSON.parse(app.request.body.read)
+          message = BabySMS::Message.new(to: adapter.from,
+                                         from: json["from"],
+                                         contents: json["body"])
+          report.incoming_message(message)
+
+          [200, { "Content-Type" => "text/plain" }, 'ok']
+        end
+      end
+    end
+  end
+end

data/lib/babysms/adapters/twilio_adapter.rb

@@ -0,0 +1,47 @@
+unless Object.const_defined?(:Twilio)
+  fail '`twilio-ruby` gem is required to use TwilioAdapter'
+end
+
+module BabySMS
+  module Adapters
+    class TwilioAdapter < BabySMS::Adapter
+      def initialize(account_sid:, auth_token:, from:)
+        super(from: from)
+
+        self.client = Twilio::REST::Client.new(account_sid, auth_token)
+      end
+
+      def deliver(message)
+        result = client.api.account.messages.create(from: from,
+                                                    to: message.to,
+                                                    body: message.contents,
+                                                    status_callback: web_hook.end_point)
+        result.sid
+      rescue Twilio::REST::TwilioError => e
+        raise BabySMS::FailedDelivery.new(e.message, adapter: self)
+      end
+
+      class WebHook < BabySMS::WebHook
+        def validate!(request)
+          validator = Twilio::Security::RequestValidator.new(adapter.client.auth_token)
+          unless validator.validate(end_point, request.params,
+                                    request.headers['X-Twilio-Signature'])
+            fail BabySMS::Unauthorized, 'twilio signature failed'
+          end
+        end
+
+        def process(app:, report:)
+          validate!(app.request)
+
+          # Of note: NumMedia, and MediaContentType0, MediaUrl0
+          message = BabySMS::Message.new(from: app.params['From'],
+                                         to: app.params['To'],
+                                         contents: app.params['Body'],
+                                         uuid: app.params['MessageSid'])
+          report.incoming_message(message)
+          [200, { 'Content-Type' => 'application/xml' }, '<Response></Response>']
+        end
+      end
+    end
+  end
+end

data/lib/babysms/errors.rb

@@ -0,0 +1,43 @@
+module BabySMS
+  class Error < StandardError
+  end
+
+  # A FailedDelivery being raised means your message didn't get sent.  This can be because of a
+  # single error, or multiple failed attempts.
+  #
+  # A FailedDelivery may contain multiple "sub-exceptions" in #exception that can be inspected
+  # to determine what happened.
+  class FailedDelivery < BabySMS::Error
+    attr_reader :exceptions
+    attr_reader :adapter
+
+    def initialize(*args, adapter: nil)
+      super(*args)
+
+      @adapter = adapter
+      @exceptions = [self]
+    end
+
+    def self.multiple(exceptions)
+      # We don't want to give a public interface to setting exceptions
+      BabySMS::FailedDelivery.new("multiple exceptions").itself do |result|
+        result.instance_variable_set(:@exceptions, exceptions)
+      end
+    end
+
+    def multiple?
+      exceptions.size > 1
+    end
+  end
+
+  class WebHookError < BabySMS::Error
+  end
+
+  # Post from provider we don't understand
+  class Malformed < BabySMS::WebHookError
+  end
+
+  # Provider signature verification fails
+  class Unauthorized < BabySMS::WebHookError
+  end
+end

data/lib/babysms/mail_man.rb

@@ -0,0 +1,77 @@
+module BabySMS
+
+  # MailMan is the link between a Message and an Adapter.  It basically has a strategy for
+  # choosing adapters, and attempting delivery until either the message is delivered, or
+  # all adapters have been tried.
+  #
+  # The boring strategy is :in_order, which is good for cases where you have a primary
+  # adapter, and one or more fallbacks.
+  #
+  # The alternative is :random, which sort of works in a load-balancing kind of way.
+
+  class MailMan
+    attr_reader :adapters
+    attr_reader :strategy
+
+    def initialize(adapters:, strategy:)
+      unless respond_to?(:"next_#{strategy}_adapter", true)
+        fail ArgumentError, "invalid strategy: #{strategy.inspect}"
+      end
+
+      @adapters = adapters.dup
+      @strategy = strategy
+    end
+
+    def deliver(message)
+      # If the message has a "from", we need to use that adapter, even if
+      # others are available
+      if message.from
+        specified = BabySMS::Adapter.for_number(message.from, pool: adapters)
+
+        if specified.nil?
+          fail BabySMS::Error, "`from:' not associated with an adapter: #{message.from}"
+        end
+        @adapters = [specified]
+      end
+
+      if @adapters.empty?
+        fail BabySMS::Error, 'no adapter configured'
+      end
+
+      # We collect and return all errors leading up to the (hopefully) successful delivery
+      failures = []
+      each_adapter do |adapter|
+        return BabySMS::Receipt.new(message_uuid: adapter.deliver(self),
+                                    message: message,
+                                    adapter: adapter,
+                                    exceptions: failures)
+      rescue BabySMS::FailedDelivery => e
+        failures.push(e)
+      end
+
+      raise BabySMS::FailedDelivery.multiple(failures)
+    end
+
+    private
+
+    def next_in_order_adapter
+      adapters.shift
+    end
+
+    def next_random_adapter
+      adapters.delete(adapters.sample)
+    end
+
+    def next_adapter
+      send(:"next_#{strategy}_adapter")
+    end
+
+    # returns each adapter in the order specified by the strategy.  Mutates adapters Array.
+    def each_adapter(&block)
+      loop do
+        raise StopIteration if adapters.empty?
+        yield next_adapter
+      end
+    end
+  end
+end

data/lib/babysms/message.rb

@@ -0,0 +1,58 @@
+module BabySMS
+  class InvalidMessage < BabySMS::Error
+  end
+
+  class Message
+    attr_accessor :to
+    attr_accessor :from
+    attr_accessor :contents
+
+    def initialize(to:, from: nil, contents:, uuid: nil)
+      @to = Phony.normalize(to)
+      @from = from
+      @contents = contents
+    end
+
+    def deliver(adapters: BabySMS.adapters, strategy: BabySMS.strategy)
+      validate!
+      BabySMS::MailMan.new(adapters: adapters, strategy: strategy).deliver(self)
+    end
+
+    # generates and delivers a reply to a message
+    def reply(contents:, adapters: BabySMS.adapters, strategy: BabySMS.strategy)
+      Message.new(to: from, from: to, contents: contents)
+             .deliver(adapters: adapters, strategy: strategy)
+    end
+
+    private
+
+    MAX_CONTENTS_LENGTH = 1600
+
+    def validate!
+      validate_to!
+      validate_contents!
+    end
+
+    def validate_to!
+      if to.nil? || to.empty?
+        fail BabySMS::InvalidMessage, 'no to:'
+      end
+
+      unless Phony.plausible?(to)
+        fail BabySMS::InvalidMessage, "implausible to: #{to}"
+      end
+    end
+
+    def validate_contents!
+      if contents.nil? || contents.empty?
+        fail BabySMS::InvalidMessage, 'no contents'
+      end
+
+      if contents.size > MAX_CONTENTS_LENGTH
+        msg = "contents too long (#{contents.size} vs max of #{MAX_CONTENTS_LENGTH}); " \
+              "contents: `#{contents}`"
+        fail BabySMS::InvalidMessage, msg
+      end
+    end
+  end
+end