cable_ready 4.5.0 → 5.0.0

data/app/channels/cable_ready/stream.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module CableReady
+  if defined?(ActionCable)
+    class Stream < ActionCable::Channel::Base
+      include CableReady::StreamIdentifier
+
+      def subscribed
+        locator = verified_stream_identifier(params[:identifier])
+        locator.present? ? stream_from(locator) : reject
+      end
+    end
+  end
+end

data/app/helpers/cable_ready/view_helper.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module CableReady
+  module ViewHelper
+    include CableReady::Compoundable
+    include CableReady::StreamIdentifier
+
+    def stream_from(...)
+      warn "DEPRECATED: please use `cable_ready_stream_from` instead. The `stream_from` view helper will be removed from a future version of CableReady 5"
+
+      cable_ready_stream_from(...)
+    end
+
+    def updates_for(...)
+      warn "DEPRECATED: please use `cable_ready_updates_for` instead. The `updates_for` view helper will be removed from a future version of CableReady 5"
+
+      cable_ready_updates_for(...)
+    end
+
+    def updates_for_if(...)
+      warn "DEPRECATED: please use `cable_ready_updates_for_if` instead. The `updates_for_if` view helper will be removed from a future version of CableReady 5"
+
+      cable_ready_updates_for_if(...)
+    end
+
+    def cable_ready_stream_from(*keys, html_options: {})
+      tag.cable_ready_stream_from(**build_options(*keys, html_options))
+    end
+
+    def cable_ready_updates_for(*keys, url: nil, debounce: nil, only: nil, ignore_inner_updates: false, html_options: {}, &block)
+      options = build_options(*keys, html_options)
+      options[:url] = url if url
+      options[:debounce] = debounce if debounce
+      options[:only] = only if only
+      options[:"ignore-inner-updates"] = "" if ignore_inner_updates
+      tag.cable_ready_updates_for(**options) { capture(&block) }
+    end
+
+    def cable_ready_updates_for_if(condition, *keys, **options, &block)
+      if condition
+        cable_ready_updates_for(*keys, **options, &block)
+      else
+        capture(&block)
+      end
+    end
+
+    def cable_car
+      CableReady::CableCar.instance
+    end
+
+    private
+
+    def build_options(*keys, html_options)
+      keys.select!(&:itself)
+      {identifier: signed_stream_identifier(compound(keys))}.merge(html_options)
+    end
+  end
+end

data/app/jobs/cable_ready/broadcast_job.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+if defined?(ActiveJob::Base)
+  class CableReady::BroadcastJob < ActiveJob::Base
+    include CableReady::Broadcaster
+
+    def perform(identifier:, operations:, model: nil)
+      if model.present?
+        cable_ready[identifier.safe_constantize].apply!(operations).broadcast_to(model)
+      else
+        cable_ready[identifier].apply!(operations).broadcast
+      end
+    end
+  end
+end

data/app/models/concerns/cable_ready/updatable/collection_updatable_callbacks.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module CableReady
+  module Updatable
+    class CollectionUpdatableCallbacks
+      def initialize(operation)
+        @operation = operation
+      end
+
+      def after_commit(model)
+        update_collections(model)
+      end
+
+      private
+
+      def update_collections(model)
+        model.class.cable_ready_collections.broadcast_for!(model, @operation)
+      end
+    end
+  end
+end

data/app/models/concerns/cable_ready/updatable/collections_registry.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module CableReady
+  module Updatable
+    Collection = Struct.new(
+      :klass,
+      :name,
+      :reflection,
+      :options,
+      :foreign_key,
+      :inverse_association,
+      :through_association,
+      :debounce_time,
+      keyword_init: true
+    )
+
+    class CollectionsRegistry
+      def initialize
+        @registered_collections = []
+      end
+
+      def register(collection)
+        @registered_collections << collection
+      end
+
+      def broadcast_for!(model, operation)
+        @registered_collections.select { |c| c.options[:on].include?(operation) }
+          .each do |collection|
+          resource = find_resource_for_update(collection, model)
+          next if resource.nil?
+
+          collection.klass.cable_ready_update_collection(resource, collection.name, model, debounce: collection.debounce_time) if collection.options[:if].call(resource)
+        end
+      end
+
+      private
+
+      def find_resource_for_update(collection, model)
+        collection.reflection ||= collection.klass.reflect_on_association(collection.name)
+
+        collection.foreign_key ||= collection.reflection&.foreign_key
+
+        # lazy load and store through and inverse associations
+        if collection.reflection&.through_reflection?
+          collection.inverse_association ||= collection.reflection&.through_reflection&.inverse_of&.name&.to_s
+          collection.through_association = collection.reflection&.through_reflection&.name&.to_s&.singularize
+        else
+          collection.inverse_association ||= collection.reflection&.inverse_of&.name&.to_s
+        end
+
+        raise ArgumentError, "Could not find inverse_of for #{collection.name}" unless collection.inverse_association
+
+        resource = model
+        resource = resource.send(collection.through_association.underscore) if collection.through_association
+        resource.send(collection.inverse_association.underscore)
+      end
+    end
+  end
+end

data/app/models/concerns/cable_ready/updatable/memory_cache_debounce_adapter.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module CableReady
+  module Updatable
+    class MemoryCacheDebounceAdapter
+      include Singleton
+
+      delegate_missing_to :@store
+
+      def initialize
+        super
+        @store = ActiveSupport::Cache::MemoryStore.new(expires_in: 5.minutes, size: 8.megabytes)
+      end
+
+      def []=(key, value)
+        @store.write(key, value)
+      end
+
+      def [](key)
+        @store.read(key)
+      end
+    end
+  end
+end

data/app/models/concerns/cable_ready/updatable/model_updatable_callbacks.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module CableReady
+  module Updatable
+    class ModelUpdatableCallbacks
+      def initialize(operation, enabled_operations = %i[create update destroy], debounce: CableReady.config.updatable_debounce_time)
+        @operation = operation
+        @enabled_operations = enabled_operations
+        @debounce = debounce
+      end
+
+      def after_commit(model)
+        return unless @enabled_operations.include?(@operation)
+
+        send("broadcast_#{@operation}", model)
+      end
+
+      private
+
+      def broadcast_create(model)
+        model.class.send(:broadcast_updates, model.class, {debounce: @debounce})
+      end
+      alias_method :broadcast_destroy, :broadcast_create
+
+      def broadcast_update(model)
+        changeset = model.respond_to?(:previous_changes) ? {changed: model.previous_changes.keys} : {}
+        options = changeset.merge({debounce: @debounce})
+        model.class.send(:broadcast_updates, model.class, options.dup)
+        model.class.send(:broadcast_updates, model.to_global_id, options)
+      end
+    end
+  end
+end

data/app/models/concerns/cable_ready/updatable.rb

@@ -0,0 +1,211 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module CableReady
+  module Updatable
+    extend ::ActiveSupport::Concern
+
+    mattr_accessor :debounce_adapter, default: ::CableReady::Updatable::MemoryCacheDebounceAdapter.instance
+
+    included do |base|
+      if defined?(ActiveRecord) && base < ActiveRecord::Base
+        include ExtendHasMany
+
+        after_commit CollectionUpdatableCallbacks.new(:create), on: :create
+        after_commit CollectionUpdatableCallbacks.new(:update), on: :update
+        after_commit CollectionUpdatableCallbacks.new(:destroy), on: :destroy
+
+        def self.enable_updates(...)
+          warn "DEPRECATED: please use `enable_cable_ready_updates` instead. The `enable_updates` class method will be removed from a future version of CableReady 5"
+
+          enable_cable_ready_updates(...)
+        end
+
+        def self.skip_updates(...)
+          warn "DEPRECATED: please use `skip_cable_ready_updates` instead. The `skip_updates` class method will be removed from a future version of CableReady 5"
+
+          skip_cable_ready_updates(...)
+        end
+
+        def self.enable_cable_ready_updates(*options)
+          options = options.extract_options!
+          options = {
+            on: [:create, :update, :destroy],
+            if: -> { true },
+            debounce: CableReady.config.updatable_debounce_time
+          }.merge(options)
+
+          enabled_operations = Array(options[:on])
+
+          after_commit(ModelUpdatableCallbacks.new(:create, enabled_operations, debounce: options[:debounce]), {on: :create, if: options[:if]})
+          after_commit(ModelUpdatableCallbacks.new(:update, enabled_operations, debounce: options[:debounce]), {on: :update, if: options[:if]})
+          after_commit(ModelUpdatableCallbacks.new(:destroy, enabled_operations, debounce: options[:debounce]), {on: :destroy, if: options[:if]})
+        end
+
+        def self.skip_cable_ready_updates
+          skip_updates_classes.push(self)
+          yield
+        ensure
+          skip_updates_classes.pop
+        end
+      end
+    end
+
+    private
+
+    module ClassMethods
+      include Compoundable
+
+      def has_many(name, scope = nil, **options, &extension)
+        option = if options.has_key?(:enable_updates)
+          warn "DEPRECATED: please use `enable_cable_ready_updates` instead. The `enable_updates` option will be removed from a future version of CableReady 5"
+          options.delete(:enable_updates)
+        else
+          options.delete(:enable_cable_ready_updates)
+        end
+
+        descendants = options.delete(:descendants)
+        debounce_time = options.delete(:debounce)
+
+        broadcast = option.present?
+        result = super
+        enrich_association_with_updates(name, option, descendants, debounce: debounce_time) if broadcast
+        result
+      end
+
+      def has_one(name, scope = nil, **options, &extension)
+        option = if options.has_key?(:enable_updates)
+          warn "DEPRECATED: please use `enable_cable_ready_updates` instead. The `enable_updates` option will be removed from a future version of CableReady 5"
+          options.delete(:enable_updates)
+        else
+          options.delete(:enable_cable_ready_updates)
+        end
+
+        descendants = options.delete(:descendants)
+        debounce_time = options.delete(:debounce)
+
+        broadcast = option.present?
+        result = super
+        enrich_association_with_updates(name, option, descendants, debounce: debounce_time) if broadcast
+        result
+      end
+
+      def has_many_attached(name, **options)
+        raise("ActiveStorage must be enabled to use has_many_attached") unless defined?(ActiveStorage)
+
+        option = if options.has_key?(:enable_updates)
+          warn "DEPRECATED: please use `enable_cable_ready_updates` instead. The `enable_updates` option will be removed from a future version of CableReady 5"
+          options.delete(:enable_updates)
+        else
+          options.delete(:enable_cable_ready_updates)
+        end
+
+        debounce_time = options.delete(:debounce)
+
+        broadcast = option.present?
+        result = super
+        enrich_attachments_with_updates(name, option, debounce: debounce_time) if broadcast
+        result
+      end
+
+      def cable_ready_collections
+        @cable_ready_collections ||= CollectionsRegistry.new
+      end
+
+      def cable_ready_update_collection(resource, name, model, debounce: CableReady.config.updatable_debounce_time)
+        identifier = resource.to_global_id.to_s + ":" + name.to_s
+        changeset = model.respond_to?(:previous_changes) ? {changed: model.previous_changes.keys} : {}
+        options = changeset.merge({debounce: debounce})
+
+        broadcast_updates(identifier, options)
+      end
+
+      def enrich_association_with_updates(name, option, descendants = nil, debounce: CableReady.config.updatable_debounce_time)
+        reflection = reflect_on_association(name)
+
+        options = build_options(option)
+
+        [reflection.klass, *descendants&.map(&:to_s)&.map(&:constantize)].each do |klass|
+          klass.send(:include, CableReady::Updatable) unless klass.respond_to?(:cable_ready_collections)
+          klass.cable_ready_collections.register(Collection.new(
+            klass: self,
+            name: name,
+            options: options,
+            reflection: reflection,
+            debounce_time: debounce
+          ))
+        end
+      end
+
+      def enrich_attachments_with_updates(name, option, debounce: CableReady.config.updatable_debounce_time)
+        options = build_options(option)
+
+        ActiveStorage::Attachment.send(:include, CableReady::Updatable) unless ActiveStorage::Attachment.respond_to?(:cable_ready_collections)
+
+        ActiveStorage::Attachment.cable_ready_collections.register(Collection.new(
+          klass: self,
+          foreign_key: "record_id",
+          name: name,
+          inverse_association: "record",
+          through_association: nil,
+          options: options,
+          debounce_time: debounce
+        ))
+      end
+
+      def build_options(option)
+        options = {
+          on: [:create, :update, :destroy],
+          if: ->(resource) { true }
+        }
+
+        case option
+        when TrueClass
+        # proceed!
+        when FalseClass
+          options[:on] = []
+        when Array
+          options[:on] = option
+        when Symbol
+          options[:on] = [option]
+        when Hash
+          option[:on] = Array(option[:on]) if option[:on]
+          options = options.merge!(option)
+        when Proc
+          options[:if] = option
+        else
+          raise ArgumentError, "Invalid enable_cable_ready_updates option #{option}"
+        end
+
+        options
+      end
+
+      def broadcast_updates(model_class, options)
+        return if skip_updates_classes.any? { |klass| klass >= self }
+        raise("ActionCable must be enabled to use Updatable") unless defined?(ActionCable)
+
+        debounce_time = options.delete(:debounce)
+        debounce_time ||= CableReady.config.updatable_debounce_time
+
+        if debounce_time.to_f > 0
+          key = compound([model_class, *options])
+          old_wait_until = CableReady::Updatable.debounce_adapter[key]
+          now = Time.now.to_f
+
+          if old_wait_until.nil? || old_wait_until < now
+            new_wait_until = now + debounce_time.to_f
+            CableReady::Updatable.debounce_adapter[key] = new_wait_until
+            ActionCable.server.broadcast(model_class, options)
+          end
+        else
+          ActionCable.server.broadcast(model_class, options)
+        end
+      end
+
+      def skip_updates_classes
+        Thread.current[:skip_updates_classes] ||= []
+      end
+    end
+  end
+end

data/app/models/concerns/extend_has_many.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "active_support/concern"
+
+module ExtendHasMany
+  extend ::ActiveSupport::Concern
+
+  class_methods do
+    def has_many(*args, &block)
+      options = args.extract_options!
+      options[:extend] = Array(options[:extend]).push(ClassMethods)
+      super(*args, **options, &block)
+    end
+  end
+end

data/bin/standardize

@@ -2,4 +2,4 @@
 
 bundle exec magic_frozen_string_literal
 bundle exec standardrb --fix
-yarn run prettier-standard ./javascript/*.js
+yarn format

data/cable_ready.gemspec

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require File.expand_path("../lib/cable_ready/version", __FILE__)
+require File.expand_path("lib/cable_ready/version", __dir__)
 
 Gem::Specification.new do |gem|
   gem.name = "cable_ready"
@@ -8,19 +8,33 @@ Gem::Specification.new do |gem|
   gem.version = CableReady::VERSION
   gem.authors = ["Nathan Hopkins"]
   gem.email = ["natehop@gmail.com"]
-  gem.homepage = "https://github.com/hopsoft/cable_ready"
+  gem.homepage = "https://github.com/stimulusreflex/cable_ready"
   gem.summary = "Out-of-Band Server Triggered DOM Operations"
 
-  gem.files = Dir["lib/**/*.rb", "app/assets/javascripts/cable_ready.js", "bin/*", "[A-Z]*"]
-  gem.test_files = Dir["test/**/*.rb"]
+  gem.files = Dir[
+    "lib/**/*.{rb,rake,tt}",
+    "app/**/*.rb",
+    "app/assets/javascripts/*",
+    "bin/*",
+    "[A-Z]*"
+  ]
 
-  gem.add_dependency "rails", ">= 5.2"
+  gem.required_ruby_version = ">= 2.7.0"
+
+  rails_version = ">= 5.2"
+
+  gem.add_dependency "actionpack", rails_version
+  gem.add_dependency "actionview", rails_version
+  gem.add_dependency "activesupport", rails_version
+  gem.add_dependency "railties", rails_version
   gem.add_dependency "thread-local", ">= 1.1.0"
 
-  gem.add_development_dependency "github_changelog_generator"
   gem.add_development_dependency "magic_frozen_string_literal"
+  gem.add_development_dependency "mocha"
   gem.add_development_dependency "pry"
   gem.add_development_dependency "pry-nav"
   gem.add_development_dependency "rake"
+  gem.add_development_dependency "sqlite3"
+  gem.add_development_dependency "standard", "1.19.1"
   gem.add_development_dependency "standardrb"
 end

data/lib/cable_ready/broadcaster.rb

@@ -1,17 +1,18 @@
 # frozen_string_literal: true
 
-require_relative "channels"
+require "active_support/concern"
 
 module CableReady
   module Broadcaster
+    include Identifiable
     extend ::ActiveSupport::Concern
 
     def cable_ready
       CableReady::Channels.instance
     end
 
-    def dom_id(record, prefix = nil)
-      "##{ActionView::RecordIdentifier.dom_id(record, prefix)}"
+    def cable_car
+      CableReady::CableCar.instance
     end
   end
 end

data/lib/cable_ready/cable_car.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "thread/local"
+
+module CableReady
+  class CableCar < OperationBuilder
+    extend Thread::Local
+
+    def initialize
+      super "CableCar"
+    end
+
+    def dispatch(clear: true)
+      payload = operations_payload
+      reset! if clear
+      payload
+    end
+  end
+end

data/lib/cable_ready/channel.rb

@@ -1,47 +1,45 @@
 # frozen_string_literal: true
 
 module CableReady
-  class Channel
-    attr_reader :identifier, :enqueued_operations
-
-    def initialize(identifier)
-      @identifier = identifier
-      reset
-      CableReady.config.operation_names.each { |name| add_operation_method name }
-
-      config_observer = self
-      CableReady.config.add_observer config_observer, :add_operation_method
-      ObjectSpace.define_finalizer self, -> { CableReady.config.delete_observer config_observer }
-    end
+  class Channel < OperationBuilder
+    attr_reader :identifier
 
     def broadcast(clear: true)
-      ActionCable.server.broadcast identifier, {"cableReady" => true, "operations" => broadcastable_operations}
-      reset if clear
+      raise("Action Cable must be enabled to use broadcast") unless defined?(ActionCable)
+      clients_received = ActionCable.server.broadcast identifier, {
+        "cableReady" => true,
+        "operations" => operations_payload,
+        "version" => CableReady::VERSION
+      }
+      reset! if clear
+      clients_received
     end
 
     def broadcast_to(model, clear: true)
-      identifier.broadcast_to model, {"cableReady" => true, "operations" => broadcastable_operations}
-      reset if clear
-    end
-
-    def add_operation_method(name)
-      return if respond_to?(name)
-      singleton_class.public_send :define_method, name, ->(options = {}) {
-        enqueued_operations[name.to_s] << options.stringify_keys
-        self # supports operation chaining
+      raise("Action Cable must be enabled to use broadcast_to") unless defined?(ActionCable)
+      clients_received = identifier.broadcast_to model, {
+        "cableReady" => true,
+        "operations" => operations_payload,
+        "version" => CableReady::VERSION
       }
+      reset! if clear
+      clients_received
     end
 
-    private
-
-    def reset
-      @enqueued_operations = Hash.new { |hash, key| hash[key] = [] }
+    def broadcast_later(clear: true, queue: nil)
+      raise("Action Cable must be enabled to use broadcast_later") unless defined?(ActionCable)
+      CableReady::BroadcastJob
+        .set(queue: queue ? queue.to_sym : CableReady.config.broadcast_job_queue)
+        .perform_later(identifier: identifier, operations: operations_payload)
+      reset! if clear
     end
 
-    def broadcastable_operations
-      enqueued_operations
-        .select { |_, list| list.present? }
-        .deep_transform_keys! { |key| key.to_s.camelize(:lower) }
+    def broadcast_later_to(model, clear: true, queue: nil)
+      raise("Action Cable must be enabled to use broadcast_later_to") unless defined?(ActionCable)
+      CableReady::BroadcastJob
+        .set(queue: queue ? queue.to_sym : CableReady.config.broadcast_job_queue)
+        .perform_later(identifier: identifier.name, operations: operations_payload, model: model)
+      reset! if clear
     end
   end
 end

data/lib/cable_ready/channels.rb

@@ -1,22 +1,21 @@
 # frozen_string_literal: true
 
 require "thread/local"
-require_relative "channel"
 
 module CableReady
   # This class is a thread local singleton: CableReady::Channels.instance
   # SEE: https://github.com/socketry/thread-local/tree/master/guides/getting-started
   class Channels
+    include Compoundable
     extend Thread::Local
 
-    attr_accessor :operations
-
     def initialize
       @channels = {}
-      @operations = {}
     end
 
-    def [](identifier)
+    def [](*keys)
+      keys.select!(&:itself)
+      identifier = (keys.many? || (keys.one? && keys.first.respond_to?(:to_global_id))) ? compound(keys) : keys.pop
       @channels[identifier] ||= CableReady::Channel.new(identifier)
     end
 

data/lib/cable_ready/compoundable.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module CableReady
+  module Compoundable
+    def compound(keys)
+      keys.map { |key|
+        key.respond_to?(:to_global_id) ? key.to_global_id.to_s : key.to_s
+      }.join(":")
+    end
+  end
+end