unotifier 0.2.10 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ec61a1237c2bdcf5f22b0f272805090d1a82f4e83dee871c3daa01bef627d5c
-  data.tar.gz: 8d0c39f00d10c01a8b452c2b1a29c7f995f144993e491102004f73f65488426e
+  metadata.gz: aaa686f0cd41483a94d0746b9538177adae345674774b7e7798cb507c9c2b61c
+  data.tar.gz: 5e61daf30bfe7dbbdd62a0edb5f2cad5c2383e5ad3dc83482ad1cec0b61781c1
 SHA512:
-  metadata.gz: 6d5bce4be79ee89ca014fdde94eb48ba55829dddefd86a8250d90e2c94ee244c49a70dcabf7fe8ff09b24d8e31c5cd92b2ef4dcb019fed6c4b8accbfda851f35
-  data.tar.gz: e087624c1ccfc08495ea06e2e8c53993c16f2c30f4fcfa017d51279da0f6f2a5bead5f7146d36c6543207edb1c41de155db8f3257d80498f1ac7643a22a8d07a
+  metadata.gz: 21fc2a10954d1a2c5e0fa1d6ae7eafc9ad199d02ec634b850c90393604669b5ee63e0d617985859507ed1eaf8787cbc1db227b7791e698308d8142d7b02d476a
+  data.tar.gz: e96f359477dde1299d359a646b0efda3c40fba6a42c546e4dc1758e7df8bd39f663b4a89f5b61778678130ba9ba0d349ea1ccd430de22fceda4f317729b6a167

data/.rubocop.yml

@@ -0,0 +1,151 @@
+require: rubocop-rails
+
+AllCops:
+  Exclude:
+    - "bin/**/*"
+    - "spec/**/*"
+    - "*.gemspec"
+    - "Gemfile"
+    - "Rakefile"
+
+Rails:
+  Enabled: true
+
+Layout/BlockAlignment:
+  EnforcedStyleAlignWith: start_of_block
+
+Layout/FirstArrayElementIndentation:
+  EnforcedStyle: consistent
+
+Layout/FirstHashElementIndentation:
+  EnforcedStyle: consistent
+
+Layout/LineLength:
+  AutoCorrect: false
+  Max: 110
+
+Layout/MultilineOperationIndentation:
+  EnforcedStyle: aligned
+
+Layout/SpaceInLambdaLiteral:
+  EnforcedStyle: require_space
+
+Lint/InheritException:
+  EnforcedStyle: standard_error
+
+Lint/SuppressedException:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Metrics/BlockLength:
+  Enabled: false
+
+Metrics/BlockNesting:
+  Max: 6
+
+Metrics/ClassLength:
+  Enabled: false
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false
+
+Naming/MethodParameterName:
+  AllowedNames: ["by", "e", "id", "to", "tx", "fn", "tz"]
+
+Metrics/ModuleLength:
+  Enabled: false
+
+Metrics/PerceivedComplexity:
+  Enabled: false
+
+Naming/PredicateName:
+  Enabled: false
+
+Rails/DynamicFindBy:
+  Enabled: false
+
+Rails/EnumHash:
+  Enabled: false
+
+Rails/HttpStatus:
+  EnforcedStyle: numeric
+
+Rails/LexicallyScopedActionFilter:
+  Enabled: false
+
+Rails/ReversibleMigration:
+  Enabled: false
+
+Rails/SafeNavigation:
+  ConvertTry: true
+
+Rails/SkipsModelValidations:
+  Enabled: false
+
+Rails/TimeZone:
+  Enabled: false
+
+Rails/UnknownEnv:
+  Environments: ["development", "test", "staging", "staging_unmerged", "testnet", "production"]
+
+Security/YAMLLoad:
+  Enabled: false
+
+Style/CollectionMethods:
+  Enabled: true
+
+Style/Documentation:
+  Enabled: false
+
+Style/DoubleNegation:
+  Enabled: false
+
+Style/FormatStringToken:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Style/GlobalVars:
+  Enabled: false
+
+Style/MultilineIfModifier:
+  Enabled: false
+
+Style/NumericPredicate:
+  EnforcedStyle: comparison
+
+Style/PercentLiteralDelimiters:
+  PreferredDelimiters:
+    default: "()"
+    "%i": "()"
+    "%I": "()"
+    "%r": "{}"
+    "%w": "()"
+    "%W": "()"
+
+Style/PreferredHashMethods:
+  Enabled: false
+
+Style/RedundantSelf:
+  Enabled: false
+
+Style/RegexpLiteral:
+  EnforcedStyle: slashes
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes
+
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: comma
+
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: comma

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    unotifier (0.2.10)
+    unotifier (0.3.0)
 
 GEM
   remote: https://rubygems.org/
@@ -44,4 +44,4 @@ DEPENDENCIES
   unotifier!
 
 BUNDLED WITH
-   1.17.1
+   1.17.3

data/lib/configuration.rb

@@ -2,6 +2,7 @@ module UNotifier
   class Configuration
     attr_accessor :site_providers
     attr_accessor :external_providers
+    attr_accessor :system_providers
     attr_accessor :resource_class
     attr_accessor :notifications_path
     attr_accessor :localization_provider
@@ -9,6 +10,7 @@ module UNotifier
     def initialize
       @site_providers = []
       @external_providers = []
+      @system_providers = []
       @resource_class = nil
       @notifications_path = nil
       @localization_provider = nil

data/lib/exceptions.rb

@@ -1,6 +1,27 @@
 module UNotifier
   class UNotifierError < StandardError; end
 
+  class EmptyLocaleKeyError < UNotifierError
+    attr_reader :key
+
+    def initialize(key)
+      @key = key
+      message = ":locale_key parameter is required for fetching '#{key}' locale"
+      super(message)
+    end
+  end
+
+  class AttributeMissingError < UNotifierError
+    attr_reader :key, :attribute
+
+    def initialize(key, attribute)
+      @key = key
+      @attribute = attribute
+      message = "Missing '#{attribute}' attribute for notification '#{key}'"
+      super(message)
+    end
+  end
+
   class NotificationsConfigNotFoundError < UNotifierError
     attr_reader :path, :absolute_path
 
@@ -33,16 +54,6 @@ module UNotifier
     end
   end
 
-  class EmptyLocaleKeyError < UNotifierError
-    attr_reader :key
-
-    def initialize(key)
-      @key = key
-      message = ":locale_key parameter is required for fetching '#{key}' locale"
-      super(message)
-    end
-  end
-
   class UnknownLocaleKeyError < UNotifierError
     attr_reader :key, :locale_key, :options
 

data/lib/hash.rb

@@ -1,6 +1,19 @@
+# rubocop:disable Style/ClassAndModuleChildren
 class ::Hash
   def deep_merge!(second)
-      merger = proc { |key, v1, v2| Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : Array === v1 && Array === v2 ? v1 | v2 : [:undefined, nil, :nil].include?(v2) ? v1 : v2 }
-      self.merge!(second.to_h, &merger)
+    merger = proc do |_, v1, v2|
+      if v1.is_a?(Hash) && v2.is_a?(Hash)
+        v1.merge(v2, &merger)
+      elsif v1.is_a?(Array) && v2.is_a?(Array)
+        v1 | v2
+      elsif [:undefined, nil, :nil].include?(v2)
+        v1
+      else
+        v2
+      end
+    end
+
+    self.merge!(second.to_h, &merger)
   end
 end
+# rubocop:enable Style/ClassAndModuleChildren

data/lib/provider/provider_base.rb

@@ -5,9 +5,10 @@ module UNotifier
         @notification_conditions = notification_conditions
       end
 
-      def can_notify?(target)
+      def can_notify?(notification)
         return true if @notification_conditions.empty?
-        @notification_conditions.all? { |c| c.call(target) }
+
+        @notification_conditions.all? { |c| c.call(notification) }
       end
     end
   end

data/lib/provider/system/action_cable.rb

@@ -0,0 +1,22 @@
+module UNotifier
+  module Provider
+    module System
+      class ActionCable < ProviderBase
+        attr_reader :server
+        attr_accessor :channel_name
+
+        def initialize(server, channel_name: nil, notification_conditions: [])
+          super(notification_conditions: notification_conditions)
+          @server = server
+          @channel_name = channel_name
+        end
+
+        def notify(notification, data)
+          return unless can_notify?(notification)
+
+          server.broadcast channel_name.call(notification), data
+        end
+      end
+    end
+  end
+end

data/lib/provider/user/action_cable.rb

@@ -0,0 +1,35 @@
+module UNotifier
+  module Provider
+    module User
+      class ActionCable < ProviderBase
+        attr_reader :server
+        attr_accessor :autohide_delay, :channel_name
+
+        def initialize(server, channel_name: nil, autohide_delay: 30, notification_conditions: [])
+          super(notification_conditions: notification_conditions)
+          @server = server
+          @channel_name = channel_name
+          @autohide_delay = autohide_delay
+        end
+
+        def notify(notification)
+          return unless can_notify?(notification)
+
+          server.broadcast channel_name.call(notification), serialize_notification(notification)
+        end
+
+        def serialize_notification(notification)
+          {
+            id: notification.id,
+            title: notification.title,
+            body: notification.body,
+            autohide_delay: notification.autohide_delay || @autohide_delay,
+            user_login: notification.target.login,
+            link: notification.link,
+            urgency: notification.urgency,
+          }
+        end
+      end
+    end
+  end
+end

data/lib/provider/user/action_mailer.rb

@@ -0,0 +1,26 @@
+module UNotifier
+  module Provider
+    module User
+      class ActionMailer < ProviderBase
+        def initialize(mailer, sending_method: :new_notification, notification_conditions: [])
+          super(notification_conditions: notification_conditions)
+          @mailer = mailer
+          @sending_method = sending_method
+        end
+
+        def notify(notification)
+          return unless can_notify?(notification)
+
+          sending_method =
+            if @sending_method.is_a?(Array)
+              @sending_method.map { |m| m.call(notification) }&.first
+            else
+              @sending_method
+            end
+
+          @mailer.public_send(sending_method, notification).deliver
+        end
+      end
+    end
+  end
+end

data/lib/provider.rb

@@ -1,6 +1,7 @@
 require_relative "provider/provider_base"
-require_relative "provider/action_cable"
-require_relative "provider/action_mailer"
+require_relative "provider/system/action_cable"
+require_relative "provider/user/action_cable"
+require_relative "provider/user/action_mailer"
 
 module UNotifier
   module Provider

data/lib/settings.rb

@@ -1,28 +1,36 @@
 module UNotifier
   class Settings
-    DEFAULT_URGENCY = "external"
+    DEFAULT_URGENCY = "external".freeze
 
     def self.customizable?(config)
-      %w(regular optional).include?(config["urgency"])
+      (
+        config.key?("urgency") &&
+          %w(regular optional).include?(config["urgency"])
+      ) || (
+        config.key?("target") &&
+          config["target"].values.any? { |c| customizable?(c) }
+      )
     end
 
     def self.filter_customizable(config)
-      config.map do |key, subkeys|
-        filtered = subkeys.select do |subkey, value|
-          (value.has_key?("urgency") && customizable?(value)) ||
-          (value.has_key?("target") && value["target"].values.any? { |subvalue| customizable?(subvalue) })
-        end
-
-        filtered = filtered.each_with_object({}) do |(subkey, value), out|
-          out[subkey] = value["urgency"] ||
-                        value["target"]
+      customizable = config.map do |key, subkeys|
+        filtered =
+          subkeys
+          .select { |_, value| value.key?("user") }
+          .map { |subkey, value| [subkey, value["user"]] }
+          .select { |_, value| customizable?(value) }
+          .each_with_object({}) do |(subkey, value), out|
+            out[subkey] = value["urgency"] ||
+                          value["target"]
                           .select { |_, subvalue| customizable?(subvalue) }
                           .map { |_, subvalue| subvalue["urgency"] }
                           .first
-        end
+          end
 
         [key, filtered]
-      end.to_h.select { |_, subkeys| !subkeys.empty?  }
+      end
+
+      customizable.to_h.reject { |_, subkeys| subkeys.empty? }
     end
 
     def self.keys_from(config)
@@ -36,8 +44,6 @@ module UNotifier
       end
     end
 
-    private
-
     def self.flatten_keys(keys)
       keys.map do |key, subkeys|
         subkeys.map do |subkey, urgency|

data/lib/unotifier/system_notifier.rb

@@ -0,0 +1,28 @@
+module UNotifier
+  module SystemNotifier
+    def self.notify_system(notification, params = {})
+      key = notification.key
+      config = UNotifier.load_notification!(key)
+      return if config["system"].nil?
+
+      # Raise only when we're sure that config has "system" block
+      raise AttributeMissingError.new(key, "system") unless params
+
+      data = config["system"]["keys"].each_with_object({}) do |(head, attributes), obj|
+        head = head.to_sym
+        attributes = attributes.map(&:to_sym)
+        raise AttributeMissingError.new(key, head) unless params.key?(head)
+
+        attributes.each { |a| raise AttributeMissingError.new(key, a) unless params[head].keys.include?(a) }
+
+        obj[head] = params[head].slice(*attributes)
+      end
+
+      data.merge!(key: notification.key)
+
+      UNotifier.configuration.system_providers.each do |provider|
+        provider.notify notification, data
+      end
+    end
+  end
+end

data/lib/unotifier/user_notifier.rb

@@ -0,0 +1,59 @@
+module UNotifier
+  module UserNotifier
+    def self.notify_user(notification, params = {})
+      locale_key = UNotifier.locale_key_for(notification.key, params)
+      user_settings = notification.target.notification_settings[notification.key]
+      user_settings ||= Settings::DEFAULT_URGENCY
+
+      notify_with = []
+
+      if !params[:external_only] && notify_onsite?(notification, user_settings)
+        notify_with += UNotifier.configuration.site_providers
+      end
+
+      if !params[:onsite_only] && notify_external?(notification, user_settings)
+        notify_with += UNotifier.configuration.external_providers
+      end
+
+      notify_with.each do |provider|
+        title_provider_key = "#{locale_key}.#{provider.class.to_s.split("::").last}.title"
+        body_provider_key  = "#{locale_key}.#{provider.class.to_s.split("::").last}.body"
+
+        if UNotifier.configuration.localization_provider.exists?(title_provider_key)
+          notification.title =
+            UNotifier.configuration.localization_provider.t(
+              title_provider_key, params.merge(locale: notification.target.locale)
+            )
+        end
+
+        if UNotifier.configuration.localization_provider.exists?(body_provider_key)
+          notification.body =
+            UNotifier.configuration.localization_provider.t(
+              body_provider_key, params.merge(locale: notification.target.locale, default: "")
+            )
+        end
+
+        provider.notify(notification)
+      end
+    end
+
+    def self.notify_onsite?(notification, user_settings)
+      return false if notification.urgency == "optional" && user_settings == "off"
+
+      notification.target.online?
+    end
+
+    def self.notify_external?(notification, user_settings)
+      case notification.urgency
+      when "immediate"
+        true
+      when "regular", "optional"
+        user_settings == "external" && !notification.target.online?
+      when "onsite"
+        false
+      else
+        false
+      end
+    end
+  end
+end

data/lib/unotifier/version.rb

@@ -1,3 +1,3 @@
 module UNotifier
-  VERSION = "0.2.10"
+  VERSION = "0.3.0".freeze
 end

data/lib/unotifier.rb

@@ -2,6 +2,8 @@ require "yaml"
 
 require_relative "hash"
 require_relative "unotifier/version"
+require_relative "unotifier/system_notifier"
+require_relative "unotifier/user_notifier"
 require_relative "exceptions"
 require_relative "provider"
 require_relative "configuration"
@@ -21,7 +23,7 @@ module UNotifier
   end
 
   def self.notifications_config
-    @notifications_config ||= if configuration.notifications_path.kind_of?(Array)
+    @notifications_config ||= if configuration.notifications_path.is_a?(Array)
                                 configuration.notifications_path.each_with_object({}) do |path, config|
                                   config.deep_merge!(YAML.load_file(path))
                                 end
@@ -29,7 +31,7 @@ module UNotifier
                                 YAML.load_file(configuration.notifications_path)
                               end
   rescue Errno::ENOENT
-    raise NotificationsConfigNotFoundError.new(configuration.notifications_path)
+    raise NotificationsConfigNotFoundError, configuration.notifications_path
   end
 
   def self.reload!
@@ -38,68 +40,62 @@ module UNotifier
   end
 
   def self.load_notification(key)
-    notifications_config.dig(*key.split('.'))
+    notifications_config.dig(*key.split("."))
   end
 
   def self.load_notification!(key)
     notification = load_notification(key)
-    raise NotificationNotFoundError.new(key) unless notification
-    notification
-  end
-
-  def self.urgency_for(key, params = {})
-    config = load_notification!(key)
+    raise NotificationNotFoundError, key unless notification
 
-    if config["target"].kind_of?(Hash)
-      urgency = config.dig("target", params[:target], "urgency")
-      raise UnknownTargetError.new(key, params[:target]) unless urgency
-      urgency
-    else
-      config["urgency"]
-    end
+    notification
   end
 
   def self.locale_key_for(key, params = {})
-    config = load_notification!(key)
+    config = load_notification!(key)["user"]
+
+    if config["locale_options"].is_a?(Array)
+      raise EmptyLocaleKeyError, key unless params[:locale_key]
 
-    if config["locale_options"].kind_of?(Array)
-      raise EmptyLocaleKeyError.new(key) unless params[:locale_key]
       raise UnknownLocaleKeyError.new(
         key, params[:locale_key], config["locale_options"]
       ) unless config["locale_options"].include?(params[:locale_key])
+
       "notifications.#{key}.#{params[:locale_key]}"
     else
       "notifications.#{key}"
     end
   end
 
-  def self.notify(key, target, params = {})
-    user_settings = target.notification_settings[key]
-    user_settings ||= Settings::DEFAULT_URGENCY
+  def self.notify(key, recepients, params = {})
+    targets = recepients.is_a?(Enumerable) ? recepients : [recepients]
+
+    targets.each do |target|
+      notify_target(key, target, params)
+    end
+  end
+
+  def self.notify_target(key, target, params = {})
     locale_key = locale_key_for(key, params)
     urgency = urgency_for(key, params)
 
     notification = configuration.resource_class.new(
       key: key,
       target: target,
-      title: configuration.localization_provider.t("#{locale_key}.title", params.merge(locale: target.locale)),
-      body: configuration.localization_provider.t("#{locale_key}.body", params.merge(locale: target.locale, default: "")),
       link: params[:link],
       autohide_delay: params[:autohide_delay],
-      urgency: urgency
+      urgency: urgency,
+      title: configuration.localization_provider.t(
+        "#{locale_key}.title", params.merge(locale: target.locale)
+      ),
+      body: configuration.localization_provider.t(
+        "#{locale_key}.body", params.merge(locale: target.locale, default: "")
+      )
     )
+
     notification.save!
 
-    notify_with = []
-    notify_with += configuration.site_providers if !params[:external_only] && notify_onsite?(notification, user_settings)
-    notify_with += configuration.external_providers if !params[:onsite_only] && notify_external?(notification, user_settings)
-    notify_with.each do |provider|
-      title_provider_key = "#{locale_key}.#{provider.class.to_s.split("::").last}.title"
-      body_provider_key  = "#{locale_key}.#{provider.class.to_s.split("::").last}.body"
-      notification.title = configuration.localization_provider.t(title_provider_key, params.merge(locale: target.locale)) if configuration.localization_provider.exists?(title_provider_key)
-      notification.body  = configuration.localization_provider.t(body_provider_key, params.merge(locale: target.locale, default: "")) if configuration.localization_provider.exists?(body_provider_key)
-      provider.notify(notification)
-    end
+    UserNotifier.notify_user(notification, params)
+    SystemNotifier.notify_system(notification, params[:system])
   end
 
   def self.notify_onsite(key, target, params)
@@ -121,23 +117,16 @@ module UNotifier
       end
   end
 
-  private
+  def self.urgency_for(key, params = {})
+    config = load_notification!(key)["user"]
 
-  def self.notify_onsite?(notification, user_settings)
-    return false if notification.urgency == "optional" && user_settings == "off"
-    notification.target.online?
-  end
+    if config["target"].is_a?(Hash)
+      urgency = config.dig("target", params[:target], "urgency")
+      raise UnknownTargetError.new(key, params[:target]) unless urgency
 
-  def self.notify_external?(notification, user_settings)
-    case notification.urgency
-    when "immediate"
-      true
-    when "regular", "optional"
-      user_settings == "external" && !notification.target.online?
-    when "onsite"
-      false
+      urgency
     else
-      false
+      config["urgency"]
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: unotifier
 version: !ruby/object:Gem::Version
-  version: 0.2.10
+  version: 0.3.0
 platform: ruby
 authors:
 - mgpnd
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-07 00:00:00.000000000 Z
+date: 2020-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -106,6 +106,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".rubocop.yml"
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
@@ -119,11 +120,14 @@ files:
 - lib/exceptions.rb
 - lib/hash.rb
 - lib/provider.rb
-- lib/provider/action_cable.rb
-- lib/provider/action_mailer.rb
 - lib/provider/provider_base.rb
+- lib/provider/system/action_cable.rb
+- lib/provider/user/action_cable.rb
+- lib/provider/user/action_mailer.rb
 - lib/settings.rb
 - lib/unotifier.rb
+- lib/unotifier/system_notifier.rb
+- lib/unotifier/user_notifier.rb
 - lib/unotifier/version.rb
 - unotifier.gemspec
 homepage: https://gitlab.com/hodlhodl-public/unotifier
@@ -148,7 +152,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.6
 signing_key: 
 specification_version: 4
 summary: Ultimate user notification tool for web apps

data/lib/provider/action_cable.rb

@@ -1,36 +0,0 @@
-module UNotifier
-  module Provider
-    class ActionCable < ProviderBase
-      attr_reader :server
-      attr_accessor :autohide_delay, :channel_name
-
-      def initialize(server, channel_name: nil, autohide_delay: 30, notification_conditions: [])
-        super(notification_conditions: notification_conditions)
-        @server = server
-        @autohide_delay = autohide_delay
-        @channel_name =
-          channel_name ||
-          -> (notification) { "notifications_for_user_#{notification.target.login}" }
-      end
-
-      def notify(notification)
-        return unless can_notify?(notification)
-        if notification.target.online?
-          @server.broadcast @channel_name.call(notification), serialize_notification(notification)
-        end
-      end
-
-      def serialize_notification(notification)
-        {
-          id: notification.id,
-          title: notification.title,
-          body: notification.body,
-          autohide_delay: notification.autohide_delay || @autohide_delay,
-          user_login: notification.target.login,
-          link: notification.link,
-          urgency: notification.urgency,
-        }
-      end
-    end
-  end
-end

data/lib/provider/action_mailer.rb

@@ -1,21 +0,0 @@
-module UNotifier
-  module Provider
-    class ActionMailer < ProviderBase
-      def initialize(mailer, sending_method: :new_notification, notification_conditions: [])
-        super(notification_conditions: notification_conditions)
-        @mailer = mailer
-        @sending_method = sending_method
-      end
-
-      def notify(notification)
-        return unless can_notify?(notification)
-        sending_method = if @sending_method.kind_of?(Array)
-          @sending_method.map { |m| m.call(notification) }&.first
-        else
-          @sending_method
-        end
-        @mailer.public_send(sending_method, notification).deliver
-      end
-    end
-  end
-end