cable_ready 5.0.0.pre0 → 5.0.0.pre4

data/app/models/concerns/cable_ready/updatable.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module CableReady
+  module Updatable
+    extend ::ActiveSupport::Concern
+
+    included do |base|
+      if base < ActiveRecord::Base
+        include ExtendHasMany
+
+        after_commit CollectionUpdatableCallbacks.new(:create), on: :create
+        after_commit CollectionUpdatableCallbacks.new(:update), on: :update
+        after_commit CollectionUpdatableCallbacks.new(:destroy), on: :destroy
+
+        def self.enable_updates(*options)
+          options = options.extract_options!
+          options = {
+            on: [:create, :update, :destroy],
+            if: -> { true }
+          }.merge(options)
+
+          enabled_operations = Array(options[:on])
+
+          after_commit(ModelUpdatableCallbacks.new(:create, enabled_operations), {on: :create, if: options[:if]})
+          after_commit(ModelUpdatableCallbacks.new(:update, enabled_operations), {on: :update, if: options[:if]})
+          after_commit(ModelUpdatableCallbacks.new(:destroy, enabled_operations), {on: :destroy, if: options[:if]})
+        end
+      end
+    end
+
+    private
+
+    module ClassMethods
+      def has_many(name, scope = nil, **options, &extension)
+        option = options.delete(:enable_updates)
+        broadcast = option.present?
+        result = super
+        enrich_association_with_updates(name, option) if broadcast
+        result
+      end
+
+      def cable_ready_collections
+        @cable_ready_collections ||= CollectionsRegistry.new
+      end
+
+      def cable_ready_update_collection(resource, name)
+        identifier = resource.to_global_id.to_s + ":" + name.to_s
+        ActionCable.server.broadcast(identifier, {})
+      end
+
+      def enrich_association_with_updates(name, option)
+        reflection = reflect_on_association(name)
+
+        inverse_of = reflection.inverse_of&.name&.to_s
+        through_association = nil
+
+        if reflection.through_reflection?
+          inverse_of = reflection.through_reflection.inverse_of&.name&.to_s
+          through_association = reflection.through_reflection.name.to_s.singularize
+        end
+
+        options = {
+          on: [:create, :update, :destroy],
+          if: ->(resource) { true }
+        }
+
+        case option
+        when TrueClass
+          # proceed!
+        when FalseClass
+          options[:on] = []
+        when Array
+          options[:on] = option
+        when Symbol
+          options[:on] = [option]
+        when Hash
+          option[:on] = Array(option[:on]) if option[:on]
+          options = options.merge!(option)
+        when Proc
+          options[:if] = option
+        else
+          raise ArgumentError, "Invalid enable_updates option #{option}"
+        end
+
+        reflection.klass.send(:include, CableReady::Updatable) unless reflection.klass.respond_to?(:cable_ready_collections)
+
+        reflection.klass.cable_ready_collections.register({
+          klass: self,
+          foreign_key: reflection.foreign_key,
+          name: name,
+          inverse_association: inverse_of,
+          through_association: through_association,
+          options: options
+        })
+      end
+    end
+  end
+end

data/app/models/concerns/extend_has_many.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ExtendHasMany
+  extend ::ActiveSupport::Concern
+
+  class_methods do
+    def has_many(*args, &block)
+      options = args.extract_options!
+      options[:extend] = Array(options[:extend]).push(ClassMethods)
+      super(*args, **options, &block)
+    end
+  end
+end

data/lib/cable_ready/channels.rb

@@ -13,7 +13,7 @@ module CableReady
 
     def [](*keys)
       keys.select!(&:itself)
-      identifier = keys.many? || (keys.one? && keys.first.is_a?(ActiveRecord::Base)) ? compound(keys) : keys.pop
+      identifier = keys.many? || (keys.one? && keys.first.respond_to?(:to_global_id)) ? compound(keys) : keys.pop
       @channels[identifier] ||= CableReady::Channel.new(identifier)
     end
 

data/lib/cable_ready/compoundable.rb

@@ -4,7 +4,7 @@ module CableReady
   module Compoundable
     def compound(keys)
       keys.map { |key|
-        key.class < ActiveRecord::Base ? key.to_global_id.to_s : key.to_s
+        key.respond_to?(:to_global_id) ? key.to_global_id.to_s : key.to_s
       }.join(":")
     end
   end

data/lib/cable_ready/config.rb

@@ -54,6 +54,8 @@ module CableReady
         outer_html
         prepend
         push_state
+        redirect_to
+        reload
         remove
         remove_attribute
         remove_css_class

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.pre0"
+  VERSION = "5.0.0.pre4"
 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!