cable_ready 4.4.3 → 5.0.0.pre1

data/app/jobs/cable_ready_broadcast_job.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class CableReadyBroadcastJob < (defined?(ActiveJob::Base) ? ActiveJob::Base : Object)
+  include CableReady::Broadcaster
+  queue_as :default if defined?(ActiveJob::Base)
+
+  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

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/lib/cable_ready.rb

@@ -1,11 +1,52 @@
 # frozen_string_literal: true
 
 require "rails/engine"
+require "open-uri"
+require "active_record"
+require "action_view"
 require "active_support/all"
+require "thread/local"
+require "monitor"
+require "observer"
+require "singleton"
 require "cable_ready/version"
+require "cable_ready/identifiable"
+require "cable_ready/operation_builder"
+require "cable_ready/config"
 require "cable_ready/broadcaster"
+require "cable_ready/sanity_checker"
+require "cable_ready/compoundable"
+require "cable_ready/channel"
+require "cable_ready/channels"
+require "cable_ready/cable_car"
+require "cable_ready/stream_identifier"
 
 module CableReady
   class Engine < Rails::Engine
+    initializer "cable_ready.sanity_check" do
+      SanityChecker.check! unless Rails.env.production?
+    end
+
+    initializer "renderer" do
+      ActiveSupport.on_load(:action_controller) do
+        ActionController::Renderers.add :operations do |operations, options|
+          render json: operations.dispatch
+        end
+      end
+    end
+  end
+
+  class << self
+    def config
+      CableReady::Config.instance
+    end
+
+    def configure
+      yield config
+    end
+
+    def signed_stream_verifier
+      @signed_stream_verifier ||= ActiveSupport::MessageVerifier.new(config.verifier_key, digest: "SHA256", serializer: JSON)
+    end
   end
 end

data/lib/cable_ready/broadcaster.rb

@@ -1,17 +1,16 @@
 # frozen_string_literal: true
 
-require_relative "channels"
-
 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,17 @@
+# frozen_string_literal: true
+
+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,49 +1,27 @@
 # frozen_string_literal: true
 
 module CableReady
-  class Channel
-    attr_reader :identifier, :operations, :available_operations
+  class Channel < OperationBuilder
+    attr_reader :identifier
 
-    def initialize(identifier, available_operations)
-      @identifier = identifier
-      @available_operations = available_operations
-      reset
-      available_operations.each do |available_operation, implementation|
-        define_singleton_method available_operation, &implementation
-      end
+    def broadcast(clear: true)
+      ActionCable.server.broadcast identifier, {"cableReady" => true, "operations" => operations_payload}
+      reset! if clear
     end
 
-    def channel_broadcast(clear)
-      operations.select! { |_, list| list.present? }
-      operations.deep_transform_keys! { |key| key.to_s.camelize(:lower) }
-      ActionCable.server.broadcast identifier, {"cableReady" => true, "operations" => operations}
-      reset if clear
+    def broadcast_to(model, clear: true)
+      identifier.broadcast_to model, {"cableReady" => true, "operations" => operations_payload}
+      reset! if clear
     end
 
-    def channel_broadcast_to(model, clear)
-      operations.select! { |_, list| list.present? }
-      operations.deep_transform_keys! { |key| key.to_s.camelize(:lower) }
-      identifier.broadcast_to model, {"cableReady" => true, "operations" => operations}
-      reset if clear
+    def broadcast_later(clear: true)
+      CableReadyBroadcastJob.perform_later(identifier: identifier, operations: operations_payload)
+      reset! if clear
     end
 
-    def broadcast(clear = true)
-      CableReady::Channels.instance.broadcast(identifier, clear: clear)
-    end
-
-    def broadcast_to(model, clear = true)
-      CableReady::Channels.instance.broadcast_to(model, identifier, clear: clear)
-    end
-
-    private
-
-    def enqueue_operation(key, options)
-      operations[key] << options
-      self
-    end
-
-    def reset
-      @operations = Hash.new { |hash, operation| hash[operation] = [] }
+    def broadcast_later_to(model, clear: true)
+      CableReadyBroadcastJob.perform_later(identifier: identifier.name, operations: operations_payload, model: model)
+      reset! if clear
     end
   end
 end

data/lib/cable_ready/channels.rb

@@ -1,83 +1,40 @@
 # frozen_string_literal: true
 
-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 Singleton
-    attr_accessor :operations
-
-    def self.configure
-      yield CableReady::Channels.instance if block_given?
-    end
+    include Compoundable
+    extend Thread::Local
 
     def initialize
       @channels = {}
-      @operations = {}
-      %i[
-        add_css_class
-        console_log
-        dispatch_event
-        inner_html
-        insert_adjacent_html
-        insert_adjacent_text
-        morph
-        notification
-        outer_html
-        push_state
-        remove
-        remove_attribute
-        remove_css_class
-        set_attribute
-        set_cookie
-        set_dataset_property
-        set_focus
-        set_property
-        set_style
-        set_styles
-        set_value
-        text_content
-      ].each do |operation|
-        add_operation operation
-      end
-    end
-
-    def add_operation(operation, &implementation)
-      @operations[operation] = implementation || ->(options = {}) { enqueue_operation(operation, options) }
     end
 
-    def [](identifier)
-      @channels[identifier] ||= CableReady::Channel.new(identifier, operations)
+    def [](*keys)
+      keys.select!(&:itself)
+      identifier = keys.many? || (keys.one? && keys.first.is_a?(ActiveRecord::Base)) ? compound(keys) : keys.pop
+      @channels[identifier] ||= CableReady::Channel.new(identifier)
     end
 
     def broadcast(*identifiers, clear: true)
-      mutex.synchronize do
-        @channels.values
-          .reject { |channel| identifiers.any? && identifiers.exclude?(channel.identifier) }
-          .select { |channel| channel.identifier.is_a?(String) }
-          .tap do |channels|
-            channels.each { |channel| @channels[channel.identifier].channel_broadcast(clear) }
-            channels.each { |channel| @channels.except!(channel.identifier) if clear }
-          end
-      end
+      @channels.values
+        .reject { |channel| identifiers.any? && identifiers.exclude?(channel.identifier) }
+        .select { |channel| channel.identifier.is_a?(String) }
+        .tap do |channels|
+          channels.each { |channel| @channels[channel.identifier].broadcast(clear: clear) }
+          channels.each { |channel| @channels.except!(channel.identifier) if clear }
+        end
     end
 
     def broadcast_to(model, *identifiers, clear: true)
-      mutex.synchronize do
-        @channels.values
-          .reject { |channel| identifiers.any? && identifiers.exclude?(channel.identifier) }
-          .reject { |channel| channel.identifier.is_a?(String) }
-          .tap do |channels|
-            channels.each { |channel| @channels[channel.identifier].channel_broadcast_to(model, clear) }
-            channels.each { |channel| @channels.except!(channel.identifier) if clear }
-          end
-      end
-    end
-
-    private
-
-    def mutex
-      @mutex ||= Mutex.new
+      @channels.values
+        .reject { |channel| identifiers.any? && identifiers.exclude?(channel.identifier) }
+        .reject { |channel| channel.identifier.is_a?(String) }
+        .tap do |channels|
+          channels.each { |channel| @channels[channel.identifier].broadcast_to(model, clear: clear) }
+          channels.each { |channel| @channels.except!(channel.identifier) if clear }
+        end
     end
   end
 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.class < ActiveRecord::Base ? key.to_global_id.to_s : key.to_s
+      }.join(":")
+    end
+  end
+end

data/lib/cable_ready/config.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module CableReady
+  # This class is a process level singleton shared by all threads: CableReady::Config.instance
+  class Config
+    include MonitorMixin
+    include Observable
+    include Singleton
+
+    attr_accessor :on_failed_sanity_checks, :on_new_version_available
+    attr_writer :verifier_key
+
+    def initialize
+      super
+      @operation_names = Set.new(default_operation_names)
+      @on_failed_sanity_checks = :exit
+      @on_new_version_available = :ignore
+    end
+
+    def observers
+      @observer_peers&.keys || []
+    end
+
+    def verifier_key
+      @verifier_key || Rails.application.key_generator.generate_key("cable_ready/verifier_key")
+    end
+
+    def operation_names
+      @operation_names.to_a
+    end
+
+    def add_operation_name(name)
+      synchronize do
+        @operation_names << name.to_sym
+        notify_observers name.to_sym
+      end
+    end
+
+    def default_operation_names
+      Set.new(%i[
+        add_css_class
+        append
+        clear_storage
+        console_log
+        console_table
+        dispatch_event
+        go
+        graft
+        inner_html
+        insert_adjacent_html
+        insert_adjacent_text
+        morph
+        notification
+        outer_html
+        prepend
+        push_state
+        remove
+        remove_attribute
+        remove_css_class
+        remove_storage_item
+        replace
+        replace_state
+        scroll_into_view
+        set_attribute
+        set_cookie
+        set_dataset_property
+        set_focus
+        set_meta
+        set_property
+        set_storage_item
+        set_style
+        set_styles
+        set_value
+        text_content
+      ]).freeze
+    end
+  end
+end

data/lib/cable_ready/identifiable.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module CableReady
+  module Identifiable
+    def dom_id(record, prefix = nil)
+      prefix = prefix.to_s.strip if prefix
+
+      id = if record.is_a?(ActiveRecord::Relation)
+        [prefix, record.model_name.plural].compact.join("_")
+      elsif record.is_a?(ActiveRecord::Base)
+        ActionView::RecordIdentifier.dom_id(record, prefix)
+      else
+        [prefix, record.to_s.strip].compact.join("_")
+      end
+
+      "##{id}".squeeze("#").strip
+    end
+  end
+end

data/lib/cable_ready/operation_builder.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module CableReady
+  class OperationBuilder
+    include Identifiable
+    attr_reader :identifier, :previous_selector
+
+    def self.finalizer_for(identifier)
+      proc {
+        channel = CableReady.config.observers.find { |o| o.try(:identifier) == identifier }
+        CableReady.config.delete_observer channel if channel
+      }
+    end
+
+    def initialize(identifier)
+      @identifier = identifier
+
+      reset!
+      CableReady.config.operation_names.each { |name| add_operation_method name }
+      CableReady.config.add_observer self, :add_operation_method
+      ObjectSpace.define_finalizer self, self.class.finalizer_for(identifier)
+    end
+
+    def add_operation_method(name)
+      return if respond_to?(name)
+      singleton_class.public_send :define_method, name, ->(*args) {
+        selector, options = nil, args.first || {} # 1 or 0 params
+        selector, options = options, {} unless options.is_a?(Hash) # swap if only selector provided
+        selector, options = args[0, 2] if args.many? # 2 or more params
+        options.stringify_keys!
+        options["selector"] = selector if selector && options.exclude?("selector")
+        options["selector"] = previous_selector if previous_selector && options.exclude?("selector")
+        if options.include?("selector")
+          @previous_selector = options["selector"]
+          options["selector"] = previous_selector.is_a?(ActiveRecord::Base) || previous_selector.is_a?(ActiveRecord::Relation) ? dom_id(previous_selector) : previous_selector
+        end
+        @enqueued_operations[name.to_s] << options
+        self
+      }
+    end
+
+    def to_json(*args)
+      @enqueued_operations.to_json(*args)
+    end
+
+    def apply!(operations = "{}")
+      operations = begin
+        JSON.parse(operations.is_a?(String) ? operations : operations.to_json)
+      rescue JSON::ParserError
+        {}
+      end
+      operations.each do |name, operation|
+        operation.each do |enqueued_operation|
+          @enqueued_operations[name.to_s] << enqueued_operation
+        end
+      end
+      self
+    end
+
+    def operations_payload
+      @enqueued_operations.select { |_, list| list.present? }.deep_transform_keys { |key| key.to_s.camelize(:lower) }
+    end
+
+    def reset!
+      @enqueued_operations = Hash.new { |hash, key| hash[key] = [] }
+      @previous_selector = nil
+    end
+  end
+end