noticent 0.0.1.pre.pre

data/lib/generators/noticent/templates/noticent_initializer.rb

@@ -0,0 +1,17 @@
+Noticent.configure do |config|
+  config.base_dir = File.join(Rails.root, 'app', 'models', 'noticent')
+  config.base_module_name = 'Noticent'
+  config.logger = Rails.logger
+  config.halt_on_error = !Rails.env.production?
+
+  # scope :post do
+  #   channel :email
+  #   channel :slack, group: :internal
+  #
+  #   alert :new_user do
+  #     notify :user
+  #     notify(:staff).on(:internal)
+  #   end
+  # end
+
+end

data/lib/generators/noticent/templates/opt_in.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class OptIn < ActiveRecord::Base
+  # scope: is the type of domain object that opt-in applies to. For example
+  # it could be post or comment
+  # entity_id: is the ID of the scope (post id or comment id)
+  # channel_name: is the name of the channel opted into. email or slack are examples
+  # alert_name: is the name of the alert: new_user or comment_posted
+  # user_id: is the name of the user who's opted into this
+
+  self.table_name = :opt_ins
+
+  validates_presence_of :scope, :entity_id, :channel_name, :alert_name, :recipient_id
+end

data/lib/noticent/active_record_opt_in_provider.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Noticent
+  # should be used only for testing
+  class ActiveRecordOptInProvider
+    def opt_in(recipient_id:, scope:, entity_id:, alert_name:, channel_name:)
+      Noticent::OptIn.create!(recipient_id: recipient_id, scope: scope, entity_id: entity_id, alert_name: alert_name, channel_name: channel_name)
+    end
+
+    def opt_out(recipient_id:, scope:, entity_id:, alert_name:, channel_name:)
+      Noticent::OptIn.where(recipient_id: recipient_id, scope: scope, entity_id: entity_id, alert_name: alert_name, channel_name: channel_name).delete
+    end
+
+    def opted_in?(recipient_id:, scope:, entity_id:, alert_name:, channel_name:)
+      Noticent::OptIn.where(recipient_id: recipient_id, scope: scope, entity_id: entity_id, alert_name: alert_name, channel_name: channel_name).count != 0
+    end
+
+    def add_alert(scope:, alert_name:, recipient_ids:, channel:)
+      ActiveRecord::Base.transaction do
+        now = Time.now.utc.to_s(:db)
+        # fetch all permutations of recipient and entity id
+        permutations = Noticent::OptIn.distinct
+                                      .where('recipient_id IN (?)', recipient_ids)
+                                      .pluck(:entity_id, :recipient_id)
+
+        return if permutations.empty?
+
+        values = permutations.map { |e, r| "('#{scope}','#{alert_name}', #{e}, #{r}, '#{channel}', '#{now}', '#{now}')" }.join(',')
+        ActiveRecord::Base.connection.execute("INSERT INTO opt_ins (scope, alert_name, entity_id, recipient_id, channel_name, created_at, updated_at) VALUES #{values}")
+      end
+    end
+
+    def remove_alert(scope:, alert_name:)
+      Noticent::OptIn.where('scope = ? AND alert_name = ?', scope, alert_name).destroy_all
+    end
+  end
+end

data/lib/noticent/channel.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Noticent
+  class Channel
+    @@default_ext = :erb
+    @@default_format = :html
+
+    def initialize(config, recipients, payload, context)
+      @config = config
+      @recipients = recipients
+      @payload = payload
+      @context = context
+      @current_user = payload.current_user if payload.respond_to? :current_user
+    end
+
+    def render_within_context(template, content)
+      rendered_content = ERB.new(content).result(get_binding)
+      template.nil? ? rendered_content : ERB.new(template).result(get_binding { rendered_content })
+    end
+
+    protected
+
+    attr_reader :payload
+    attr_reader :recipients
+    attr_reader :context
+
+    class << self
+      def default_format(format)
+        @@default_format = format
+      end
+
+      def default_ext(ext)
+        @@default_ext = ext
+      end
+    end
+
+    def get_binding
+      binding
+    end
+
+    def current_user
+      raise Noticent::NoCurrentUser if @current_user.nil?
+
+      @current_user
+    end
+
+    def render(format: @@default_format, ext: @@default_ext, layout: '')
+      alert_name = caller[0][/`.*'/][1..-2]
+      channel_name = self.class.name.split('::').last.underscore
+      view_filename, layout_filename = filenames(channel: channel_name, alert: alert_name, format: format, ext: ext, layout: layout)
+
+      raise Noticent::ViewNotFound, "view #{view_filename} not found" unless File.exist?(view_filename)
+
+      view = View.new(view_filename, template_filename: layout_filename, channel: self)
+      view.process
+
+      [view.data, view.content]
+    end
+
+    private
+
+    def view_file(channel:, alert:, format:, ext:)
+      File.join(@config.view_dir, channel, "#{alert}.#{format}.#{ext}")
+    end
+
+    def filenames(channel:, alert:, format:, ext:, layout:)
+      view_filename = view_file(channel: channel, alert: alert, format: format, ext: ext)
+      layout_filename = ''
+      layout_filename = File.join(@config.view_dir, 'layouts', "#{layout}.#{format}.#{ext}") unless layout == ''
+
+      return view_filename, layout_filename
+    end
+
+  end
+end

data/lib/noticent/config.rb

@@ -0,0 +1,209 @@
+# frozen_string_literal: true
+
+module Noticent
+  def self.configure(options = {}, &block)
+    if ENV['NOTICENT_RSPEC'] == '1'
+      options = options.merge(
+        base_module_name: 'Noticent::Testing',
+        base_dir: File.expand_path("#{File.dirname(__FILE__)}/../../testing"),
+        halt_on_error: true
+      )
+    end
+
+    @config = Noticent::Config::Builder.new(options, &block).build
+    @config.validate!
+
+    @config
+  end
+
+  def self.configuration
+    @config || (raise Noticent::MissingConfiguration)
+  end
+
+  def self.notify(alert_name, payload)
+    engine = Noticent::Dispatcher.new(@config, alert_name, payload)
+
+    return if engine.notifiers.nil?
+
+    engine.dispatch
+  end
+
+  class Config
+    attr_reader :hooks
+    attr_reader :channels
+    attr_reader :scopes
+    attr_reader :alerts
+    attr_reader :products
+
+    def initialize(options = {})
+      @options = options
+      @products = {}
+    end
+
+    def channels_by_group(group)
+      return [] if @channels.nil?
+
+      @channels.values.select { |x| x.group == group }
+    end
+
+    def channel_groups
+      return [] if @channels.nil?
+
+      @channels.values.collect(&:group).uniq
+    end
+
+    def alert_channels(alert_name)
+      alert = @alerts[alert_name]
+      raise ArgumentError, "no alert #{alert_name} found" if alert.nil?
+      return [] if alert.notifiers.nil?
+
+      alert.notifiers.values.collect { |notifier| channels_by_group(notifier.channel_group).uniq }.uniq.flatten
+    end
+
+    def products_by_alert(alert_name)
+      alert = @alerts[alert_name]
+      raise ArgumentError "no alert #{alert_name} found" if alert.nil?
+
+      alert.products
+    end
+
+    def alerts_by_scope(scope)
+      return [] if @alerts.nil?
+
+      @alerts.values.select { |x| x.scope.name == scope }
+    end
+
+    def base_dir
+      @options[:base_dir]
+    end
+
+    def base_module_name
+      @options[:base_module_name]
+    end
+
+    def opt_in_provider
+      @options[:opt_in_provider] || Noticent::ActiveRecordOptInProvider.new
+    end
+
+    def logger
+      @options[:logger] || Logger.new(STDOUT)
+    end
+
+    def halt_on_error
+      @options[:halt_on_error].nil? || false
+    end
+
+    def payload_dir
+      File.join(base_dir, 'payloads')
+    end
+
+    def scope_dir
+      File.join(base_dir, 'scopes')
+    end
+
+    def channel_dir
+      File.join(base_dir, 'channels')
+    end
+
+    def view_dir
+      File.join(base_dir, 'views')
+    end
+
+    def validate!
+      # check all scopes
+      scopes&.values&.each(&:validate!)
+      alerts&.values&.each(&:validate!)
+    end
+
+    class Builder
+      def initialize(options = {}, &block)
+        @options = options
+        @config = Noticent::Config.new(options)
+        raise BadConfiguration, 'no OptInProvider configured' if @config.opt_in_provider.nil?
+
+        instance_eval(&block) if block_given?
+
+        @config.instance_variable_set(:@options, @options)
+      end
+
+      def build
+        @config
+      end
+
+      def base_dir=(value)
+        @options[:base_dir] = value
+      end
+
+      def base_module_name=(value)
+        @options[:base_module_name] = value
+      end
+
+      def opt_in_provider=(value)
+        @options[:opt_in_provider] = value
+      end
+
+      def logger=(value)
+        @options[:logger] = value
+      end
+
+      def halt_on_error=(value)
+        @options[:halt_on_error] = value
+      end
+
+      def hooks
+        if @config.hooks.nil?
+          @config.instance_variable_set(:@hooks, Noticent::Definitions::Hooks.new)
+        else
+          @config.hooks
+        end
+      end
+
+      def product(name, &block)
+        products = @config.instance_variable_get(:@products) || {}
+
+        raise BadConfiguration, "product #{name} already defined" if products[name]
+
+        product = Noticent::Definitions::Product.new(@config, name)
+        hooks.run(:pre_product_registration, product)
+        product.instance_eval(&block) if block_given?
+        hooks.run(:post_product_registration, product)
+
+        products[name] = product
+
+        @config.instance_variable_set(:@products, products)
+
+        product
+      end
+
+      def channel(name, group: :default, klass: nil, &block)
+        channels = @config.instance_variable_get(:@channels) || {}
+
+        raise BadConfiguration, "channel '#{name}' already defined" if channels.include? name
+
+        channel = Noticent::Definitions::Channel.new(@config, name, group: group, klass: klass)
+        hooks.run(:pre_channel_registration, channel)
+        channel.instance_eval(&block) if block_given?
+        hooks.run(:post_channel_registration, channel)
+
+        channels[name] = channel
+
+        @config.instance_variable_set(:@channels, channels)
+        channel
+      end
+
+      def scope(name, payload_class: nil, &block)
+        scopes = @config.instance_variable_get(:@scopes) || {}
+
+        raise BadConfiguration, "scope '#{name}' already defined" if scopes.include? name
+
+        scope = Noticent::Definitions::Scope.new(@config, name, payload_class: payload_class)
+        scope.instance_eval(&block)
+
+        scopes[name] = scope
+
+        @config.instance_variable_set(:@scopes, scopes)
+        scope
+      end
+    end
+  end
+end

data/lib/noticent/definitions/alert.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Noticent
+  module Definitions
+    class Alert
+      attr_reader :name
+      attr_reader :scope
+      attr_reader :notifiers
+      attr_reader :config
+      attr_reader :products
+
+      def initialize(config, name:, scope:)
+        @config = config
+        @name = name
+        @scope = scope
+        @products = Noticent::Definitions::ProductGroup.new(@config)
+      end
+
+      def notify(recipient, template: '')
+        notifiers = @notifiers || {}
+        raise BadConfiguration, "a notify is already defined for '#{recipient}'" unless notifiers[recipient].nil?
+
+        alert_notifier = Noticent::Definitions::Alert::Notifier.new(self, recipient, template: template)
+        notifiers[recipient] = alert_notifier
+        @notifiers = notifiers
+
+        alert_notifier
+      end
+
+      def applies
+        @products
+      end
+
+      def validate!
+        channels = @config.alert_channels(@name)
+        channels.each do |channel|
+          raise BadConfiguration, "channel #{channel.name} (#{channel.klass}) has no method called #{@name}" unless channel.klass.method_defined? @name
+        end
+      end
+
+      # holds a list of recipient + channel
+      class Notifier
+        attr_reader :recipient
+        attr_reader :channel_group
+        attr_reader :template
+
+        def initialize(alert, recipient, template: '')
+          @recipient = recipient
+          @alert = alert
+          @config = alert.config
+          @template = template
+          @channel_group = :default
+        end
+
+        def on(channel_group)
+          # validate the group name
+          raise ArgumentError, "no channel group found named '#{channel_group}'" if @config.channels_by_group(channel_group).empty?
+
+          @channel_group = channel_group
+        end
+      end
+    end
+  end
+end

data/lib/noticent/definitions/channel.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Noticent
+  module Definitions
+    class Channel
+      attr_reader :name
+      attr_reader :group
+      attr_reader :klass
+      attr_reader :options
+
+      def initialize(config, name, group: :default, klass: nil)
+        @name = name
+        @group = group
+        @config = config
+
+        suggested_class_name = @config.base_module_name + '::' + name.to_s.camelize
+        @klass = klass.nil? ? suggested_class_name.camelize.constantize : klass
+      rescue NameError
+        raise Noticent::BadConfiguration, "no class found for #{suggested_class_name}"
+      end
+
+      def using(options = {})
+        @options = options
+      end
+
+      def instance(config, recipients, payload, context)
+        inst = @klass.new(config, recipients, payload, context)
+        return inst if @options.nil? || @options.empty?
+
+        @options.each do |k, v|
+          inst.send("#{k}=", v)
+        rescue NoMethodError
+          raise Noticent::BadConfiguration, "no method #{k}= found on #{@klass} as it is defined with the `using` clause"
+        end
+
+        inst
+      rescue ArgumentError
+        raise Noticent::BadConfiguration, "channel #{@klass} initializer arguments are mismatching."
+      end
+
+    end
+  end
+end

data/lib/noticent/definitions/hooks.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Noticent
+  module Definitions
+    class Hooks
+      VALID_STEPS = %i[pre_alert_registration post_alert_registration pre_channel_registration post_channel_registration pre_product_registration post_product_registration].freeze
+
+      def add(step, klass)
+        raise BadConfiguration, "invalid step. valid values are #{VALID_STEPS}" unless VALID_STEPS.include? step
+        raise BadConfiguration, "hook #{klass} doesn't have a #{step} method" unless klass.respond_to? step
+
+        storage[step] = [] if storage[step].nil?
+        storage[step] << klass
+      end
+
+      def fetch(step)
+        raise ::ArgumentError, "invalid step. valid values are #{VALID_STEPS}" unless VALID_STEPS.include? step
+
+        storage[step]
+      end
+
+      def run(step, chan)
+        chain = fetch(step)
+        return if chain.nil?
+
+        chain.each do |to_run|
+          to_run.send(step, chan) if to_run.respond_to? step
+        end
+      end
+
+      private
+
+      def storage
+        @storage ||= {}
+      end
+    end
+  end
+end

data/lib/noticent/definitions/product.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Noticent
+  module Definitions
+    class Product
+      attr_reader :name
+
+      def initialize(config, name)
+        raise BadConfiguration, 'product name should be a symbol' unless name.is_a? Symbol
+
+        @config = config
+        @name = name
+      end
+    end
+  end
+end

data/lib/noticent/definitions/product_group.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Noticent
+  module Definitions
+    class ProductGroup
+
+      attr_reader :products
+
+      def initialize(config)
+        @config = config
+        @products = {}
+      end
+
+      def to(name)
+        raise BadConfiguration, 'product name should be a symbol' unless name.is_a? Symbol
+        raise BadConfiguration, "product #{name} is already in the list" if @products[name]
+        raise BadConfiguration, "product #{name} is not defined. Use products to define it first" unless @config.products[name]
+
+        @products[name] = @config.products[name]
+      end
+
+      def not_to(name)
+        raise BadConfiguration, 'product name should be a symbol' unless name.is_a? Symbol
+        raise BadConfiguration, "product #{name} is not defined. Use products to define it first" unless @config.products[name]
+
+        # include all products, except the one named
+        @config.products.each { |k, v| @products[k] = v unless k == name }
+      end
+
+      def count
+        @products.count
+      end
+
+      def keys
+        @products.keys
+      end
+
+      def values
+        @products.values
+      end
+
+    end
+  end
+end

data/lib/noticent/definitions/scope.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module Noticent
+  module Definitions
+    class Scope
+      attr_reader :name
+      attr_reader :payload_class
+
+      def initialize(config, name, payload_class: nil)
+        @config = config
+        @name = name
+        suggeste_name = config.base_module_name + "::#{name.capitalize}Payload"
+        @payload_class = payload_class.nil? ? suggeste_name.constantize : payload_class
+      rescue NameError
+        raise BadConfiguration, "scope #{suggeste_name} class not found"
+      end
+
+      def alert(name, &block)
+        alerts = @config.instance_variable_get(:@alerts) || {}
+
+        raise BadConfiguration, "alert '#{name}' already defined" if alerts.include? name
+
+        alert = Noticent::Definitions::Alert.new(@config, name: name, scope: self)
+        @config.hooks&.run(:pre_alert_registration, alert)
+        alert.instance_eval(&block) if block_given?
+        @config.hooks&.run(:post_alert_registration, alert)
+
+        alerts[name] = alert
+
+        @config.instance_variable_set(:@alerts, alerts)
+        alert
+      end
+
+      def validate!
+        # klass is valid already as it's used in the initializer
+        # does it have the right attributes?
+        # fetch all alerts for this scope
+        return if @payload_class.nil?
+
+        @config.alerts_by_scope(name).each do |alert|
+          next if alert.notifiers.nil?
+
+          alert.notifiers.keys.each do |recipient|
+            raise BadConfiguration, "payload class #{@payload_class} doesn't have a method or attribute called #{recipient}" unless @payload_class.method_defined? recipient
+          end
+        end
+
+        raise BadConfiguration, "payload class #{@payload_class} does have an attribute or method called #{name}_id" if !@payload_class.nil? && !@payload_class.method_defined?("#{name}_id")
+      end
+    end
+  end
+end

data/lib/noticent/dispatcher.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Noticent
+  class Dispatcher
+    def initialize(config, alert_name, payload, context = {})
+      @config = config
+      @alert_name = alert_name
+      @payload = payload
+      @context = context
+
+      validate!
+
+      @entity_id = @payload.send("#{scope.name}_id")
+    end
+
+    def alert
+      @config.alerts[@alert_name]
+    end
+
+    def scope
+      alert.scope
+    end
+
+    def notifiers
+      alert.notifiers
+    end
+
+    # returns all recipients of a certain notifier unfiltered regardless of "opt-in" and duplicates
+    def recipients(notifier_name)
+      raise Noticent::InvalidScope, "payload #{@payload.klass} doesn't have a #{notifier_name} method" unless @payload.respond_to? notifier_name
+
+      @payload.send(notifier_name)
+    end
+
+    # only returns recipients that have opted-in for this channel
+    def filter_recipients(recipients, channel)
+      raise ArgumentError, 'channel should be a string or symbol' unless channel.is_a?(String) || channel.is_a?(Symbol)
+      raise ArgumentError, 'recipients is nil' if recipients.nil?
+
+      recipients.select { |recipient| @config.opt_in_provider.opted_in?(recipient_id: recipient.id, scope: scope.name, entity_id: @entity_id, alert_name: alert.name, channel_name: channel) }
+    end
+
+    def dispatch
+      notifiers.values.each do |notifier|
+        recs = recipients(notifier.recipient)
+        @config.channels_by_group(notifier.channel_group).each do |channel|
+          to_send = filter_recipients(recs, channel.name)
+          channel_instance = channel.instance(@config, to_send, @payload, @context)
+          begin
+            raise Noticent::BadConfiguration, "channel #{channel.name} (#{channel.klass}) doesn't have a method called #{alert.name}" unless channel_instance.respond_to? alert.name
+
+            channel_instance.send(alert.name)
+          rescue StandardError => e
+            # log and move on
+            raise if @config.halt_on_error
+
+            Noticent.logger.error e
+          end
+        end
+      end
+    end
+
+    private
+
+    def validate!
+      raise Noticent::BadConfiguration, 'no base_dir defined' if @config.base_dir.nil?
+      raise Noticent::MissingConfiguration if @config.nil?
+      raise Noticent::BadConfiguration if @config.alerts.nil?
+      raise Noticent::InvalidAlert, "no alert #{@alert_name} found" if @config.alerts[@alert_name].nil?
+      raise ::ArgumentError, 'payload is nil' if @payload.nil?
+      raise ::ArgumentError, 'alert is not a symbol' unless @alert_name.is_a?(Symbol)
+      raise Noticent::BadConfiguration, "payload (#{@payload.class}) doesn't belong to this scope (#{scope.name}) as it requires #{scope.payload_class}" unless !scope.payload_class.nil? && @payload.is_a?(scope.payload_class)
+      raise Noticent::BadConfiguration, "payload doesn't have a #{scope.name}_id method" unless @payload.respond_to?("#{scope.name}_id")
+    end
+  end
+end