cable_ready 4.5.0 → 5.0.0.pre0

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,47 +1,27 @@
 # 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
+      ActionCable.server.broadcast identifier, {"cableReady" => true, "operations" => operations_payload}
+      reset! if clear
     end
 
     def broadcast_to(model, clear: true)
-      identifier.broadcast_to model, {"cableReady" => true, "operations" => broadcastable_operations}
-      reset if clear
+      identifier.broadcast_to model, {"cableReady" => true, "operations" => operations_payload}
+      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
-      }
-    end
-
-    private
-
-    def reset
-      @enqueued_operations = Hash.new { |hash, key| hash[key] = [] }
+    def broadcast_later(clear: true)
+      CableReadyBroadcastJob.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)
+      CableReadyBroadcastJob.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,19 @@
 # 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.is_a?(ActiveRecord::Base)) ? 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.class < ActiveRecord::Base ? key.to_global_id.to_s : key.to_s
+      }.join(":")
+    end
+  end
+end

data/lib/cable_ready/config.rb

@@ -1,9 +1,5 @@
 # frozen_string_literal: true
 
-require "monitor"
-require "observer"
-require "singleton"
-
 module CableReady
   # This class is a process level singleton shared by all threads: CableReady::Config.instance
   class Config
@@ -11,9 +7,22 @@ module CableReady
     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
@@ -33,6 +42,7 @@ module CableReady
         append
         clear_storage
         console_log
+        console_table
         dispatch_event
         go
         graft
@@ -42,7 +52,6 @@ module CableReady
         morph
         notification
         outer_html
-        play_sound
         prepend
         push_state
         remove
@@ -56,6 +65,7 @@ module CableReady
         set_cookie
         set_dataset_property
         set_focus
+        set_meta
         set_property
         set_storage_item
         set_style

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

data/lib/cable_ready/sanity_checker.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+class CableReady::SanityChecker
+  LATEST_VERSION_FORMAT = /^(\d+\.\d+\.\d+)$/
+  NODE_VERSION_FORMAT = /(\d+\.\d+\.\d+.*):/
+  JSON_VERSION_FORMAT = /(\d+\.\d+\.\d+.*)"/
+
+  class << self
+    def check!
+      return if CableReady.config.on_failed_sanity_checks == :ignore
+      return if called_by_generate_config?
+
+      instance = new
+      instance.check_javascript_package_version
+      instance.check_new_version_available
+    end
+
+    private
+
+    def called_by_generate_config?
+      ARGV.include? "cable_ready:initializer"
+    end
+  end
+
+  def check_javascript_package_version
+    if javascript_package_version.nil?
+      warn_and_exit <<~WARN
+        Can't locate the cable_ready npm package.
+        Either add it to your package.json as a dependency or use "yarn link cable_ready" if you are doing development.
+      WARN
+    end
+
+    unless javascript_version_matches?
+      warn_and_exit <<~WARN
+        The cable_ready npm package version (#{javascript_package_version}) does not match the Rubygem version (#{gem_version}).
+        To update the cable_ready npm package:
+          yarn upgrade cable_ready@#{gem_version}
+      WARN
+    end
+  end
+
+  def check_new_version_available
+    return unless Rails.env.development?
+    return if CableReady.config.on_new_version_available == :ignore
+    return unless using_stable_release
+    begin
+      latest_version = URI.open("https://raw.githubusercontent.com/stimulusreflex/cable_ready/master/LATEST", open_timeout: 1, read_timeout: 1).read.strip
+      if latest_version != CableReady::VERSION
+        puts <<~WARN
+
+          There is a new version of CableReady available!
+          Current: #{CableReady::VERSION} Latest: #{latest_version}
+
+          If you upgrade, it is very important that you update BOTH Gemfile and package.json
+          Then, run `bundle install && yarn install` to update to #{latest_version}.
+
+        WARN
+        exit if CableReady.config.on_new_version_available == :exit
+      end
+    rescue
+      puts "CableReady #{CableReady::VERSION} update check skipped: connection timeout"
+    end
+  end
+
+  private
+
+  def javascript_version_matches?
+    javascript_package_version == gem_version
+  end
+
+  def using_stable_release
+    stable = CableReady::VERSION.match?(LATEST_VERSION_FORMAT)
+    puts "CableReady #{CableReady::VERSION} update check skipped: pre-release build" unless stable
+    stable
+  end
+
+  def gem_version
+    @_gem_version ||= CableReady::VERSION.gsub(".pre", "-pre")
+  end
+
+  def javascript_package_version
+    @_js_version ||= find_javascript_package_version
+  end
+
+  def find_javascript_package_version
+    if (match = search_file(package_json_path, regex: /version/))
+      match[JSON_VERSION_FORMAT, 1]
+    elsif (match = search_file(yarn_lock_path, regex: /^cable_ready/))
+      match[NODE_VERSION_FORMAT, 1]
+    end
+  end
+
+  def search_file(path, regex:)
+    return unless File.exist?(path)
+    File.foreach(path).grep(regex).first
+  end
+
+  def package_json_path
+    Rails.root.join("node_modules", "cable_ready", "package.json")
+  end
+
+  def yarn_lock_path
+    Rails.root.join("yarn.lock")
+  end
+
+  def initializer_path
+    @_initializer_path ||= Rails.root.join("config", "initializers", "cable_ready.rb")
+  end
+
+  def warn_and_exit(text)
+    puts "WARNING:"
+    puts text
+    exit_with_info if CableReady.config.on_failed_sanity_checks == :exit
+  end
+
+  def exit_with_info
+    puts
+
+    if File.exist?(initializer_path)
+      puts <<~INFO
+        If you know what you are doing and you want to start the application anyway,
+        you can add the following directive to the CableReady initializer,
+        which is located at #{initializer_path}
+
+          CableReady.configure do |config|
+            config.on_failed_sanity_checks = :warn
+          end
+
+      INFO
+    else
+      puts <<~INFO
+        If you know what you are doing and you want to start the application anyway,
+        you can create a CableReady initializer with the command:
+
+        bundle exec rails generate cable_ready:config
+
+        Then open your initializer at
+
+        #{initializer_path}
+
+        and then add the following directive:
+
+          CableReady.configure do |config|
+            config.on_failed_sanity_checks = :warn
+          end
+
+      INFO
+    end
+    exit false unless Rails.env.test?
+  end
+end

data/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