cable_ready 5.0.0.pre9 → 5.0.0.pre10

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

@@ -1,18 +1,32 @@
 # frozen_string_literal: true
 
+require "active_support/concern"
+
 module CableReady
   module Updatable
     extend ::ActiveSupport::Concern
 
     included do |base|
-      if base < ActiveRecord::Base
+      if defined?(ActiveRecord) && 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)
+        def self.enable_updates(...)
+          warn "DEPRECATED: please use `enable_cable_ready_updates` instead. The `enable_updates` class method will be removed from a future version of CableReady 5"
+
+          enable_cable_ready_updates(...)
+        end
+
+        def self.skip_updates(...)
+          warn "DEPRECATED: please use `skip_cable_ready_updates` instead. The `skip_updates` class method will be removed from a future version of CableReady 5"
+
+          skip_cable_ready_updates(...)
+        end
+
+        def self.enable_cable_ready_updates(*options)
           options = options.extract_options!
           options = {
             on: [:create, :update, :destroy],
@@ -26,7 +40,7 @@ module CableReady
           after_commit(ModelUpdatableCallbacks.new(:destroy, enabled_operations), {on: :destroy, if: options[:if]})
         end
 
-        def self.skip_updates
+        def self.skip_cable_ready_updates
           skip_updates_classes.push(self)
           yield
         ensure
@@ -39,15 +53,47 @@ module CableReady
 
     module ClassMethods
       def has_many(name, scope = nil, **options, &extension)
-        option = options.delete(:enable_updates)
+        option = if options.has_key?(:enable_updates)
+          warn "DEPRECATED: please use `enable_cable_ready_updates` instead. The `enable_updates` option will be removed from a future version of CableReady 5"
+          options.delete(:enable_updates)
+        else
+          options.delete(:enable_cable_ready_updates)
+        end
+
+        descendants = options.delete(:descendants)
+
+        broadcast = option.present?
+        result = super
+        enrich_association_with_updates(name, option, descendants) if broadcast
+        result
+      end
+
+      def has_one(name, scope = nil, **options, &extension)
+        option = if options.has_key?(:enable_updates)
+          warn "DEPRECATED: please use `enable_cable_ready_updates` instead. The `enable_updates` option will be removed from a future version of CableReady 5"
+          options.delete(:enable_updates)
+        else
+          options.delete(:enable_cable_ready_updates)
+        end
+
+        descendants = options.delete(:descendants)
+
         broadcast = option.present?
         result = super
-        enrich_association_with_updates(name, option) if broadcast
+        enrich_association_with_updates(name, option, descendants) if broadcast
         result
       end
 
       def has_many_attached(name, **options)
-        option = options.delete(:enable_updates)
+        raise("ActiveStorage must be enabled to use has_many_attached") unless defined?(ActiveStorage)
+
+        option = if options.has_key?(:enable_updates)
+          warn "DEPRECATED: please use `enable_cable_ready_updates` instead. The `enable_updates` option will be removed from a future version of CableReady 5"
+          options.delete(:enable_updates)
+        else
+          options.delete(:enable_cable_ready_updates)
+        end
+
         broadcast = option.present?
         result = super
         enrich_attachments_with_updates(name, option) if broadcast
@@ -63,7 +109,7 @@ module CableReady
         broadcast_updates(identifier, model.respond_to?(:previous_changes) ? {changed: model.previous_changes.keys} : {})
       end
 
-      def enrich_association_with_updates(name, option)
+      def enrich_association_with_updates(name, option, descendants = nil)
         reflection = reflect_on_association(name)
 
         inverse_of = reflection.inverse_of&.name&.to_s
@@ -76,16 +122,17 @@ module CableReady
 
         options = build_options(option)
 
-        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
-        })
+        [reflection.klass, *descendants&.map(&:to_s)&.map(&:constantize)].each do |klass|
+          klass.send(:include, CableReady::Updatable) unless klass.respond_to?(:cable_ready_collections)
+          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
 
       def enrich_attachments_with_updates(name, option)
@@ -111,7 +158,7 @@ module CableReady
 
         case option
         when TrueClass
-          # proceed!
+        # proceed!
         when FalseClass
           options[:on] = []
         when Array
@@ -124,7 +171,7 @@ module CableReady
         when Proc
           options[:if] = option
         else
-          raise ArgumentError, "Invalid enable_updates option #{option}"
+          raise ArgumentError, "Invalid enable_cable_ready_updates option #{option}"
         end
 
         options
@@ -132,6 +179,7 @@ module CableReady
 
       def broadcast_updates(model_class, options)
         return if skip_updates_classes.any? { |klass| klass >= self }
+        raise("ActionCable must be enabled to use Updatable") unless defined?(ActionCable)
         ActionCable.server.broadcast(model_class, options)
       end
 

data/app/models/concerns/extend_has_many.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/concern"
+
 module ExtendHasMany
   extend ::ActiveSupport::Concern
 

data/cable_ready.gemspec

@@ -12,31 +12,29 @@ Gem::Specification.new do |gem|
   gem.summary = "Out-of-Band Server Triggered DOM Operations"
 
   gem.files = Dir[
-    "lib/**/*.rb",
+    "lib/**/*.{rb,rake}",
     "app/**/*.rb",
     "app/assets/javascripts/*",
     "bin/*",
     "[A-Z]*"
   ]
 
-  gem.test_files = Dir["test/**/*.rb"]
+  gem.required_ruby_version = ">= 2.7.0"
 
   rails_version = ">= 5.2"
-  gem.add_dependency "actioncable", rails_version
+
   gem.add_dependency "actionpack", rails_version
   gem.add_dependency "actionview", rails_version
-  gem.add_dependency "activerecord", rails_version
   gem.add_dependency "activesupport", rails_version
   gem.add_dependency "railties", rails_version
-
   gem.add_dependency "thread-local", ">= 1.1.0"
 
   gem.add_development_dependency "magic_frozen_string_literal"
   gem.add_development_dependency "mocha"
   gem.add_development_dependency "pry"
   gem.add_development_dependency "pry-nav"
-  gem.add_development_dependency "rails", rails_version
   gem.add_development_dependency "rake"
   gem.add_development_dependency "sqlite3"
+  gem.add_development_dependency "standard", "1.19.1"
   gem.add_development_dependency "standardrb"
 end

data/lib/cable_ready/broadcaster.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/concern"
+
 module CableReady
   module Broadcaster
     include Identifiable

data/lib/cable_ready/cable_car.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "thread/local"
+
 module CableReady
   class CableCar < OperationBuilder
     extend Thread::Local

data/lib/cable_ready/channel.rb

@@ -5,6 +5,7 @@ module CableReady
     attr_reader :identifier
 
     def broadcast(clear: true)
+      raise("Action Cable must be enabled to use broadcast") unless defined?(ActionCable)
       clients_received = ActionCable.server.broadcast identifier, {
         "cableReady" => true,
         "operations" => operations_payload,
@@ -15,6 +16,7 @@ module CableReady
     end
 
     def broadcast_to(model, clear: true)
+      raise("Action Cable must be enabled to use broadcast_to") unless defined?(ActionCable)
       clients_received = identifier.broadcast_to model, {
         "cableReady" => true,
         "operations" => operations_payload,
@@ -24,13 +26,19 @@ module CableReady
       clients_received
     end
 
-    def broadcast_later(clear: true)
-      CableReadyBroadcastJob.perform_later(identifier: identifier, operations: operations_payload)
+    def broadcast_later(clear: true, queue: nil)
+      raise("Action Cable must be enabled to use broadcast_later") unless defined?(ActionCable)
+      CableReadyBroadcastJob
+        .set(queue: queue ? queue.to_sym : CableReady.config.broadcast_job_queue)
+        .perform_later(identifier: identifier, operations: operations_payload)
       reset! if clear
     end
 
-    def broadcast_later_to(model, clear: true)
-      CableReadyBroadcastJob.perform_later(identifier: identifier.name, operations: operations_payload, model: model)
+    def broadcast_later_to(model, clear: true, queue: nil)
+      raise("Action Cable must be enabled to use broadcast_later_to") unless defined?(ActionCable)
+      CableReadyBroadcastJob
+        .set(queue: queue ? queue.to_sym : CableReady.config.broadcast_job_queue)
+        .perform_later(identifier: identifier.name, operations: operations_payload, model: model)
       reset! if clear
     end
   end

data/lib/cable_ready/channels.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "thread/local"
+
 module CableReady
   # This class is a thread local singleton: CableReady::Channels.instance
   # SEE: https://github.com/socketry/thread-local/tree/master/guides/getting-started
@@ -13,7 +15,7 @@ module CableReady
 
     def [](*keys)
       keys.select!(&:itself)
-      identifier = keys.many? || (keys.one? && keys.first.respond_to?(:to_global_id)) ? 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/config.rb

@@ -1,5 +1,9 @@
 # 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
@@ -7,14 +11,23 @@ module CableReady
     include Observable
     include Singleton
 
-    attr_accessor :on_failed_sanity_checks, :on_new_version_available
+    attr_accessor :on_failed_sanity_checks, :broadcast_job_queue, :precompile_assets
     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
-      @on_new_version_available = :ignore
+      @broadcast_job_queue = :default
+      @precompile_assets = true
     end
 
     def observers
@@ -72,6 +85,7 @@ module CableReady
         set_storage_item
         set_style
         set_styles
+        set_title
         set_value
         text_content
       ]).freeze

data/lib/cable_ready/engine.rb

@@ -1,7 +1,24 @@
+# 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.min.js
+      cable_ready.min.js.map
+      cable_ready.umd.js
+      cable_ready.umd.min.js
+      cable_ready.umd.min.js.map
+    ]
+
     initializer "cable_ready.sanity_check" do
       SanityChecker.check! unless Rails.env.production?
     end
@@ -18,15 +35,8 @@ module CableReady
     end
 
     initializer "cable_ready.assets" do |app|
-      if app.config.respond_to?(:assets)
-        app.config.assets.precompile += %w[
-          cable_ready.js
-          cable_ready.min.js
-          cable_ready.min.js.map
-          cable_ready.umd.js
-          cable_ready.umd.min.js
-          cable_ready.umd.min.js.map
-        ]
+      if app.config.respond_to?(:assets) && CableReady.config.precompile_assets
+        app.config.assets.precompile += PRECOMPILE_ASSETS
       end
     end
 

data/lib/cable_ready/identifiable.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "action_view"
+
 module CableReady
   module Identifiable
     def dom_id(record, prefix = nil)
@@ -9,9 +11,9 @@ module CableReady
 
       id = if record.respond_to?(:to_dom_id)
         record.to_dom_id
-      elsif record.is_a?(ActiveRecord::Relation)
+      elsif ar_relation?(record)
         [prefix, record.model_name.plural].compact.join("_")
-      elsif record.is_a?(ActiveRecord::Base)
+      elsif ar_base?(record)
         ActionView::RecordIdentifier.dom_id(record, prefix)
       else
         [prefix, record.to_s.strip].compact.join("_")
@@ -21,10 +23,26 @@ module CableReady
     end
 
     def identifiable?(obj)
-      obj.respond_to?(:to_dom_selector) ||
+      (
+        obj.respond_to?(:to_dom_selector) ||
         obj.respond_to?(:to_dom_id) ||
-        obj.is_a?(ActiveRecord::Relation) ||
-        obj.is_a?(ActiveRecord::Base)
+        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

@@ -1,2 +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.min.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

@@ -64,7 +64,7 @@ module CableReady
       rescue JSON::ParserError
         {}
       end
-      @enqueued_operations.push(operations)
+      @enqueued_operations.concat(Array.wrap(operations))
       self
     end