nuntius 1.0.27 → 1.1.4

data/app/message_boxes/nuntius/base_message_box.rb

@@ -1,8 +1,26 @@
 # frozen_string_literal: true
 
+# Base class for MessageBoxes
+# These allow you to receive messages based on transport/provider and routes
 module Nuntius
   # Message boxes process inbound messages
   class BaseMessageBox
+    attr_reader :message
+
+    def initialize(message)
+      @message = message
+    end
+
+    # In case of mail transport mail will return the mail itself, using https://github.com/mikel/mail
+    # For other transports  it will return nil.
+    # @return [Mail::Message]
+    def mail
+      return nil unless self.class.transport.to_sym == :mail
+      return @mail if @mail
+
+      @mail = Mail.new(message.raw_message.download)
+    end
+
     class << self
       attr_reader :routes
 
@@ -16,23 +34,26 @@ module Nuntius
         @transport
       end
 
-      def route(mapping = nil)
+      def route(attribute = :to, test = /.*/, to:)
         @routes ||= {}
-        @routes = @routes.merge(mapping) if mapping.is_a?(Hash)
+        @routes[attribute] = {test: test, to: to}
         @routes
       end
 
       # Defines the settings
-      def settings(hash = {})
+      def settings(hash = nil)
         @settings = hash if hash
         @settings
       end
 
       def deliver(message)
         klasses = message_box_for(transport: message.transport.to_sym, provider: message.provider.to_sym)
-        klass, method = message_box_for_route(klasses, message.to)
+        klass, method = message_box_for_route(klasses, message)
 
-        klass.new(message).send(method) if method
+        if method
+          klass.new(message).send(method)
+          true
+        end
       end
 
       def message_box_for(transport: nil, provider: nil)
@@ -42,34 +63,36 @@ module Nuntius
         result
       end
 
-      def mail
-        return nil if transport != 'mail' && provider != 'imap'
-        return @mail if @mail
-
-        @mail = Mail.read(inbound_message.raw_message.download)
-      end
-
       private
 
       def descendants
         ObjectSpace.each_object(Class).select { |k| k < self }
       end
 
-      def message_box_for_route(message_boxes, recipients)
+      def message_box_for_route(message_boxes, message)
         klass = message_boxes.find do |message_box|
-          routes = (message_box.routes || {})
-          routes.any? { |regexp, _method| [*recipients].any? { |recipient| regexp.match(recipient) } }
+          routes = message_box.routes || {}
+          routes.any? do |attribute, hash|
+            value = message.send(attribute)
+            if value.is_a? Array
+              value.any? { |value_item| hash[:test].match(value_item) }
+            else
+              hash[:test].match(value)
+            end
+          end
         end
-        method = klass.routes.find { |regexp, _method| [*recipients].any? { |recipient| regexp.match(recipient) } }&.last if klass
-
-        [klass, method] if method
-      end
-    end
 
-    attr_reader :message
+        route = klass&.routes&.find do |attribute, hash|
+          value = message.send(attribute)
+          if value.is_a? Array
+            value.any? { |value_item| hash[:test].match(value_item) }
+          else
+            hash[:test].match(value)
+          end
+        end
 
-    def initialize(message)
-      @message = message
+        [klass, route.last[:to]] if route
+      end
     end
   end
 end

data/app/messengers/nuntius/base_messenger.rb

@@ -61,20 +61,21 @@ module Nuntius
         return obj.keys.first.to_s if obj.is_a?(Hash)
 
         plural = obj.is_a?(Array) || obj.is_a?(ActiveRecord::Relation)
-        list   = plural ? obj : [obj]
-        klass  = list.first.class
-        klass  = klass.base_class if klass.respond_to?(:base_class)
-        name   = klass.name.demodulize
-        name   = name.pluralize if plural
+        list = plural ? obj : [obj]
+        klass = list.first.class
+        klass = klass.base_class if klass.respond_to?(:base_class)
+        name = klass.name.demodulize
+        name = name.pluralize if plural
         name.underscore
       end
 
       def class_name_for(obj)
-        if obj.is_a?(Array) || obj.is_a?(ActiveRecord::Relation)
+        case obj
+        when Array, ActiveRecord::Relation
           obj.first.class.name.demodulize
-        elsif obj.is_a?(Hash)
-          'Custom'
-        elsif obj.is_a?(Class)
+        when Hash
+          "Custom"
+        when Class
           obj.name.demodulize
         else
           obj.class.name
@@ -143,7 +144,7 @@ module Nuntius
       end
 
       def timebased_scope(name, &scope_proc)
-        raise ArgumentError, 'timebased_scope must start with before or after' unless %w[before after].detect { |prefix| name.to_s.start_with?(prefix) }
+        raise ArgumentError, "timebased_scope must start with before or after" unless %w[before after].detect { |prefix| name.to_s.start_with?(prefix) }
 
         name = name.to_sym
         timebased_scopes[name] = scope_proc if scope_proc.present?
@@ -183,10 +184,10 @@ module Nuntius
     def liquid_context
       assigns = @params || {}
       instance_variables.reject { |i| %w[@params @object @locale @templates @template_scope].include? i.to_s }.each do |i|
-        assigns[i.to_s[1..-1]] = instance_variable_get(i)
+        assigns[i.to_s[1..]] = instance_variable_get(i)
       end
 
-      context = { liquid_variable_name_for(@object) => (@object.is_a?(Hash) ? @object[@object.keys.first].deep_stringify_keys : @object) }
+      context = {liquid_variable_name_for(@object) => (@object.is_a?(Hash) ? @object[@object.keys.first].deep_stringify_keys : @object)}
       assigns.merge(context)
     end
   end

data/app/models/nuntius/application_record.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative 'concerns/metadata_scoped'
+require_relative "concerns/metadata_scoped"
 
 module Nuntius
   class ApplicationRecord < ActiveRecord::Base

data/app/models/nuntius/attachment.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 module Nuntius
   class Attachment < ApplicationRecord
-    has_and_belongs_to_many :messages, class_name: 'Message'
+    has_and_belongs_to_many :messages, class_name: "Message"
 
     delegate :download, :content_type, :filename, :signed_id, to: :content
 
     begin
       has_one_attached :content, service: Nuntius.config.active_storage_service
-    rescue StandardError
+    rescue
       nil
     end
   end

data/app/models/nuntius/campaign.rb

@@ -8,68 +8,21 @@ module Nuntius
     accepts_nested_attributes_for :list, reject_if: :all_blank
 
     belongs_to :layout, optional: true
-    has_many :messages, class_name: 'Nuntius::Message'
+    has_many :messages, class_name: "Nuntius::Message"
     validates :name, presence: true
 
     state_machine initial: :draft do
-      after_transition any => any, do: :do_after_transition
-
       event :publish do
         transition draft: :sending
       end
+
       event :sent do
         transition sending: :sent
       end
-    end
-
-    def deliver
-      t = BaseTransport.class_from_name(transport).new
-      list.subscribers.each do |subscriber|
-        t.deliver(new_message(subscriber))
-      end
-    end
-
-    def new_message(subscriber, assigns = {})
-      if subscriber.nuntiable
-        name = Nuntius::BaseMessenger.liquid_variable_name_for(subscriber.nuntiable)
-        assigns[name] = subscriber.nuntiable
-      end
-      message = Nuntius::Message.new(transport: transport, campaign: self, nuntiable: subscriber.nuntiable, metadata: metadata)
-
-      locale_proc = Nuntius::BaseMessenger.messenger_for_obj(subscriber.nuntiable).locale
-      locale = instance_exec(object, &locale_proc) if locale_proc
 
-      message.from = render(:from, assigns, locale)
-      message.to = if transport == 'mail'
-                     %["#{subscriber.first_name} #{subscriber.last_name}" <#{subscriber.email}>]
-                   elsif transport == 'sms'
-                     subscriber.phone_number
-                   elsif transport == 'voice'
-                     subscriber.phone_number
-                   end
-
-      message.subject = render(:subject, assigns, locale)
-      message.html = render(:html, assigns, locale, layout: layout&.data)
-
-      message
-    end
-
-    def translation_scope
-      scope = %w[nuntius]
-      scope << layout.name.underscore.tr(' ', '_') if layout
-      scope.join('.')
-    end
-
-    private
-
-    def render(attr, assigns, locale, options = {})
-      I18n.with_locale(locale) do
-        ::Liquidum.render(send(attr), assigns: assigns.merge(options.merge('campaign' => self)), registers: { 'campaign' => self })
+      after_transition(on: :publish) do |campaign, transition|
+        DeliverCampaignService.perform(campaign: campaign)
       end
     end
-
-    def do_after_transition(transition)
-      deliver if transition.event == :publish
-    end
   end
 end

data/app/models/nuntius/concerns/yamlify.rb

@@ -8,11 +8,11 @@ module Nuntius
       class_methods do
         def yamlify(attr)
           define_method(:"#{attr}_yaml=") do |yaml|
-            write_attribute attr, YAML.safe_load(yaml.gsub("\t", '  '))
+            write_attribute attr, YAML.safe_load(yaml.gsub("\t", "  "))
           end
 
           define_method(:"#{attr}_yaml") do
-            return '' if attributes[attr.to_s].blank?
+            return "" if attributes[attr.to_s].blank?
 
             YAML.dump(attributes[attr.to_s])
           end

data/app/models/nuntius/inbound_message.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Nuntius
   class InboundMessage < ApplicationRecord
     has_one_attached :raw_message, service: Nuntius.config.active_storage_service

data/app/models/nuntius/list.rb

@@ -3,8 +3,18 @@
 module Nuntius
   class List < ApplicationRecord
     include Nuntius::Concerns::MetadataScoped
+    include Nuntius::Concerns::Yamlify
+
+    has_many :subscribers, counter_cache: :subscribers_count, dependent: :delete_all
+
+    validates :name, presence: true
+    validates :slug, presence: true, uniqueness: true
+
+    yamlify :metadata
 
-    has_many :subscribers, counter_cache: :subscribers_count
     accepts_nested_attributes_for :subscribers, reject_if: :all_blank
+
+    scope :subscribed_by, ->(nuntiable) { where(id: nuntiable.nuntius_subscriptions.select(:list_id)) }
+    scope :not_subscribed_by, ->(nuntiable) { where.not(id: nuntiable.nuntius_subscriptions.select(:list_id)) }
   end
 end

data/app/models/nuntius/message.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "pry"
 module Nuntius
   # Stores individual messages to individual recipients
   #
@@ -13,12 +14,12 @@ module Nuntius
   class Message < ApplicationRecord
     include Nuntius::Concerns::MetadataScoped
 
-    has_and_belongs_to_many :attachments, class_name: 'Attachment'
+    has_and_belongs_to_many :attachments, class_name: "Attachment"
 
     belongs_to :campaign, optional: true
     belongs_to :template, optional: true
-    belongs_to :parent_message, class_name: 'Message', optional: true
-    has_many :child_messages, class_name: 'Message', foreign_key: 'parent_message_id', dependent: :destroy
+    belongs_to :parent_message, class_name: "Message", optional: true
+    has_many :child_messages, class_name: "Message", foreign_key: "parent_message_id", dependent: :destroy
     belongs_to :nuntiable, polymorphic: true, optional: true
 
     validates :transport, presence: true
@@ -32,19 +33,19 @@ module Nuntius
     # end
 
     def pending?
-      status == 'pending'
+      status == "pending"
     end
 
     def sent?
-      status == 'sent'
+      status == "sent"
     end
 
     def blocked?
-      status == 'blocked'
+      status == "blocked"
     end
 
     def delivered?
-      status == 'delivered'
+      status == "delivered"
     end
 
     def delivered_or_blocked?
@@ -52,12 +53,12 @@ module Nuntius
     end
 
     def undelivered?
-      status == 'undelivered'
+      status == "undelivered"
     end
 
     # Removes only pending child messages
     def cleanup!
-      Nuntius::Message.where(status: 'pending').where(parent_message: self).destroy_all
+      Nuntius::Message.where(status: "pending").where(parent_message: self).destroy_all
     end
 
     def add_attachment(options)
@@ -65,35 +66,39 @@ module Nuntius
 
       uri = options[:url] && URI.parse(options[:url])
 
-      if uri&.scheme == 'file'
+      if uri&.scheme == "file"
+        # FIXME: This is a possible security problem
         attachment[:io] = File.open(uri.path)
       elsif uri
-        client = HTTPClient.new
-        client.ssl_config.verify_mode = OpenSSL::SSL::VERIFY_NONE
-        client.ssl_config.set_default_paths unless Gem.win_platform?
-        response = client.get(options[:url], follow_redirect: true)
-        content_disposition = response.headers['Content-Disposition'] || ''
+        client = Faraday.new(ssl: {verify: false}) do |builder|
+          builder.response :follow_redirects
+          builder.adapter Faraday.default_adapter
+        end
+
+        response = client.get(options[:url])
+        content_disposition = response.headers["Content-Disposition"] || ""
+
         options[:filename] ||= content_disposition[/filename="([^"]+)"/, 1]
-        attachment[:content_type] = response.content_type
+        attachment[:content_type] = response.headers["Content-Type"]
         attachment[:io] = if response.body.is_a? String
-                            StringIO.new(response.body)
-                          else
-                            # Assume IO object
-                            response.body
-                          end
+          StringIO.new(response.body)
+        else
+          # Assume IO object
+          response.body
+        end
       elsif options[:content].respond_to?(:read)
         attachment[:content_type] = options[:content_type]
         attachment[:io] = options[:content]
       else
-        raise 'Cannot add attachment without url or content'
+        raise "Cannot add attachment without url or content"
       end
 
       # Set the filename
-      attachment[:filename] = options[:filename] || uri.path.split('/').last || 'attachment'
+      attachment[:filename] = options[:filename] || uri.path.split("/").last || "attachment"
 
       # (Try to) add file extension if it is missing
-      file_extension = File.extname(attachment[:filename]).delete('.')
-      attachment[:filename] += ".#{Mime::Type.lookup(attachment[:content_type].split(';').first).to_sym}" if file_extension.blank? && attachment[:content_type]
+      file_extension = File.extname(attachment[:filename]).delete(".")
+      attachment[:filename] += ".#{Mime::Type.lookup(attachment[:content_type].split(";").first).to_sym}" if file_extension.blank? && attachment[:content_type]
 
       # Fix content type if file extension known but content type blank
       attachment[:content_type] ||= Mime::Type.lookup_by_extension(file_extension)&.to_s if file_extension
@@ -103,17 +108,17 @@ module Nuntius
           zio.put_next_entry attachment[:file_name]
           zio.write attachment[:io].read
         end
-        attachment[:content_type] = 'application/zip'
+        attachment[:content_type] = "application/zip"
         attachment[:io] = zip_stream
       end
 
       nuntius_attachment = Nuntius::Attachment.new
       nuntius_attachment.content.attach(io: attachment[:io],
-                                        filename: attachment[:filename],
-                                        content_type: attachment[:content_type])
+        filename: attachment[:filename],
+        content_type: attachment[:content_type])
 
       attachments.push(nuntius_attachment)
-    rescue StandardError => e
+    rescue => e
       Nuntius.config.logger.error "Message: Could not attach #{attachment[:filename]} #{e.message}"
     end
 

data/app/models/nuntius/subscriber.rb

@@ -5,8 +5,28 @@ module Nuntius
     belongs_to :list
     belongs_to :nuntiable, polymorphic: true, optional: true
 
+    scope :subscribed, -> { where(unsubscribed_at: nil) }
+
     def name
-      [first_name, last_name].join(' ')
+      [first_name, last_name].compact.join(" ").presence || email
+    end
+
+    def first_name
+      return nuntiable.first_name if nuntiable.respond_to?(:first_name)
+
+      super
+    end
+
+    def last_name
+      return nuntiable.last_name if nuntiable.respond_to?(:last_name)
+
+      super
+    end
+
+    def email
+      return nuntiable.email if nuntiable.respond_to?(:email)
+
+      super
     end
   end
 end

data/app/models/nuntius/template.rb

@@ -6,9 +6,9 @@ module Nuntius
     include Nuntius::Concerns::Yamlify
 
     belongs_to :layout, optional: true
-    has_many :messages, class_name: 'Nuntius::Message', dependent: :nullify
+    has_many :messages, class_name: "Nuntius::Message", dependent: :nullify
 
-    LIQUID_TAGS = /{%(?:(?!%}).)*%}|{{(?:(?!}}).)*}}/.freeze
+    LIQUID_TAGS = /{%(?:(?!%}).)*%}|{{(?:(?!}}).)*}}/
 
     validates :description, presence: true
     validates :from, liquid: true
@@ -18,8 +18,8 @@ module Nuntius
     validates :text, liquid: true
 
     validates :event, presence: true
-    validates :event, format: { with: /.+#.+/ }, if: ->(t) { t.klass == 'Custom' }
-    validates :interval, format: { allow_blank: true, with: /\A[1-9][0-9]*\s(month|week|day|hour|minute)s?\z/ }
+    validates :event, format: {with: /.+#.+/}, if: ->(t) { t.klass == "Custom" }
+    validates :interval, format: {allow_blank: true, with: /\A[1-9][0-9]*\s(month|week|day|hour|minute)s?\z/}
 
     yamlify :metadata
 
@@ -31,10 +31,10 @@ module Nuntius
       locale = instance_exec(object, &locale_proc) if locale_proc
       locale = params[:locale].to_sym if params[:locale]
 
-      options = { registers: { 'template' => self, 'message' => message } }
+      options = {registers: {"template" => self, "message" => message}}
 
-      message.to = render(:to, assigns, locale, options).split(',').reject(&:empty?).join(',')
-      message.from = render(:from, assigns, locale, options).split(',').reject(&:empty?).join(',')
+      message.to = render(:to, assigns, locale, options).split(",").reject(&:empty?).join(",")
+      message.from = render(:from, assigns, locale, options).split(",").reject(&:empty?).join(",")
       message.subject = render(:subject, assigns, locale, options)
       message.html = render(:html, assigns, locale, options.merge(layout: layout&.data))
       message.text = render(:text, assigns, locale, options)
@@ -45,12 +45,12 @@ module Nuntius
 
     def translation_scope
       scope = %w[]
-      scope << layout.name.underscore.tr(' ', '_') if layout
-      scope << klass.underscore.tr('/', '_')
+      scope << layout.name.underscore.tr(" ", "_") if layout
+      scope << klass.underscore.tr("/", "_")
       scope << event
       scope << transport
-      scope << description.underscore.gsub(/[^a-z]+/, '_') if description
-      scope.join('.')
+      scope << description.underscore.gsub(/[^a-z]+/, "_") if description
+      scope.join(".")
     end
 
     # Trix correctly escapes the HTML, but for liquid this is not what we need.
@@ -64,7 +64,7 @@ module Nuntius
 
     def interval_duration
       unless interval.blank?
-        number, type = interval.split(' ')
+        number, type = interval.split(" ")
         number = number.to_i
 
         return number.public_send(type) if number.respond_to?(type)
@@ -76,11 +76,11 @@ module Nuntius
     def interval_time_range
       return 0.seconds..0.seconds if interval.blank?
 
-      start = if event.start_with?('before')
-                interval_duration.after
-              else
-                interval_duration.ago
-              end
+      start = if event.start_with?("before")
+        interval_duration.after
+      else
+        interval_duration.ago
+      end
 
       (start - 1.hour)..start
     end
@@ -90,11 +90,11 @@ module Nuntius
     def render(attr, assigns, locale, options = {})
       I18n.with_locale(locale) do
         if attr == :payload
-          YAML.safe_load(::Liquidum.render(send(attr), { assigns: assigns.merge('template' => self), registers: { 'template' => self } }.merge(options)))
+          YAML.safe_load(::Liquidum.render(send(attr), {assigns: assigns.merge("template" => self), registers: {"template" => self}}.merge(options)))
         elsif attr == :html
-          ::Liquidum.render(send(attr), { filter: 'markdown', assigns: assigns.merge('template' => self), registers: { 'template' => self } }.merge(options))
+          ::Liquidum.render(send(attr), {filter: "markdown", assigns: assigns.merge("template" => self), registers: {"template" => self}}.merge(options))
         else
-          ::Liquidum.render(send(attr), { assigns: assigns.merge('template' => self), registers: { 'template' => self } }.merge(options))
+          ::Liquidum.render(send(attr), {assigns: assigns.merge("template" => self), registers: {"template" => self}}.merge(options))
         end
       end
     end

data/app/presenters/application_presenter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'delegate'
+require "delegate"
 
 # http://nithinbekal.com/posts/rails-presenters/
 class ApplicationPresenter < SimpleDelegator

data/app/presenters/template_presenter.rb

@@ -4,12 +4,12 @@ class TemplatePresenter < ApplicationPresenter
   def all_events
     events = []
     Nuntius.config.nuntiable_class_names.each do |class_name|
-      next if class_name == 'Custom'
+      next if class_name == "Custom"
 
       messenger = Nuntius::BaseMessenger.messenger_for_class(class_name)
       messenger.instance_methods(false).each do |m|
-        events << [m, m, { 'data-chain': class_name,
-                           'data-timebased': messenger.timebased_scopes.include?(m) }]
+        events << [m, m, {"data-chain": class_name,
+                          "data-timebased": messenger.timebased_scopes.include?(m)}]
       end
     end
     events.sort_by(&:first)

data/app/providers/nuntius/apnotic_push_provider.rb

@@ -1,31 +1,31 @@
 # frozen_string_literal: true
 
-require 'apnotic'
+require "apnotic"
 
 module Nuntius
   class ApnoticPushProvider < BaseProvider
     transport :push
 
     setting_reader :certificate,
-                   required: true,
-                   description: 'The contents of a valid APNS push certificate in .pem format'
+      required: true,
+      description: "The contents of a valid APNS push certificate in .pem format"
     setting_reader :passphrase,
-                   required: false,
-                   description: 'If the APNS certificate is protected by a passphrase, ' \
-                                'provide this variable to use when decrypting it.'
+      required: false,
+      description: "If the APNS certificate is protected by a passphrase, " \
+                   "provide this variable to use when decrypting it."
     setting_reader :environment,
-                   required: false,
-                   default: :production,
-                   description: 'Development or production, defaults to production'
+      required: false,
+      default: :production,
+      description: "Development or production, defaults to production"
 
     def deliver
       return message if message.to.size != 64
 
       connection = if environment.to_sym == :development
-                     Apnotic::Connection.development(cert_path: StringIO.new(certificate), cert_pass: passphrase)
-                   else
-                     Apnotic::Connection.new(cert_path: StringIO.new(certificate), cert_pass: passphrase)
-                   end
+        Apnotic::Connection.development(cert_path: StringIO.new(certificate), cert_pass: passphrase)
+      else
+        Apnotic::Connection.new(cert_path: StringIO.new(certificate), cert_pass: passphrase)
+      end
 
       notification = Apnotic::Notification.new(message.to)
       notification.alert = message.text
@@ -34,10 +34,10 @@ module Nuntius
       response = connection.push(notification)
 
       message.status = if response.ok?
-                         'sent'
-                       else
-                         'undelivered'
-                       end
+        "sent"
+      else
+        "undelivered"
+      end
       message
     end
   end