cable_ready 4.5.0 → 5.0.0

data/lib/cable_ready/config.rb

@@ -11,9 +11,32 @@ module CableReady
     include Observable
     include Singleton
 
+    attr_accessor :on_failed_sanity_checks, :broadcast_job_queue, :precompile_assets, :updatable_debounce_time
+    attr_writer :verifier_key
+
+    def on_new_version_available
+      warn "NOTICE: The `config.on_new_version_available` option has been removed from the CableReady initializer. You can safely remove this option from your initializer."
+    end
+
+    def on_new_version_available=(_)
+      warn "NOTICE: The `config.on_new_version_available` option has been removed from the CableReady initializer. You can safely remove this option from your initializer."
+    end
+
     def initialize
       super
       @operation_names = Set.new(default_operation_names)
+      @on_failed_sanity_checks = :exit
+      @broadcast_job_queue = :default
+      @precompile_assets = true
+      @updatable_debounce_time = 0.1.seconds
+    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 +56,7 @@ module CableReady
         append
         clear_storage
         console_log
+        console_table
         dispatch_event
         go
         graft
@@ -42,9 +66,10 @@ module CableReady
         morph
         notification
         outer_html
-        play_sound
         prepend
         push_state
+        redirect_to
+        reload
         remove
         remove_attribute
         remove_css_class
@@ -56,10 +81,12 @@ module CableReady
         set_cookie
         set_dataset_property
         set_focus
+        set_meta
         set_property
         set_storage_item
         set_style
         set_styles
+        set_title
         set_value
         text_content
       ]).freeze

data/lib/cable_ready/engine.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require "rails/engine"
+
+module CableReady
+  class Engine < Rails::Engine
+    # If you don't want to precompile CableReady's assets (eg. because you're using webpack),
+    # you can do this in an initializer:
+    #
+    # config.after_initialize do
+    #   config.assets.precompile -= CableReady::Engine::PRECOMPILE_ASSETS
+    # end
+    PRECOMPILE_ASSETS = %w[
+      cable_ready.js
+      cable_ready.umd.js
+    ]
+
+    initializer "cable_ready.assets" do |app|
+      if app.config.respond_to?(:assets) && CableReady.config.precompile_assets
+        app.config.assets.precompile += PRECOMPILE_ASSETS
+      end
+    end
+
+    initializer "cable_ready.sanity_check" do
+      SanityChecker.check! unless Rails.env.production?
+    end
+
+    initializer "cable_ready.mimetype" do
+      Mime::Type.register "text/vnd.cable-ready.json", :cable_ready
+    end
+
+    initializer "cable_ready.renderer" do
+      ActiveSupport.on_load(:action_controller) do
+        ActionController::Renderers.add :operations do |operations, options|
+          warn "DEPRECATED: CableReady's `render operations:` call has been renamed to `render cable_ready:`. Please update your render call."
+
+          response.content_type ||= Mime[:cable_ready]
+          response.headers["X-Cable-Ready-Version"] = CableReady::VERSION
+
+          render json: operations.respond_to?(:dispatch) ? operations.dispatch : operations
+        end
+
+        ActionController::Renderers.add :cable_ready do |operations, options|
+          response.content_type ||= Mime[:cable_ready]
+          response.headers["X-Cable-Ready-Version"] = CableReady::VERSION
+
+          render json: operations.respond_to?(:dispatch) ? operations.dispatch : operations
+        end
+      end
+    end
+
+    initializer "cable_ready.importmap", before: "importmap" do |app|
+      if app.config.respond_to?(:importmap)
+        app.config.importmap.paths << Engine.root.join("lib/cable_ready/importmap.rb")
+        app.config.importmap.cache_sweepers << Engine.root.join("app/assets/javascripts")
+      end
+    end
+  end
+end

data/lib/cable_ready/identifiable.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "action_view"
+
+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 ar_relation?(record)
+        [prefix, record.model_name.plural].compact.join("_")
+      elsif ar_base?(record)
+        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) ||
+        ar_relation?(obj) ||
+        ar_base?(obj)
+      )
+    end
+
+    private
+
+    def ar_relation?(obj)
+      return false if defined?(ActiveRecord).nil? || defined?(ActiveRecord::Relation).nil?
+
+      obj.is_a?(ActiveRecord::Relation)
+    end
+
+    def ar_base?(obj)
+      return false if defined?(ActiveRecord).nil? || defined?(ActiveRecord::Base).nil?
+
+      obj.is_a?(ActiveRecord::Base)
+    end
+  end
+end

data/lib/cable_ready/importmap.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+pin "morphdom", to: "https://ga.jspm.io/npm:morphdom@2.6.1/dist/morphdom.js", preload: true
+pin "cable_ready", to: "cable_ready.js", preload: true

data/lib/cable_ready/installer.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require "cable_ready/version"
+
+### general utilities
+
+def fetch(step_path, file)
+  relative_path = step_path + file
+  location = template_src + relative_path
+
+  Pathname.new(location)
+end
+
+def complete_step(step)
+  create_file "tmp/cable_ready_installer/#{step}", verbose: false
+end
+
+def create_or_append(path, *args, &block)
+  FileUtils.touch(path)
+  append_file(path, *args, &block)
+end
+
+def current_template
+  ENV["LOCATION"].split("/").last.gsub(".rb", "")
+end
+
+def pack_path_missing?
+  return false unless pack_path.nil?
+  halt "#{friendly_pack_path} is missing. You need a valid application pack file to proceed."
+end
+
+def halt(message)
+  say "❌ #{message}", :red
+  create_file "tmp/cable_ready_installer/halt", verbose: false
+end
+
+def backup(path, delete: false)
+  if !path.exist?
+    yield
+    return
+  end
+
+  backup_path = Pathname.new("#{path}.bak")
+  old_path = path.relative_path_from(Rails.root).to_s
+  filename = path.to_path.split("/").last
+
+  if backup_path.exist?
+    if backup_path.read == path.read
+      path.delete if delete
+      yield
+      return
+    end
+    backup_path.delete
+  end
+
+  copy_file(path, backup_path, verbose: false)
+  path.delete if delete
+
+  yield
+
+  if path.read != backup_path.read
+    create_or_append(backups_path, "#{old_path}\n", verbose: false)
+  end
+  say "📦 #{old_path} backed up as #{filename}.bak"
+end
+
+def add_gem(name)
+  create_or_append(add_gem_list, "#{name}\n", verbose: false)
+  say "☑️  Added #{name} to the Gemfile"
+end
+
+def remove_gem(name)
+  create_or_append(remove_gem_list, "#{name}\n", verbose: false)
+  say "❎ Removed #{name} from Gemfile"
+end
+
+def add_package(name)
+  create_or_append(package_list, "#{name}\n", verbose: false)
+  say "☑️  Enqueued #{name} to be added to dependencies"
+end
+
+def add_dev_package(name)
+  create_or_append(dev_package_list, "#{name}\n", verbose: false)
+  say "☑️  Enqueued #{name} to be added to dev dependencies"
+end
+
+def drop_package(name)
+  create_or_append(drop_package_list, "#{name}\n", verbose: false)
+  say "❎ Enqueued #{name} to be removed from dependencies"
+end
+
+def gemfile_hash
+  Digest::MD5.hexdigest(gemfile_path.read)
+end
+
+### memoized values
+
+def cr_npm_version
+  @cr_npm_version ||= CableReady::VERSION.gsub(".pre", "-pre")
+end
+
+def package_json
+  @package_json ||= Rails.root.join("package.json")
+end
+
+def entrypoint
+  @entrypoint ||= File.read("tmp/cable_ready_installer/entrypoint")
+end
+
+def bundler
+  @bundler ||= File.read("tmp/cable_ready_installer/bundler")
+end
+
+def config_path
+  @config_path ||= Rails.root.join(entrypoint, "config")
+end
+
+def importmap_path
+  @importmap_path ||= Rails.root.join("config/importmap.rb")
+end
+
+def friendly_importmap_path
+  @friendly_importmap_path ||= importmap_path.relative_path_from(Rails.root).to_s
+end
+
+def pack
+  @pack ||= pack_path.read
+end
+
+def friendly_pack_path
+  @friendly_pack_path ||= pack_path.relative_path_from(Rails.root).to_s
+end
+
+def pack_path
+  @pack_path ||= [
+    Rails.root.join(entrypoint, "application.js"),
+    Rails.root.join(entrypoint, "packs/application.js"),
+    Rails.root.join(entrypoint, "entrypoints/application.js")
+  ].find(&:exist?)
+end
+
+def package_list
+  @package_list ||= Rails.root.join("tmp/cable_ready_installer/npm_package_list")
+end
+
+def dev_package_list
+  @dev_package_list ||= Rails.root.join("tmp/cable_ready_installer/npm_dev_package_list")
+end
+
+def drop_package_list
+  @drop_package_list ||= Rails.root.join("tmp/cable_ready_installer/drop_npm_package_list")
+end
+
+def template_src
+  @template_src ||= File.read("tmp/cable_ready_installer/template_src")
+end
+
+def controllers_path
+  @controllers_path ||= Rails.root.join(entrypoint, "controllers")
+end
+
+def gemfile_path
+  @gemfile_path ||= Rails.root.join("Gemfile")
+end
+
+def gemfile
+  @gemfile ||= gemfile_path.read
+end
+
+def prefix
+  # standard:disable Style/RedundantStringEscape
+  @prefix ||= {
+    "vite" => "..\/",
+    "webpacker" => "",
+    "shakapacker" => "",
+    "importmap" => "",
+    "esbuild" => ".\/"
+  }[bundler]
+  # standard:enable Style/RedundantStringEscape
+end
+
+def application_record_path
+  @application_record_path ||= Rails.root.join("app/models/application_record.rb")
+end
+
+def action_cable_initializer_path
+  @action_cable_initializer_path ||= Rails.root.join("config/initializers/action_cable.rb")
+end
+
+def action_cable_initializer_working_path
+  @action_cable_initializer_working_path ||= Rails.root.join(working, "action_cable.rb")
+end
+
+def development_path
+  @development_path ||= Rails.root.join("config/environments/development.rb")
+end
+
+def development_working_path
+  @development_working_path ||= Rails.root.join(working, "development.rb")
+end
+
+def backups_path
+  @backups_path ||= Rails.root.join("tmp/cable_ready_installer/backups")
+end
+
+def add_gem_list
+  @add_gem_list ||= Rails.root.join("tmp/cable_ready_installer/add_gem_list")
+end
+
+def remove_gem_list
+  @remove_gem_list ||= Rails.root.join("tmp/cable_ready_installer/remove_gem_list")
+end
+
+def options_path
+  @options_path ||= Rails.root.join("tmp/cable_ready_installer/options")
+end
+
+def options
+  @options ||= YAML.safe_load(File.read(options_path))
+end
+
+def working
+  @working ||= Rails.root.join("tmp/cable_ready_installer/working")
+end

data/lib/cable_ready/operation_builder.rb

@@ -0,0 +1,80 @@
+# 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) {
+        if args.one? && args.first.respond_to?(:to_operation_options) && [Array, Hash].include?(args.first.to_operation_options.class)
+          case args.first.to_operation_options
+          when Array
+            selector, options = nil, args.first.to_operation_options
+              .select { |e| e.is_a?(Symbol) && args.first.respond_to?("to_#{e}".to_sym) }
+              .each_with_object({}) { |option, memo| memo[option.to_s] = args.first.send("to_#{option}".to_sym) }
+          when Hash
+            selector, options = nil, args.first.to_operation_options
+          else
+            raise TypeError, ":to_operation_options returned an #{args.first.to_operation_options.class.name}. Must be an Array or Hash."
+          end
+        else
+          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.each { |key, value| options[key] = value.send("to_#{key}".to_sym) if value.respond_to?("to_#{key}".to_sym) }
+        end
+        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"] = identifiable?(previous_selector) ? dom_id(previous_selector) : previous_selector
+        end
+        options["operation"] = name.to_s.camelize(:lower)
+        @enqueued_operations << 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
+      @enqueued_operations.concat(Array.wrap(operations))
+      self
+    end
+
+    def operations_payload
+      @enqueued_operations.map { |operation| operation.deep_transform_keys! { |key| key.to_s.camelize(:lower) } }
+    end
+
+    def reset!
+      @enqueued_operations = []
+      @previous_selector = nil
+    end
+  end
+end

data/lib/cable_ready/sanity_checker.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+class CableReady::SanityChecker
+  LATEST_VERSION_FORMAT = /^(\d+\.\d+\.\d+)$/
+
+  class << self
+    def check!
+      return if ENV["SKIP_SANITY_CHECK"]
+      return if CableReady.config.on_failed_sanity_checks == :ignore
+      return if called_by_generate_config?
+      return if called_by_rake?
+
+      new
+    end
+
+    private
+
+    def called_by_generate_config?
+      ARGV.include?("cable_ready:initializer")
+    end
+
+    def called_by_rake?
+      File.basename($PROGRAM_NAME) == "rake"
+    end
+  end
+
+  private
+
+  def initializer_missing?
+    File.exist?(Rails.root.join("config", "initializers", "cable_ready.rb")) == false
+  end
+
+  def warn_and_exit(text)
+    puts
+    puts "Heads up! 🔥"
+    puts
+    puts text
+    puts
+    if CableReady.config.on_failed_sanity_checks == :exit
+      puts <<~INFO
+        To ignore any warnings and start the application anyway, you can set the SKIP_SANITY_CHECK environment variable:
+
+          SKIP_SANITY_CHECK=true rails
+
+        To do this permanently, add the following directive to the CableReady initializer:
+
+          CableReady.configure do |config|
+            config.on_failed_sanity_checks = :warn
+          end
+
+      INFO
+      if initializer_missing?
+        puts <<~INFO
+          You can create a CableReady initializer with the command:
+
+            bundle exec rails generate cable_ready:initializer
+
+        INFO
+      end
+      exit false if Rails.env.test? == false
+    end
+  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

data/lib/cable_ready/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module CableReady
-  VERSION = "4.5.0"
+  VERSION = "5.0.0"
 end

data/lib/cable_ready.rb

@@ -1,20 +1,33 @@
 # frozen_string_literal: true
 
-require "rails/engine"
-require "active_support/all"
-require "cable_ready/version"
+require "open-uri"
+require "active_support/message_verifier"
+require "cable_ready/identifiable"
+require "cable_ready/operation_builder"
 require "cable_ready/config"
 require "cable_ready/broadcaster"
+require "cable_ready/engine"
+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"
+require "cable_ready/version"
+require "cable_ready_helper"
 
 module CableReady
-  class Engine < Rails::Engine
-  end
+  class << self
+    def config
+      CableReady::Config.instance
+    end
 
-  def self.config
-    CableReady::Config.instance
-  end
+    def configure
+      yield config
+    end
 
-  def self.configure
-    yield config
+    def signed_stream_verifier
+      @signed_stream_verifier ||= ActiveSupport::MessageVerifier.new(config.verifier_key, digest: "SHA256", serializer: JSON)
+    end
   end
 end

data/lib/cable_ready_helper.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# TODO: remove me once CableReady 5.0 was released
+
+require_relative "../app/helpers/cable_ready/view_helper"
+
+module CableReadyHelper
+  def self.included(base)
+    warn "NOTICE: `CableReadyHelper` was renamed to `CableReady::ViewHelper`. Please update your include accordingly."
+
+    base.include(::CableReady::ViewHelper)
+  end
+end