Merge pull request rails#51035 from rails/rm-docs-actioncable

Transform actioncable documentation to Markdown

Author: rafaelfranca

actioncable/lib/action_cable/channel/base.rb

@@ -1,102 +1,112 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 require "set"
 require "active_support/rescuable"
 require "active_support/parameter_filter"
 
 module ActionCable
   module Channel
-    # = Action Cable \Channel \Base
+    # # Action Cable Channel Base
     #
-    # The channel provides the basic structure of grouping behavior into logical units when communicating over the WebSocket connection.
-    # You can think of a channel like a form of controller, but one that's capable of pushing content to the subscriber in addition to simply
-    # responding to the subscriber's direct requests.
+    # The channel provides the basic structure of grouping behavior into logical
+    # units when communicating over the WebSocket connection. You can think of a
+    # channel like a form of controller, but one that's capable of pushing content
+    # to the subscriber in addition to simply responding to the subscriber's direct
+    # requests.
     #
-    # Channel instances are long-lived. A channel object will be instantiated when the cable consumer becomes a subscriber, and then
-    # lives until the consumer disconnects. This may be seconds, minutes, hours, or even days. That means you have to take special care
-    # not to do anything silly in a channel that would balloon its memory footprint or whatever. The references are forever, so they won't be released
-    # as is normally the case with a controller instance that gets thrown away after every request.
+    # Channel instances are long-lived. A channel object will be instantiated when
+    # the cable consumer becomes a subscriber, and then lives until the consumer
+    # disconnects. This may be seconds, minutes, hours, or even days. That means you
+    # have to take special care not to do anything silly in a channel that would
+    # balloon its memory footprint or whatever. The references are forever, so they
+    # won't be released as is normally the case with a controller instance that gets
+    # thrown away after every request.
     #
-    # Long-lived channels (and connections) also mean you're responsible for ensuring that the data is fresh. If you hold a reference to a user
-    # record, but the name is changed while that reference is held, you may be sending stale data if you don't take precautions to avoid it.
+    # Long-lived channels (and connections) also mean you're responsible for
+    # ensuring that the data is fresh. If you hold a reference to a user record, but
+    # the name is changed while that reference is held, you may be sending stale
+    # data if you don't take precautions to avoid it.
     #
-    # The upside of long-lived channel instances is that you can use instance variables to keep reference to objects that future subscriber requests
-    # can interact with. Here's a quick example:
+    # The upside of long-lived channel instances is that you can use instance
+    # variables to keep reference to objects that future subscriber requests can
+    # interact with. Here's a quick example:
     #
-    #   class ChatChannel < ApplicationCable::Channel
-    #     def subscribed
-    #       @room = Chat::Room[params[:room_number]]
-    #     end
+    #     class ChatChannel < ApplicationCable::Channel
+    #       def subscribed
+    #         @room = Chat::Room[params[:room_number]]
+    #       end
     #
-    #     def speak(data)
-    #       @room.speak data, user: current_user
+    #       def speak(data)
+    #         @room.speak data, user: current_user
+    #       end
     #     end
-    #   end
     #
-    # The #speak action simply uses the Chat::Room object that was created when the channel was first subscribed to by the consumer when that
-    # subscriber wants to say something in the room.
+    # The #speak action simply uses the Chat::Room object that was created when the
+    # channel was first subscribed to by the consumer when that subscriber wants to
+    # say something in the room.
     #
-    # == Action processing
+    # ## Action processing
     #
     # Unlike subclasses of ActionController::Base, channels do not follow a RESTful
     # constraint form for their actions. Instead, Action Cable operates through a
-    # remote-procedure call model. You can declare any public method on the
-    # channel (optionally taking a <tt>data</tt> argument), and this method is
-    # automatically exposed as callable to the client.
+    # remote-procedure call model. You can declare any public method on the channel
+    # (optionally taking a `data` argument), and this method is automatically
+    # exposed as callable to the client.
     #
     # Example:
     #
-    #   class AppearanceChannel < ApplicationCable::Channel
-    #     def subscribed
-    #       @connection_token = generate_connection_token
-    #     end
-    #
-    #     def unsubscribed
-    #       current_user.disappear @connection_token
-    #     end
+    #     class AppearanceChannel < ApplicationCable::Channel
+    #       def subscribed
+    #         @connection_token = generate_connection_token
+    #       end
     #
-    #     def appear(data)
-    #       current_user.appear @connection_token, on: data['appearing_on']
-    #     end
+    #       def unsubscribed
+    #         current_user.disappear @connection_token
+    #       end
     #
-    #     def away
-    #       current_user.away @connection_token
-    #     end
+    #       def appear(data)
+    #         current_user.appear @connection_token, on: data['appearing_on']
+    #       end
     #
-    #     private
-    #       def generate_connection_token
-    #         SecureRandom.hex(36)
+    #       def away
+    #         current_user.away @connection_token
     #       end
-    #   end
     #
-    # In this example, the subscribed and unsubscribed methods are not callable methods, as they
-    # were already declared in ActionCable::Channel::Base, but <tt>#appear</tt>
-    # and <tt>#away</tt> are. <tt>#generate_connection_token</tt> is also not
-    # callable, since it's a private method. You'll see that appear accepts a data
-    # parameter, which it then uses as part of its model call. <tt>#away</tt>
-    # does not, since it's simply a trigger action.
+    #       private
+    #         def generate_connection_token
+    #           SecureRandom.hex(36)
+    #         end
+    #     end
+    #
+    # In this example, the subscribed and unsubscribed methods are not callable
+    # methods, as they were already declared in ActionCable::Channel::Base, but
+    # `#appear` and `#away` are. `#generate_connection_token` is also not callable,
+    # since it's a private method. You'll see that appear accepts a data parameter,
+    # which it then uses as part of its model call. `#away` does not, since it's
+    # simply a trigger action.
     #
-    # Also note that in this example, <tt>current_user</tt> is available because
-    # it was marked as an identifying attribute on the connection. All such
-    # identifiers will automatically create a delegation method of the same name
-    # on the channel instance.
+    # Also note that in this example, `current_user` is available because it was
+    # marked as an identifying attribute on the connection. All such identifiers
+    # will automatically create a delegation method of the same name on the channel
+    # instance.
     #
-    # == Rejecting subscription requests
+    # ## Rejecting subscription requests
     #
     # A channel can reject a subscription request in the #subscribed callback by
     # invoking the #reject method:
     #
-    #   class ChatChannel < ApplicationCable::Channel
-    #     def subscribed
-    #       @room = Chat::Room[params[:room_number]]
-    #       reject unless current_user.can_access?(@room)
+    #     class ChatChannel < ApplicationCable::Channel
+    #       def subscribed
+    #         @room = Chat::Room[params[:room_number]]
+    #         reject unless current_user.can_access?(@room)
+    #       end
     #     end
-    #   end
     #
-    # In this example, the subscription will be rejected if the
-    # <tt>current_user</tt> does not have access to the chat room. On the
-    # client-side, the <tt>Channel#rejected</tt> callback will get invoked when
-    # the server rejects the subscription request.
+    # In this example, the subscription will be rejected if the `current_user` does
+    # not have access to the chat room. On the client-side, the `Channel#rejected`
+    # callback will get invoked when the server rejects the subscription request.
     class Base
       include Callbacks
       include PeriodicTimers
@@ -109,14 +119,13 @@ class Base
       delegate :logger, to: :connection
 
       class << self
-        # A list of method names that should be considered actions. This
-        # includes all public instance methods on a channel, less
-        # any internal methods (defined on Base), adding back in
-        # any methods that are internal, but still exist on the class
-        # itself.
+        # A list of method names that should be considered actions. This includes all
+        # public instance methods on a channel, less any internal methods (defined on
+        # Base), adding back in any methods that are internal, but still exist on the
+        # class itself.
         #
-        # ==== Returns
-        # * <tt>Set</tt> - A set of all methods that should be considered actions.
+        # #### Returns
+        # *   `Set` - A set of all methods that should be considered actions.
         def action_methods
           @action_methods ||= begin
             # All public instance methods of this class, including ancestors
@@ -130,9 +139,9 @@ def action_methods
         end
 
         private
-          # action_methods are cached and there is sometimes need to refresh
-          # them. ::clear_action_methods! allows you to do that, so next time
-          # you run action_methods, they will be recalculated.
+          # action_methods are cached and there is sometimes need to refresh them.
+          # ::clear_action_methods! allows you to do that, so next time you run
+          # action_methods, they will be recalculated.
           def clear_action_methods! # :doc:
             @action_methods = nil
           end
@@ -161,9 +170,9 @@ def initialize(connection, identifier, params = {})
         delegate_connection_identifiers
       end
 
-      # Extract the action name from the passed data and process it via the channel. The process will ensure
-      # that the action requested is a public method on the channel declared by the user (so not one of the callbacks
-      # like #subscribed).
+      # Extract the action name from the passed data and process it via the channel.
+      # The process will ensure that the action requested is a public method on the
+      # channel declared by the user (so not one of the callbacks like #subscribed).
       def perform_action(data)
         action = extract_action(data)
 
@@ -177,8 +186,8 @@ def perform_action(data)
         end
       end
 
-      # This method is called after subscription has been added to the connection
-      # and confirms or rejects the subscription.
+      # This method is called after subscription has been added to the connection and
+      # confirms or rejects the subscription.
       def subscribe_to_channel
         run_callbacks :subscribe do
           subscribed
@@ -188,29 +197,32 @@ def subscribe_to_channel
         ensure_confirmation_sent
       end
 
-      # Called by the cable connection when it's cut, so the channel has a chance to cleanup with callbacks.
-      # This method is not intended to be called directly by the user. Instead, override the #unsubscribed callback.
+      # Called by the cable connection when it's cut, so the channel has a chance to
+      # cleanup with callbacks. This method is not intended to be called directly by
+      # the user. Instead, override the #unsubscribed callback.
       def unsubscribe_from_channel # :nodoc:
         run_callbacks :unsubscribe do
           unsubscribed
         end
       end
 
       private
-        # Called once a consumer has become a subscriber of the channel. Usually the place to set up any streams
-        # you want this channel to be sending to the subscriber.
+        # Called once a consumer has become a subscriber of the channel. Usually the
+        # place to set up any streams you want this channel to be sending to the
+        # subscriber.
         def subscribed # :doc:
           # Override in subclasses
         end
 
-        # Called once a consumer has cut its cable connection. Can be used for cleaning up connections or marking
-        # users as offline or the like.
+        # Called once a consumer has cut its cable connection. Can be used for cleaning
+        # up connections or marking users as offline or the like.
         def unsubscribed # :doc:
           # Override in subclasses
         end
 
-        # Transmit a hash of data to the subscriber. The hash will automatically be wrapped in a JSON envelope with
-        # the proper channel identifier marked as the recipient.
+        # Transmit a hash of data to the subscriber. The hash will automatically be
+        # wrapped in a JSON envelope with the proper channel identifier marked as the
+        # recipient.
         def transmit(data, via: nil) # :doc:
           logger.debug do
             status = "#{self.class.name} transmitting #{data.inspect.truncate(300)}"

actioncable/lib/action_cable/channel/broadcasting.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 require "active_support/core_ext/object/to_param"
 
 module ActionCable
@@ -8,17 +10,17 @@ module Broadcasting
       extend ActiveSupport::Concern
 
       module ClassMethods
-        # Broadcast a hash to a unique broadcasting for this <tt>model</tt> in this channel.
+        # Broadcast a hash to a unique broadcasting for this `model` in this channel.
         def broadcast_to(model, message)
           ActionCable.server.broadcast(broadcasting_for(model), message)
         end
 
-        # Returns a unique broadcasting identifier for this <tt>model</tt> in this channel:
+        # Returns a unique broadcasting identifier for this `model` in this channel:
         #
-        #    CommentsChannel.broadcasting_for("all") # => "comments:all"
+        #     CommentsChannel.broadcasting_for("all") # => "comments:all"
         #
-        # You can pass any object as a target (e.g. Active Record model), and it
-        # would be serialized into a string under the hood.
+        # You can pass any object as a target (e.g. Active Record model), and it would
+        # be serialized into a string under the hood.
         def broadcasting_for(model)
           serialize_broadcasting([ channel_name, model ])
         end

actioncable/lib/action_cable/channel/callbacks.rb

@@ -1,36 +1,39 @@
 # frozen_string_literal: true
 
+# :markup: markdown
+
 require "active_support/callbacks"
 
 module ActionCable
   module Channel
-    # = Action Cable \Channel \Callbacks
+    # # Action Cable Channel Callbacks
+    #
+    # Action Cable Channel provides callback hooks that are invoked during the life
+    # cycle of a channel:
     #
-    # Action Cable Channel provides callback hooks that are invoked during the
-    # life cycle of a channel:
+    # *   [before_subscribe](rdoc-ref:ClassMethods#before_subscribe)
+    # *   [after_subscribe](rdoc-ref:ClassMethods#after_subscribe) (aliased as
+    #     [on_subscribe](rdoc-ref:ClassMethods#on_subscribe))
+    # *   [before_unsubscribe](rdoc-ref:ClassMethods#before_unsubscribe)
+    # *   [after_unsubscribe](rdoc-ref:ClassMethods#after_unsubscribe) (aliased as
+    #     [on_unsubscribe](rdoc-ref:ClassMethods#on_unsubscribe))
     #
-    # * {before_subscribe}[rdoc-ref:ClassMethods#before_subscribe]
-    # * {after_subscribe}[rdoc-ref:ClassMethods#after_subscribe] (aliased as
-    #   {on_subscribe}[rdoc-ref:ClassMethods#on_subscribe])
-    # * {before_unsubscribe}[rdoc-ref:ClassMethods#before_unsubscribe]
-    # * {after_unsubscribe}[rdoc-ref:ClassMethods#after_unsubscribe] (aliased as
-    #   {on_unsubscribe}[rdoc-ref:ClassMethods#on_unsubscribe])
     #
-    # ==== Example
+    # #### Example
     #
-    #   class ChatChannel < ApplicationCable::Channel
-    #     after_subscribe :send_welcome_message, unless: :subscription_rejected?
-    #     after_subscribe :track_subscription
+    #     class ChatChannel < ApplicationCable::Channel
+    #       after_subscribe :send_welcome_message, unless: :subscription_rejected?
+    #       after_subscribe :track_subscription
     #
-    #     private
-    #       def send_welcome_message
-    #         broadcast_to(...)
-    #       end
+    #       private
+    #         def send_welcome_message
+    #           broadcast_to(...)
+    #         end
     #
-    #       def track_subscription
-    #         # ...
-    #       end
-    #   end
+    #         def track_subscription
+    #           # ...
+    #         end
+    #     end
     #
     module Callbacks
       extend  ActiveSupport::Concern
@@ -46,14 +49,13 @@ def before_subscribe(*methods, &block)
           set_callback(:subscribe, :before, *methods, &block)
         end
 
-        # This callback will be triggered after the Base#subscribed method is
-        # called, even if the subscription was rejected with the Base#reject
-        # method.
+        # This callback will be triggered after the Base#subscribed method is called,
+        # even if the subscription was rejected with the Base#reject method.
         #
         # To trigger the callback only on successful subscriptions, use the
         # Base#subscription_rejected? method:
         #
-        #   after_subscribe :my_method, unless: :subscription_rejected?
+        #     after_subscribe :my_method, unless: :subscription_rejected?
         #
         def after_subscribe(*methods, &block)
           set_callback(:subscribe, :after, *methods, &block)