activity_notification 2.5.0 → 2.6.0

data/lib/activity_notification/apis/notification_api.rb

@@ -25,7 +25,7 @@ module ActivityNotification
         #   @notifications = @user.notifications.group_owners_only.latest_order
         # @param [Boolean] reverse If notification index will be ordered as earliest first
         # @param [Boolean] with_group_members If notification index will include group members
-        # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        # @return [ActiveRecord_AssociationRelation<Notification>, Mongoid::Criteria<Notification>] Database query of filtered notifications
         scope :all_index!,                        ->(reverse = false, with_group_members = false) {
           target_index = with_group_members ? self : group_owners_only
           reverse ? target_index.earliest_order : target_index.latest_order
@@ -36,12 +36,12 @@ module ActivityNotification
         # is defined same as
         #   ActivityNotification::Notification.unopened_only.group_owners_only.latest_order
         # @scope class
-        # @example Get unopened notificaton index of the @user
+        # @example Get unopened notification index of the @user
         #   @notifications = @user.notifications.unopened_index
         #   @notifications = @user.notifications.unopened_only.group_owners_only.latest_order
         # @param [Boolean] reverse If notification index will be ordered as earliest first
         # @param [Boolean] with_group_members If notification index will include group members
-        # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        # @return [ActiveRecord_AssociationRelation<Notification>, Mongoid::Criteria<Notification>] Database query of filtered notifications
         scope :unopened_index,                    ->(reverse = false, with_group_members = false) {
           target_index = with_group_members ? unopened_only : unopened_only.group_owners_only
           reverse ? target_index.earliest_order : target_index.latest_order
@@ -52,54 +52,54 @@ module ActivityNotification
         # is defined same as
         #   ActivityNotification::Notification.opened_only(limit).group_owners_only.latest_order
         # @scope class
-        # @example Get unopened notificaton index of the @user with limit 10
+        # @example Get unopened notification index of the @user with limit 10
         #   @notifications = @user.notifications.opened_index(10)
         #   @notifications = @user.notifications.opened_only(10).group_owners_only.latest_order
         # @param [Integer] limit Limit to query for opened notifications
         # @param [Boolean] reverse If notification index will be ordered as earliest first
         # @param [Boolean] with_group_members If notification index will include group members
-        # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        # @return [ActiveRecord_AssociationRelation<Notification>, Mongoid::Criteria<Notification>] Database query of filtered notifications
         scope :opened_index,                      ->(limit, reverse = false, with_group_members = false) {
           target_index = with_group_members ? opened_only(limit) : opened_only(limit).group_owners_only
           reverse ? target_index.earliest_order : target_index.latest_order
         }
 
         # Selects filtered notifications by target_type.
-        # @example Get filtered unopened notificatons of User as target type
+        # @example Get filtered unopened notification of User as target type
         #   @notifications = ActivityNotification.Notification.unopened_only.filtered_by_target_type('User')
         # @scope class
         # @param [String] target_type Target type for filter
-        # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        # @return [ActiveRecord_AssociationRelation<Notification>, Mongoid::Criteria<Notification>] Database query of filtered notifications
         scope :filtered_by_target_type,           ->(target_type) { where(target_type: target_type) }
 
         # Selects filtered notifications by notifiable_type.
-        # @example Get filtered unopened notificatons of the @user for Comment notifiable class
+        # @example Get filtered unopened notification of the @user for Comment notifiable class
         #   @notifications = @user.notifications.unopened_only.filtered_by_type('Comment')
         # @scope class
         # @param [String] notifiable_type Notifiable type for filter
-        # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        # @return [ActiveRecord_AssociationRelation<Notification>, Mongoid::Criteria<Notification>] Database query of filtered notifications
         scope :filtered_by_type,                  ->(notifiable_type) { where(notifiable_type: notifiable_type) }
 
         # Selects filtered notifications by key.
-        # @example Get filtered unopened notificatons of the @user with key 'comment.reply'
+        # @example Get filtered unopened notification of the @user with key 'comment.reply'
         #   @notifications = @user.notifications.unopened_only.filtered_by_key('comment.reply')
         # @scope class
         # @param [String] key Key of the notification for filter
-        # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        # @return [ActiveRecord_AssociationRelation<Notification>, Mongoid::Criteria<Notification>] Database query of filtered notifications
         scope :filtered_by_key,                   ->(key) { where(key: key) }
 
         # Selects filtered notifications by notifiable_type, group or key with filter options.
-        # @example Get filtered unopened notificatons of the @user for Comment notifiable class
+        # @example Get filtered unopened notification of the @user for Comment notifiable class
         #   @notifications = @user.notifications.unopened_only.filtered_by_options({ filtered_by_type: 'Comment' })
-        # @example Get filtered unopened notificatons of the @user for @article as group
+        # @example Get filtered unopened notification of the @user for @article as group
         #   @notifications = @user.notifications.unopened_only.filtered_by_options({ filtered_by_group: @article })
-        # @example Get filtered unopened notificatons of the @user for Article instance id=1 as group
+        # @example Get filtered unopened notification of the @user for Article instance id=1 as group
         #   @notifications = @user.notifications.unopened_only.filtered_by_options({ filtered_by_group_type: 'Article', filtered_by_group_id: '1' })
-        # @example Get filtered unopened notificatons of the @user with key 'comment.reply'
+        # @example Get filtered unopened notification of the @user with key 'comment.reply'
         #   @notifications = @user.notifications.unopened_only.filtered_by_options({ filtered_by_key: 'comment.reply' })
-        # @example Get filtered unopened notificatons of the @user for Comment notifiable class with key 'comment.reply'
+        # @example Get filtered unopened notification of the @user for Comment notifiable class with key 'comment.reply'
         #   @notifications = @user.notifications.unopened_only.filtered_by_options({ filtered_by_type: 'Comment', filtered_by_key: 'comment.reply' })
-        # @example Get custom filtered notificatons of the @user
+        # @example Get custom filtered notification of the @user
         #   @notifications = @user.notifications.unopened_only.filtered_by_options({ custom_filter: ["created_at >= ?", time.hour.ago] })
         # @scope class
         # @param [Hash] options Options for filter
@@ -111,7 +111,7 @@ module ActivityNotification
         # @option options [String]     :later_than             (nil) ISO 8601 format time to filter notification index later than specified time
         # @option options [String]     :earlier_than           (nil) ISO 8601 format time to filter notification index earlier than specified time
         # @option options [Array|Hash] :custom_filter          (nil) Custom notification filter (e.g. ["created_at >= ?", time.hour.ago] with ActiveRecord or {:created_at.gt => time.hour.ago} with Mongoid)
-        # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of filtered notifications
+        # @return [ActiveRecord_AssociationRelation<Notification>, Mongoid::Criteria<Notification>] Database query of filtered notifications
         scope :filtered_by_options,               ->(options = {}) {
           options = ActivityNotification.cast_to_indifferent_hash(options)
           filtered_notifications = all
@@ -141,22 +141,22 @@ module ActivityNotification
         }
 
         # Orders by latest (newest) first as created_at: :desc.
-        # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of notifications ordered by latest first
+        # @return [ActiveRecord_AssociationRelation<Notification>, Mongoid::Criteria<Notification>] Database query of notifications ordered by latest first
         scope :latest_order,                      -> { order(created_at: :desc) }
 
         # Orders by earliest (older) first as created_at: :asc.
-        # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of notifications ordered by earliest first
+        # @return [ActiveRecord_AssociationRelation<Notification>, Mongoid::Criteria<Notification>] Database query of notifications ordered by earliest first
         scope :earliest_order,                    -> { order(created_at: :asc) }
 
         # Orders by latest (newest) first as created_at: :desc.
         # This method is to be overridden in implementation for each ORM.
         # @param [Boolean] reverse If notifications will be ordered as earliest first
-        # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of ordered notifications
+        # @return [ActiveRecord_AssociationRelation<Notification>, Mongoid::Criteria<Notification>] Database query of ordered notifications
         scope :latest_order!,                     ->(reverse = false) { reverse ? earliest_order : latest_order }
 
         # Orders by earliest (older) first as created_at: :asc.
         # This method is to be overridden in implementation for each ORM.
-        # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of notifications ordered by earliest first
+        # @return [ActiveRecord_AssociationRelation<Notification>, Mongoid::Criteria<Notification>] Database query of notifications ordered by earliest first
         scope :earliest_order!,                   -> { earliest_order }
 
         # Returns latest notification instance.
@@ -224,14 +224,18 @@ module ActivityNotification
       # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
       # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
       # @option options [Boolean]                 :pass_full_options        (false)                               Whether it passes full options to notifiable.notification_targets, not a key only
-      # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
-      # @return [Array<Notificaion>] Array of generated notifications
+      # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc.) and values are options
+      # @return [Array<Notification>] Array of generated notifications
       def notify(target_type, notifiable, options = {})
         if options[:notify_later]
           notify_later(target_type, notifiable, options)
         else
           targets = notifiable.notification_targets(target_type, options[:pass_full_options] ? options : options[:key])
-          unless targets.blank?
+          # Merge targets from instance-level subscriptions and deduplicate
+          instance_targets = notifiable.instance_subscription_targets(target_type, options[:key])
+          targets = merge_targets(targets, instance_targets)
+          # Optimize blank check to avoid loading all records for ActiveRecord relations
+          unless targets_empty?(targets)
             notify_all(targets, notifiable, options)
           end
         end
@@ -262,8 +266,8 @@ module ActivityNotification
       # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
       # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
       # @option options [Boolean]                 :pass_full_options        (false)                               Whether it passes full options to notifiable.notification_targets, not a key only
-      # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
-      # @return [Array<Notificaion>] Array of generated notifications
+      # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc.) and values are options
+      # @return [Array<Notification>] Array of generated notifications
       def notify_later(target_type, notifiable, options = {})
         target_type = target_type.to_s if target_type.is_a? Symbol
         options.delete(:notify_later)
@@ -272,10 +276,17 @@ module ActivityNotification
 
       # Generates notifications to specified targets.
       #
-      # @example Notify to all users
+      # For large target collections, this method uses batch processing to reduce memory consumption:
+      # - ActiveRecord::Relation: Uses find_each (loads in batches of 1000 records)
+      # - Mongoid::Criteria: Uses each with cursor batching
+      # - Arrays: Standard iteration (already in memory)
+      #
+      # @example Notify to all users (with ActiveRecord relation for memory efficiency)
       #   ActivityNotification::Notification.notify_all User.all, @comment
+      # @example Notify to all users with custom batch size
+      #   ActivityNotification::Notification.notify_all User.all, @comment, batch_size: 500
       #
-      # @param [Array<Object>] targets Targets to send notifications
+      # @param [ActiveRecord::Relation, Mongoid::Criteria, Array<Object>] targets Targets to send notifications
       # @param [Object] notifiable Notifiable instance
       # @param [Hash] options Options for notifications
       # @option options [String]                  :key                      (notifiable.default_notification_key) Key of the notification
@@ -287,23 +298,32 @@ module ActivityNotification
       # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
       # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
       # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
-      # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
-      # @return [Array<Notificaion>] Array of generated notifications
+      # @option options [Integer]                 :batch_size               (1000)                                Batch size for ActiveRecord find_each (optional)
+      # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc.) and values are options
+      # @return [Array<Notification>] Array of generated notifications
       def notify_all(targets, notifiable, options = {})
         if options[:notify_later]
           notify_all_later(targets, notifiable, options)
         else
-          targets.map { |target| notify_to(target, notifiable, options) }
+          # Optimize for large ActiveRecord relations by using batch processing
+          process_targets_in_batches(targets, notifiable, options)
         end
       end
       alias_method :notify_all_now, :notify_all
 
       # Generates notifications to specified targets later by ActiveJob queue.
       #
+      # Note: When passing ActiveRecord relations or Mongoid criteria to async jobs,
+      # they may be serialized to arrays before job execution, which can consume memory
+      # for large target sets. For very large datasets (10,000+ records), consider using
+      # notify_later with target_type instead, which generates notifications asynchronously
+      # without loading all targets upfront:
+      #   ActivityNotification::Notification.notify(:users, @comment, notify_later: true)
+      #
       # @example Notify to all users later
       #   ActivityNotification::Notification.notify_all_later User.all, @comment
       #
-      # @param [Array<Object>] targets Targets to send notifications
+      # @param [ActiveRecord::Relation, Mongoid::Criteria, Array<Object>] targets Targets to send notifications
       # @param [Object] notifiable Notifiable instance
       # @param [Hash] options Options for notifications
       # @option options [String]                  :key                      (notifiable.default_notification_key) Key of the notification
@@ -314,8 +334,8 @@ module ActivityNotification
       # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
       # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
       # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
-      # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
-      # @return [Array<Notificaion>] Array of generated notifications
+      # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc.) and values are options
+      # @return [Array<Notification>] Array of generated notifications
       def notify_all_later(targets, notifiable, options = {})
         options.delete(:notify_later)
         ActivityNotification::NotifyAllJob.perform_later(targets, notifiable, options)
@@ -324,7 +344,7 @@ module ActivityNotification
       # Generates notifications to one target.
       #
       # @example Notify to one user
-      #   ActivityNotification::Notification.notify_to @comment.auther, @comment
+      #   ActivityNotification::Notification.notify_to @comment.author, @comment
       #
       # @param [Object] target Target to send notifications
       # @param [Object] notifiable Notifiable instance
@@ -338,7 +358,7 @@ module ActivityNotification
       # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
       # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
       # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
-      # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
+      # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc.) and values are options
       # @return [Notification] Generated notification instance
       def notify_to(target, notifiable, options = {})
         if options[:notify_later]
@@ -366,7 +386,7 @@ module ActivityNotification
       # Generates notifications to one target later by ActiveJob queue.
       #
       # @example Notify to one user later
-      #   ActivityNotification::Notification.notify_later_to @comment.auther, @comment
+      #   ActivityNotification::Notification.notify_later_to @comment.author, @comment
       #
       # @param [Object] target Target to send notifications
       # @param [Object] notifiable Notifiable instance
@@ -379,7 +399,7 @@ module ActivityNotification
       # @option options [Boolean]                 :send_email               (true)                                Whether it sends notification email
       # @option options [Boolean]                 :send_later               (true)                                Whether it sends notification email asynchronously
       # @option options [Boolean]                 :publish_optional_targets (true)                                Whether it publishes notification to optional targets
-      # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc) and values are options
+      # @option options [Hash<String, Hash>]      :optional_targets         ({})                                  Options for optional targets, keys are optional target name (:amazon_sns or :slack etc.) and values are options
       # @return [Notification] Generated notification instance
       def notify_later_to(target, notifiable, options = {})
         options.delete(:notify_later)
@@ -396,7 +416,7 @@ module ActivityNotification
       # @option options [Hash]    :parameters ({})                                  Additional parameters of the notifications
       def generate_notification(target, notifiable, options = {})
         key = options[:key] || notifiable.default_notification_key
-        if target.subscribes_to_notification?(key)
+        if target.subscribes_to_notification?(key, notifiable: notifiable)
           # Store notification
           notification = store_notification(target, notifiable, key, options)
         end
@@ -474,7 +494,7 @@ module ActivityNotification
       # Returns if group member of the notifications exists.
       # This method is designed to be called from controllers or views to avoid N+1.
       #
-      # @param [Array<Notificaion>, ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] notifications Array or database query of the notifications to test member exists
+      # @param [Array<Notification>, ActiveRecord_AssociationRelation<Notification>, Mongoid::Criteria<Notification>] notifications Array or database query of the notifications to test member exists
       # @return [Boolean] If group member of the notifications exists
       def group_member_exists?(notifications)
         notifications.present? and group_members_of_owner_ids_only(notifications.map(&:id)).exists?
@@ -503,7 +523,7 @@ module ActivityNotification
 
       # Returns available options for kinds of notify methods.
       #
-      # @return [Array<Notificaion>] Available options for kinds of notify methods
+      # @return [Array<Notification>] Available options for kinds of notify methods
       def available_options
         [:key, :group, :group_expiry_delay, :notifier, :parameters, :send_email, :send_later, :pass_full_options].freeze
       end
@@ -520,7 +540,7 @@ module ActivityNotification
       # @param [String]                  key                Key of the notification
       # @param [Object]                  group              Group unit of the notifications
       # @param [ActiveSupport::Duration] group_expiry_delay Expiry period of a notification group
-      # @return [Notificaion] Valid group owner within the expiration period
+      # @return [Notification] Valid group owner within the expiration period
       def valid_group_owner(target, notifiable, key, group, group_expiry_delay)
         return nil if group.blank?
         # Bundle notification group by target, notifiable_type, group and key
@@ -549,6 +569,71 @@ module ActivityNotification
         notification.after_store
         notification
       end
+
+      # Checks if targets collection is empty without loading all records
+      # @api private
+      # @param [Object] targets Targets collection (can be an ActiveRecord::Relation, Mongoid::Criteria, Array, etc.)
+      # @return [Boolean] True if targets is empty
+      def targets_empty?(targets)
+        # For ActiveRecord relations and Mongoid criteria, use exists? to avoid loading all records
+        if targets.respond_to?(:exists?)
+          !targets.exists?
+        else
+          # For arrays and other enumerables, use blank?
+          targets.blank?
+        end
+      end
+
+      # Merges instance subscription targets with the main targets list, deduplicating.
+      # @api private
+      #
+      # @param [Object] targets Main targets collection (can be an ActiveRecord::Relation, Mongoid::Criteria, Array, etc.)
+      # @param [Array] instance_targets Targets from instance-level subscriptions
+      # @return [Array] Deduplicated array of all targets
+      def merge_targets(targets, instance_targets)
+        return targets if instance_targets.blank?
+        all_targets = targets.respond_to?(:to_a) ? targets.to_a : Array(targets)
+        (all_targets + instance_targets).uniq
+      end
+
+      # Processes targets in batches for memory efficiency with large collections
+      # @api private
+      # 
+      # For ActiveRecord::Relation, uses find_each which loads records in batches (default 1000).
+      # For Mongoid::Criteria, uses each which leverages MongoDB's cursor batching.
+      # For Arrays and other enumerables, uses standard iteration.
+      # 
+      # Note: When called from async jobs (notify_all_later), ActiveRecord relations may be
+      # serialized to arrays before reaching this method, which limits batch processing benefits.
+      # Consider using notify_later with target_type instead of notify_all_later with relations
+      # for large datasets in async scenarios.
+      #
+      # @param [Object] targets Targets collection (can be an ActiveRecord::Relation, Mongoid::Criteria, Array, etc.)
+      # @param [Object] notifiable Notifiable instance
+      # @param [Hash] options Options for notifications
+      # @option options [Integer] :batch_size (1000) Batch size for ActiveRecord find_each (optional)
+      # @return [Array<Notification>] Array of generated notifications
+      def process_targets_in_batches(targets, notifiable, options = {})
+        notifications = []
+        
+        # For ActiveRecord relations, use find_each to process in batches
+        # This loads records in batches (default 1000) to avoid loading all records into memory
+        if targets.respond_to?(:find_each)
+          batch_options = {}
+          batch_options[:batch_size] = options[:batch_size] if options[:batch_size]
+          
+          targets.find_each(**batch_options) do |target|
+            notification = notify_to(target, notifiable, options)
+            notifications << notification
+          end
+        else
+          # For arrays and other enumerables, use standard map approach
+          # Already in memory, so no batching benefit
+          notifications = targets.map { |target| notify_to(target, notifiable, options) }
+        end
+        
+        notifications
+      end
     end
 
     # :nocov:
@@ -713,7 +798,7 @@ module ActivityNotification
     # Returns the latest group member notification instance of this notification.
     # If this group owner has no group members, group owner instance self will be returned.
     #
-    # @return [Notificaion] Notification instance of the latest group member notification
+    # @return [Notification] Notification instance of the latest group member notification
     def latest_group_member
       notification = group_member? && group_owner.present? ? group_owner : self
       notification.group_member_exists? ? notification.group_members.latest : self
@@ -721,7 +806,7 @@ module ActivityNotification
 
     # Remove from notification group and make a new group owner.
     #
-    # @return [Notificaion] New group owner instance of the notification group
+    # @return [Notification] New group owner instance of the notification group
     def remove_from_group
       new_group_owner = group_members.earliest
       if new_group_owner.present?

data/lib/activity_notification/apis/subscription_api.rb

@@ -11,7 +11,7 @@ module ActivityNotification
         #   @subscriptions = @user.subscriptions.filtered_by_key('comment.reply')
         # @scope class
         # @param [String] key Key of the subscription for filter
-        # @return [ActiveRecord_AssociationRelation<Subscription>, Mongoid::Criteria<Notificaion>] Database query of filtered subscriptions
+        # @return [ActiveRecord_AssociationRelation<Subscription>, Mongoid::Criteria<Notification>] Database query of filtered subscriptions
         scope :filtered_by_key,     ->(key) { where(key: key) }
 
         # Selects filtered subscriptions by key with filter options.
@@ -23,7 +23,7 @@ module ActivityNotification
         # @param [Hash] options Options for filter
         # @option options [String]     :filtered_by_key        (nil) Key of the subscription for filter
         # @option options [Array|Hash] :custom_filter          (nil) Custom subscription filter (e.g. ["created_at >= ?", time.hour.ago] or ['created_at.gt': time.hour.ago])
-        # @return [ActiveRecord_AssociationRelation<Subscription>, Mongoid::Criteria<Notificaion>] Database query of filtered subscriptions
+        # @return [ActiveRecord_AssociationRelation<Subscription>, Mongoid::Criteria<Notification>] Database query of filtered subscriptions
         scope :filtered_by_options, ->(options = {}) {
           options = ActivityNotification.cast_to_indifferent_hash(options)
           filtered_subscriptions = all
@@ -37,34 +37,34 @@ module ActivityNotification
         }
 
         # Orders by latest (newest) first as created_at: :desc.
-        # @return [ActiveRecord_AssociationRelation<Subscription>, Mongoid::Criteria<Notificaion>] Database query of subscriptions ordered by latest first
+        # @return [ActiveRecord_AssociationRelation<Subscription>, Mongoid::Criteria<Notification>] Database query of subscriptions ordered by latest first
         scope :latest_order,              -> { order(created_at: :desc) }
 
         # Orders by earliest (older) first as created_at: :asc.
-        # @return [ActiveRecord_AssociationRelation<Subscription>, Mongoid::Criteria<Notificaion>] Database query of subscriptions ordered by earliest first
+        # @return [ActiveRecord_AssociationRelation<Subscription>, Mongoid::Criteria<Notification>] Database query of subscriptions ordered by earliest first
         scope :earliest_order,            -> { order(created_at: :asc) }
 
         # Orders by latest (newest) first as created_at: :desc.
         # This method is to be overridden in implementation for each ORM.
         # @param [Boolean] reverse If subscriptions will be ordered as earliest first
-        # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of ordered subscriptions
+        # @return [ActiveRecord_AssociationRelation<Notification>, Mongoid::Criteria<Notification>] Database query of ordered subscriptions
         scope :latest_order!,             ->(reverse = false) { reverse ? earliest_order : latest_order }
 
         # Orders by earliest (older) first as created_at: :asc.
         # This method is to be overridden in implementation for each ORM.
-        # @return [ActiveRecord_AssociationRelation<Notificaion>, Mongoid::Criteria<Notificaion>] Database query of subscriptions ordered by earliest first
+        # @return [ActiveRecord_AssociationRelation<Notification>, Mongoid::Criteria<Notification>] Database query of subscriptions ordered by earliest first
         scope :earliest_order!,           -> { earliest_order }
 
         # Orders by latest (newest) first as subscribed_at: :desc.
-        # @return [ActiveRecord_AssociationRelation<Subscription>, Mongoid::Criteria<Notificaion>] Database query of subscriptions ordered by latest subscribed_at first
+        # @return [ActiveRecord_AssociationRelation<Subscription>, Mongoid::Criteria<Notification>] Database query of subscriptions ordered by latest subscribed_at first
         scope :latest_subscribed_order,   -> { order(subscribed_at: :desc) }
 
         # Orders by earliest (older) first as subscribed_at: :asc.
-        # @return [ActiveRecord_AssociationRelation<Subscription>, Mongoid::Criteria<Notificaion>] Database query of subscriptions ordered by earliest subscribed_at first
+        # @return [ActiveRecord_AssociationRelation<Subscription>, Mongoid::Criteria<Notification>] Database query of subscriptions ordered by earliest subscribed_at first
         scope :earliest_subscribed_order, -> { order(subscribed_at: :asc) }
 
         # Orders by key name as key: :asc.
-        # @return [ActiveRecord_AssociationRelation<Subscription>, Mongoid::Criteria<Notificaion>] Database query of subscriptions ordered by key name
+        # @return [ActiveRecord_AssociationRelation<Subscription>, Mongoid::Criteria<Notification>] Database query of subscriptions ordered by key name
         scope :key_order,                 -> { order(key: :asc) }
 
         # Convert Time value to store in database as Hash value.
@@ -182,7 +182,7 @@ module ActivityNotification
     # Returns if the target subscribes to the specified optional target.
     #
     # @param [Symbol]  optional_target_name Symbol class name of the optional target implementation (e.g. :amazon_sns, :slack)
-    # @param [Boolean] subscribe_as_default Default subscription value to use when the subscription record does not configured
+    # @param [Boolean] subscribe_as_default Default subscription value to use when the subscription record is not configured
     # @return [Boolean] If the target subscribes to the specified optional target
     def subscribing_to_optional_target?(optional_target_name, subscribe_as_default = ActivityNotification.config.subscribe_to_optional_targets_as_default)
       optional_target_key = Subscription.to_optional_target_key(optional_target_name)

data/lib/activity_notification/common.rb

@@ -105,7 +105,7 @@ module ActivityNotification
       end
     end
 
-    # Convets to class name.
+    # Converts to class name.
     # This function returns base_class name for STI models if the class responds to base_class method.
     # @see https://github.com/simukappu/activity_notification/issues/89
     # @see https://github.com/simukappu/activity_notification/pull/139
@@ -114,26 +114,26 @@ module ActivityNotification
       self.class.respond_to?(:base_class) ? self.class.base_class.name : self.class.name
     end
 
-    # Convets to singularized model name (resource name).
+    # Converts to singularized model name (resource name).
     # @return [String] Singularized model name (resource name)
     def to_resource_name
       self.to_class_name.demodulize.singularize.underscore
     end
 
-    # Convets to pluralized model name (resources name).
+    # Converts to pluralized model name (resources name).
     # @return [String] Pluralized model name (resources name)
     def to_resources_name
       self.to_class_name.demodulize.pluralize.underscore
     end
 
-    # Convets to printable model type name to be humanized.
+    # Converts to printable model type name to be humanized.
     # @return [String] Printable model type name
     # @todo Is this the best to make readable?
     def printable_type
       "#{self.to_class_name.demodulize.humanize}"
     end
 
-    # Convets to printable model name to show in view or email.
+    # Converts to printable model name to show in view or email.
     # @return [String] Printable model name
     def printable_name
       "#{self.printable_type} (#{id})"

data/lib/activity_notification/config.rb

@@ -91,6 +91,15 @@ module ActivityNotification
     #   @return [String, Array<String>, Proc] CC email address(es) for notification email.
     attr_accessor :mailer_cc
 
+    # @overload mailer_attachments
+    #   Returns attachment specification(s) for notification emails
+    #   @return [Hash, Array<Hash>, Proc, nil] Attachment specification(s) for notification emails.
+    # @overload mailer_attachments=(value)
+    #   Sets attachment specification(s) for notification emails
+    #   @param [Hash, Array<Hash>, Proc, nil] mailer_attachments The new mailer_attachments
+    #   @return [Hash, Array<Hash>, Proc, nil] Attachment specification(s) for notification emails.
+    attr_accessor :mailer_attachments
+
     # @overload mailer
     #   Returns mailer class for email notification
     #   @return [String] Mailer class for email notification.
@@ -173,8 +182,8 @@ module ActivityNotification
     attr_accessor :composite_key_delimiter
 
     # @overload store_with_associated_records
-    #   Returns whether activity_notification stores notificaion records including associated records like target and notifiable
-    #   @return [Boolean] Whether activity_notification stores notificaion records including associated records like target and notifiable.
+    #   Returns whether activity_notification stores notification records including associated records like target and notifiable
+    #   @return [Boolean] Whether activity_notification stores Notification records including associated records like target and notifiable.
     attr_reader :store_with_associated_records
 
     # @overload action_cable_enabled
@@ -246,6 +255,7 @@ module ActivityNotification
       @subscribe_to_optional_targets_as_default = nil
       @mailer_sender                            = nil
       @mailer_cc                                = nil
+      @mailer_attachments                       = nil
       @mailer                                   = 'ActivityNotification::Mailer'
       @parent_mailer                            = 'ActionMailer::Base'
       @parent_job                               = 'ActiveJob::Base'
@@ -271,10 +281,10 @@ module ActivityNotification
       @orm = orm.to_sym
     end
 
-    # Sets whether activity_notification stores notificaion records including associated records like target and notifiable.
+    # Sets whether activity_notification stores notification records including associated records like target and notifiable.
     # This store_with_associated_records option can be set true only when you use mongoid or dynamoid ORM.
     # @param [Boolean] store_with_associated_records The new store_with_associated_records
-    # @return [Boolean] Whether activity_notification stores notificaion records including associated records like target and notifiable.
+    # @return [Boolean] Whether activity_notification stores notification records including associated records like target and notifiable.
     def store_with_associated_records=(store_with_associated_records)
       if store_with_associated_records && [:mongoid, :dynamoid].exclude?(@orm) then raise ActivityNotification::ConfigError, "config.store_with_associated_records can be set true only when you use mongoid or dynamoid ORM." end
       @store_with_associated_records = store_with_associated_records
@@ -289,7 +299,7 @@ module ActivityNotification
     end
 
     # Returns default optional target subscription value to use when the subscription record does not configured
-    # @return [Boolean] Default optinal target subscription value to use when the subscription record does not configured.
+    # @return [Boolean] Default optional target subscription value to use when the subscription record does not configured.
     def subscribe_to_optional_targets_as_default
       return false unless @subscribe_as_default
 

data/lib/activity_notification/controllers/common_controller.rb

@@ -67,14 +67,12 @@ module ActivityNotification
       end
 
       # Returns path of the target view templates.
-      # Do not make this method public unless Rendarable module calls controller's target_view_path method to render resources.
+      # Do not make this method public unless Renderable module calls controller's target_view_path method to render resources.
       # @api protected
       def target_view_path
         target_type = @target.to_resources_name
         view_path = [controller_path, target_type].join('/')
-        lookup_context.exists?(action_name, view_path) ?
-          view_path :
-          [controller_path, DEFAULT_VIEW_DIRECTORY].join('/')
+        lookup_context.exists?(action_name, view_path) ? view_path : [controller_path, DEFAULT_VIEW_DIRECTORY].join('/')
       end
 
       # Sets view prefixes for target view path.

data/lib/activity_notification/controllers/devise_authentication_controller.rb

@@ -14,7 +14,7 @@ module ActivityNotification
       # Authenticate devise resource by Devise (e.g. calling authenticate_user! method).
       # @api protected
       # @todo Needs to call authenticate method by more secure way
-      # @return [Response] Redirects for unsigned in target by Devise, returns HTTP 403 without neccesary target method or returns 400 when request parameters are not enough
+      # @return [Response] Redirects for unsigned in target by Devise, returns HTTP 403 without necessary target method or returns 400 when request parameters are not enough
       def authenticate_devise_resource!
         if params[:devise_type].present?
           authenticate_method_name = "authenticate_#{params[:devise_type].to_resource_name}!"
@@ -29,7 +29,7 @@ module ActivityNotification
       end
 
       # Sets @target instance variable from request parameters.
-      # This method override super (ActivityNotiication::CommonController#set_target)
+      # This method override super (ActivityNotification::CommonController#set_target)
       # to set devise authenticated target when the target_id params is not specified.
       # @api protected
       # @return [Object] Target instance (Returns HTTP 400 when request parameters are not enough)