stream_from

app/channels/cable_ready/stream.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module CableReady
+  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

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

javascript/action_cable.js

@@ -0,0 +1,7 @@
+export let consumer
+
+export default {
+  setConsumer (value) {
+    consumer = value
+  }
+}

javascript/cable_ready.js

@@ -2,6 +2,8 @@ import { verifyNotMutable, verifyNotPermanent } from './morph_callbacks'
 import { xpathToElement } from './utils'
 import activeElement from './active_element'
 import DOMOperations from './operations'
+import actionCable from './action_cable'
+import './stream_from_element'
 
 export const shouldMorphCallbacks = [verifyNotMutable, verifyNotPermanent]
 export const didMorphCallbacks = []
@@ -59,6 +61,11 @@ const performAsync = (
   })
 }
 
+const initialize = (initializeOptions = {}) => {
+  const { consumer } = initializeOptions
+  actionCable.setConsumer(consumer)
+}
+
 document.addEventListener('DOMContentLoaded', function () {
   if (!document.audio && document.body.hasAttribute('data-unlock-audio')) {
     document.audio = new Audio(
@@ -82,5 +89,6 @@ export default {
   performAsync,
   DOMOperations,
   shouldMorphCallbacks,
-  didMorphCallbacks
+  didMorphCallbacks,
+  initialize
 }

javascript/stream_from_element.js

@@ -0,0 +1,38 @@
+import CableReady from 'cable_ready'
+import { consumer } from './action_cable'
+
+class StreamFromElement extends HTMLElement {
+  connectedCallback () {
+    if (this.preview) return
+    if (consumer) {
+      this.channel = consumer.subscriptions.create(
+        {
+          channel: 'CableReady::Stream',
+          identifier: this.getAttribute('identifier')
+        },
+        {
+          received (data) {
+            if (data.cableReady) CableReady.perform(data.operations)
+          }
+        }
+      )
+    } else {
+      console.error(
+        `The stream_from helper cannot connect without an ActionCable consumer.\nPlease set 'CableReady.initialize({ consumer })' in your index.js.`
+      )
+    }
+  }
+
+  disconnectedCallback () {
+    if (this.channel) this.channel.unsubscribe()
+  }
+
+  get preview () {
+    return (
+      document.documentElement.hasAttribute('data-turbolinks-preview') ||
+      document.documentElement.hasAttribute('data-turbo-preview')
+    )
+  }
+}
+
+customElements.define('stream-from', StreamFromElement)

lib/cable_ready.rb

@@ -13,9 +13,11 @@
 require "cable_ready/operation_builder"
 require "cable_ready/config"
 require "cable_ready/broadcaster"
+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
@@ -28,11 +30,17 @@ class Engine < Rails::Engine
     end
   end
 
-  def self.config
-    CableReady::Config.instance
-  end
+  class << self
+    def config
+      CableReady::Config.instance
+    end
 
-  def self.configure
-    yield config
+    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

lib/cable_ready/channels.rb

@@ -4,13 +4,16 @@ 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
 
     def initialize
       @channels = {}
     end
 
-    def [](identifier)
+    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
 

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

lib/cable_ready/config.rb

@@ -7,6 +7,8 @@ class Config
     include Observable
     include Singleton
 
+    attr_writer :verifier_key
+
     def initialize
       super
       @operation_names = Set.new(default_operation_names)
@@ -16,6 +18,10 @@ 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

lib/cable_ready/stream_identifier.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module CableReady
+  module StreamIdentifier
+    def verified_stream_identifier(signed_stream_identifier)
+      CableReady.signed_stream_verifier.verified signed_stream_identifier
+    end
+
+    def signed_stream_identifier(compoundable)
+      CableReady.signed_stream_verifier.generate compoundable
+    end
+  end
+end

lib/generators/cable_ready/stream_from_generator.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "fileutils"
+
+module CableReady
+  class StreamFromGenerator < Rails::Generators::Base
+    desc "Initializes CableReady with a reference to the shared ActionCable consumer"
+    source_root File.expand_path("templates", __dir__)
+
+    def copy_controller_file
+      main_folder = defined?(Webpacker) ? Webpacker.config.source_path.to_s.gsub("#{Rails.root}/", "") : "app/javascript"
+
+      filepath = [
+        "#{main_folder}/controllers/index.js",
+        "#{main_folder}/controllers/index.ts",
+        "#{main_folder}/packs/application.js",
+        "#{main_folder}/packs/application.ts"
+      ]
+        .select { |path| File.exist?(path) }
+        .map { |path| Rails.root.join(path) }
+        .first
+
+      lines = File.open(filepath, "r") { |f| f.readlines }
+
+      unless lines.find { |line| line.start_with?("import CableReady") }
+        matches = lines.select { |line| line =~ /\A(require|import)/ }
+        lines.insert lines.index(matches.last).to_i + 1, "import CableReady from 'cable_ready'\n"
+        File.open(filepath, "w") { |f| f.write lines.join }
+      end
+
+      unless lines.find { |line| line.start_with?("import consumer") }
+        matches = lines.select { |line| line =~ /\A(require|import)/ }
+        lines.insert lines.index(matches.last).to_i + 1, "import consumer from '../channels/consumer'\n"
+        File.open(filepath, "w") { |f| f.write lines.join }
+      end
+
+      unless lines.find { |line| line.include?("CableReady.initialize({ consumer })") }
+        append_to_file filepath, "CableReady.initialize({ consumer })"
+      end
+    end
+  end
+end