cable_ready 5.0.0.pre1 → 5.0.0.pre5

data/lib/cable_ready/identifiable.rb

@@ -3,9 +3,13 @@
 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.is_a?(ActiveRecord::Relation)
+      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)
@@ -13,7 +17,14 @@ module CableReady
         [prefix, record.to_s.strip].compact.join("_")
       end
 
-      "##{id}".squeeze("#").strip
+      "##{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

@@ -24,17 +24,32 @@ module CableReady
     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!
+        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"] = previous_selector.is_a?(ActiveRecord::Base) || previous_selector.is_a?(ActiveRecord::Relation) ? dom_id(previous_selector) : previous_selector
+          options["selector"] = identifiable?(previous_selector) ? dom_id(previous_selector) : previous_selector
         end
-        @enqueued_operations[name.to_s] << options
+        options["operation"] = name.to_s.camelize(:lower)
+        @enqueued_operations << options
         self
       }
     end
@@ -43,26 +58,22 @@ module CableReady
       @enqueued_operations.to_json(*args)
     end
 
-    def apply!(operations = "{}")
+    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
+      @enqueued_operations.push(operations)
       self
     end
 
     def operations_payload
-      @enqueued_operations.select { |_, list| list.present? }.deep_transform_keys { |key| key.to_s.camelize(:lower) }
+      @enqueued_operations.map { |operation| operation.deep_transform_keys! { |key| key.to_s.camelize(:lower) } }
     end
 
     def reset!
-      @enqueued_operations = Hash.new { |hash, key| hash[key] = [] }
+      @enqueued_operations = []
       @previous_selector = nil
     end
   end

data/lib/cable_ready/sanity_checker.rb

@@ -7,48 +7,59 @@ class CableReady::SanityChecker
 
   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_javascript_package_version
+      instance.check_package_versions_match
       instance.check_new_version_available
     end
 
     private
 
     def called_by_generate_config?
-      ARGV.include? "cable_ready:initializer"
+      ARGV.include?("cable_ready:initializer")
+    end
+
+    def called_by_rake?
+      File.basename($PROGRAM_NAME) == "rake"
     end
   end
 
-  def check_javascript_package_version
-    if javascript_package_version.nil?
+  def check_package_versions_match
+    if npm_version.nil?
       warn_and_exit <<~WARN
-        Can't locate the cable_ready npm package.
+        👉 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
 
-    unless javascript_version_matches?
+    if package_version_mismatch?
       warn_and_exit <<~WARN
-        The cable_ready npm package version (#{javascript_package_version}) does not match the Rubygem version (#{gem_version}).
+        👉 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 unless Rails.env.development?
     return if CableReady.config.on_new_version_available == :ignore
-    return unless using_stable_release
+    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!
+          👉 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
@@ -58,31 +69,31 @@ class CableReady::SanityChecker
         exit if CableReady.config.on_new_version_available == :exit
       end
     rescue
-      puts "CableReady #{CableReady::VERSION} update check skipped: connection timeout"
+      puts "👉 CableReady #{CableReady::VERSION} update check skipped: connection timeout"
     end
   end
 
   private
 
-  def javascript_version_matches?
-    javascript_package_version == gem_version
+  def package_version_mismatch?
+    npm_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
+  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 javascript_package_version
-    @_js_version ||= find_javascript_package_version
+  def npm_version
+    @_npm_version ||= find_npm_version
   end
 
-  def find_javascript_package_version
+  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/))
@@ -91,7 +102,7 @@ class CableReady::SanityChecker
   end
 
   def search_file(path, regex:)
-    return unless File.exist?(path)
+    return if File.exist?(path) == false
     File.foreach(path).grep(regex).first
   end
 
@@ -103,49 +114,38 @@ class CableReady::SanityChecker
     Rails.root.join("yarn.lock")
   end
 
-  def initializer_path
-    @_initializer_path ||= Rails.root.join("config", "initializers", "cable_ready.rb")
+  def initializer_missing?
+    File.exist?(Rails.root.join("config", "initializers", "cable_ready.rb")) == false
   end
 
   def warn_and_exit(text)
-    puts "WARNING:"
+    puts
+    puts "Heads up! 🔥"
+    puts
     puts text
-    exit_with_info if CableReady.config.on_failed_sanity_checks == :exit
-  end
-
-  def exit_with_info
     puts
-
-    if File.exist?(initializer_path)
+    if CableReady.config.on_failed_sanity_checks == :exit
       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}
+        To ignore any warnings and start the application anyway, you can set the SKIP_SANITY_CHECK environment variable:
 
-          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
+          SKIP_SANITY_CHECK=true rails
 
-        Then open your initializer at
-
-        #{initializer_path}
-
-        and then add the following directive:
+        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
-    exit false unless Rails.env.test?
   end
 end

data/lib/cable_ready/version.rb

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

data/lib/cable_ready.rb

@@ -30,8 +30,11 @@ module CableReady
     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

data/lib/generators/cable_ready/{stream_from_generator.rb → helpers_generator.rb}

@@ -4,7 +4,7 @@ require "rails/generators"
 require "fileutils"
 
 module CableReady
-  class StreamFromGenerator < Rails::Generators::Base
+  class HelpersGenerator < Rails::Generators::Base
     desc "Initializes CableReady with a reference to the shared ActionCable consumer"
     source_root File.expand_path("templates", __dir__)
 

data/test/dummy/app/channels/application_cable/channel.rb

@@ -0,0 +1,4 @@
+module ApplicationCable
+  class Channel < ActionCable::Channel::Base
+  end
+end

data/test/dummy/app/channels/application_cable/connection.rb

@@ -0,0 +1,4 @@
+module ApplicationCable
+  class Connection < ActionCable::Connection::Base
+  end
+end

data/test/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,2 @@
+class ApplicationController < ActionController::Base
+end

data/test/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end

data/test/dummy/app/jobs/application_job.rb

@@ -0,0 +1,7 @@
+class ApplicationJob < ActiveJob::Base
+  # Automatically retry jobs that encountered a deadlock
+  # retry_on ActiveRecord::Deadlocked
+
+  # Most jobs are safe to ignore if the underlying records are no longer available
+  # discard_on ActiveJob::DeserializationError
+end

data/test/dummy/app/mailers/application_mailer.rb

@@ -0,0 +1,4 @@
+class ApplicationMailer < ActionMailer::Base
+  default from: 'from@example.com'
+  layout 'mailer'
+end

data/test/dummy/app/models/application_record.rb

@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end

data/test/dummy/app/models/global_idable_entity.rb

@@ -0,0 +1,16 @@
+class GlobalIdableEntity
+  include GlobalID::Identification
+  include CableReady::Updatable
+
+  def id
+    "fake-id"
+  end
+
+  def self.find(id)
+    new if id == "fake-id"
+  end
+
+  def fake_update
+    ModelUpdatableCallbacks.new(:update).after_commit(self)
+  end
+end

data/test/dummy/app/models/post.rb

@@ -0,0 +1,4 @@
+class Post < ApplicationRecord
+  include CableReady::Updatable
+  belongs_to :user
+end

data/test/dummy/app/models/section.rb

@@ -0,0 +1,6 @@
+class Section < ApplicationRecord
+  include CableReady::Updatable
+  enable_updates if: -> { updates_enabled }
+
+  attribute :updates_enabled, :boolean, default: false
+end

data/test/dummy/app/models/team.rb

@@ -0,0 +1,6 @@
+class Team < ApplicationRecord
+  include CableReady::Updatable
+  enable_updates
+
+  has_many :users, enable_updates: true
+end

data/test/dummy/app/models/topic.rb

@@ -0,0 +1,4 @@
+class Topic < ApplicationRecord
+  include CableReady::Updatable
+  enable_updates on: :create
+end

data/test/dummy/app/models/user.rb

@@ -0,0 +1,7 @@
+class User < ApplicationRecord
+  include CableReady::Updatable
+  enable_updates
+
+  has_many :posts, enable_updates: true
+  belongs_to :team, optional: true, touch: true
+end

data/test/dummy/config/application.rb

@@ -0,0 +1,22 @@
+require_relative "boot"
+
+require "rails/all"
+
+# Require the gems listed in Gemfile, including any gems
+# you've limited to :test, :development, or :production.
+Bundler.require(*Rails.groups)
+require "cable_ready"
+
+module Dummy
+  class Application < Rails::Application
+    config.load_defaults Rails::VERSION::STRING.to_f
+
+    # Configuration for the application, engines, and railties goes here.
+    #
+    # These settings can be overridden in specific environments using the files
+    # in config/environments, which are processed later.
+    #
+    # config.time_zone = "Central Time (US & Canada)"
+    # config.eager_load_paths << Rails.root.join("extras")
+  end
+end

data/test/dummy/config/boot.rb

@@ -0,0 +1,5 @@
+# Set up gems listed in the Gemfile.
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../../../Gemfile', __dir__)
+
+require "bundler/setup" if File.exist?(ENV["BUNDLE_GEMFILE"])
+$LOAD_PATH.unshift File.expand_path('../../../lib', __dir__)

data/test/dummy/config/environment.rb

@@ -0,0 +1,5 @@
+# Load the Rails application.
+require_relative "application"
+
+# Initialize the Rails application.
+Rails.application.initialize!

data/test/dummy/config/environments/development.rb

@@ -0,0 +1,76 @@
+require "active_support/core_ext/integer/time"
+
+Rails.application.configure do
+  # Settings specified here will take precedence over those in config/application.rb.
+
+  # In the development environment your application's code is reloaded any time
+  # it changes. This slows down response time but is perfect for development
+  # since you don't have to restart the web server when you make code changes.
+  config.cache_classes = false
+
+  # Do not eager load code on boot.
+  config.eager_load = false
+
+  # Show full error reports.
+  config.consider_all_requests_local = true
+
+  # Enable/disable caching. By default caching is disabled.
+  # Run rails dev:cache to toggle caching.
+  if Rails.root.join('tmp', 'caching-dev.txt').exist?
+    config.action_controller.perform_caching = true
+    config.action_controller.enable_fragment_cache_logging = true
+
+    config.cache_store = :memory_store
+    config.public_file_server.headers = {
+      'Cache-Control' => "public, max-age=#{2.days.to_i}"
+    }
+  else
+    config.action_controller.perform_caching = false
+
+    config.cache_store = :null_store
+  end
+
+  # Store uploaded files on the local file system (see config/storage.yml for options).
+  config.active_storage.service = :local
+
+  # Don't care if the mailer can't send.
+  config.action_mailer.raise_delivery_errors = false
+
+  config.action_mailer.perform_caching = false
+
+  # Print deprecation notices to the Rails logger.
+  config.active_support.deprecation = :log
+
+  # Raise exceptions for disallowed deprecations.
+  config.active_support.disallowed_deprecation = :raise
+
+  # Tell Active Support which deprecation messages to disallow.
+  config.active_support.disallowed_deprecation_warnings = []
+
+  # Raise an error on page load if there are pending migrations.
+  config.active_record.migration_error = :page_load
+
+  # Highlight code that triggered database queries in logs.
+  config.active_record.verbose_query_logs = true
+
+  # Debug mode disables concatenation and preprocessing of assets.
+  # This option may cause significant delays in view rendering with a large
+  # number of complex assets.
+  config.assets.debug = true
+
+  # Suppress logger output for asset requests.
+  config.assets.quiet = true
+
+  # Raises error for missing translations.
+  # config.i18n.raise_on_missing_translations = true
+
+  # Annotate rendered view with file names.
+  # config.action_view.annotate_rendered_view_with_filenames = true
+
+  # Use an evented file watcher to asynchronously detect changes in source code,
+  # routes, locales, etc. This feature depends on the listen gem.
+  # config.file_watcher = ActiveSupport::EventedFileUpdateChecker
+
+  # Uncomment if you wish to allow Action Cable access from any origin.
+  # config.action_cable.disable_request_forgery_protection = true
+end

data/test/dummy/config/environments/production.rb

@@ -0,0 +1,120 @@
+require "active_support/core_ext/integer/time"
+
+Rails.application.configure do
+  # Settings specified here will take precedence over those in config/application.rb.
+
+  # Code is not reloaded between requests.
+  config.cache_classes = true
+
+  # Eager load code on boot. This eager loads most of Rails and
+  # your application in memory, allowing both threaded web servers
+  # and those relying on copy on write to perform better.
+  # Rake tasks automatically ignore this option for performance.
+  config.eager_load = true
+
+  # Full error reports are disabled and caching is turned on.
+  config.consider_all_requests_local       = false
+  config.action_controller.perform_caching = true
+
+  # Ensures that a master key has been made available in either ENV["RAILS_MASTER_KEY"]
+  # or in config/master.key. This key is used to decrypt credentials (and other encrypted files).
+  # config.require_master_key = true
+
+  # Disable serving static files from the `/public` folder by default since
+  # Apache or NGINX already handles this.
+  config.public_file_server.enabled = ENV['RAILS_SERVE_STATIC_FILES'].present?
+
+  # Compress CSS using a preprocessor.
+  # config.assets.css_compressor = :sass
+
+  # Do not fallback to assets pipeline if a precompiled asset is missed.
+  config.assets.compile = false
+
+  # Enable serving of images, stylesheets, and JavaScripts from an asset server.
+  # config.asset_host = 'http://assets.example.com'
+
+  # Specifies the header that your server uses for sending files.
+  # config.action_dispatch.x_sendfile_header = 'X-Sendfile' # for Apache
+  # config.action_dispatch.x_sendfile_header = 'X-Accel-Redirect' # for NGINX
+
+  # Store uploaded files on the local file system (see config/storage.yml for options).
+  config.active_storage.service = :local
+
+  # Mount Action Cable outside main process or domain.
+  # config.action_cable.mount_path = nil
+  # config.action_cable.url = 'wss://example.com/cable'
+  # config.action_cable.allowed_request_origins = [ 'http://example.com', /http:\/\/example.*/ ]
+
+  # Force all access to the app over SSL, use Strict-Transport-Security, and use secure cookies.
+  # config.force_ssl = true
+
+  # Include generic and useful information about system operation, but avoid logging too much
+  # information to avoid inadvertent exposure of personally identifiable information (PII).
+  config.log_level = :info
+
+  # Prepend all log lines with the following tags.
+  config.log_tags = [ :request_id ]
+
+  # Use a different cache store in production.
+  # config.cache_store = :mem_cache_store
+
+  # Use a real queuing backend for Active Job (and separate queues per environment).
+  # config.active_job.queue_adapter     = :resque
+  # config.active_job.queue_name_prefix = "dummy_production"
+
+  config.action_mailer.perform_caching = false
+
+  # Ignore bad email addresses and do not raise email delivery errors.
+  # Set this to true and configure the email server for immediate delivery to raise delivery errors.
+  # config.action_mailer.raise_delivery_errors = false
+
+  # Enable locale fallbacks for I18n (makes lookups for any locale fall back to
+  # the I18n.default_locale when a translation cannot be found).
+  config.i18n.fallbacks = true
+
+  # Send deprecation notices to registered listeners.
+  config.active_support.deprecation = :notify
+
+  # Log disallowed deprecations.
+  config.active_support.disallowed_deprecation = :log
+
+  # Tell Active Support which deprecation messages to disallow.
+  config.active_support.disallowed_deprecation_warnings = []
+
+  # Use default logging formatter so that PID and timestamp are not suppressed.
+  config.log_formatter = ::Logger::Formatter.new
+
+  # Use a different logger for distributed setups.
+  # require "syslog/logger"
+  # config.logger = ActiveSupport::TaggedLogging.new(Syslog::Logger.new 'app-name')
+
+  if ENV["RAILS_LOG_TO_STDOUT"].present?
+    logger           = ActiveSupport::Logger.new(STDOUT)
+    logger.formatter = config.log_formatter
+    config.logger    = ActiveSupport::TaggedLogging.new(logger)
+  end
+
+  # Do not dump schema after migrations.
+  config.active_record.dump_schema_after_migration = false
+
+  # Inserts middleware to perform automatic connection switching.
+  # The `database_selector` hash is used to pass options to the DatabaseSelector
+  # middleware. The `delay` is used to determine how long to wait after a write
+  # to send a subsequent read to the primary.
+  #
+  # The `database_resolver` class is used by the middleware to determine which
+  # database is appropriate to use based on the time delay.
+  #
+  # The `database_resolver_context` class is used by the middleware to set
+  # timestamps for the last write to the primary. The resolver uses the context
+  # class timestamps to determine how long to wait before reading from the
+  # replica.
+  #
+  # By default Rails will store a last write timestamp in the session. The
+  # DatabaseSelector middleware is designed as such you can define your own
+  # strategy for connection switching and pass that into the middleware through
+  # these configuration options.
+  # config.active_record.database_selector = { delay: 2.seconds }
+  # config.active_record.database_resolver = ActiveRecord::Middleware::DatabaseSelector::Resolver
+  # config.active_record.database_resolver_context = ActiveRecord::Middleware::DatabaseSelector::Resolver::Session
+end