cable_ready 4.5.0 → 5.0.0.pre3

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,10 +8,10 @@ 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"
@@ -23,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,20 +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
-  end
+    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
 
-  def self.config
-    CableReady::Config.instance
+        Mime::Type.register "application/vnd.cable-ready.json", :cable_ready
+      end
+    end
   end
 
-  def self.configure
-    yield config
+  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,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,9 +52,10 @@ module CableReady
         morph
         notification
         outer_html
-        play_sound
         prepend
         push_state
+        redirect_to
+        reload
         remove
         remove_attribute
         remove_css_class
@@ -56,6 +67,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,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

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.push(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,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 ENV["SKIP_SANITY_CHECK"]
+      return if CableReady.config.on_failed_sanity_checks == :ignore
+      return if called_by_generate_config?
+      return if called_by_rake?
+
+      instance = new
+      instance.check_package_versions_match
+      instance.check_new_version_available
+    end
+
+    private
+
+    def called_by_generate_config?
+      ARGV.include?("cable_ready:initializer")
+    end
+
+    def called_by_rake?
+      File.basename($PROGRAM_NAME) == "rake"
+    end
+  end
+
+  def check_package_versions_match
+    if npm_version.nil?
+      warn_and_exit <<~WARN
+        👉 Can't locate the cable_ready npm package.
+
+          yarn add cable_ready@#{gem_version}
+
+        Either add it to your package.json as a dependency or use "yarn link cable_ready" if you are doing development.
+      WARN
+    end
+
+    if package_version_mismatch?
+      warn_and_exit <<~WARN
+        👉 The cable_ready npm package version (#{npm_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 if CableReady.config.on_new_version_available == :ignore
+    return if Rails.env.development? == false
+    return if using_preview_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 package_version_mismatch?
+    npm_version != gem_version
+  end
+
+  def using_preview_release?
+    preview = CableReady::VERSION.match?(LATEST_VERSION_FORMAT) == false
+    puts "👉 CableReady #{CableReady::VERSION} update check skipped: pre-release build" if preview
+    preview
+  end
+
+  def gem_version
+    @_gem_version ||= CableReady::VERSION.gsub(".pre", "-pre")
+  end
+
+  def npm_version
+    @_npm_version ||= find_npm_version
+  end
+
+  def find_npm_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 if File.exist?(path) == false
+    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_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