cable_ready 4.4.6 → 5.0.0.pre2

data/app/helpers/cable_ready_helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module CableReadyHelper
+  include CableReady::Compoundable
+  include CableReady::StreamIdentifier
+
+  def stream_from(*keys)
+    keys.select!(&:itself)
+    tag.stream_from(identifier: signed_stream_identifier(compound(keys)))
+  end
+end

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/cable_ready.gemspec

@@ -8,13 +8,14 @@ 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.files = Dir["lib/**/*.rb", "app/**/*.rb", "bin/*", "[A-Z]*"]
   gem.test_files = Dir["test/**/*.rb"]
 
   gem.add_dependency "rails", ">= 5.2"
+  gem.add_dependency "thread-local", ">= 1.1.0"
 
   gem.add_development_dependency "github_changelog_generator"
   gem.add_development_dependency "magic_frozen_string_literal"
@@ -22,4 +23,5 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency "pry-nav"
   gem.add_development_dependency "rake"
   gem.add_development_dependency "standardrb"
+  gem.add_development_dependency "mocha"
 end

data/lib/cable_ready.rb

@@ -1,11 +1,55 @@
 # 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|
+          response.content_type ||= Mime[:cable_ready]
+          render json: operations.dispatch
+        end
+
+        Mime::Type.register "application/vnd.cable-ready.json", :cable_ready
+      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,86 +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
-        clear_storage
-        console_log
-        dispatch_event
-        inner_html
-        insert_adjacent_html
-        insert_adjacent_text
-        morph
-        notification
-        outer_html
-        push_state
-        remove
-        remove_attribute
-        remove_css_class
-        remove_storage_item
-        set_attribute
-        set_cookie
-        set_dataset_property
-        set_focus
-        set_property
-        set_storage_item
-        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,30 @@
+# frozen_string_literal: true
+
+module CableReady
+  module Identifiable
+    def dom_id(record, prefix = nil)
+      return record.to_dom_selector if record.respond_to?(:to_dom_selector)
+
+      prefix = prefix.to_s.strip if prefix
+
+      id = if record.respond_to?(:to_dom_id)
+        record.to_dom_id
+      elsif 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.downcase
+    end
+
+    def identifiable?(obj)
+      obj.respond_to?(:to_dom_selector) ||
+        obj.respond_to?(:to_dom_id) ||
+        obj.is_a?(ActiveRecord::Relation) ||
+        obj.is_a?(ActiveRecord::Base)
+    end
+  end
+end