sms_carrier 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8856860fad36aa1fa2eef28c277106e3c3e8a361
+  data.tar.gz: 261bcc32724a7d9c75eae9217208800a1117881f
+SHA512:
+  metadata.gz: 0f5dccb9d50b80a849099fb1df1dc732ae78a6ca50c4d7e750e725472ef1debe2b149845b8cd46e78d881b017473df20445e8d9979d35fe4910e017d81ec39d5
+  data.tar.gz: 0a144ff33491e6ae9bd781010eacb4cbf76e347b670a886b5c9102e5dd755b8c31a3365ccef590b1f925378bae702129e3970ae112fb669350afdfcb8da85363

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+rvm:
+  - 2.2.2
+before_install: gem install bundler
+branches:
+  only:
+    - master
+env:
+  - COVERALLS=1

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# v0.1.0 / 2015-10-23
+
+Create project

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sms_carrier.gemspec
+gemspec
+
+gem 'simplecov', :require => false
+gem 'coveralls', :require => false

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Chen Yi-Cyuan
+
+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.md

@@ -0,0 +1,86 @@
+# SMS Carrier
+
+[![Build Status](https://api.travis-ci.org/emn178/sms_carrier.png)](https://travis-ci.org/emn178/sms_carrier)
+[![Coverage Status](https://coveralls.io/repos/emn178/sms_carrier/badge.svg?branch=master)](https://coveralls.io/r/emn178/sms_carrier?branch=master)
+
+SMS Carrier is a framework for designing SMS service layers. These layers are used to consolidate code for sending out confirmation token, and any other use case that requires a written notification to either a person or another system.
+
+SMS Carrier is in essence a wrapper around Action Controller. It provides a way to make SMSes using templates in the same way that Action Controller renders views using templates.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sms_carrier'
+```
+
+And then execute:
+
+    bundle
+
+Or install it yourself as:
+
+    gem install sms_carrier
+
+## Usage
+### Sending SMSes
+The framework works by initializing any instance variables you want to be available in the SMS template, followed by a call to sms to deliver the SMS.
+
+This can be as simple as:
+```Ruby
+class Notifier < SmsCarrier::Base
+  default from: '+886987654321'
+
+  def welcome(recipient, token)
+    @token = token
+    sms(to: recipient)
+  end
+end
+```
+The body of the SMS is created by using an Action View template (regular ERB) that has the instance variables that are declared in the carrier action.
+
+So the corresponding body template for the method above could look like this:
+```
+Your token is <%= @token %>, please confirm your phone number
+```
+If the token was given as “1234”, the SMS generated would look like this:
+```
+Your token is 1234, please confirm your phone number
+```
+In order to send SMSes, you simply call the method and then call deliver_now on the return value.
+
+Calling the method returns a Sms object:
+```Ruby
+message = Notifier.welcome("1234")   # => Returns a SmsCarrier::Sms object
+message.deliver_now                  # => delivers the SMS
+```
+Or you can just chain the methods together like:
+```Ruby
+Notifier.welcome("1234").deliver_now # Creates the SMS and sends it immediately
+```
+Or you can send SMS without carrier and template:
+```Ruby
+SmsCarrier::Base.sms(from: "+886987654321", to: "+886912345678", body: "Your token is #{@token}").deliver_now
+```
+
+### Setting defaults
+It is possible to set default values that will be used in every method in your SMS Carrier class. To implement this functionality, you just call the public class method default which you get for free from SmsCarrier::Base. This method accepts a Hash as the parameter. You can use any of the options, SMS messages have, like :from as the key. You can also pass in a string as the key, like “Content-Type”, but SMS Carrier does this out of the box for you, so you won't need to worry about that. Finally, it is also possible to pass in a Proc that will get evaluated when it is needed.
+
+Note that every value you set with this method will get overwritten if you use the same key in your carrier method.
+
+Example:
+```Ruby
+class AuthenticationCarrier < SmsCarrier::Base
+  default from: "+886987654321", body: Proc.new { "SMS was generated at #{Time.now}" }
+  .....
+end
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## Contact
+The project's website is located at https://github.com/emn178/sms_carrier  
+Author: emn178@gmail.com

data/Rakefile

@@ -0,0 +1,23 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+desc "Default Task"
+task default: [ :test ]
+
+# Run the unit tests
+Rake::TestTask.new { |t|
+  t.libs << "test"
+  t.pattern = 'test/**/*_test.rb'
+  t.warning = true
+  t.verbose = true
+  t.ruby_opts = ["--dev"] if defined?(JRUBY_VERSION)
+}
+
+namespace :test do
+  task :isolated do
+    Dir.glob("test/**/*_test.rb").all? do |file|
+      sh(Gem.ruby, '-w', '-Ilib:test', file)
+    end or raise "Failures"
+  end
+end

data/lib/sms_carrier.rb

@@ -0,0 +1,22 @@
+require 'abstract_controller'
+require 'sms_carrier/version'
+
+# Common Active Support usage in SmsCarrier
+require 'active_support/rails'
+require 'active_support/core_ext/class'
+require 'active_support/core_ext/module/attr_internal'
+require 'active_support/core_ext/string/inflections'
+require 'active_support/lazy_load_hooks'
+
+module SmsCarrier
+  extend ::ActiveSupport::Autoload
+
+  autoload :Base
+  autoload :DeliveryMethods
+  autoload :TestCase
+  autoload :TestHelper
+  autoload :MessageDelivery
+  autoload :DeliveryJob
+end
+
+require "sms_carrier/railtie" if defined? ::Rails

data/lib/sms_carrier/base.rb

@@ -0,0 +1,292 @@
+require 'active_support/core_ext/string/inflections'
+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/module/anonymous'
+
+require 'sms_carrier/sms'
+require 'sms_carrier/log_subscriber'
+
+module SmsCarrier
+  class Base < AbstractController::Base
+    include DeliveryMethods
+
+    abstract!
+
+    include AbstractController::Rendering
+
+    include AbstractController::Logger
+    include AbstractController::Helpers
+    include AbstractController::Translation
+    include AbstractController::AssetPaths
+    include AbstractController::Callbacks
+
+    include ActionView::Layouts
+
+    PROTECTED_IVARS = AbstractController::Rendering::DEFAULT_PROTECTED_INSTANCE_VARIABLES + [:@_action_has_layout]
+
+    def _protected_ivars # :nodoc:
+      PROTECTED_IVARS
+    end
+
+    private_class_method :new #:nodoc:
+
+    class_attribute :default_params
+    self.default_params = {}.freeze
+
+    class << self
+      # Register one or more Observers which will be notified when SMS is delivered.
+      def register_observers(*observers)
+        observers.flatten.compact.each { |observer| register_observer(observer) }
+      end
+
+      # Register one or more Interceptors which will be called before SMS is sent.
+      def register_interceptors(*interceptors)
+        interceptors.flatten.compact.each { |interceptor| register_interceptor(interceptor) }
+      end
+
+      # Register an Observer which will be notified when SMS is delivered.
+      # Either a class, string or symbol can be passed in as the Observer.
+      # If a string or symbol is passed in it will be camelized and constantized.
+      def register_observer(observer)
+        delivery_observer = case observer
+          when String, Symbol
+            observer.to_s.camelize.constantize
+          else
+            observer
+          end
+
+        Sms.register_observer(delivery_observer)
+      end
+
+      # Register an Interceptor which will be called before SMS is sent.
+      # Either a class, string or symbol can be passed in as the Interceptor.
+      # If a string or symbol is passed in it will be camelized and constantized.
+      def register_interceptor(interceptor)
+        delivery_interceptor = case interceptor
+          when String, Symbol
+            interceptor.to_s.camelize.constantize
+          else
+            interceptor
+          end
+
+        Sms.register_interceptor(delivery_interceptor)
+      end
+
+      # Returns the name of current carrier.
+      # If this is an anonymous carrier, this method will return +anonymous+ instead.
+      def carrier_name
+        @carrier_name ||= anonymous? ? "anonymous" : name.underscore
+      end
+      # Allows to set the name of current carrier.
+      attr_writer :carrier_name
+      alias :controller_path :carrier_name
+
+      # Sets the defaults through app configuration:
+      #
+      #     config.sms_carrier.default(from: "+886987654321")
+      #
+      # Aliased by ::default_options=
+      def default(value = nil)
+        self.default_params = default_params.merge(value).freeze if value
+        default_params
+      end
+      # Allows to set defaults through app configuration:
+      #
+      #    config.sms_carrier.default_options = { from: "+886987654321" }
+      alias :default_options= :default
+
+      # Wraps an SMS delivery inside of <tt>ActiveSupport::Notifications</tt> instrumentation.
+      #
+      # This method is actually called by the <tt>Sms</tt> object itself
+      # through a callback when you call <tt>:deliver</tt> on the <tt>Sms</tt>,
+      # calling +deliver_sms+ directly and passing a <tt>Sms</tt> will do
+      # nothing except tell the logger you sent the SMS.
+      def deliver_sms(sms) #:nodoc:
+        ActiveSupport::Notifications.instrument("deliver.sms_carrier") do |payload|
+          set_payload_for_sms(payload, sms)
+          yield # Let Sms do the delivery actions
+        end
+      end
+
+      def respond_to?(method, include_private = false) #:nodoc:
+        super || action_methods.include?(method.to_s)
+      end
+
+      protected
+
+      def set_payload_for_sms(payload, sms) #:nodoc:
+        payload[:carrier]     = name
+        payload[:to]         = sms.to
+        payload[:from]       = sms.from
+        payload[:sms]        = sms.body
+      end
+
+      def method_missing(method_name, *args) #:nodoc:
+        if action_methods.include?(method_name.to_s)
+          MessageDelivery.new(self, method_name, *args)
+        else
+          super
+        end
+      end
+    end
+
+    attr_internal :message
+
+    # Instantiate a new carrier object. If +method_name+ is not +nil+, the carrier
+    # will be initialized according to the named method. If not, the carrier will
+    # remain uninitialized (useful when you only need to invoke the "receive"
+    # method, for instance).
+    def initialize(method_name=nil, *args)
+      super()
+      @_sms_was_called = false
+      @_message = Sms.new
+      process(method_name, *args) if method_name
+    end
+
+    def process(method_name, *args) #:nodoc:
+      payload = {
+        carrier: self.class.name,
+        action: method_name
+      }
+
+      ActiveSupport::Notifications.instrument("process.sms_carrier", payload) do
+        super
+        @_message = NullMessage.new unless @_sms_was_called
+      end
+    end
+
+    class NullMessage #:nodoc:
+      def body; '' end
+
+      def respond_to?(string, include_all=false)
+        true
+      end
+
+      def method_missing(*args)
+        nil
+      end
+    end
+
+    # Returns the name of the carrier object.
+    def carrier_name
+      self.class.carrier_name
+    end
+
+    # Allows you to pass random and unusual options to the new <tt>SmsCarrier::Sms</tt>
+    # object which will add them to itself.
+    #
+    #   options['X-Special-Domain-Specific-Option'] = "SecretValue"
+    #
+    # The resulting <tt>SmsCarrier::Sms</tt> will have the following in its option:
+    #
+    #   X-Special-Domain-Specific-Option: SecretValue
+    # def options
+    #   @_message.options
+    # end
+
+    def options(args = nil)
+      if args
+        @_message.options.merge!(args)
+      else
+        @_message
+      end
+    end
+
+    # The main method that creates the message and renders the SMS templates. There are
+    # two ways to call this method, with a block, or without a block.
+    #
+    # It accepts a headers hash. This hash allows you to specify
+    # the most used headers in an SMS message, these are:
+    #
+    # * +:to+ - Who the message is destined for, can be a string of addresses, or an array
+    #   of addresses.
+    # * +:from+ - Who the message is from
+    #
+    # You can set default values for any of the above headers (except +:date+)
+    # by using the ::default class method:
+    #
+    #  class Notifier < SmsCarrier::Base
+    #    default from: '+886987654321'
+    #  end
+    #
+    # If you do not pass a block to the +sms+ method, it will find all
+    # templates in the view paths using by default the carrier name and the
+    # method name that it is being called from, it will then create parts for
+    # each of these templates intelligently, making educated guesses on correct
+    # content type and sequence, and return a fully prepared <tt>Sms</tt>
+    # ready to call <tt>:deliver</tt> on to send.
+    #
+    # For example:
+    #
+    #   class Notifier < SmsCarrier::Base
+    #     default from: 'no-reply@test.lindsaar.net'
+    #
+    #     def welcome
+    #       sms(to: 'mikel@test.lindsaar.net')
+    #     end
+    #   end
+    #
+    # Will look for all templates at "app/views/notifier" with name "welcome".
+    # If no welcome template exists, it will raise an ActionView::MissingTemplate error.
+    #
+    # However, those can be customized:
+    #
+    #   sms(template_path: 'notifications', template_name: 'another')
+    #
+    # And now it will look for all templates at "app/views/notifications" with name "another".
+    #
+    # You can even render plain text directly without using a template:
+    #
+    #   sms(to: '+886987654321', body: 'Hello Mikel!')
+    #
+    def sms(options = {})
+      return @_message if @_sms_was_called && options.blank?
+
+      m = @_message
+
+      # Call all the procs (if any)
+      default_values = {}
+      self.class.default.each do |k,v|
+        default_values[k] = v.is_a?(Proc) ? instance_eval(&v) : v
+      end
+
+      # Handle defaults
+      options = options.reverse_merge(default_values)
+
+      # Set configure delivery behavior
+      wrap_delivery_behavior!(options.delete(:delivery_method), options.delete(:delivery_method_options))
+
+      # Assign all options except body, template_name, and template_path
+      assignable = options.except(:body, :template_name, :template_path)
+      assignable.each { |k, v| m[k] = v }
+
+      # Render the templates and blocks
+      m.body = response(options)
+      @_sms_was_called = true
+
+      m
+    end
+
+    def response(options) #:nodoc:
+      if options[:body]
+        return options.delete(:body)
+      else
+        templates_path = options.delete(:template_path) || self.class.carrier_name
+        templates_name = options.delete(:template_name) || action_name
+
+        template = lookup_context.find(templates_name, templates_path)
+        if template.nil?
+          raise ActionView::MissingTemplate.new(templates_path, templates_name, templates_path, false, 'carrier')
+        else
+          return render(template: template)
+        end
+      end
+    end
+
+    # SMS do not support relative path links.
+    def self.supports_path?
+      false
+    end
+
+    ActiveSupport.run_load_hooks(:sms_carrier, self)
+  end
+end

data/lib/sms_carrier/delivery_job.rb

@@ -0,0 +1,13 @@
+require 'active_job'
+
+module SmsCarrier
+  # The <tt>SmsCarrier::DeliveryJob</tt> class is used when you
+  # want to send SMSes outside of the request-response cycle.
+  class DeliveryJob < ActiveJob::Base # :nodoc:
+    queue_as { SmsCarrier::Base.deliver_later_queue_name }
+
+    def perform(sms, sms_method, delivery_method, *args) #:nodoc:
+      sms.constantize.public_send(sms_method, *args).send(delivery_method)
+    end
+  end
+end

data/lib/sms_carrier/delivery_methods.rb

@@ -0,0 +1,67 @@
+require 'sms_carrier/test_carrier'
+
+module SmsCarrier
+  # This module handles everything related to SMS delivery, from registering
+  # new delivery methods to configuring the SMS object to be sent.
+  module DeliveryMethods
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :delivery_methods, :delivery_method
+
+      # Do not make this inheritable, because we always want it to propagate
+      cattr_accessor :raise_delivery_errors
+      self.raise_delivery_errors = true
+
+      cattr_accessor :perform_deliveries
+      self.perform_deliveries = true
+
+      cattr_accessor :deliver_later_queue_name
+      self.deliver_later_queue_name = :carriers
+
+      self.delivery_methods = {}.freeze
+      self.delivery_method  = :test
+
+      add_delivery_method :test, TestCarrier
+    end
+
+    # Helpers for creating and wrapping delivery behavior, used by DeliveryMethods.
+    module ClassMethods
+      # Provides a list of SMSes that have been delivered by TestCarrier
+      delegate :deliveries, :deliveries=, to: TestCarrier
+
+      # Adds a new delivery method through the given class using the given
+      # symbol as alias and the default options supplied.
+      def add_delivery_method(symbol, klass, default_options = {})
+        class_attribute(:"#{symbol}_settings") unless respond_to?(:"#{symbol}_settings")
+        send(:"#{symbol}_settings=", default_options)
+        self.delivery_methods = delivery_methods.merge(symbol.to_sym => klass).freeze
+      end
+
+      def wrap_delivery_behavior(sms, method = nil, options = nil) # :nodoc:
+        method ||= delivery_method
+        sms.delivery_handler = self
+
+        case method
+        when NilClass
+          raise "Delivery method cannot be nil"
+        when Symbol
+          if klass = delivery_methods[method]
+            sms.delivery_method(klass, (send(:"#{method}_settings") || {}).merge(options || {}))
+          else
+            raise "Invalid delivery method #{method.inspect}"
+          end
+        else
+          sms.delivery_method(method)
+        end
+
+        sms.perform_deliveries    = perform_deliveries
+        sms.raise_delivery_errors = raise_delivery_errors
+      end
+    end
+    
+    def wrap_delivery_behavior!(*args)  # :nodoc:
+      self.class.wrap_delivery_behavior(message, *args)
+    end
+  end
+end

data/lib/sms_carrier/log_subscriber.rb

@@ -0,0 +1,33 @@
+require 'active_support/log_subscriber'
+
+module SmsCarrier
+  # Implements the ActiveSupport::LogSubscriber for logging notifications when
+  # sms is delivered or received.
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    # An SMS was delivered.
+    def deliver(event)
+      info do
+        recipients = Array(event.payload[:to]).join(', ')
+        "\nSent SMS to #{recipients} (#{event.duration.round(1)}ms)"
+      end
+
+      debug { event.payload[:sms] }
+    end
+
+    # An SMS was generated.
+    def process(event)
+      debug do
+        carrier = event.payload[:carrier]
+        action = event.payload[:action]
+        "\n#{carrier}##{action}: processed outbound SMS in #{event.duration.round(1)}ms"
+      end
+    end
+
+    # Use the logger configured for SmsCarrier::Base.
+    def logger
+      SmsCarrier::Base.logger
+    end
+  end
+end
+
+SmsCarrier::LogSubscriber.attach_to :sms_carrier

data/lib/sms_carrier/message_delivery.rb

@@ -0,0 +1,93 @@
+require 'delegate'
+
+module SmsCarrier
+  # The <tt>SmsCarrier::MessageDelivery</tt> class is used by
+  # <tt>SmsCarrier::Base</tt> when creating a new carrier.
+  # <tt>MessageDelivery</tt> is a wrapper (+Delegator+ subclass) around a lazy
+  # created <tt>Sms</tt>. You can get direct access to the
+  # <tt>Sms</tt>, deliver the SMS or schedule the SMS to be sent
+  # through Active Job.
+  #
+  #   Notifier.welcome(User.first)               # an SmsCarrier::MessageDelivery object
+  #   Notifier.welcome(User.first).deliver_now   # sends the email
+  #   Notifier.welcome(User.first).deliver_later # enqueue email delivery as a job through Active Job
+  #   Notifier.welcome(User.first).message       # a Sms object
+  class MessageDelivery < Delegator
+    def initialize(carrier, sms_method, *args)  #:nodoc:
+      @carrier = carrier
+      @sms_method = sms_method
+      @args = args
+    end
+
+    def __getobj__  #:nodoc:
+      @obj ||= @carrier.send(:new, @sms_method, *@args).message
+    end
+
+    def __setobj__(obj)  #:nodoc:
+      @obj = obj
+    end
+
+    # Returns the Message object
+    def message
+      __getobj__
+    end
+
+    # Enqueues the SMS to be delivered through Active Job. When the
+    # job runs it will send the SMS using +deliver_now!+. That means
+    # that the message will be sent bypassing checking +perform_deliveries+
+    # and +raise_delivery_errors+, so use with caution.
+    #
+    #   Notifier.welcome(User.first).deliver_later!
+    #   Notifier.welcome(User.first).deliver_later!(wait: 1.hour)
+    #   Notifier.welcome(User.first).deliver_later!(wait_until: 10.hours.from_now)
+    #
+    # Options:
+    #
+    # * <tt>:wait</tt> - Enqueue the SMS to be delivered with a delay
+    # * <tt>:wait_until</tt> - Enqueue the SMS to be delivered at (after) a specific date / time
+    # * <tt>:queue</tt> - Enqueue the SMS on the specified queue
+    def deliver_later!(options={})
+      enqueue_delivery :deliver_now!, options
+    end
+
+    # Enqueues the SMS to be delivered through Active Job. When the
+    # job runs it will send the SMS using +deliver_now+.
+    #
+    #   Notifier.welcome(User.first).deliver_later
+    #   Notifier.welcome(User.first).deliver_later(wait: 1.hour)
+    #   Notifier.welcome(User.first).deliver_later(wait_until: 10.hours.from_now)
+    #
+    # Options:
+    #
+    # * <tt>:wait</tt> - Enqueue the SMS to be delivered with a delay.
+    # * <tt>:wait_until</tt> - Enqueue the SMS to be delivered at (after) a specific date / time.
+    # * <tt>:queue</tt> - Enqueue the SMS on the specified queue.
+    def deliver_later(options={})
+      enqueue_delivery :deliver_now, options
+    end
+
+    # Delivers an SMS without checking +perform_deliveries+ and +raise_delivery_errors+,
+    # so use with caution.
+    #
+    #   Notifier.welcome(User.first).deliver_now!
+    #
+    def deliver_now!
+      message.deliver!
+    end
+
+    # Delivers an SMS:
+    #
+    #   Notifier.welcome(User.first).deliver_now
+    #
+    def deliver_now
+      message.deliver
+    end
+
+    private
+
+    def enqueue_delivery(delivery_method, options={})
+      args = @carrier.name, @sms_method.to_s, delivery_method.to_s, *@args
+      SmsCarrier::DeliveryJob.set(options).perform_later(*args)
+    end
+  end
+end

data/lib/sms_carrier/railtie.rb

@@ -0,0 +1,45 @@
+require 'active_job/railtie'
+require "sms_carrier"
+require "rails"
+require "abstract_controller/railties/routes_helpers"
+
+module SmsCarrier
+  class Railtie < Rails::Railtie # :nodoc:
+    config.sms_carrier = ActiveSupport::OrderedOptions.new
+    config.eager_load_namespaces << SmsCarrier
+
+    initializer "sms_carrier.logger" do
+      ActiveSupport.on_load(:sms_carrier) { self.logger ||= Rails.logger }
+    end
+
+    initializer "sms_carrier.set_configs" do |app|
+      paths   = app.config.paths
+      options = app.config.sms_carrier
+
+      options.assets_dir      ||= paths["public"].first
+      options.javascripts_dir ||= paths["public/javascripts"].first
+      options.stylesheets_dir ||= paths["public/stylesheets"].first
+
+      # make sure readers methods get compiled
+      options.asset_host          ||= app.config.asset_host
+      options.relative_url_root   ||= app.config.relative_url_root
+
+      ActiveSupport.on_load(:sms_carrier) do
+        include AbstractController::UrlFor
+        extend ::AbstractController::Railties::RoutesHelpers.with(app.routes, false)
+        include app.routes.mounted_helpers
+
+        register_interceptors(options.delete(:interceptors))
+        register_observers(options.delete(:observers))
+
+        options.each { |k,v| send("#{k}=", v) }
+      end
+    end
+
+    initializer "sms_carrier.compile_config_methods" do
+      ActiveSupport.on_load(:sms_carrier) do
+        config.compile_methods! if config.respond_to?(:compile_methods!)
+      end
+    end
+  end
+end

data/lib/sms_carrier/sms.rb

@@ -0,0 +1,126 @@
+module SmsCarrier
+  class Sms
+    attr_accessor :body, :from, :to, :options, :perform_deliveries, :raise_delivery_errors, :delivery_handler
+
+    def initialize
+      @options = {}
+      @perform_deliveries = true
+      @raise_delivery_errors = true
+      @to = []
+    end
+
+    def [](name)
+      options[name]
+    end
+
+    def []=(name, value)
+      if name.to_s == 'body'
+        self.body = value
+      elsif name.to_s == 'from'
+        self.from = value
+      elsif name.to_s == 'to'
+        self.to = value
+      else
+        options[name] = value
+      end
+    end
+
+    def to( val = nil )
+      if val.nil?
+        @to
+      elsif val.is_a? Array
+        @to = @to + val
+      elsif !@to.include? val
+        @to << val
+      end
+    end
+
+    def to=( val )
+      to(val)
+    end
+
+    def inform_observers
+      Sms.inform_observers(self)
+    end
+
+    def inform_interceptors
+      Sms.inform_interceptors(self)
+    end
+
+    def deliver
+      inform_interceptors
+      if delivery_handler
+        delivery_handler.deliver_sms(self) { do_delivery }
+      else
+        do_delivery
+      end
+      inform_observers
+      self
+    end
+
+    def deliver!
+      inform_interceptors
+      response = delivery_method.deliver!(self)
+      inform_observers
+      delivery_method.settings[:return_response] ? response : self
+    end
+
+    def delivery_method(method = nil, settings = {})
+      unless method
+        @delivery_method
+      else
+        @delivery_method = method.new(settings)
+      end
+    end
+
+    def to_s
+      buffer = ''
+      options.each do |key, value|
+        buffer += "#{key}: #{value}\n"
+      end
+      buffer += "From: #{from}\n"
+      buffer += "To: #{to}\n"
+      buffer += "Body: #{body}\n"
+      buffer
+    end
+
+    @@delivery_notification_observers = []
+    @@delivery_interceptors = []
+
+    def self.register_observer(observer)
+      unless @@delivery_notification_observers.include?(observer)
+        @@delivery_notification_observers << observer
+      end
+    end
+
+    def self.register_interceptor(interceptor)
+      unless @@delivery_interceptors.include?(interceptor)
+        @@delivery_interceptors << interceptor
+      end
+    end
+
+    def self.inform_observers(sms)
+      @@delivery_notification_observers.each do |observer|
+        observer.delivered_sms(sms)
+      end
+    end
+
+    def self.inform_interceptors(sms)
+      @@delivery_interceptors.each do |interceptor|
+        interceptor.delivering_sms(sms)
+      end
+    end
+
+    private
+
+    def do_delivery
+      begin
+        if perform_deliveries
+          delivery_method.deliver!(self)
+        end
+      rescue => e
+        raise e if raise_delivery_errors
+      end
+    end
+  end
+end

data/lib/sms_carrier/test_carrier.rb

@@ -0,0 +1,21 @@
+module SmsCarrier
+  class TestCarrier
+    attr_accessor :settings
+
+    def initialize(settings)
+      self.settings = settings
+    end
+
+    def deliver!(sms)
+      TestCarrier.deliveries << sms
+    end
+
+    def self.deliveries
+      @@deliveries ||= []
+    end
+
+    def self.deliveries=(val)
+      @@deliveries = val
+    end
+  end
+end

data/lib/sms_carrier/test_case.rb

@@ -0,0 +1,85 @@
+require 'active_support/test_case'
+
+module SmsCarrier
+  class NonInferrableCarrierError < ::StandardError
+    def initialize(name)
+      super "Unable to determine the carrier to test from #{name}. " +
+        "You'll need to specify it using tests YourCarrier in your " +
+        "test case definition"
+    end
+  end
+
+  class TestCase < ActiveSupport::TestCase
+    module Behavior
+      extend ActiveSupport::Concern
+
+      include ActiveSupport::Testing::ConstantLookup
+      include TestHelper
+
+      included do
+        class_attribute :_carrier_class
+        setup :initialize_test_deliveries
+        setup :set_expected_sms
+        teardown :restore_test_deliveries
+      end
+
+      module ClassMethods
+        def tests(carrier)
+          case carrier
+          when String, Symbol
+            self._carrier_class = carrier.to_s.camelize.constantize
+          when Module
+            self._carrier_class = carrier
+          else
+            raise NonInferrableCarrierError.new(carrier)
+          end
+        end
+
+        def carrier_class
+          if carrier = self._carrier_class
+            carrier
+          else
+            tests determine_default_carrier(name)
+          end
+        end
+
+        def determine_default_carrier(name)
+          carrier = determine_constant_from_test_name(name) do |constant|
+            Class === constant && constant < SmsCarrier::Base
+          end
+          raise NonInferrableCarrierError.new(name) if carrier.nil?
+          carrier
+        end
+      end
+
+      protected
+
+      def initialize_test_deliveries # :nodoc:
+        set_delivery_method :test
+        @old_perform_deliveries = SmsCarrier::Base.perform_deliveries
+        SmsCarrier::Base.perform_deliveries = true
+      end
+
+      def restore_test_deliveries # :nodoc:
+        restore_delivery_method
+        SmsCarrier::Base.perform_deliveries = @old_perform_deliveries
+        SmsCarrier::Base.deliveries.clear
+      end
+
+      def set_delivery_method(method) # :nodoc:
+        @old_delivery_method = SmsCarrier::Base.delivery_method
+        SmsCarrier::Base.delivery_method = method
+      end
+
+      def restore_delivery_method # :nodoc:
+        SmsCarrier::Base.delivery_method = @old_delivery_method
+      end
+
+      def set_expected_sms # :nodoc:
+        @expected = Sms.new
+      end
+    end
+
+    include Behavior
+  end
+end

data/lib/sms_carrier/test_helper.rb

@@ -0,0 +1,66 @@
+require 'active_job'
+
+module SmsCarrier
+  # Provides helper methods for testing SmsCarrier, including #assert_smses
+  # and #assert_no_smses.
+  module TestHelper
+    include ActiveJob::TestHelper
+
+    # Asserts that the number of SMSes sent matches the given number.
+    #
+    #   def test_smses
+    #     assert_smses 0
+    #     ContactCarrier.welcome.deliver_now
+    #     assert_smses 1
+    #     ContactCarrier.welcome.deliver_now
+    #     assert_smses 2
+    #   end
+    #
+    # If a block is passed, that block should cause the specified number of
+    # SMSes to be sent.
+    #
+    #   def test_smses_again
+    #     assert_smses 1 do
+    #       ContactCarrier.welcome.deliver_now
+    #     end
+    #
+    #     assert_smses 2 do
+    #       ContactCarrier.welcome.deliver_now
+    #       ContactCarrier.welcome.deliver_now
+    #     end
+    #   end
+    def assert_smses(number)
+      if block_given?
+        original_count = SmsCarrier::Base.deliveries.size
+        yield
+        new_count = SmsCarrier::Base.deliveries.size
+        assert_equal number, new_count - original_count, "#{number} SMSes expected, but #{new_count - original_count} were sent"
+      else
+        assert_equal number, SmsCarrier::Base.deliveries.size
+      end
+    end
+
+    # Assert that no SMSes have been sent.
+    #
+    #   def test_smses
+    #     assert_no_smses
+    #     ContactCarrier.welcome.deliver_now
+    #     assert_smses 1
+    #   end
+    #
+    # If a block is passed, that block should not cause any SMSes to be sent.
+    #
+    #   def test_smses_again
+    #     assert_no_smses do
+    #       # No SMSes should be sent from this block
+    #     end
+    #   end
+    #
+    # Note: This assertion is simply a shortcut for:
+    #
+    #   assert_smses 0
+    def assert_no_smses(&block)
+      assert_smses 0, &block
+    end
+  end
+end

data/lib/sms_carrier/version.rb

@@ -0,0 +1,3 @@
+module SmsCarrier
+  VERSION = "0.1.0"
+end

data/sms_carrier.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sms_carrier/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sms_carrier"
+  spec.version       = SmsCarrier::VERSION
+  spec.authors       = ["Chen Yi-Cyuan"]
+  spec.email         = ["emn178@gmail.com"]
+
+  spec.summary       = %q{SMS composition and delivery framework.}
+  spec.description   = %q{SMS on Rails. Compose, deliver and test SMSes using the familiar controller/view pattern.}
+  spec.homepage      = "https://github.com/emn178/sms_carrier"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "actionpack", '>= 4.2.0'
+  spec.add_dependency 'actionview', '>= 4.2.0'
+  spec.add_dependency "activejob", '>= 4.2.0'
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "mocha"
+end

metadata

@@ -0,0 +1,150 @@
+--- !ruby/object:Gem::Specification
+name: sms_carrier
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Chen Yi-Cyuan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: actionview
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: activejob
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  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: SMS on Rails. Compose, deliver and test SMSes using the familiar controller/view
+  pattern.
+email:
+- emn178@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/sms_carrier.rb
+- lib/sms_carrier/base.rb
+- lib/sms_carrier/delivery_job.rb
+- lib/sms_carrier/delivery_methods.rb
+- lib/sms_carrier/log_subscriber.rb
+- lib/sms_carrier/message_delivery.rb
+- lib/sms_carrier/railtie.rb
+- lib/sms_carrier/sms.rb
+- lib/sms_carrier/test_carrier.rb
+- lib/sms_carrier/test_case.rb
+- lib/sms_carrier/test_helper.rb
+- lib/sms_carrier/version.rb
+- sms_carrier.gemspec
+homepage: https://github.com/emn178/sms_carrier
+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.8
+signing_key: 
+specification_version: 4
+summary: SMS composition and delivery framework.
+test_files: []