voltron-notify 0.1.9 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6cdac4cb0e2b131d7b6a088ea7a952cc422a1263
-  data.tar.gz: 9d41eb541fe1686afdca60334d0525583489ebbe
+  metadata.gz: 698c826b9ee01c01f1daea0727c9f9a858bd53f9
+  data.tar.gz: f2f0cb75ae14e44a046c6fc5faf590a1efbdb02c
 SHA512:
-  metadata.gz: 679e4b2d86d9901e23c7df5db41e01cefebd8ef34d2cba4182f7130093d948c61fe09f49fe59c61f2c3d5707c98614e4fee8c5fbdefca95409c6e1480f61dc62
-  data.tar.gz: a3758d441c5b7cf86332fff0e784f187d5211b7cec6c2797000f8350740e27458f36092cb6df62ec2b5ec309990e387dcc9fb578739c9fcde2b85e5d24498284
+  metadata.gz: d44cbe91644c6cfcc2bb082ed1f1244969a87ed69eb1abfb1033ed968cfde3f5810c1319ad4d9295fce5a17c5b5a3fc953e7ade7c6f8bc5d51922606e7769ada
+  data.tar.gz: 87ab64f59e3fb1b486eb869df10263625f112198792b5d4b84981873e42442a65c854d1e3e142f1450bef3c606b9f820bc67cf6c2529f34a8b9fd9a6b0491959

data/.travis.yml

@@ -3,4 +3,6 @@ language: ruby
 rvm:
   - 2.2.3
   - 2.3.1
+  - 2.3.3
+  - 2.4.1
 before_install: gem install bundler -v 1.12.5

data/Gemfile

@@ -1,6 +1,5 @@
 source 'https://rubygems.org'
-source 'http://gem.minow.io'
+source 'https://gem.minow.io'
 
 # Specify your gem's dependencies in voltron-notify.gemspec
-gem 'colorize'
 gemspec

data/README.md

@@ -1,9 +1,11 @@
+[![Code Climate](https://codeclimate.com/github/ehainer/voltron-notify.png)](https://codeclimate.com/github/ehainer/voltron-notify)
 [![Build Status](https://travis-ci.org/ehainer/voltron-notify.svg?branch=master)](https://travis-ci.org/ehainer/voltron-notify)
 
 # Voltron::Notify
 
 Voltron Notify is an attempt to join Twilio's SMS api with Rails' default mailer functionality into one single method.
 
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -20,7 +22,7 @@ Or install it yourself as:
 
     $ gem install voltron-notify
 
-Then run the following to create the voltron.rb initializer (if not exists already) and add the notify config:
+Then run the following to create the voltron.rb initializer and add the notify config:
 
     $ rails g voltron:notify:install
 
@@ -31,12 +33,25 @@ Once installed and configured, add `notifyable` at the top of any model you wish
 ```ruby
 class User < ActiveRecord::Base
 
-  notifyable
+  notifyable [args]
+
+end
+```
+
+`notifyable` will create a `notifications` association on whatever model it is called on. The one optional argument should be a hash with default SMS/Email ActiveJob options. See "ActiveJob Integration" below for more info on how/when the default options will be used.
+
+Defined default options should look like so:
+
+```ruby
+class User < ActiveRecord::Base
+
+  notifyable sms: { wait: 10.minutes, queue: 'sms' },
+             email: { wait_until: 10.minutes.from_now, queue: 'mailers' }
 
 end
 ```
 
-`notifyable` will create a notifications association on whatever model it is called on. Once done, you can utilize Voltron Notify like so:
+Once done, you can utilize Voltron Notify like so:
 
 ```ruby
 @user = User.find(1)
@@ -49,7 +64,7 @@ end
 
   # First argument is email subject, remaining arguments can consist of [:to, :from] or any other param you'd like,
   # they will all be converted to @variables for use in the mailer template
-  n.email "This is the mail subject", { to: "info@example.com" }, { param_one: "Hi there", param_two: "" }
+  n.email "This is the mail subject", { to: "info@example.com", param_one: "Hi there", param_two: "" }
 end
 ```
 
@@ -86,40 +101,82 @@ Optionally, you may pass a block to the `sms` or `email` methods that allows for
 end
 ```
 
+In the case of the methods `mailer`, `method`, `arguments`, and `template`, below is each's purpose and default values
+
+| Method    | Default                                                                                                                                                                        | Comment                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+|-----------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| mailer    | Voltron::NotificationMailer                                                                                                                                                    | Defines what mailer class should be used to handle the sending of email notifications. Can be defined as the actual class name or a string, even in the format '&lt;module&gt;/&lt;mailer&gt;'. It is eventually converted to a string anyways, converted to a valid format with [classify](https://apidock.com/rails/v4.2.7/String/classify) and then instantiated with [constantize](https://apidock.com/rails/String/constantize)                                                                                                                                                                                                                                                                               |
+| method    | :notify                                                                                                                                                                        | Specifies what method within the defined mailer should be called. Can be a string or symbol                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        |
+| arguments | nil                                                                                                                                                                            | Accepts an unlimited number of arguments that will be passed directly through to your mailer method Can be anything you want, so long as +mailer+.+method+() will understand it.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| template  | nil, but due to ActionMailer's default behavior, assuming +mailer+ and +method+ are not modified, it will look for `app/views/voltron/notification_mailer/notify.<format>.erb` | Overrides the default mailer template by parsing a single string argument into separate [template_path](http://guides.rubyonrails.org/action_mailer_basics.html#mailer-views) and [template_name](http://guides.rubyonrails.org/action_mailer_basics.html#mailer-views) arguments for the +mail+ method. Note that this argument should be the path relative to your applications `app/views` directory, and that it strips any file extensions. So, in the case of a view located at `app/views/my_mailer/sub_dir/special_template.html.erb` you can specify the path `my_mailer/sub_dir/special_template`. Depending on what format email you've chosen to send it will look for `special_template.<format>.erb` |
 Note that both SMS and Email notifications have validations on the :to/:from fields, the email subject, and the SMS body text. Since `notifications` is an association, any errors in the actual notification content will bubble up, possibly preventing the `notifyable` model from saving. For that reason, it may be more logical to instead use a @notifyable.notifications.build / @notifyable.save syntax to properly handle errors that may occur.
 
-Also supported are Twilio status update callbacks for SMS notifications. To enable, you can add the following to your `routes.rb` file
 
-```ruby
-Rails.application.routes.draw do
+## ActiveJob Integration
+
+Voltron Notify supports sending both email (via deliver_later) and SMS (via Voltron::SmsJob and perform_later). To have all notifications be handled by ActiveJob in conjunction with Sidekiq/Resque/whatever you need only set the config value `Voltron.config.notify.use_queue` to `true`. If ActiveJob is configured properly notifications will send that way instead. You may also optionally set the delay for each notification by setting the value of `Voltron.config.notify.delay` to any time value (i.e. 5.minutes, 3.months, 0.seconds)
+
+If the value of `Voltron.config.notify.use_queue` is `true`, additional methods for sending SMS/Email can be used to further control the ActiveJob params.
+
+For the `email` method:
+
+| Queue Specific Methods Available | Accepts Arguments?                                                                                                                                                                                                                                                                                                                                                                                   | Behavior                                                                                                                                                                                | Default Behavior If Not Manually Called                                 |
+|----------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------|
+| deliver_now                      | No                                                                                                                                                                                                                                                                                                                                                                                                   | Same as [deliver_now](https://apidock.com/rails/v4.2.7/ActionMailer/MessageDelivery/deliver_now), except this will not occur until the parent notification association is saved         | Yes, if `Voltron.config.notify.use_queue` is *not* truthy. No otherwise |
+| deliver_now!                     | No                                                                                                                                                                                                                                                                                                                                                                                                   | Same as [deliver_now!](https://apidock.com/rails/ActionMailer/MessageDelivery/deliver_now%21), except this will not occur until the parent notification association is saved            | No                                                                      |
+| deliver_later                    | Yes, same as what [deliver_later](https://apidock.com/rails/v4.2.7/ActionMailer/MessageDelivery/deliver_later) would accept. These arguments will come from the defaults specified when `notifyable` is called in the model. Default arguments are always overridden by the same options defined in this methods arguments. See documentation of `notifyable` and it's accepted arguments above.     | Same as [deliver_later](https://apidock.com/rails/v4.2.7/ActionMailer/MessageDelivery/deliver_later), except this will not occur until the parent notification association is saved     | Yes, if `Voltron.config.notify.use_queue` is truthy. No otherwise       |
+| deliver_later!                   | Yes, same as what [deliver_later!](https://apidock.com/rails/v4.2.7/ActionMailer/MessageDelivery/deliver_later%21) would accept. These arguments will come from the defaults specified when `notifyable` is called in the model. Default arguments are always overridden by the same options defined in this methods arguments. See documentation of `notifyable` and it's accepted arguments above. | Same as [deliver_later!](https://apidock.com/rails/v4.2.7/ActionMailer/MessageDelivery/deliver_later%21), except this will not occur until the parent notification association is saved | No                                                                      |
 
-  allow_notification_update(options = {})
 
+For the `sms` method:
+
+| Queue Specific Methods Available | Accepts Arguments?                                                                                                                                                                                                                                                                                                                                                   | Behavior                                                                                                                                                            | Default Behavior If Not Manually Called                                 |
+|----------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------|-------------------------------------------------------------------------|
+| deliver_now                      | No                                                                                                                                                                                                                                                                                                                                                                   | When associated notification object is saved, SMS will be sent immediately (via ActiveJob's [perform_now](https://apidock.com/rails/v4.2.1/ActiveJob/Execution/ClassMethods/perform_now)), in a blocking way, aka - rails will wait until SMS is sent before continuing execution. | Yes, if `Voltron.config.notify.use_queue` is *not* truthy. No otherwise |
+| deliver_later                    | Yes, same as what [set](https://apidock.com/rails/ActiveJob/Core/ClassMethods/set) would accept. These arguments will come from the defaults specified when `notifyable` is called in the model. Default arguments are always overridden by the same options defined in this methods arguments. See documentation of `notifyable` and it's accepted arguments above. | When associated notification object is saved, ActiveJob's [perform_later](https://apidock.com/rails/ActiveJob/Enqueuing/ClassMethods/perform_later) is called.                                                                                                                     | Yes, if `Voltron.config.notify.use_queue` is truthy. No otherwise       |
+
+
+Example usage:
+
+```ruby
+@user = User.find(1)
+
+@user.notifications.build do |n|
+  n.sms("Immediate Message").deliver_now # Will deliver the SMS as soon as the notification is saved
+  n.sms("Delayed Message").deliver_later(queue: 'sms', wait_until: 10.minutes.from_now) # Will deliver the SMS via +perform_now+ with ActiveJob
+  n.email("Delayed Mail Subject", { param_one: "Hi there", param_two: "" }).deliver_later(wait: 5.minutes)
 end
+
+@user.save # Will finally perform the actual actions defined. Basically, +deliver_*+ does nothing until the notification is saved.
 ```
 
-By default, the default options for notification updates are as follows:
 
-```
-# The default url path that Twilio will POST updates to. Can be anything you want so long as it's a valid URL path
-path: '/notification/update'
+## Updating SMS Notifications
 
-# The controller that will handle the notification update
-controller: 'voltron/notification'
+Also supported are Twilio status update callbacks for SMS notifications. To enable, you can add the following to your `routes.rb` file
 
-# The action that will perform the update
-action: 'update' #
+```ruby
+Rails.application.routes.draw do
+
+  allow_notification_update(options={})
+
+end
 ```
 
+Without specifying, the default options for notification updates are as follows:
+
+| Option     | Default              | Comment                                                                                                                   |
+|------------|----------------------|---------------------------------------------------------------------------------------------------------------------------|
+| path       | /notification/update | The default url path that Twilio will POST updates to. Can be anything you want so long as it's a valid URL path          |
+| controller | voltron/notification | The controller that will handle the notification update (in this case `app/controllers/voltron/notification_controller.rb`) |
+| action     | update               | The controller action (method) that will perform the update                                                               |
+
 If the value of `controller` or `action` are modified, it is assumed that whatever they point to will handle SMS notification updates. See the description column for "StatusCallback" parameter [here](https://www.twilio.com/docs/api/rest/sending-messages) for information on what Twilio will POST to the callback url. Or, take a look at this gems `app/controller/voltron/notification_controller.rb` file to see what it does by default.
 
 In order for `allow_notification_update` to generate the correct callback url, please ensure the value of `Voltron.config.base_url` is a valid host name. By default it will attempt to obtain this information from the `:host` parameter of `Rails.application.config.action_controller.default_url_options` but if specified in the Voltron initializer that will 
 
 Note that `allow_notification_update` does nothing if running on a host matching `/localhost|127\.0\.0\.1/i` Since Twilio can't reach locally running apps to POST to, the app will not even provide Twilio with the callback url to try it. If you have a local app host named Twilio will try and POST to it, but will obviously fail for the reasons previously stated. Basically, this feature only works on remotely accessible hosts.
 
-## Integration with ActiveJob
-
-Voltron Notify supports sending both email (via deliver_later) and SMS (via Voltron::SmsJob and perform_later). To have all notifications be handled by ActiveJob in conjunction with Sidekiq/Resque/whatever you need only set the config value `Voltron.config.notify.use_queue` to `true`. If ActiveJob is configured properly notifications will send that way instead. You may also optionally set the delay for each notification by setting the value of `Voltron.config.notify.delay` to any time value (i.e. 5.minutes, 3.months, 0.seconds)
 
 ## Development
 

data/app/jobs/voltron/sms_job.rb

@@ -1,7 +1,7 @@
 class Voltron::SmsJob < ActiveJob::Base
 
   def perform(sms)
-    sms.deliver_now
+    sms.send(:send_now)
   end
 
 end

data/app/models/voltron/notification.rb

@@ -18,7 +18,7 @@ module Voltron
       params = { subject: subject, notifyable.class.name.downcase => notifyable }.compact.merge(**args)
 
       # Build the options hash from the provided arguments
-      options = { subject: subject }.merge(**args.select { |k,v| PERMITTED_ATTRIBUTES.include?(k.to_sym) })
+      options = { subject: subject }.merge(**args.select { |k, _| PERMITTED_ATTRIBUTES.include?(k.to_sym) })
 
       # Build a new SMS notification object
       notification_email = email_notifications.build(options)
@@ -27,7 +27,10 @@ module Voltron
       notification_email.vars = params
 
       # If a block is provided, allow calls to methods like `attach`
-      notification_email.instance_exec &block if block_given?
+      notification_email.instance_exec(&block) if block_given?
+
+      # Return the email notification instance
+      notification_email
     end
 
     def sms(message, **args, &block)
@@ -38,7 +41,10 @@ module Voltron
       notification_sms = sms_notifications.build(options)
 
       # If a block is provided, allow calls to methods like `attach`
-      notification_sms.instance_exec &block if block_given?
+      notification_sms.instance_exec(&block) if block_given?
+
+      # Return the SMS notification instance
+      notification_sms
     end
 
     # Called from the before_validation callback within `notifyable`
@@ -50,18 +56,17 @@ module Voltron
       sms_notifications.each { |n| n.to ||= phone }
     end
 
+    def self.format_output_of(json)
+      # Ensure returned object is an array of response hashes, for consistency
+      out = Array.wrap((JSON.parse(json) rescue nil)).compact
+      out.map { |h| h.with_indifferent_access }
+    end
+
     private
 
       def validate
-        # Add SMS related errors to self
-        sms_notifications.each do |n|
-          unless n.valid?
-            n.errors.full_messages.each { |msg| self.errors.add(:base, msg) }
-          end
-        end
-
-        # Add Email related errors to self
-        email_notifications.each do |n|
+        # Add SMS/Email related errors to self
+        (sms_notifications.to_a + email_notifications.to_a).each do |n|
           unless n.valid?
             n.errors.full_messages.each { |msg| self.errors.add(:base, msg) }
           end

data/app/models/voltron/notification/email_notification.rb

@@ -4,9 +4,11 @@ class Voltron::Notification::EmailNotification < ActiveRecord::Base
 
   after_initialize :setup
 
-  before_create :deliver_now, unless: :use_queue?
+  before_create :send_now, if: Proc.new { |n| !n.send(:use_queue?) || n.immediate }
 
-  after_create :deliver_later, if: :use_queue?
+  # We have a separate check for +created+ because we trigger +save+ within this callback,
+  # and there are known issues of recursion when that is the case. See: https://github.com/rails/rails/issues/14493
+  after_commit :send_later, on: :create, if: Proc.new { |n| n.send(:use_queue?) && !n.created }
 
   validates_presence_of :to, message: I18n.t('voltron.notification.email.to_blank')
 
@@ -14,41 +16,14 @@ class Voltron::Notification::EmailNotification < ActiveRecord::Base
 
   attr_accessor :vars, :attachments
 
-  def setup
-    @request = []
-    @response = []
-    @vars ||= {}
-    @attachments ||= {}
-    @mailer_arguments = nil
-    self.mailer_class ||= Voltron.config.notify.default_mailer
-    self.mailer_method ||= Voltron.config.notify.default_method
-    template(Voltron.config.notify.default_template)
-  end
+  attr_accessor :created, :immediate
 
   def request
-    # Wrap entire request in array, for consistency
-    Array.wrap({ request: (JSON.parse(request_json) rescue {}) }.with_indifferent_access[:request])
+    Voltron::Notification.format_output_of(request_json)
   end
 
   def response
-    # Wrap entire response in array, for consistency
-    Array.wrap({ response: (JSON.parse(response_json) rescue {}) }.with_indifferent_access[:response])
-  end
-
-  def after_deliver
-    self.request_json = @request.to_json
-    self.response_json = @response.to_json
-  end
-
-  def deliver_now
-    mail.deliver_now
-    @response << ActionMailer::Base.deliveries.last
-    after_deliver
-  end
-
-  def deliver_later
-    @response << mail.deliver_later(wait: Voltron.config.notify.delay)
-    after_deliver
+    Voltron::Notification.format_output_of(response_json)
   end
 
   def attach(file, name = nil)
@@ -58,7 +33,7 @@ class Voltron::Notification::EmailNotification < ActiveRecord::Base
     if file.is_a?(File)
       path = file.path
       file.close
-    elsif !File.exists?(path)
+    elsif !File.exist?(path)
       path = Voltron.asset.find(path)
     end
 
@@ -78,13 +53,76 @@ class Voltron::Notification::EmailNotification < ActiveRecord::Base
   end
 
   def template(fullpath)
-    parts = fullpath.split("/")
+    parts = fullpath.split('/')
     self.template_name = parts.pop.sub(/\.(html|text)\..*$/, '')
     self.template_path = parts.join('/')
   end
 
+  def deliver_now
+    @delivery_method = :deliver_now
+    @immediate = true
+  end
+
+  def deliver_now!
+    @delivery_method = :deliver_now!
+    @immediate = true
+  end
+
+  def deliver_later(options={})
+    @mail_options = options
+    @delivery_method = :deliver_later
+  end
+
+  def deliver_later!(options={})
+    @mail_options = options
+    @delivery_method = :deliver_later!
+  end
+
   private
 
+    def send_now
+      mail.send(delivery_method)
+      @response << ActionMailer::Base.deliveries.last
+      after_deliver
+    end
+
+    def send_later
+      @response << mail.send(delivery_method, default_options.merge(mail_options))
+      after_deliver
+    end
+
+    def setup
+      @request = []
+      @response = []
+      @vars ||= {}
+      @attachments ||= {}
+      @mailer_arguments = nil
+      self.mailer_class ||= Voltron.config.notify.default_mailer
+      self.mailer_method ||= Voltron.config.notify.default_method
+      template(Voltron.config.notify.default_template)
+    end
+
+    def mail_options
+      @mail_options ||= {}
+    end
+
+    def delivery_method
+      @delivery_method ||= (use_queue? ? :deliver_later : :deliver_now)
+    end
+
+    def default_options
+      notification.notifyable.class.instance_variable_get('@_notification_defaults').try(:[], :email) || {}
+    end
+
+    def after_deliver
+      @created = true
+      @immediate = nil
+      @mail_options = nil
+      @delivery_method = nil
+      self.request_json = @request.to_json
+      self.response_json = @response.to_json
+    end
+
     def use_queue?
       Voltron.config.notify.use_queue
     end
@@ -93,10 +131,10 @@ class Voltron::Notification::EmailNotification < ActiveRecord::Base
       # If no mailer arguments, use default order of arguments as defined in Voltron::NotificationMailer.notify
       if @mailer_arguments.blank?
         @request << { to: to, from: from, subject: subject, template_path: template_path, template_name: template_name }.compact.merge(vars: vars, attachments: attachments)
-        mailer.send method, { to: to, from: from, subject: subject, template_path: template_path, template_name: template_name }.compact, vars, attachments
+        @outgoing = mailer.send method, { to: to, from: from, subject: subject, template_path: template_path, template_name: template_name }.compact, vars, attachments
       else
         @request << @mailer_arguments.compact
-        mailer.send method, *@mailer_arguments.compact
+        @outgoing = mailer.send method, *@mailer_arguments.compact
       end
     end
 

data/app/models/voltron/notification/sms_notification.rb

@@ -10,9 +10,11 @@ class Voltron::Notification::SmsNotification < ActiveRecord::Base
 
   after_initialize :setup
 
-  before_create :deliver_now, unless: :use_queue?
+  before_create :send_now, unless: :use_queue?
 
-  after_create :deliver_later, if: :use_queue?
+  # We have a separate check for +created+ because we trigger +save+ within this callback,
+  # and there are known issues of recursion when that is the case. See: https://github.com/rails/rails/issues/14493
+  after_commit :send_later, on: :create, if: Proc.new { |n| n.send(:use_queue?) && !n.created }
 
   validates :status, presence: false, inclusion: { in: %w( accepted queued sending sent delivered received failed undelivered unknown ), message: I18n.t('voltron.notification.sms.status_invalid') }, on: :update
 
@@ -24,60 +26,26 @@ class Voltron::Notification::SmsNotification < ActiveRecord::Base
 
   validate :valid_phone_number
 
-  def setup
-    @request = []
-    @response = []
-  end
+  attr_accessor :created
 
   def request
-    # Ensure returned object is an array of request hashes, for consistency
-    out = Array.wrap((JSON.parse(request_json) rescue nil)).compact
-    out.map { |h| h.with_indifferent_access }
+    Voltron::Notification.format_output_of(request_json)
   end
 
   def response
-    # Ensure returned object is an array of response hashes, for consistency
-    out = Array.wrap((JSON.parse(response_json) rescue nil)).compact
-    out.map { |h| h.with_indifferent_access }
-  end
-
-  def after_deliver
-    self.request_json = @request.to_json
-    self.response_json = @response.to_json
-    self.sid = response.first.try(:[], :sid)
-    self.status = response.first.try(:[], :status) || 'unknown'
-
-    # if use_queue?, meaning if this was sent via ActiveJob, we need to save ourself
-    # since we got to here within after_create, meaning setting the attributes alone won't cut it
-    self.save if use_queue?
+    Voltron::Notification.format_output_of(response_json)
   end
 
+  # Establish that we will perform the job immediately. Will cause +send_now+ to be called instead when saved
   def deliver_now
-    @request = request
-    @response = response
-
-    all_attachments = attachments.map(&:attachment)
-
-    # If sending more than 1 attachment, iterate through all but one attachment and send each without a body...
-    if all_attachments.count > 1
-      begin
-        client.messages.create({ from: from_formatted, to: to_formatted, media_url: all_attachments.shift, status_callback: callback_url }.compact)
-        @request << Rack::Utils.parse_nested_query(client.last_request.body)
-        @response << JSON.parse(client.last_response.body)
-      end until all_attachments.count == 1
-    end
-
-    # ... Then send the last attachment (if any) with the actual text body. This way we're not sending multiple SMS's with same body
-    client.messages.create({ from: from_formatted, to: to_formatted, body: message, media_url: all_attachments.shift, status_callback: callback_url }.compact)
-    @request << Rack::Utils.parse_nested_query(client.last_request.body)
-    @response << JSON.parse(client.last_response.body)
-    after_deliver
+    @job_options = {}
+    @job_method = :perform_now
   end
 
-  def deliver_later
-    job = Voltron::SmsJob.set(wait: Voltron.config.notify.delay).perform_later self
-    @request << job
-    after_deliver
+  # Establish that the job should be enqueued, and set the options
+  def deliver_later(options={})
+    @job_options = options
+    @job_method = :perform_later
   end
 
   def attach(*urls)
@@ -92,7 +60,6 @@ class Voltron::Notification::SmsNotification < ActiveRecord::Base
 
   def valid_phone?
     begin
-      return true if to.blank? # Handle a blank `to` separately in the errors method below
       to_formatted
       true
     rescue => e
@@ -101,15 +68,76 @@ class Voltron::Notification::SmsNotification < ActiveRecord::Base
     end
   end
 
-  def callback_url
-    url = try(:update_voltron_notification_url, host: Voltron.config.base_url).to_s
-    # Don't allow local or blank urls
-    return nil if url.include?('localhost') || url.include?('127.0.0.1') || url.blank?
-    url
-  end
-
   private
 
+    # Sends the SMS message
+    def send_now
+      @request = request
+      @response = response
+
+      all_attachments = attachments.map(&:attachment)
+
+      # If sending more than 1 attachment, iterate through all but one attachment and send each without a body...
+      if all_attachments.count > 1
+        loop do
+          break if all_attachments.count == 1
+          client.messages.create({ from: from_formatted, to: to_formatted, media_url: all_attachments.shift, status_callback: callback_url }.compact)
+          @request << Rack::Utils.parse_nested_query(client.last_request.body)
+          @response << JSON.parse(client.last_response.body)
+        end
+      end
+
+      # ... Then send the last attachment (if any) with the actual text body. This way we're not sending multiple SMS's with same body
+      client.messages.create({ from: from_formatted, to: to_formatted, body: message, media_url: all_attachments.shift, status_callback: callback_url }.compact)
+      @request << Rack::Utils.parse_nested_query(client.last_request.body)
+      @response << JSON.parse(client.last_response.body)
+      after_deliver
+    end
+
+    # Enqueue a job to deliver the SMS message, with options defined by calls to +deliver_later+
+    def send_later
+      @request << Voltron::SmsJob.set(default_options.merge(job_options)).send(job_method, self)
+      after_deliver
+    end
+
+    def setup
+      @request = []
+      @response = []
+    end
+
+    def job_options
+      @job_options ||= {}
+    end
+
+    def job_method
+      @job_method ||= :perform_later
+    end
+
+    def default_options
+      notification.notifyable.class.instance_variable_get('@_notification_defaults').try(:[], :sms) || {}
+    end
+
+    def after_deliver
+      @created = true
+      @job_options = nil
+      @job_method = nil
+      self.request_json = @request.to_json
+      self.response_json = @response.to_json
+      self.sid = response.first.try(:[], :sid)
+      self.status = response.first.try(:[], :status) || 'unknown'
+
+      # if use_queue?, meaning if this was sent via ActiveJob, we need to save ourself
+      # since we got to here within after_create, meaning setting the attributes alone won't cut it
+      self.save if use_queue?
+    end
+
+    def callback_url
+      url = try(:update_voltron_notification_url, host: Voltron.config.base_url).to_s
+      # Don't allow local or blank urls
+      return nil if url.include?('localhost') || url.include?('127.0.0.1') || url.blank?
+      url
+    end
+
     def valid_phone_number
       errors.add :to, I18n.t('voltron.notification.sms.invalid_phone', number: to) unless valid_phone?
     end
@@ -119,7 +147,7 @@ class Voltron::Notification::SmsNotification < ActiveRecord::Base
     end
 
     def to_formatted
-      format to
+      format to || notification.notifyable.try(:phone)
     end
 
     def from_formatted

data/app/views/voltron/notification_mailer/notify.text.erb

@@ -0,0 +1 @@
+<%= @body %>

data/lib/generators/voltron/notify/install_generator.rb

@@ -14,7 +14,7 @@ module Voltron
           voltron_initialzer_path = Rails.root.join('config', 'initializers', 'voltron.rb')
 
           unless File.exist? voltron_initialzer_path
-            unless system("cd #{Rails.root.to_s} && rails generate voltron:install")
+            unless system("cd #{Rails.root} && rails generate voltron:install")
               puts 'Voltron initializer does not exist. Please ensure you have the \'voltron\' gem installed and run `rails g voltron:install` to create it'
               return false
             end
@@ -32,9 +32,6 @@ module Voltron
   # A queue is still only used if configured via config.active_job.queue_adapter
   # config.notify.use_queue = false
 
-  # How long to delay sending email/sms messages. Use this in conjunction with config.notify.use_queue
-  # config.notify.delay = 0.seconds
-
   # Twilio account id number
   # config.notify.sms_account_sid = ''
 
@@ -74,13 +71,14 @@ CONTENT
 
         def copy_views
           copy_file '../../../app/views/voltron/notification_mailer/notify.html.erb', Rails.root.join('app', 'views', 'voltron', 'notification_mailer', 'notify.html.erb')
+          copy_file '../../../app/views/voltron/notification_mailer/notify.text.erb', Rails.root.join('app', 'views', 'voltron', 'notification_mailer', 'notify.text.erb')
         end
 
         def copy_locales
           locale_path = Rails.root.join('config', 'locales', 'voltron.yml')
           locale = YAML.load_file(locale_path).symbolize_keys rescue {}
 
-          compact_nested = Proc.new do |k, v|
+          compact_nested = Proc.new do |_, v|
             v.respond_to?(:delete_if) ? (v.delete_if(&compact_nested); nil) : v.blank?
           end
 

data/lib/voltron/config/notify.rb

@@ -7,7 +7,7 @@ module Voltron
 
     class Notify
 
-      attr_accessor :use_queue, :delay
+      attr_accessor :use_queue
 
       # SMS config settings
       attr_accessor :sms_account_sid, :sms_auth_token, :sms_from
@@ -17,7 +17,6 @@ module Voltron
 
       def initialize
         @use_queue ||= false
-        @delay ||= 0.seconds
         @email_from ||= 'no-reply@example.com'
         @default_mailer = Voltron::NotificationMailer
         @default_method = :notify

data/lib/voltron/notify.rb

@@ -8,9 +8,11 @@ module Voltron
 
     LOG_COLOR = :light_yellow
 
-    def notifyable
+    def notifyable(defaults={})
       include InstanceMethods
 
+      @_notification_defaults = defaults.with_indifferent_access
+
       before_validation :validate_notifications
 
       after_validation :clean_notification_validation

data/lib/voltron/notify/version.rb

@@ -1,5 +1,5 @@
 module Voltron
   module Notify
-    VERSION = '0.1.9'.freeze
+    VERSION = '0.2.0'.freeze
   end
 end

data/voltron-notify.gemspec

@@ -21,15 +21,16 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'rails', '>= 4.2'
   spec.add_dependency 'twilio-ruby', '~> 4.11'
   spec.add_dependency 'rack', '>= 1.6'
-  spec.add_dependency 'voltron', '>= 0.2.1'
+  spec.add_dependency 'voltron', '~> 0.2', '>= 0.2.1'
 
-  spec.add_development_dependency 'simplecov', '0.11.0'
-  spec.add_development_dependency 'bundler', '>= 1.12'
-  spec.add_development_dependency 'rake', '>= 10.0'
-  spec.add_development_dependency 'rspec', '>= 3.0'
-  spec.add_development_dependency 'rspec-rails', '>= 3.4'
-  spec.add_development_dependency 'sqlite3', '>= 1.2'
-  spec.add_development_dependency 'factory_girl_rails', '>= 4.7'
-  spec.add_development_dependency 'letter_opener', '>= 1.0.0'
+  spec.add_development_dependency 'simplecov', '~> 0.11'
+  spec.add_development_dependency 'codeclimate-test-reporter', '~> 1.0'
+  spec.add_development_dependency 'bundler', '~> 1.12'
+  spec.add_development_dependency 'rake', '~> 11.3'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'rspec-rails', '~> 3.4'
+  spec.add_development_dependency 'sqlite3', '~> 1.2'
+  spec.add_development_dependency 'factory_girl_rails', '~> 4.7'
+  spec.add_development_dependency 'letter_opener', '~> 1.4'
   spec.add_development_dependency 'sidekiq', '~> 4.2.10'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: voltron-notify
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.2.0
 platform: ruby
 authors:
 - Eric Hainer
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-04-08 00:00:00.000000000 Z
+date: 2017-04-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -56,6 +56,9 @@ dependencies:
   name: voltron
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.2.1
@@ -63,6 +66,9 @@ dependencies:
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.2.1
@@ -70,114 +76,128 @@ dependencies:
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.11.0
+        version: '0.11'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.11.0
+        version: '0.11'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.12'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.12'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '11.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '11.3'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rspec-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '3.4'
 - !ruby/object:Gem::Dependency
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '1.2'
 - !ruby/object:Gem::Dependency
   name: factory_girl_rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '4.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: '4.7'
 - !ruby/object:Gem::Dependency
   name: letter_opener
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0
+        version: '1.4'
 - !ruby/object:Gem::Dependency
   name: sidekiq
   requirement: !ruby/object:Gem::Requirement
@@ -215,6 +235,7 @@ files:
 - app/models/voltron/notification/sms_notification.rb
 - app/models/voltron/notification/sms_notification/attachment.rb
 - app/views/voltron/notification_mailer/notify.html.erb
+- app/views/voltron/notification_mailer/notify.text.erb
 - bin/console
 - bin/setup
 - lib/generators/templates/config/locales/voltron-notification.yml