pushing 0.1.0

data/lib/pushing/adapters/apn/houston_adapter.rb

@@ -0,0 +1,33 @@
+require 'houston'
+
+module Pushing
+  module Adapters
+    class HoustonAdapter
+      attr_reader :certificate_path, :environment, :client
+
+      def initialize(apn_settings)
+        @certificate_path = apn_settings.certificate_path
+        @environment      = apn_settings.environment
+
+        @client = {
+          production: Houston::Client.production,
+          development: Houston::Client.development
+        }
+        @client[:production].certificate = @client[:development].certificate = File.read(certificate_path)
+      end
+
+      def push!(notification)
+        payload      = notification.payload
+        aps          = payload.delete(:aps)
+        aps[:device] = notification.device_token
+
+        houston_notification = Houston::Notification.new(payload.merge(aps))
+        client[notification.environment || environment].push(houston_notification)
+      rescue => cause
+        error = Pushing::ApnDeliveryError.new("Error while trying to send push notification: #{cause.message}", nil, notification)
+
+        raise error, error.message, cause.backtrace
+      end
+    end
+  end
+end

data/lib/pushing/adapters/apn/lowdown_adapter.rb

@@ -0,0 +1,70 @@
+# frozen-string-literal: true
+
+require 'json'
+
+module Pushing
+  module Adapters
+    class LowdownAdapter
+      attr_reader :environment, :topic, :clients
+
+      def initialize(apn_settings)
+        @environment = apn_settings.environment.to_sym
+        @topic       = apn_settings.topic
+
+        # Don't load lowdown earlier as it may load Celluloid (and start it)
+        # before daemonizing the workers spun up by a gem (e,g, delayed_job).
+        require 'lowdown' unless defined?(Lodwown)
+
+        cert = File.read(apn_settings.certificate_path)
+        @clients = {
+          development: Lowdown::Client.production(false, certificate: cert, keep_alive: true),
+          production: Lowdown::Client.production(true, certificate: cert, keep_alive: true)
+        }
+      end
+
+      def push!(notification)
+        if notification.headers[:'apns-id']
+          warn("The lowdown gem does not allow for overriding `apns_id'.")
+        end
+
+        if notification.headers[:'apns-collapse-id']
+          warn("The lowdown gem does not allow for overriding `apns-collapse-id'.")
+        end
+
+        lowdown_notification = Lowdown::Notification.new(token: notification.device_token)
+        lowdown_notification.payload = notification.payload
+
+        lowdown_notification.expiration = notification.headers[:'apns-expiration'].to_i if notification.headers[:'apns-expiration']
+        lowdown_notification.priority   = notification.headers[:'apns-priority']
+        lowdown_notification.topic      = notification.headers[:'apns-topic'] || topic
+
+        response = nil
+        clients[notification.environment || environment].group do |group|
+          group.send_notification(lowdown_notification) do |_response|
+            response = _response
+          end
+        end
+
+        raise response.raw_body if !response.success?
+        ApnResponse.new(response)
+      rescue => cause
+        response = response ? ApnResponse.new(response) : nil
+        error    = Pushing::ApnDeliveryError.new("Error while trying to send push notification: #{cause.message}", response, notification)
+
+        raise error, error.message, cause.backtrace
+      end
+
+      class ApnResponse < SimpleDelegator
+        def code
+          __getobj__.status
+        end
+
+        def json
+          @json ||= JSON.parse(__getobj__.raw_body, symbolize_names: true) if __getobj__.raw_body
+        end
+      end
+
+      private_constant :ApnResponse
+    end
+  end
+end

data/lib/pushing/adapters/fcm/andpush_adapter.rb

@@ -0,0 +1,47 @@
+# frozen-string-literal: true
+
+require 'andpush'
+require 'active_support/core_ext/hash/transform_values'
+
+module Pushing
+  module Adapters
+    class AndpushAdapter
+      attr_reader :server_key
+
+      def initialize(fcm_settings)
+        @server_key = fcm_settings.server_key
+      end
+
+      def push!(notification)
+        FcmResponse.new(client.push(notification.payload))
+      rescue => e
+        response = e.respond_to?(:response) ? FcmResponse.new(e.response) : nil
+        error    = Pushing::FcmDeliveryError.new("Error while trying to send push notification: #{e.message}", response, notification)
+
+        raise error, error.message, e.backtrace
+      end
+
+      private
+
+      def client
+        @client ||= Andpush.build(server_key)
+      end
+
+      class FcmResponse < SimpleDelegator
+        def json
+          @json ||= __getobj__.json
+        end
+
+        def code
+          __getobj__.code.to_i
+        end
+
+        def headers
+          __getobj__.headers.transform_values {|value| value.join(", ") }
+        end
+      end
+
+      private_constant :FcmResponse
+    end
+  end
+end

data/lib/pushing/adapters/fcm/fcm_gem_adapter.rb

@@ -0,0 +1,52 @@
+# frozen-string-literal: true
+
+require 'json'
+require 'fcm'
+require 'active_support/core_ext/hash/slice'
+
+module Pushing
+  module Adapters
+    class FcmGemAdapter
+      SUCCESS_CODES = (200..299).freeze
+
+      attr_reader :server_key
+
+      def initialize(fcm_settings)
+        @server_key = fcm_settings.server_key
+      end
+
+      def push!(notification)
+        json     = notification.payload
+        ids      = json.delete(:registration_ids) || Array(json.delete(:to))
+        response = FCM.new(server_key).send(ids, json)
+
+        if SUCCESS_CODES.include?(response[:status_code])
+          FcmResponse.new(response.slice(:body, :headers, :status_code).merge(raw_response: response))
+        else
+          raise "#{response[:response]} (response body: #{response[:body]})"
+        end
+      rescue => cause
+        resopnse = FcmResponse.new(response.slice(:body, :headers, :status_code).merge(raw_response: response)) if response
+        error    = Pushing::FcmDeliveryError.new("Error while trying to send push notification: #{cause.message}", resopnse, notification)
+
+        raise error, error.message, cause.backtrace
+      end
+
+      class FcmResponse
+        attr_reader :body, :headers, :status_code, :raw_response
+
+        alias code status_code
+
+        def initialize(body: , headers: , status_code: , raw_response: )
+          @body, @headers, @status_code, @raw_response = body, headers, status_code, raw_response
+        end
+
+        def json
+          @json ||= JSON.parse(body, symbolize_names: true) if body.is_a?(String)
+        end
+      end
+
+      private_constant :FcmResponse
+    end
+  end
+end

data/lib/pushing/adapters/test_adapter.rb

@@ -0,0 +1,37 @@
+require 'active_support/core_ext/module/attribute_accessors'
+
+module Pushing
+  module Adapters
+    class TestAdapter
+      class Deliveries
+        include Enumerable
+
+        def initialize
+          @deliveries = []
+        end
+
+        delegate :each, :empty?, :clear, :<<, :length, :size, to: :@deliveries
+
+        def apn
+          select {|delivery| delivery.is_a?(Platforms::ApnPayload) }
+        end
+
+        def fcm
+          select {|delivery| delivery.is_a?(Platforms::FcmPayload) }
+        end
+      end
+
+      private_constant :Deliveries
+      cattr_accessor :deliveries
+      self.deliveries = Deliveries.new
+
+      def initialize(*)
+      end
+
+      def push!(notification)
+        self.class.deliveries << notification if notification
+        notification
+      end
+    end
+  end
+end

data/lib/pushing/base.rb

@@ -0,0 +1,187 @@
+# frozen-string-literal: true
+
+require "abstract_controller"
+require 'active_support/core_ext/module/attribute_accessors'
+require 'active_support/core_ext/object/blank'
+
+require 'pushing/log_subscriber'
+require 'pushing/rescuable'
+require 'pushing/platforms'
+require 'pushing/template_handlers'
+
+module Pushing
+  class Base < AbstractController::Base
+    include Rescuable
+
+    abstract!
+
+    include AbstractController::Rendering
+    include AbstractController::Logger
+    include AbstractController::Helpers
+    include AbstractController::Translation
+    include AbstractController::AssetPaths
+    include AbstractController::Callbacks
+    begin
+      include AbstractController::Caching
+    rescue NameError
+      # AbstractController::Caching does not exist in rails 4.2. No-op.
+    end
+
+    include ActionView::Rendering
+
+    PROTECTED_IVARS = AbstractController::Rendering::DEFAULT_PROTECTED_INSTANCE_VARIABLES + [:@_action_has_layout]
+
+    def _protected_ivars # :nodoc:
+      PROTECTED_IVARS
+    end
+
+    cattr_accessor :deliver_later_queue_name
+    self.deliver_later_queue_name = :notifiers
+
+    cattr_reader :delivery_notification_observers
+    @@delivery_notification_observers = []
+
+    cattr_reader :delivery_interceptors
+    @@delivery_interceptors = []
+
+    class << self
+      delegate :deliveries, :deliveries=, to: Pushing::Adapters::TestAdapter
+
+      # Register one or more Observers which will be notified when notification 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 notification is sent.
+      def register_interceptors(*interceptors)
+        interceptors.flatten.compact.each { |interceptor| register_interceptor(interceptor) }
+      end
+
+      # Register an Observer which will be notified when notification 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)
+        unless delivery_notification_observers.include?(observer)
+          delivery_notification_observers << observer
+        end
+      end
+
+      # Register an Interceptor which will be called before notification 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)
+        unless delivery_interceptors.include?(interceptor)
+          delivery_interceptors << interceptor
+        end
+      end
+
+      def inform_observers(notification, response)
+        delivery_notification_observers.each do |observer|
+          observer.delivered_notification(notification, response)
+        end
+      end
+
+      def inform_interceptors(notification)
+        delivery_interceptors.each do |interceptor|
+          interceptor.delivering_notification(notification)
+        end
+      end
+
+      def notifier_name
+        @notifier_name ||= anonymous? ? "anonymous" : name.underscore
+      end
+      # Allows to set the name of current notifier.
+      attr_writer :notifier_name
+      alias :controller_path :notifier_name
+
+      # Wraps a notification delivery inside of <tt>ActiveSupport::Notifications</tt> instrumentation.
+      def deliver_notification(notification) #:nodoc:
+        ActiveSupport::Notifications.instrument("deliver.push_notification") do |payload|
+          set_payload_for_notification(payload, notification)
+          yield # Let NotificationDelivery do the delivery actions
+        end
+      end
+
+      private
+
+      def set_payload_for_notification(payload, notification)
+        payload[:notifier]     = name
+        payload[:notification] = notification.message.to_h
+      end
+
+      def method_missing(method_name, *args)
+        if action_methods.include?(method_name.to_s)
+          NotificationDelivery.new(self, method_name, *args)
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, include_all = false)
+        action_methods.include?(method.to_s) || super
+      end
+    end
+
+    def process(method_name, *args) #:nodoc:
+      payload = {
+        notifier: self.class.name,
+        action: method_name,
+        args: args
+      }
+
+      ActiveSupport::Notifications.instrument("process.push_notification", payload) do
+        super
+        @_notification ||= NullNotification.new
+      end
+    end
+
+    class NullNotification #:nodoc:
+      def respond_to?(string, include_all = false)
+        true
+      end
+
+      def method_missing(*args)
+        nil
+      end
+    end
+
+    attr_internal :notification
+
+    def push(headers)
+      return notification if notification && headers.blank?
+
+      payload = {}
+      headers.each do |platform, options|
+        payload_class = ::Pushing::Platforms.lookup(platform)
+
+        if payload_class.should_render?(options)
+          json = render_json(platform, headers)
+          payload[platform] = payload_class.new(json, options)
+        end
+      end
+
+      # TODO: Do not use OpenStruct
+      @_notification = OpenStruct.new(payload)
+    end
+
+    private
+
+    def render_json(platform, headers)
+      templates_path = headers[:template_path] || self.class.notifier_name
+      templates_name = headers[:template_name] || action_name
+
+      lookup_context.variants = platform
+      template = lookup_context.find(templates_name, Array(templates_path))
+
+      unless template.instance_variable_get(:@compiled)
+        engine  = File.extname(template.identifier).tr!(".", "")
+        handler = ::Pushing::TemplateHandlers.lookup(engine)
+        template.instance_variable_set(:@handler, handler)
+      end
+
+      view_renderer.render_template(view_context, template: template)
+    end
+
+    ActiveSupport.run_load_hooks(:pushing, self)
+  end
+end

data/lib/pushing/delivery_job.rb

@@ -0,0 +1,31 @@
+require 'active_job'
+
+module Pushing
+  class DeliveryJob < ActiveJob::Base # :nodoc:
+    queue_as { Pushing::Base.deliver_later_queue_name }
+
+    if ActiveSupport::VERSION::MAJOR > 4
+      rescue_from StandardError, with: :handle_exception_with_notifier_class
+    end
+
+    def perform(notifier, mail_method, delivery_method, *args) #:nodoc:
+      notifier.constantize.public_send(mail_method, *args).send(delivery_method)
+    end
+
+    private
+
+    def notifier_class
+      if notifier = Array(@serialized_arguments).first || Array(arguments).first
+        notifier.constantize
+      end
+    end
+
+    def handle_exception_with_notifier_class(exception)
+      if klass = notifier_class
+        klass.handle_exception exception
+      else
+        raise exception
+      end
+    end
+  end
+end