actioncable 6.1.7.9 → 7.2.2.1

data/lib/action_cable/connection/test_case.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 require "active_support"
 require "active_support/test_case"
 require "active_support/core_ext/hash/indifferent_access"
@@ -18,25 +20,33 @@ module ActionCable
     end
 
     module Assertions
-      # Asserts that the connection is rejected (via +reject_unauthorized_connection+).
+      # Asserts that the connection is rejected (via
+      # `reject_unauthorized_connection`).
       #
-      #   # Asserts that connection without user_id fails
-      #   assert_reject_connection { connect params: { user_id: '' } }
+      #     # Asserts that connection without user_id fails
+      #     assert_reject_connection { connect params: { user_id: '' } }
       def assert_reject_connection(&block)
         assert_raises(Authorization::UnauthorizedError, "Expected to reject connection but no rejection was made", &block)
       end
     end
 
-    # We don't want to use the whole "encryption stack" for connection
-    # unit-tests, but we want to make sure that users test against the correct types
-    # of cookies (i.e. signed or encrypted or plain)
-    class TestCookieJar < ActiveSupport::HashWithIndifferentAccess
+    class TestCookies < ActiveSupport::HashWithIndifferentAccess # :nodoc:
+      def []=(name, options)
+        value = options.is_a?(Hash) ? options.symbolize_keys[:value] : options
+        super(name, value)
+      end
+    end
+
+    # We don't want to use the whole "encryption stack" for connection unit-tests,
+    # but we want to make sure that users test against the correct types of cookies
+    # (i.e. signed or encrypted or plain)
+    class TestCookieJar < TestCookies
       def signed
-        self[:signed] ||= {}.with_indifferent_access
+        @signed ||= TestCookies.new
       end
 
       def encrypted
-        self[:encrypted] ||= {}.with_indifferent_access
+        @encrypted ||= TestCookies.new
       end
     end
 
@@ -56,75 +66,77 @@ module ActionCable
       end
     end
 
+    # # Action Cable Connection TestCase
+    #
     # Unit test Action Cable connections.
     #
-    # Useful to check whether a connection's +identified_by+ gets assigned properly
+    # Useful to check whether a connection's `identified_by` gets assigned properly
     # and that any improper connection requests are rejected.
     #
-    # == Basic example
+    # ## Basic example
     #
     # Unit tests are written as follows:
     #
-    # 1. Simulate a connection attempt by calling +connect+.
-    # 2. Assert state, e.g. identifiers, has been assigned.
+    # 1.  Simulate a connection attempt by calling `connect`.
+    # 2.  Assert state, e.g. identifiers, has been assigned.
     #
     #
-    #   class ApplicationCable::ConnectionTest < ActionCable::Connection::TestCase
-    #     def test_connects_with_proper_cookie
-    #       # Simulate the connection request with a cookie.
-    #       cookies["user_id"] = users(:john).id
+    #     class ApplicationCable::ConnectionTest < ActionCable::Connection::TestCase
+    #       def test_connects_with_proper_cookie
+    #         # Simulate the connection request with a cookie.
+    #         cookies["user_id"] = users(:john).id
     #
-    #       connect
+    #         connect
     #
-    #       # Assert the connection identifier matches the fixture.
-    #       assert_equal users(:john).id, connection.user.id
-    #     end
+    #         # Assert the connection identifier matches the fixture.
+    #         assert_equal users(:john).id, connection.user.id
+    #       end
     #
-    #     def test_rejects_connection_without_proper_cookie
-    #       assert_reject_connection { connect }
+    #       def test_rejects_connection_without_proper_cookie
+    #         assert_reject_connection { connect }
+    #       end
     #     end
-    #   end
     #
-    # +connect+ accepts additional information about the HTTP request with the
-    # +params+, +headers+, +session+ and Rack +env+ options.
+    # `connect` accepts additional information about the HTTP request with the
+    # `params`, `headers`, `session`, and Rack `env` options.
     #
-    #   def test_connect_with_headers_and_query_string
-    #     connect params: { user_id: 1 }, headers: { "X-API-TOKEN" => "secret-my" }
+    #     def test_connect_with_headers_and_query_string
+    #       connect params: { user_id: 1 }, headers: { "X-API-TOKEN" => "secret-my" }
     #
-    #     assert_equal "1", connection.user.id
-    #     assert_equal "secret-my", connection.token
-    #   end
+    #       assert_equal "1", connection.user.id
+    #       assert_equal "secret-my", connection.token
+    #     end
     #
-    #   def test_connect_with_params
-    #     connect params: { user_id: 1 }
+    #     def test_connect_with_params
+    #       connect params: { user_id: 1 }
     #
-    #     assert_equal "1", connection.user.id
-    #   end
+    #       assert_equal "1", connection.user.id
+    #     end
     #
     # You can also set up the correct cookies before the connection request:
     #
-    #   def test_connect_with_cookies
-    #     # Plain cookies:
-    #     cookies["user_id"] = 1
+    #     def test_connect_with_cookies
+    #       # Plain cookies:
+    #       cookies["user_id"] = 1
     #
-    #     # Or signed/encrypted:
-    #     # cookies.signed["user_id"] = 1
-    #     # cookies.encrypted["user_id"] = 1
+    #       # Or signed/encrypted:
+    #       # cookies.signed["user_id"] = 1
+    #       # cookies.encrypted["user_id"] = 1
     #
-    #     connect
+    #       connect
     #
-    #     assert_equal "1", connection.user_id
-    #   end
+    #       assert_equal "1", connection.user_id
+    #     end
     #
-    # == Connection is automatically inferred
+    # ## Connection is automatically inferred
     #
-    # ActionCable::Connection::TestCase will automatically infer the connection under test
-    # from the test class name. If the channel cannot be inferred from the test
-    # class name, you can explicitly set it with +tests+.
+    # ActionCable::Connection::TestCase will automatically infer the connection
+    # under test from the test class name. If the channel cannot be inferred from
+    # the test class name, you can explicitly set it with `tests`.
     #
-    #   class ConnectionTest < ActionCable::Connection::TestCase
-    #     tests ApplicationCable::Connection
-    #   end
+    #     class ConnectionTest < ActionCable::Connection::TestCase
+    #       tests ApplicationCable::Connection
+    #     end
     #
     class TestCase < ActiveSupport::TestCase
       module Behavior
@@ -176,10 +188,10 @@ module ActionCable
         #
         # Accepts request path as the first argument and the following request options:
         #
-        # - params – URL parameters (Hash)
-        # - headers – request headers (Hash)
-        # - session – session data (Hash)
-        # - env – additional Rack env configuration (Hash)
+        # *   params – URL parameters (Hash)
+        # *   headers – request headers (Hash)
+        # *   session – session data (Hash)
+        # *   env – additional Rack env configuration (Hash)
         def connect(path = ActionCable.server.config.mount_path, **request_params)
           path ||= DEFAULT_PATH
 

data/lib/action_cable/connection/web_socket.rb

@@ -1,9 +1,13 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 require "websocket/driver"
 
 module ActionCable
   module Connection
+    # # Action Cable Connection WebSocket
+    #
     # Wrap the real socket to minimize the externally-presented API
     class WebSocket # :nodoc:
       def initialize(env, event_target, event_loop, protocols: ActionCable::INTERNAL[:protocols])
@@ -15,23 +19,23 @@ module ActionCable
       end
 
       def alive?
-        websocket && websocket.alive?
+        websocket&.alive?
       end
 
-      def transmit(data)
-        websocket.transmit data
+      def transmit(...)
+        websocket&.transmit(...)
       end
 
-      def close
-        websocket.close
+      def close(...)
+        websocket&.close(...)
       end
 
       def protocol
-        websocket.protocol
+        websocket&.protocol
       end
 
       def rack_response
-        websocket.rack_response
+        websocket&.rack_response
       end
 
       private

data/lib/action_cable/deprecator.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# :markup: markdown
+
+module ActionCable
+  def self.deprecator # :nodoc:
+    @deprecator ||= ActiveSupport::Deprecation.new
+  end
+end

data/lib/action_cable/engine.rb

@@ -1,16 +1,20 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 require "rails"
 require "action_cable"
-require "action_cable/helpers/action_cable_helper"
 require "active_support/core_ext/hash/indifferent_access"
 
 module ActionCable
   class Engine < Rails::Engine # :nodoc:
     config.action_cable = ActiveSupport::OrderedOptions.new
     config.action_cable.mount_path = ActionCable::INTERNAL[:default_mount_path]
+    config.action_cable.precompile_assets = true
 
-    config.eager_load_namespaces << ActionCable
+    initializer "action_cable.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:action_cable] = ActionCable.deprecator
+    end
 
     initializer "action_cable.helpers" do
       ActiveSupport.on_load(:action_view) do
@@ -22,6 +26,20 @@ module ActionCable
       ActiveSupport.on_load(:action_cable) { self.logger ||= ::Rails.logger }
     end
 
+    initializer "action_cable.health_check_application" do
+      ActiveSupport.on_load(:action_cable) {
+        self.health_check_application = ->(env) { Rails::HealthController.action(:show).call(env) }
+      }
+    end
+
+    initializer "action_cable.asset" do
+      config.after_initialize do |app|
+        if app.config.respond_to?(:assets) && app.config.action_cable.precompile_assets
+          app.config.assets.precompile += %w( actioncable.js actioncable.esm.js )
+        end
+      end
+    end
+
     initializer "action_cable.set_configs" do |app|
       options = app.config.action_cable
       options.allowed_request_origins ||= /https?:\/\/localhost:\d+/ if ::Rails.env.development?
@@ -30,11 +48,12 @@ module ActionCable
 
       ActiveSupport.on_load(:action_cable) do
         if (config_path = Pathname.new(app.config.paths["config/cable"].first)).exist?
-          self.cable = Rails.application.config_for(config_path).to_h.with_indifferent_access
+          self.cable = app.config_for(config_path).to_h.with_indifferent_access
         end
 
         previous_connection_class = connection_class
         self.connection_class = -> { "ApplicationCable::Connection".safe_constantize || previous_connection_class.call }
+        self.filter_parameters += app.config.filter_parameters
 
         options.each { |k, v| send("#{k}=", v) }
       end
@@ -45,7 +64,7 @@ module ActionCable
         config = app.config
         unless config.action_cable.mount_path.nil?
           app.routes.prepend do
-            mount ActionCable.server => config.action_cable.mount_path, internal: true
+            mount ActionCable.server => config.action_cable.mount_path, internal: true, anchor: true
           end
         end
       end
@@ -54,10 +73,10 @@ module ActionCable
     initializer "action_cable.set_work_hooks" do |app|
       ActiveSupport.on_load(:action_cable) do
         ActionCable::Server::Worker.set_callback :work, :around, prepend: true do |_, inner|
-          app.executor.wrap do
-            # If we took a while to get the lock, we may have been halted
-            # in the meantime. As we haven't started doing any real work
-            # yet, we should pretend that we never made it off the queue.
+          app.executor.wrap(source: "application.action_cable") do
+            # If we took a while to get the lock, we may have been halted in the meantime.
+            # As we haven't started doing any real work yet, we should pretend that we never
+            # made it off the queue.
             unless stopping?
               inner.call
             end
@@ -65,7 +84,7 @@ module ActionCable
         end
 
         wrap = lambda do |_, inner|
-          app.executor.wrap(&inner)
+          app.executor.wrap(source: "application.action_cable", &inner)
         end
         ActionCable::Channel::Base.set_callback :subscribe, :around, prepend: true, &wrap
         ActionCable::Channel::Base.set_callback :unsubscribe, :around, prepend: true, &wrap

data/lib/action_cable/gem_version.rb

@@ -1,16 +1,18 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 module ActionCable
-  # Returns the version of the currently loaded Action Cable as a <tt>Gem::Version</tt>.
+  # Returns the currently loaded version of Action Cable as a `Gem::Version`.
   def self.gem_version
     Gem::Version.new VERSION::STRING
   end
 
   module VERSION
-    MAJOR = 6
-    MINOR = 1
-    TINY  = 7
-    PRE   = "9"
+    MAJOR = 7
+    MINOR = 2
+    TINY  = 2
+    PRE   = "1"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/action_cable/helpers/action_cable_helper.rb

@@ -1,34 +1,37 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 module ActionCable
   module Helpers
     module ActionCableHelper
-      # Returns an "action-cable-url" meta tag with the value of the URL specified in your
-      # configuration. Ensure this is above your JavaScript tag:
+      # Returns an "action-cable-url" meta tag with the value of the URL specified in
+      # your configuration. Ensure this is above your JavaScript tag:
       #
-      #   <head>
-      #     <%= action_cable_meta_tag %>
-      #     <%= javascript_include_tag 'application', 'data-turbolinks-track' => 'reload' %>
-      #   </head>
+      #     <head>
+      #       <%= action_cable_meta_tag %>
+      #       <%= javascript_include_tag 'application', 'data-turbo-track' => 'reload' %>
+      #     </head>
       #
-      # This is then used by Action Cable to determine the URL of your WebSocket server.
-      # Your JavaScript can then connect to the server without needing to specify the
-      # URL directly:
+      # This is then used by Action Cable to determine the URL of your WebSocket
+      # server. Your JavaScript can then connect to the server without needing to
+      # specify the URL directly:
       #
-      #   window.Cable = require("@rails/actioncable")
-      #   window.App = {}
-      #   App.cable = Cable.createConsumer()
+      #     import Cable from "@rails/actioncable"
+      #     window.Cable = Cable
+      #     window.App = {}
+      #     App.cable = Cable.createConsumer()
       #
       # Make sure to specify the correct server location in each of your environment
       # config files:
       #
-      #   config.action_cable.mount_path = "/cable123"
-      #   <%= action_cable_meta_tag %> would render:
-      #   => <meta name="action-cable-url" content="/cable123" />
+      #     config.action_cable.mount_path = "/cable123"
+      #     <%= action_cable_meta_tag %> would render:
+      #     => <meta name="action-cable-url" content="/cable123" />
       #
-      #   config.action_cable.url = "ws://actioncable.com"
-      #   <%= action_cable_meta_tag %> would render:
-      #   => <meta name="action-cable-url" content="ws://actioncable.com" />
+      #     config.action_cable.url = "ws://actioncable.com"
+      #     <%= action_cable_meta_tag %> would render:
+      #     => <meta name="action-cable-url" content="ws://actioncable.com" />
       #
       def action_cable_meta_tag
         tag "meta", name: "action-cable-url", content: (

data/lib/action_cable/remote_connections.rb

@@ -1,24 +1,33 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 require "active_support/core_ext/module/redefine_method"
 
 module ActionCable
+  # # Action Cable Remote Connections
+  #
   # If you need to disconnect a given connection, you can go through the
   # RemoteConnections. You can find the connections you're looking for by
   # searching for the identifier declared on the connection. For example:
   #
-  #   module ApplicationCable
-  #     class Connection < ActionCable::Connection::Base
-  #       identified_by :current_user
-  #       ....
+  #     module ApplicationCable
+  #       class Connection < ActionCable::Connection::Base
+  #         identified_by :current_user
+  #         ....
+  #       end
   #     end
-  #   end
   #
-  #   ActionCable.server.remote_connections.where(current_user: User.find(1)).disconnect
+  #     ActionCable.server.remote_connections.where(current_user: User.find(1)).disconnect
+  #
+  # This will disconnect all the connections established for `User.find(1)`,
+  # across all servers running on all machines, because it uses the internal
+  # channel that all of these servers are subscribed to.
+  #
+  # By default, server sends a "disconnect" message with "reconnect" flag set to
+  # true. You can override it by specifying the `reconnect` option:
   #
-  # This will disconnect all the connections established for
-  # <tt>User.find(1)</tt>, across all servers running on all machines, because
-  # it uses the internal channel that all of these servers are subscribed to.
+  #     ActionCable.server.remote_connections.where(current_user: User.find(1)).disconnect(reconnect: false)
   class RemoteConnections
     attr_reader :server
 
@@ -31,8 +40,11 @@ module ActionCable
     end
 
     private
-      # Represents a single remote connection found via <tt>ActionCable.server.remote_connections.where(*)</tt>.
-      # Exists solely for the purpose of calling #disconnect on that connection.
+      # # Action Cable Remote Connection
+      #
+      # Represents a single remote connection found via
+      # `ActionCable.server.remote_connections.where(*)`. Exists solely for the
+      # purpose of calling #disconnect on that connection.
       class RemoteConnection
         class InvalidIdentifiersError < StandardError; end
 
@@ -44,8 +56,8 @@ module ActionCable
         end
 
         # Uses the internal channel to disconnect the connection.
-        def disconnect
-          server.broadcast internal_channel, { type: "disconnect" }
+        def disconnect(reconnect: true)
+          server.broadcast internal_channel, { type: "disconnect", reconnect: reconnect }
         end
 
         # Returns all the identifiers that were applied to this connection.

data/lib/action_cable/server/base.rb

@@ -1,13 +1,20 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 require "monitor"
 
 module ActionCable
   module Server
-    # A singleton ActionCable::Server instance is available via ActionCable.server. It's used by the Rack process that starts the Action Cable server, but
-    # is also used by the user to reach the RemoteConnections object, which is used for finding and disconnecting connections across all servers.
+    # # Action Cable Server Base
+    #
+    # A singleton ActionCable::Server instance is available via ActionCable.server.
+    # It's used by the Rack process that starts the Action Cable server, but is also
+    # used by the user to reach the RemoteConnections object, which is used for
+    # finding and disconnecting connections across all servers.
     #
-    # Also, this is the server instance used for broadcasting. See Broadcasting for more information.
+    # Also, this is the server instance used for broadcasting. See Broadcasting for
+    # more information.
     class Base
       include ActionCable::Server::Broadcasting
       include ActionCable::Server::Connections
@@ -29,11 +36,13 @@ module ActionCable
 
       # Called by Rack to set up the server.
       def call(env)
+        return config.health_check_application.call(env) if env["PATH_INFO"] == config.health_check_path
         setup_heartbeat_timer
         config.connection_class.call.new(self, env).process
       end
 
-      # Disconnect all the connections identified by +identifiers+ on this server or any others via RemoteConnections.
+      # Disconnect all the connections identified by `identifiers` on this server or
+      # any others via RemoteConnections.
       def disconnect(identifiers)
         remote_connections.where(identifiers).disconnect
       end
@@ -63,17 +72,22 @@ module ActionCable
         @event_loop || @mutex.synchronize { @event_loop ||= ActionCable::Connection::StreamEventLoop.new }
       end
 
-      # The worker pool is where we run connection callbacks and channel actions. We do as little as possible on the server's main thread.
-      # The worker pool is an executor service that's backed by a pool of threads working from a task queue. The thread pool size maxes out
-      # at 4 worker threads by default. Tune the size yourself with <tt>config.action_cable.worker_pool_size</tt>.
+      # The worker pool is where we run connection callbacks and channel actions. We
+      # do as little as possible on the server's main thread. The worker pool is an
+      # executor service that's backed by a pool of threads working from a task queue.
+      # The thread pool size maxes out at 4 worker threads by default. Tune the size
+      # yourself with `config.action_cable.worker_pool_size`.
       #
-      # Using Active Record, Redis, etc within your channel actions means you'll get a separate connection from each thread in the worker pool.
-      # Plan your deployment accordingly: 5 servers each running 5 Puma workers each running an 8-thread worker pool means at least 200 database
-      # connections.
+      # Using Active Record, Redis, etc within your channel actions means you'll get a
+      # separate connection from each thread in the worker pool. Plan your deployment
+      # accordingly: 5 servers each running 5 Puma workers each running an 8-thread
+      # worker pool means at least 200 database connections.
       #
-      # Also, ensure that your database connection pool size is as least as large as your worker pool size. Otherwise, workers may oversubscribe
-      # the database connection pool and block while they wait for other workers to release their connections. Use a smaller worker pool or a larger
-      # database connection pool instead.
+      # Also, ensure that your database connection pool size is as least as large as
+      # your worker pool size. Otherwise, workers may oversubscribe the database
+      # connection pool and block while they wait for other workers to release their
+      # connections. Use a smaller worker pool or a larger database connection pool
+      # instead.
       def worker_pool
         @worker_pool || @mutex.synchronize { @worker_pool ||= ActionCable::Server::Worker.new(max_size: config.worker_pool_size) }
       end
@@ -83,7 +97,8 @@ module ActionCable
         @pubsub || @mutex.synchronize { @pubsub ||= config.pubsub_adapter.new(self) }
       end
 
-      # All of the identifiers applied to the connection class associated with this server.
+      # All of the identifiers applied to the connection class associated with this
+      # server.
       def connection_identifiers
         config.connection_class.call.identifiers
       end

data/lib/action_cable/server/broadcasting.rb

@@ -1,32 +1,40 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 module ActionCable
   module Server
-    # Broadcasting is how other parts of your application can send messages to a channel's subscribers. As explained in Channel, most of the time, these
-    # broadcastings are streamed directly to the clients subscribed to the named broadcasting. Let's explain with a full-stack example:
+    # # Action Cable Server Broadcasting
+    #
+    # Broadcasting is how other parts of your application can send messages to a
+    # channel's subscribers. As explained in Channel, most of the time, these
+    # broadcastings are streamed directly to the clients subscribed to the named
+    # broadcasting. Let's explain with a full-stack example:
     #
-    #   class WebNotificationsChannel < ApplicationCable::Channel
-    #     def subscribed
-    #       stream_from "web_notifications_#{current_user.id}"
+    #     class WebNotificationsChannel < ApplicationCable::Channel
+    #       def subscribed
+    #         stream_from "web_notifications_#{current_user.id}"
+    #       end
     #     end
-    #   end
     #
-    #   # Somewhere in your app this is called, perhaps from a NewCommentJob:
-    #   ActionCable.server.broadcast \
-    #     "web_notifications_1", { title: "New things!", body: "All that's fit for print" }
+    #     # Somewhere in your app this is called, perhaps from a NewCommentJob:
+    #     ActionCable.server.broadcast \
+    #       "web_notifications_1", { title: "New things!", body: "All that's fit for print" }
     #
-    #   # Client-side CoffeeScript, which assumes you've already requested the right to send web notifications:
-    #   App.cable.subscriptions.create "WebNotificationsChannel",
-    #     received: (data) ->
-    #       new Notification data['title'], body: data['body']
+    #     # Client-side CoffeeScript, which assumes you've already requested the right to send web notifications:
+    #     App.cable.subscriptions.create "WebNotificationsChannel",
+    #       received: (data) ->
+    #         new Notification data['title'], body: data['body']
     module Broadcasting
-      # Broadcast a hash directly to a named <tt>broadcasting</tt>. This will later be JSON encoded.
+      # Broadcast a hash directly to a named `broadcasting`. This will later be JSON
+      # encoded.
       def broadcast(broadcasting, message, coder: ActiveSupport::JSON)
         broadcaster_for(broadcasting, coder: coder).broadcast(message)
       end
 
-      # Returns a broadcaster for a named <tt>broadcasting</tt> that can be reused. Useful when you have an object that
-      # may need multiple spots to transmit to a specific broadcasting over and over.
+      # Returns a broadcaster for a named `broadcasting` that can be reused. Useful
+      # when you have an object that may need multiple spots to transmit to a specific
+      # broadcasting over and over.
       def broadcaster_for(broadcasting, coder: ActiveSupport::JSON)
         Broadcaster.new(self, String(broadcasting), coder: coder)
       end