action_cable_notifications 0.1.27 → 0.1.35

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: bbf5459391f70a5ea26fcbe49d73d658ee0018e1
-  data.tar.gz: 139cee45492e3dbac434fa59428784ee779ffc14
+SHA256:
+  metadata.gz: 791d0cda5f750319e778b0f7e0c9c656721d4ad4a3b2dcc6bf7377a88e7d10d8
+  data.tar.gz: '085b106ff16bde873da19f9c0d800cb5dfcdb184c4bf6607c60872d156fdf0a2'
 SHA512:
-  metadata.gz: f81b284758a85fb93d2c189ae4ec8b4f642ba4855309534017e0f3def93260851545d35a23a4ea5a1ba125c58c331c9df50cc29d9fa939e563786b272a1c9164
-  data.tar.gz: dbdf1d02cc3bc63458ddc7e460f8e47a48d58031a2b6008ca22943b1fc1a84fbda856962241dba5e43ad3b8773a1d018a4954aaf2563248935758f9b4641f885
+  metadata.gz: 0d4270f9e8441719683eda7d7874b8f984c108999bcefa5ecf3df371a753c4172f53ea91ba441aa8147cf530126aeef5677d1168b675cd40a8e18e37ec1bcc66
+  data.tar.gz: 8f4c6acbecb415cd2e9f018ccc0fc17d1187a99ddd9cb77b00fe9aa5645378d693bda60a666707e21c5c6a3e538d5b4752d4f25df2f451b5663d7a5b07f13188

data/README.md

@@ -19,9 +19,17 @@ class TestChannel < ApplicationCable::Channel
   include ActionCableNotifications::Channel
 
   def subscribed
+    # Config streaming for Customer model with default options
     stream_notifications_for Customer
     # Can have more than one ActiveRecord model streaming per channel
-    stream_notifications_for Invoice, scope: { limit: 5, order: :id, select: [:id, :customer_id, :seller_id, :amount] }
+    stream_notifications_for Invoice,
+      model_options: {
+        scope: { 
+          limit: 5, 
+          order: :id, 
+          select: [:id, :customer_id, :seller_id, :amount]
+      }
+    }
   end
 
   def unsubscribed
@@ -40,10 +48,14 @@ stream_notifications_for(model, options = {}, &block)
 * options: **(Hash)** - Options to be used for configuracion. Default options are:
 ```ruby
 {
-  actions: [:create, :update, :destroy],     # Controller actions to attach to
-  broadcasting: model.model_name.collection, # Name of the pubsub stream
-  params: params,                            # Params sent during subscription
-  scope: :all                                # Default collection scope. Can be an Array or Hash
+  publication: model.model_name.collection, # Name of the pubsub stream
+  params: params,                            # Params sent when client subscribes
+  cache: false,                              # Turn off server-side cache of client-side data
+  model_options: {
+    actions: [:create, :update, :destroy],     # Model callbacks to attach to
+    scope: :all                                # Default collection scope. Can be an ,Array or Hash
+    track_scope_changes: true                 # During model updates, checks if the changes affect scope inclusion of the resulting record
+  }
 }
 ```
 

data/app/assets/javascripts/action_cable_notifications/collection.coffee

@@ -4,7 +4,7 @@ class CableNotifications.Collection
   upstream = (command, params={}) ->
     if @sync
       cmd =
-        collection: @tableName
+        publication: @publication
         command: command
         params: params
 
@@ -35,7 +35,7 @@ class CableNotifications.Collection
 
   # Public methods
   #######################################
-  constructor: (@store, @name, @tableName, @callbacks) ->
+  constructor: (@store, @name, @publication=name, callbacks) ->
     # Data storage array
     @data = []
     # Channel used to sync with upstream collection
@@ -47,8 +47,21 @@ class CableNotifications.Collection
     # Stores records that needs to be tracked when inserted into the collection
     @trackedRecords = []
 
+    @callbacks = {}
+
+    @observeChanges(callbacks)
+
     @callbacks?.initialize?.call(this)
 
+  # Update the callback stack for collection
+  observeChanges: (new_callbacks) ->
+    _.each(new_callbacks, (cb, name) =>
+      old_cb = @callbacks?[name]
+      @callbacks[name] = () ->
+        cb.apply(this, arguments)
+        old_cb?.apply(this, arguments)
+    )
+
   # Sync collection to ActionCable Channel
   syncToChannel: (@channel) ->
     @sync = true
@@ -90,7 +103,7 @@ class CableNotifications.Collection
       record
 
   # Creates a new record
-  create: (fields={}) ->
+  create: (fields={}, options={}) ->
     record = _.find(@data, {id: fields.id})
     if record
       console.warn("[create] Not expected to find an existing record with id #{fields.id}")
@@ -105,8 +118,9 @@ class CableNotifications.Collection
     if !@sync
       @data.push (fields)
       @callbacks?.create?.call(this, fields)
-
-    upstream.call(this, "create", {fields: fields})
+      @callbacks?.changed?.call(this, @data) unless options.batching
+    else
+      upstream.call(this, "create", {fields: fields})
     fields
 
   # Update an existing record
@@ -114,23 +128,24 @@ class CableNotifications.Collection
     record = _.find(@data, selector)
     if !record
       if options.upsert
-        @create(fields)
+        @create(fields, options)
       else
         console.warn("[update] Couldn't find a matching record:", selector)
     else
       if !@sync
         @callbacks?.update?.call(this, selector, fields, options)
         _.extend(record, fields)
-
-      upstream.call(this, "update", {id: record.id, fields: fields})
+        @callbacks?.changed?.call(this, @data) unless options.batching
+      else
+        upstream.call(this, "update", {id: record.id, fields: fields})
       record
 
   # Update an existing record or inserts a new one if there is no match
-  upsert: (selector={}, fields) ->
-    @update(selector, fields, {upsert: true})
+  upsert: (selector={}, fields, options={}) ->
+    @update(selector, fields, _.extend(options, {upsert: true}))
 
   # Destroy an existing record
-  destroy: (selector={}) ->
+  destroy: (selector={}, options={}) ->
     index = _.findIndex(@data, selector)
     if index < 0
       console.warn("[destroy] Couldn't find a matching record:", selector)
@@ -139,6 +154,7 @@ class CableNotifications.Collection
       if !@sync
         @data.splice(index, 1)
         @callbacks?.destroy?.call(this, selector)
-
-      upstream.call(this, "destroy", {id: record.id})
+        @callbacks?.changed?.call(this, @data) unless options.batching
+      else
+        upstream.call(this, "destroy", {id: record.id})
       record

data/app/assets/javascripts/action_cable_notifications/default_callbacks.coffee

@@ -15,12 +15,15 @@ class CableNotifications.Store.DefaultCallbacks
     collection.update({id: packet.id}, packet.data)
 
   update_many: (packet, collection) ->
-    _.each packet.data, (fields) ->
-      collection.update({id: fields.id}, fields)
+    _.each packet.data, (fields, index, records) ->
+      collection.update({id: fields.id}, fields, {batching: index<records.length-1})
+
+  upsert: (packet, collection) ->
+    collection.upsert({id: packet.id}, packet.data)
 
   upsert_many: (packet, collection) ->
-    _.each packet.data, (fields) ->
-      collection.upsert({id: fields.id}, fields)
+    _.each packet.data, (fields, index, records) ->
+      collection.upsert({id: fields.id}, fields, {batching: index<records.length-1})
 
   destroy: (packet, collection) ->
     collection.destroy({id: packet.id})

data/app/assets/javascripts/action_cable_notifications/store.coffee

@@ -16,10 +16,10 @@ class CableNotifications.Store
   # Then call original callback
   packetReceived = (channelInfo) ->
     (packet) ->
-      if packet?.collection
+      if packet?.publication
         # Search if there is a collection in this Store that receives packets from the server
         collection = _.find(channelInfo.collections,
-          {tableName: packet.collection})
+          {publication: packet.publication})
         if collection
           dispatchPacket.call(this, packet, collection)
       channelInfo.callbacks.received?.apply(channelInfo.channel, arguments)
@@ -56,12 +56,11 @@ class CableNotifications.Store
   #######################################
 
   # Register a new collection
-  registerCollection: (name, channel, tableName, actions) ->
-    tableName = name unless tableName
+  registerCollection: (name, channel, publication=name, actions) ->
     if @collections[name]
       console.warn "[registerCollection]: Collection '#{name}' already exists"
     else
-      @collections[name] = new CableNotifications.Collection(this, name, tableName, actions)
+      @collections[name] = new CableNotifications.Collection(this, name, publication, actions)
       if channel
         @syncToChannel(channel, @collections[name])
 

data/lib/action_cable_notifications/channel.rb

@@ -6,10 +6,7 @@ module ActionCableNotifications
     extend ActiveSupport::Concern
 
     included do
-      # class variables
-      class_attribute :ActionCableNotifications
 
-      self.ActionCableNotifications = {}
     end
 
     #
@@ -21,42 +18,46 @@ module ActionCableNotifications
     #
     # @param [Hash] data Contains command to be executed and its parameters
     # {
-    #   "collection": "model.model_name.collection"
+    #   "publication": "model.model_name.name"
     #   "command": "fetch"
     #   "params": {}
     # }
     def action(data)
       data.deep_symbolize_keys!
 
-      channel_options = self.ActionCableNotifications[data[:collection]]
+      publication = data[:publication]
+      channel_options = @ChannelPublications[publication]
       if channel_options
         model = channel_options[:model]
-        broadcasting = channel_options[:broadcasting]
-        model_options = model.ActionCableNotificationsOptions[broadcasting]
+        model_options = model.ChannelPublications[publication]
+        params = data[:params]
+        command = data[:command]
 
-        params = {
+        action_params = {
+          publication: publication,
           model: model,
           model_options: model_options,
-          params: data[:params],
-          command: data[:command]
+          options: channel_options,
+          params: params,
+          command: command
         }
 
-        case data[:command]
+        case command
         when "fetch"
-          fetch(params)
+          fetch(action_params)
         when "create"
-          create(params)
+          create(action_params)
         when "update"
-          update(params)
+          update(action_params)
         when "destroy"
-          destroy(params)
+          destroy(action_params)
         end
       else
         response = {
-          collection: data[:collection],
+          publication: publication,
           msg: 'error',
-          command: data[:command],
-          error: "Collection '#{data[:collection]}' does not exist."
+          command: command,
+          error: "Stream for publication '#{publication}' does not exist in channel '#{self.channel_name}'."
         }
 
         # Send error notification to the client
@@ -65,8 +66,9 @@ module ActionCableNotifications
     end
 
     def initialize(*args)
-      super
       @collections = {}
+      @ChannelPublications = {}
+      super
     end
 
     def subscribed
@@ -94,35 +96,45 @@ module ActionCableNotifications
     # @param [Hash] options Streaming options
     #
     def stream_notifications_for(model, options = {})
-      # Default options
+
+      # Default publication options
       options = {
-        broadcasting: model.model_name.collection,
-        params: nil
-      }.merge(options)
+        publication: model.model_name.name,
+        cache: false,
+        model_options: {},
+        scope: :all
+      }.merge(options).merge(params.deep_symbolize_keys)
 
       # These options cannot be overridden
       options[:model] = model
-      options[:channel] = self
-      model_name = model.model_name.collection
 
-      # Sets channel options
-      self.ActionCableNotifications[model_name] = options
+      publication = options[:publication]
 
-      # Checks if model already includes notification callbacks
-      if !model.respond_to? :ActionCableNotificationsOptions
-        model.send('include', ActionCableNotifications::Model)
-      end
+      # Checks if the publication already exists in the channel
+      if not @ChannelPublications.include?(publication)
+        # Sets channel options
+        @ChannelPublications[publication] = options
 
-      # Sets broadcast options if they are not already present in the model
-      if not model.ActionCableNotificationsOptions.key? options[:broadcasting]
-        model.broadcast_notifications_from options[:broadcasting], options
-      end
+        # Checks if model already includes notification callbacks
+        if !model.respond_to? :ChannelPublications
+          model.send('include', ActionCableNotifications::Model)
+        end
 
-      # Start streaming
-      stream_from options[:broadcasting], coder: ActiveSupport::JSON do |packet|
-        transmit_packet(packet)
-      end
+        # Sets broadcast options if they are not already present in the model
+        if not model.ChannelPublications.key? publication
+          model.broadcast_notifications_from publication, options[:model_options]
+        else # Reads options configuracion from model
+          options[:model_options] = model.ChannelPublications[publication]
+        end
 
+        # Start streaming
+        stream_from publication, coder: ActiveSupport::JSON do |packet|
+          packet.merge!({publication: publication})
+          transmit_packet(packet, options)
+        end
+        # XXX: Transmit initial data
+
+      end
     end
 
     #
@@ -130,10 +142,22 @@ module ActionCableNotifications
     #
     # @param [Hash] packet Packet with changes notifications
     #
-    def transmit_packet(packet)
-      packet = packet.as_json.deep_symbolize_keys!
-      if update_cache(packet)
-        transmit packet
+    def transmit_packet(packet, options={})
+      # Default options
+      options = {
+        cache: false
+      }.merge(options)
+
+      packet = packet.as_json.deep_symbolize_keys
+
+      if validate_packet(packet, options)
+        if options[:cache]==true
+          if update_cache(packet)
+            transmit packet
+          end
+        else
+          transmit packet
+        end
       end
     end
 

data/lib/action_cable_notifications/channel_actions.rb

@@ -12,20 +12,36 @@ module ActionCableNotifications
         params = data[:params] || {}
 
         # Get results using provided parameters and model configured scope
-        results = data[:model].
+        begin
+          temp_scope = data[:model_options][:scope].deep_dup || {}
+          if (data[:model_options][:scope].is_a? Hash) && (data[:model_options][:scope][:where].is_a? Hash)
+            #temp_scope = temp_scope.merge(params)
+            temp_scope[:where].each{|k,v| v.is_a?(Proc) ? temp_scope[:where][k]=v.call() : nil }
+          end
+          results = data[:model].
                     select(params[:select] || []).
                     limit(params[:limit]).
                     where(params[:where] || {}).
-                    scoped_collection(data[:model_options][:scope]).
+                    scoped_collection(temp_scope).
                     to_a() rescue []
 
-        response = { collection: data[:model].model_name.collection,
-          msg: 'upsert_many',
-          data: results
-        }
+          response = {
+            publication: data[:publication],
+            msg: 'upsert_many',
+            data: results
+          }
+        rescue Exception => e
+          response = {
+            publication: data[:publication],
+            collection: data[:model].model_name.collection,
+            msg: 'error',
+            command: data[:command],
+            error: e.message
+          }
+        end
 
         # Send data to the client
-        transmit_packet response
+        transmit_packet response, data[:options]
       end
 
       #
@@ -62,7 +78,7 @@ module ActionCableNotifications
           }
 
           # Send error notification to the client
-          transmit response
+          transmit_packet response
         end
 
       end
@@ -99,7 +115,7 @@ module ActionCableNotifications
           }
 
           # Send error notification to the client
-          transmit response
+          transmit_packet response
         end
 
       end
@@ -134,7 +150,7 @@ module ActionCableNotifications
           }
 
           # Send error notification to the client
-          transmit response
+          transmit_packet response
         end
 
       end

data/lib/action_cable_notifications/channel_cache.rb

@@ -1,7 +1,51 @@
+require 'action_cable_notifications/hash_db.rb'
+
 module ActionCableNotifications
   module Channel
     module Cache
 
+      def initialize(*args)
+        super
+        @cache = HashDB::Base.new()
+      end
+
+      #
+      # Validates packet before transmitting the message
+      #
+      # @param [Hash] packet Packet to be transmitted
+      # @param [Hash] options Channels options used to validate the packet
+      #
+      # @return [Boolean] <description>
+      #
+      def validate_packet(packet, options = {})
+        options = {
+        }.merge(options)
+
+        if packet[:msg].in? ['upsert_many', 'create', 'update', 'destroy']
+          if packet[:msg].in? ['upsert_many']
+            data = packet[:data]
+          else
+            data = [(packet[:data] || {}).merge({id: packet[:id]})]
+          end
+
+          packet_validator = HashDB::Base.new(data)
+          data = packet_validator.scoped_collection(options[:scope]).data
+          if data.present?
+            if packet[:msg].in? ['upsert_many']
+              packet[:data] = data
+            else
+              packet[:data] = data.first
+            end
+            true
+          else
+            false
+          end
+        else
+          true
+        end
+
+      end
+
       #
       # Updates server side cache of client side collections
       # XXX compute cache diff before sending to clients

data/lib/action_cable_notifications/hash_db.rb

@@ -0,0 +1,111 @@
+module HashDB
+  class Base
+
+    def initialize(data=nil)
+      if data.present?
+        @data = Array(data)
+      else
+        @data = []
+      end
+    end
+
+    def data
+      @data
+    end
+
+    def data=(data)
+      @data = data || []
+    end
+
+    def wrap(data)
+      HashDB::Base.new(data)
+    end
+
+    private :wrap
+
+    def all(options={})
+      if options.has_key?(:conditions)
+        where(options[:conditions])
+      else
+        wrap(@data ||= [])
+      end
+    end
+
+    def count
+      all.length
+    end
+
+    def where(options)
+      return @data if options.blank?
+
+      data = (@data || []).select do |record|
+        match_options?(record, options)
+      end
+
+      wrap(data)
+    end
+
+    def match_options?(record, options)
+      options.all? do |col, match|
+        if [Array, Range].include?(match.class)
+          match.include?(record[col])
+        else
+          record[col] == match
+        end
+      end
+    end
+
+    private :match_options?
+
+    def scoped_collection ( scope = :all )
+      scope = scope.to_a if scope.is_a? Hash
+      Array(scope).inject(self) do |o, a|
+        o.try(*a)
+      end
+    end
+
+    def select( fields=nil )
+      if fields.present?
+        wrap(@data.map{|v| v.slice(*(Array(fields).map(&:to_sym)))})
+      else
+        all
+      end
+    end
+
+    def limit( count=nil )
+      if count.present? and count>0
+        wrap(@data.slice(0,count))
+      else
+        all
+      end
+    end
+
+    def delete_all
+      @data = []
+    end
+
+    def first
+      @data.first
+    end
+
+    def last
+      @data.last
+    end
+
+    def find(id, * args)
+      case id
+        when nil
+          nil
+        when :all
+          all
+        when :first
+          all(*args).first
+        when Array
+          id.map { |i| find(i) }
+        else
+          where({id: id})
+      end
+    end
+
+  end
+end

data/lib/action_cable_notifications/model.rb

@@ -4,31 +4,44 @@ module ActionCableNotifications
 
     included do
       # Action cable notification options storage
-      class_attribute :ActionCableNotificationsOptions
-      self.ActionCableNotificationsOptions = {}
+      class_attribute :ChannelPublications
+      self.ChannelPublications = {}
 
       # Register Callbacks
+      before_update :prepare_update
       after_update :notify_update
       after_create :notify_create
       after_destroy :notify_destroy
-    end
 
-    module ClassMethods
+      def record_within_scope records
+        if records.respond_to?(:where)
+          found_record = records.where(id: self.id).first
+        elsif records.respond_to?(:detect) and (found_record = records.detect{|e| e["id"]==self.id})
+          found_record
+        else
+          nil
+        end
+      end
+
+    end
 
+    class_methods do
       #
       # Sets or removes notificacions options for Active Record model
       #
-      # @param [sym] broadcasting Topic name to broadcast in
+      # @param [sym] publication Topic name to broadcast in
       # @param [hash] options Hash containing notification options
       #
-      def broadcast_notifications_from ( broadcasting, options = {} )
+      def broadcast_notifications_from ( publication, options = {} )
         # Default options
         options = {
           actions: [:create, :update, :destroy],
-          scope: :all             # Default collection scope
+          track_scope_changes: false,
+          scope: :all,             # Default collection scope
+          records: []
           }.merge(options)
 
-        self.ActionCableNotificationsOptions[broadcasting.to_s] = options
+        self.ChannelPublications[publication.to_s] = options
       end
 
       #
@@ -47,19 +60,17 @@ module ActionCableNotifications
       #
       # Retrieves initial values to be sent to clients upon subscription
       #
-      # @param [Sym] broadcasting Name of broadcasting stream
+      # @param [Sym] publication Name of publication stream
       #
       # @return [Hash] Hash containing the results in the following format:
       # {
-      #   collection: self.model_name.collection,
       #   msg: 'add_collection',
       #   data: self.scoped_collection(options[:scope])
       # }
-      def notify_initial ( broadcasting )
-        options = self.ActionCableNotificationsOptions[broadcasting.to_s]
+      def notify_initial ( publication )
+        options = self.ChannelPublications[publication.to_s]
         if options.present?
           {
-            collection: self.model_name.collection,
             msg: 'upsert_many',
             data: self.scoped_collection(options[:scope])
           }
@@ -71,12 +82,13 @@ module ActionCableNotifications
     # Broadcast notifications when a new record is created
     #
     def notify_create
-      self.ActionCableNotificationsOptions.each do |broadcasting, options|
+      self.ChannelPublications.each do |publication, options|
         if options[:actions].include? :create
-          # Checks if record is within scope before broadcasting
-          if self.class.scoped_collection(options[:scope]).where(id: self.id)
-            ActionCable.server.broadcast broadcasting,
-              collection: self.model_name.collection,
+          # Checks if records is within scope before broadcasting
+          records = self.class.scoped_collection(options[:scope])
+
+          if options[:scope]==:all or record_within_scope(records)
+            ActionCable.server.broadcast publication,
               msg: 'create',
               id: self.id,
               data: self
@@ -85,32 +97,81 @@ module ActionCableNotifications
       end
     end
 
+    def prepare_update
+      self.ChannelPublications.each do |publication, options|
+        if options[:actions].include? :update
+          if options[:scope]==:all
+            options[:records].push self
+          else
+            record = record_within_scope(self.class.scoped_collection(options[:scope]))
+            if record.present?
+              options[:records].push record
+            end
+          end
+        end
+      end
+    end
+
     #
-    # Broadcast notifications when a record is updated. Only changed
-    # field will be sent.
+    # Broadcast notifications when a record is updated. Only changed fields will be sent
+    # if they are within configured scope
     #
     def notify_update
-      changes = {}
-      self.changes.each do |k,v|
-        changes[k] = v[1]
+      # Get model changes
+      if self.respond_to?(:saved_changes) # For Rails >= 5.1
+        changes = self.saved_changes.transform_values(&:second)
+      else # For Rails < 5.1
+        changes = self.changes.transform_values(&:second)
       end
 
+      # Checks if there are changes in the model
       if !changes.empty?
-        self.ActionCableNotificationsOptions.each do |broadcasting, options|
+        self.ChannelPublications.each do |publication, options|
           if options[:actions].include? :update
-            # Checks if record is within scope before broadcasting
-            if self.class.scoped_collection(options[:scope]).where(id: self.id)
-              # XXX: Performance required. For small data sets this should be
-              # fast enough, but for large data sets this could be slow. As
-              # clients should have a limited subset of the dataset loaded at a
-              # time, caching the results already sent to clients in server memory
-              # should not have a big impact in memory usage but can improve
-              # performance for large data sets where only a sub
-              ActionCable.server.broadcast broadcasting,
-                collection: self.model_name.collection,
-                msg: 'update',
-                id: self.id,
-                data: changes
+            # Checks if previous record was within scope
+            record = record_within_scope(options[:records])
+            was_in_scope = record.present?
+
+            options[:records].delete(record) if was_in_scope
+
+            # Checks if current record is within scope
+            if options[:track_scope_changes]==true
+              is_in_scope = false
+              if options[:scope]==:all
+                record = self
+                is_in_scope = true
+              else
+                record = record_within_scope(self.class.scoped_collection(options[:scope]))
+                if record.present?
+                  is_in_scope = true
+                end
+              end
+            else
+              is_in_scope = was_in_scope
+            end
+
+            # Broadcasts notifications about model changes
+            if is_in_scope
+              if was_in_scope
+                # Get model changes and applies them to the scoped collection record
+                changes.select!{|k,v| record.respond_to?(k)}
+
+                if !changes.empty?
+                  ActionCable.server.broadcast publication,
+                    msg: 'update',
+                    id: self.id,
+                    data: changes
+                end
+              else
+                ActionCable.server.broadcast publication,
+                  msg: 'create',
+                  id: record.id,
+                  data: record
+              end
+            elsif was_in_scope # checks if needs to delete the record if its no longer in scope
+              ActionCable.server.broadcast publication,
+                msg: 'destroy',
+                id: self.id
             end
           end
         end
@@ -121,12 +182,11 @@ module ActionCableNotifications
     # Broadcast notifications when a record is destroyed.
     #
     def notify_destroy
-      self.ActionCableNotificationsOptions.each do |broadcasting, options|
-        if options[:actions].include? :destroy
+      self.ChannelPublications.each do |publication, options|
+        if options[:scope]==:all or options[:actions].include? :destroy
           # Checks if record is within scope before broadcasting
-          if self.class.scoped_collection(options[:scope]).where(id: self.id)
-            ActionCable.server.broadcast broadcasting,
-              collection: self.model_name.collection,
+          if options[:scope]==:all or record_within_scope(self.class.scoped_collection(options[:scope])).present?
+            ActionCable.server.broadcast publication,
               msg: 'destroy',
               id: self.id
           end

data/lib/action_cable_notifications/version.rb

@@ -1,3 +1,3 @@
 module ActionCableNotifications
-  VERSION = '0.1.27'
+  VERSION = '0.1.35'
 end

metadata

@@ -1,22 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: action_cable_notifications
 version: !ruby/object:Gem::Version
-  version: 0.1.27
+  version: 0.1.35
 platform: ruby
 authors:
 - ByS Sistemas de Control
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-09 00:00:00.000000000 Z
+date: 2022-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 5.0.0
     - - ">="
       - !ruby/object:Gem::Version
         version: 5.0.0.1
@@ -24,9 +21,6 @@ dependencies:
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 5.0.0
     - - ">="
       - !ruby/object:Gem::Version
         version: 5.0.0.1
@@ -34,14 +28,14 @@ dependencies:
   name: lodash-rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 4.15.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: 4.15.0
 - !ruby/object:Gem::Dependency
@@ -86,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Rails engine that provides Automatic realtime notification broadcast
   for ActiveRecord models changes using Action Cable and websockets
 email:
@@ -118,6 +126,7 @@ files:
 - lib/action_cable_notifications/channel_actions.rb
 - lib/action_cable_notifications/channel_cache.rb
 - lib/action_cable_notifications/engine.rb
+- lib/action_cable_notifications/hash_db.rb
 - lib/action_cable_notifications/model.rb
 - lib/action_cable_notifications/version.rb
 - lib/tasks/action_cable_notifications_tasks.rake
@@ -140,8 +149,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: Automatic realtime notification broadcast for ActiveRecord models changes