action_cable_notifications 0.1.28 → 0.1.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6a2dc5fdc10bc32033f2ecf6d124718ab3949382
-  data.tar.gz: a8a4331d41f25160ca387f189df4ef087472ee91
+  metadata.gz: 64f6e0167fd97bc6b64dc43e1292c331cf7baff7
+  data.tar.gz: bf24e8703a9953a7be75a3d80f73deb27a118508
 SHA512:
-  metadata.gz: 1ab592b4eee5232708d9e768bd8d5dec672e77ad4ab28bfd6124bc5e99421dfc652235f4e0e659c5f71c76d6a64b7e261eea87422f38abf3b528c2d463a91e4f
-  data.tar.gz: 52f6f172a7090127f99e195e546c5f72fd0c56ecf68c2c9c5048e3660c60667ce39a150f8995dfd733223f68c1b3f75407a6b023563a85be933ab6120f197a38
+  metadata.gz: 624a3425d47cd3ea0291abdc706a7b3bc5c12c5d19715775012c364b70d4b00d30907399b3c161357012bca7b33ca4f9afd48ab6f09b4fd95f21c048444b8d1b
+  data.tar.gz: 2848f179da19c2af48b313e07ae81638e481beac62cef85734d9c888e86c10622ffda3230bc2aa091f3589a9434624eebffd805a8d76a9fec6cbc5bfc7c7cb03

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
 
@@ -38,7 +38,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
@@ -50,8 +50,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
@@ -93,7 +106,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}")
@@ -108,6 +121,7 @@ class CableNotifications.Collection
     if !@sync
       @data.push (fields)
       @callbacks?.create?.call(this, fields)
+      @callbacks?.changed?.call(this, @data) unless options.batching
 
     upstream.call(this, "create", {fields: fields})
     fields
@@ -117,20 +131,21 @@ 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)
+        @callbacks?.changed?.call(this, @data) unless options.batching
 
       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={}) ->
@@ -142,6 +157,7 @@ class CableNotifications.Collection
       if !@sync
         @data.splice(index, 1)
         @callbacks?.destroy?.call(this, selector)
+        @callbacks?.changed?.call(this, @data) unless options.batching
 
       upstream.call(this, "destroy", {id: record.id})
       record

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

@@ -15,15 +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

@@ -18,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 = @ActionCableNotificationsOptions[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
@@ -63,7 +67,7 @@ module ActionCableNotifications
 
     def initialize(*args)
       @collections = {}
-      @ActionCableNotificationsOptions = {}
+      @ChannelPublications = {}
       super
     end
 
@@ -92,38 +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: params,
+        publication: model.model_name.name,
         cache: false,
         model_options: {},
-        channel_options: {}
-      }.merge(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
-      @ActionCableNotificationsOptions[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[:model_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, options)
-      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
 
     #
@@ -137,14 +148,16 @@ module ActionCableNotifications
         cache: false
       }.merge(options)
 
-      packet = packet.as_json.deep_symbolize_keys!
+      packet = packet.as_json.deep_symbolize_keys
 
-      if options[:cache]==true
-        if update_cache(packet)
+      if validate_packet(packet, options)
+        if options[:cache]==true
+          if update_cache(packet)
+            transmit packet
+          end
+        else
           transmit packet
         end
-      else
-        transmit packet
       end
     end
 

data/lib/action_cable_notifications/channel_actions.rb

@@ -21,12 +21,13 @@ module ActionCableNotifications
                     to_a() rescue []
 
           response = {
-            collection: data[:model].model_name.collection,
+            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],
@@ -35,7 +36,7 @@ module ActionCableNotifications
         end
 
         # Send data to the client
-        transmit_packet response
+        transmit_packet response, data[:options]
       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,8 +4,8 @@ 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
@@ -19,19 +19,19 @@ module ActionCableNotifications
       #
       # 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],
-          track_scope_changes: true,
+          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
 
       #
@@ -50,19 +50,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])
           }
@@ -74,12 +72,11 @@ 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 options[:scope]==:all or self.class.scoped_collection(options[:scope]).where(id: self.id).present?
-            ActionCable.server.broadcast broadcasting,
-              collection: self.model_name.collection,
+            ActionCable.server.broadcast publication,
               msg: 'create',
               id: self.id,
               data: self
@@ -89,7 +86,7 @@ module ActionCableNotifications
     end
 
     def prepare_update
-      self.ActionCableNotificationsOptions.each do |broadcasting, options|
+      self.ChannelPublications.each do |publication, options|
         if options[:actions].include? :update
           if options[:scope]==:all
             options[:records].push self
@@ -108,9 +105,16 @@ module ActionCableNotifications
     # if they are within configured scope
     #
     def notify_update
+      # 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 !self.changes.empty?
-        self.ActionCableNotificationsOptions.each do |broadcasting, options|
+      if !changes.empty?
+        self.ChannelPublications.each do |publication, options|
           if options[:actions].include? :update
             # Checks if previous record was within scope
             record = options[:records].detect{|r| r.id==self.id}
@@ -136,24 +140,24 @@ module ActionCableNotifications
 
             # Broadcasts notifications about model changes
             if is_in_scope
-              # Get model changes and applies them to the scoped collection record
-              changes = {}
-              self.changes.each do |k,v|
-                if record.respond_to?(k)
-                  changes[k] = v[1]
-                end
-              end
+              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 broadcasting,
-                  collection: self.model_name.collection,
-                  msg: 'upsert',
-                  id: self.id,
-                  data: changes
+                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 broadcasting,
-                collection: self.model_name.collection,
+              ActionCable.server.broadcast publication,
                 msg: 'destroy',
                 id: self.id
             end
@@ -166,12 +170,11 @@ module ActionCableNotifications
     # Broadcast notifications when a record is destroyed.
     #
     def notify_destroy
-      self.ActionCableNotificationsOptions.each do |broadcasting, options|
+      self.ChannelPublications.each do |publication, options|
         if options[:scope]==:all or options[:actions].include? :destroy
           # Checks if record is within scope before broadcasting
           if options[:scope]==:all or self.class.scoped_collection(options[:scope]).where(id: self.id).present?
-            ActionCable.server.broadcast broadcasting,
-              collection: self.model_name.collection,
+            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.28'
+  VERSION = '0.1.30'
 end

metadata

@@ -1,22 +1,19 @@
 --- !ruby/object:Gem::Specification
 name: action_cable_notifications
 version: !ruby/object:Gem::Version
-  version: 0.1.28
+  version: 0.1.30
 platform: ruby
 authors:
 - ByS Sistemas de Control
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-04 00:00:00.000000000 Z
+date: 2017-05-19 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
@@ -132,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