actioncable 5.0.1 → 6.1.3

data/lib/action_cable.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 #--
-# Copyright (c) 2015-2016 Basecamp, LLC
+# Copyright (c) 2015-2020 Basecamp, LLC
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -21,22 +23,28 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-require 'active_support'
-require 'active_support/rails'
-require 'action_cable/version'
+require "active_support"
+require "active_support/rails"
+require "action_cable/version"
 
 module ActionCable
   extend ActiveSupport::Autoload
 
   INTERNAL = {
     message_types: {
-      welcome: 'welcome'.freeze,
-      ping: 'ping'.freeze,
-      confirmation: 'confirm_subscription'.freeze,
-      rejection: 'reject_subscription'.freeze
+      welcome: "welcome",
+      disconnect: "disconnect",
+      ping: "ping",
+      confirmation: "confirm_subscription",
+      rejection: "reject_subscription"
+    },
+    disconnect_reasons: {
+      unauthorized: "unauthorized",
+      invalid_request: "invalid_request",
+      server_restart: "server_restart"
     },
-    default_mount_path: '/cable'.freeze,
-    protocols: ["actioncable-v1-json".freeze, "actioncable-unsupported".freeze].freeze
+    default_mount_path: "/cable",
+    protocols: ["actioncable-v1-json", "actioncable-unsupported"].freeze
   }
 
   # Singleton instance of the server
@@ -49,4 +57,6 @@ module ActionCable
   autoload :Channel
   autoload :RemoteConnections
   autoload :SubscriptionAdapter
+  autoload :TestHelper
+  autoload :TestCase
 end

data/lib/action_cable/channel.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionCable
   module Channel
     extend ActiveSupport::Autoload
@@ -9,6 +11,7 @@ module ActionCable
       autoload :Naming
       autoload :PeriodicTimers
       autoload :Streams
+      autoload :TestCase
     end
   end
 end

data/lib/action_cable/channel/base.rb

@@ -1,4 +1,7 @@
-require 'set'
+# frozen_string_literal: true
+
+require "set"
+require "active_support/rescuable"
 
 module ActionCable
   module Channel
@@ -97,6 +100,7 @@ module ActionCable
       include Streams
       include Naming
       include Broadcasting
+      include ActiveSupport::Rescuable
 
       attr_reader :params, :connection, :identifier
       delegate :logger, to: :connection
@@ -122,16 +126,16 @@ module ActionCable
           end
         end
 
-        protected
+        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.
-          def clear_action_methods!
+          def clear_action_methods! # :doc:
             @action_methods = nil
           end
 
           # Refresh the cached action_methods when a new action_method is added.
-          def method_added(name)
+          def method_added(name) # :doc:
             super
             clear_action_methods!
           end
@@ -189,24 +193,25 @@ module ActionCable
         end
       end
 
-
-      protected
-        # Called once a consumer has become a subscriber of the channel. Usually the place to setup any streams
+      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.
-        def subscribed
+        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.
-        def unsubscribed
+        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.
-        def transmit(data, via: nil)
-          logger.info "#{self.class.name} transmitting #{data.inspect.truncate(300)}".tap { |m| m << " (via #{via})" if via }
+        def transmit(data, via: nil) # :doc:
+          status = "#{self.class.name} transmitting #{data.inspect.truncate(300)}"
+          status += " (via #{via})" if via
+          logger.debug(status)
 
           payload = { channel_class: self.class.name, data: data, via: via }
           ActiveSupport::Notifications.instrument("transmit.action_cable", payload) do
@@ -214,33 +219,32 @@ module ActionCable
           end
         end
 
-        def ensure_confirmation_sent
+        def ensure_confirmation_sent # :doc:
           return if subscription_rejected?
           @defer_subscription_confirmation_counter.decrement
           transmit_subscription_confirmation unless defer_subscription_confirmation?
         end
 
-        def defer_subscription_confirmation!
+        def defer_subscription_confirmation! # :doc:
           @defer_subscription_confirmation_counter.increment
         end
 
-        def defer_subscription_confirmation?
+        def defer_subscription_confirmation? # :doc:
           @defer_subscription_confirmation_counter.value > 0
         end
 
-        def subscription_confirmation_sent?
+        def subscription_confirmation_sent? # :doc:
           @subscription_confirmation_sent
         end
 
-        def reject
+        def reject # :doc:
           @reject_subscription = true
         end
 
-        def subscription_rejected?
+        def subscription_rejected? # :doc:
           @reject_subscription
         end
 
-      private
         def delegate_connection_identifiers
           connection.identifiers.each do |identifier|
             define_singleton_method(identifier) do
@@ -250,7 +254,7 @@ module ActionCable
         end
 
         def extract_action(data)
-          (data['action'].presence || :receive).to_sym
+          (data["action"].presence || :receive).to_sym
         end
 
         def processable_action?(action)
@@ -265,11 +269,13 @@ module ActionCable
           else
             public_send action
           end
+        rescue Exception => exception
+          rescue_with_handler(exception) || raise
         end
 
         def action_signature(action, data)
-          "#{self.class.name}##{action}".tap do |signature|
-            if (arguments = data.except('action')).any?
+          (+"#{self.class.name}##{action}").tap do |signature|
+            if (arguments = data.except("action")).any?
               signature << "(#{arguments.inspect})"
             end
           end
@@ -277,7 +283,7 @@ module ActionCable
 
         def transmit_subscription_confirmation
           unless subscription_confirmation_sent?
-            logger.info "#{self.class.name} is transmitting the subscription confirmation"
+            logger.debug "#{self.class.name} is transmitting the subscription confirmation"
 
             ActiveSupport::Notifications.instrument("transmit_subscription_confirmation.action_cable", channel_class: self.class.name) do
               connection.transmit identifier: @identifier, type: ActionCable::INTERNAL[:message_types][:confirmation]
@@ -292,7 +298,7 @@ module ActionCable
         end
 
         def transmit_subscription_rejection
-          logger.info "#{self.class.name} is transmitting the subscription rejection"
+          logger.debug "#{self.class.name} is transmitting the subscription rejection"
 
           ActiveSupport::Notifications.instrument("transmit_subscription_rejection.action_cable", channel_class: self.class.name) do
             connection.transmit identifier: @identifier, type: ActionCable::INTERNAL[:message_types][:rejection]
@@ -301,3 +307,5 @@ module ActionCable
     end
   end
 end
+
+ActiveSupport.run_load_hooks(:action_cable_channel, ActionCable::Channel::Base)

data/lib/action_cable/channel/broadcasting.rb

@@ -1,26 +1,38 @@
-require 'active_support/core_ext/object/to_param'
+# frozen_string_literal: true
+
+require "active_support/core_ext/object/to_param"
 
 module ActionCable
   module Channel
     module Broadcasting
       extend ActiveSupport::Concern
 
-      delegate :broadcasting_for, to: :class
+      delegate :broadcasting_for, :broadcast_to, to: :class
 
-      class_methods do
+      module ClassMethods
         # Broadcast a hash to a unique broadcasting for this <tt>model</tt> in this channel.
         def broadcast_to(model, message)
-          ActionCable.server.broadcast(broadcasting_for([ channel_name, model ]), message)
+          ActionCable.server.broadcast(broadcasting_for(model), message)
+        end
+
+        # Returns a unique broadcasting identifier for this <tt>model</tt> in this channel:
+        #
+        #    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.
+        def broadcasting_for(model)
+          serialize_broadcasting([ channel_name, model ])
         end
 
-        def broadcasting_for(model) #:nodoc:
+        def serialize_broadcasting(object) #:nodoc:
           case
-          when model.is_a?(Array)
-            model.map { |m| broadcasting_for(m) }.join(':')
-          when model.respond_to?(:to_gid_param)
-            model.to_gid_param
+          when object.is_a?(Array)
+            object.map { |m| serialize_broadcasting(m) }.join(":")
+          when object.respond_to?(:to_gid_param)
+            object.to_gid_param
           else
-            model.to_param
+            object.to_param
           end
         end
       end

data/lib/action_cable/channel/callbacks.rb

@@ -1,4 +1,6 @@
-require 'active_support/callbacks'
+# frozen_string_literal: true
+
+require "active_support/callbacks"
 
 module ActionCable
   module Channel
@@ -11,7 +13,7 @@ module ActionCable
         define_callbacks :unsubscribe
       end
 
-      class_methods do
+      module ClassMethods
         def before_subscribe(*methods, &block)
           set_callback(:subscribe, :before, *methods, &block)
         end

data/lib/action_cable/channel/naming.rb

@@ -1,17 +1,20 @@
+# frozen_string_literal: true
+
 module ActionCable
   module Channel
     module Naming
       extend ActiveSupport::Concern
 
-      class_methods do
+      module ClassMethods
         # Returns the name of the channel, underscored, without the <tt>Channel</tt> ending.
         # If the channel is in a namespace, then the namespaces are represented by single
         # colon separators in the channel name.
         #
         #   ChatChannel.channel_name # => 'chat'
         #   Chats::AppearancesChannel.channel_name # => 'chats:appearances'
+        #   FooChats::BarAppearancesChannel.channel_name # => 'foo_chats:bar_appearances'
         def channel_name
-          @channel_name ||= name.sub(/Channel$/, '').gsub('::',':').underscore
+          @channel_name ||= name.delete_suffix("Channel").gsub("::", ":").underscore
         end
       end
 

data/lib/action_cable/channel/periodic_timers.rb

@@ -1,11 +1,12 @@
+# frozen_string_literal: true
+
 module ActionCable
   module Channel
     module PeriodicTimers
       extend ActiveSupport::Concern
 
       included do
-        class_attribute :periodic_timers, instance_reader: false
-        self.periodic_timers = []
+        class_attribute :periodic_timers, instance_reader: false, default: []
 
         after_subscribe   :start_periodic_timers
         after_unsubscribe :stop_periodic_timers
@@ -30,7 +31,7 @@ module ActionCable
         def periodically(callback_or_method_name = nil, every:, &block)
           callback =
             if block_given?
-              raise ArgumentError, 'Pass a block or provide a callback arg, not both' if callback_or_method_name
+              raise ArgumentError, "Pass a block or provide a callback arg, not both" if callback_or_method_name
               block
             else
               case callback_or_method_name

data/lib/action_cable/channel/streams.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActionCable
   module Channel
     # Streams allow channels to route broadcastings to the subscriber. A broadcasting is, as discussed elsewhere, a pubsub queue where any data
@@ -19,14 +21,14 @@ module ActionCable
     #   end
     #
     # Based on the above example, the subscribers of this channel will get whatever data is put into the,
-    # let's say, `comments_for_45` broadcasting as soon as it's put there.
+    # let's say, <tt>comments_for_45</tt> broadcasting as soon as it's put there.
     #
     # An example broadcasting for this channel looks like so:
     #
-    #   ActionCable.server.broadcast "comments_for_45", author: 'DHH', content: 'Rails is just swell'
+    #   ActionCable.server.broadcast "comments_for_45", { author: 'DHH', content: 'Rails is just swell' }
     #
     # If you have a stream that is related to a model, then the broadcasting used can be generated from the model and channel.
-    # The following example would subscribe to a broadcasting like `comments:Z2lkOi8vVGVzdEFwcC9Qb3N0LzE`
+    # The following example would subscribe to a broadcasting like <tt>comments:Z2lkOi8vVGVzdEFwcC9Qb3N0LzE</tt>.
     #
     #   class CommentsChannel < ApplicationCable::Channel
     #     def subscribed
@@ -69,8 +71,8 @@ module ActionCable
 
       # Start streaming from the named <tt>broadcasting</tt> pubsub queue. Optionally, you can pass a <tt>callback</tt> that'll be used
       # instead of the default of just transmitting the updates straight to the subscriber.
-      # Pass `coder: ActiveSupport::JSON` to decode messages as JSON before passing to the callback.
-      # Defaults to `coder: nil` which does no decoding, passes raw messages.
+      # Pass <tt>coder: ActiveSupport::JSON</tt> to decode messages as JSON before passing to the callback.
+      # Defaults to <tt>coder: nil</tt> which does no decoding, passes raw messages.
       def stream_from(broadcasting, callback = nil, coder: nil, &block)
         broadcasting = String(broadcasting)
 
@@ -80,7 +82,7 @@ module ActionCable
         # Build a stream handler by wrapping the user-provided callback with
         # a decoder or defaulting to a JSON-decoding retransmitter.
         handler = worker_pool_stream_handler(broadcasting, callback || block, coder: coder)
-        streams << [ broadcasting, handler ]
+        streams[broadcasting] = handler
 
         connection.server.event_loop.post do
           pubsub.subscribe(broadcasting, handler, lambda do
@@ -94,10 +96,24 @@ module ActionCable
       # <tt>callback</tt> that'll be used instead of the default of just transmitting the updates straight
       # to the subscriber.
       #
-      # Pass `coder: ActiveSupport::JSON` to decode messages as JSON before passing to the callback.
-      # Defaults to `coder: nil` which does no decoding, passes raw messages.
+      # Pass <tt>coder: ActiveSupport::JSON</tt> to decode messages as JSON before passing to the callback.
+      # Defaults to <tt>coder: nil</tt> which does no decoding, passes raw messages.
       def stream_for(model, callback = nil, coder: nil, &block)
-        stream_from(broadcasting_for([ channel_name, model ]), callback || block, coder: coder)
+        stream_from(broadcasting_for(model), callback || block, coder: coder)
+      end
+
+      # Unsubscribes streams from the named <tt>broadcasting</tt>.
+      def stop_stream_from(broadcasting)
+        callback = streams.delete(broadcasting)
+        if callback
+          pubsub.unsubscribe(broadcasting, callback)
+          logger.info "#{self.class.name} stopped streaming from #{broadcasting}"
+        end
+      end
+
+      # Unsubscribes streams for the <tt>model</tt>.
+      def stop_stream_for(model)
+        stop_stream_from(broadcasting_for(model))
       end
 
       # Unsubscribes all streams associated with this channel from the pubsub queue.
@@ -108,11 +124,23 @@ module ActionCable
         end.clear
       end
 
+      # Calls stream_for if record is present, otherwise calls reject.
+      # This method is intended to be called when you're looking
+      # for a record based on a parameter, if its found it will start
+      # streaming. If the record is nil then it will reject the connection.
+      def stream_or_reject_for(record)
+        if record
+          stream_for record
+        else
+          reject
+        end
+      end
+
       private
         delegate :pubsub, to: :connection
 
         def streams
-          @_streams ||= []
+          @_streams ||= {}
         end
 
         # Always wrap the outermost handler to invoke the user handler on the
@@ -138,7 +166,7 @@ module ActionCable
         end
 
         # May be overridden to change the default stream handling behavior
-        # which decodes JSON and transmits to client.
+        # which decodes JSON and transmits to the client.
         #
         # TODO: Tests demonstrating this.
         #

data/lib/action_cable/channel/test_case.rb

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/test_case"
+require "active_support/core_ext/hash/indifferent_access"
+require "json"
+
+module ActionCable
+  module Channel
+    class NonInferrableChannelError < ::StandardError
+      def initialize(name)
+        super "Unable to determine the channel to test from #{name}. " +
+          "You'll need to specify it using `tests YourChannel` in your " +
+          "test case definition."
+      end
+    end
+
+    # Stub +stream_from+ to track streams for the channel.
+    # Add public aliases for +subscription_confirmation_sent?+ and
+    # +subscription_rejected?+.
+    module ChannelStub
+      def confirmed?
+        subscription_confirmation_sent?
+      end
+
+      def rejected?
+        subscription_rejected?
+      end
+
+      def stream_from(broadcasting, *)
+        streams << broadcasting
+      end
+
+      def stop_all_streams
+        @_streams = []
+      end
+
+      def streams
+        @_streams ||= []
+      end
+
+      # Make periodic timers no-op
+      def start_periodic_timers; end
+      alias stop_periodic_timers start_periodic_timers
+    end
+
+    class ConnectionStub
+      attr_reader :transmissions, :identifiers, :subscriptions, :logger
+
+      def initialize(identifiers = {})
+        @transmissions = []
+
+        identifiers.each do |identifier, val|
+          define_singleton_method(identifier) { val }
+        end
+
+        @subscriptions = ActionCable::Connection::Subscriptions.new(self)
+        @identifiers = identifiers.keys
+        @logger = ActiveSupport::TaggedLogging.new ActiveSupport::Logger.new(StringIO.new)
+      end
+
+      def transmit(cable_message)
+        transmissions << cable_message.with_indifferent_access
+      end
+    end
+
+    # Superclass for Action Cable channel functional tests.
+    #
+    # == Basic example
+    #
+    # Functional tests are written as follows:
+    # 1. First, one uses the +subscribe+ method to simulate subscription creation.
+    # 2. Then, one asserts whether the current state is as expected. "State" can be anything:
+    #    transmitted messages, subscribed streams, etc.
+    #
+    # For example:
+    #
+    #   class ChatChannelTest < ActionCable::Channel::TestCase
+    #     def test_subscribed_with_room_number
+    #       # Simulate a subscription creation
+    #       subscribe room_number: 1
+    #
+    #       # Asserts that the subscription was successfully created
+    #       assert subscription.confirmed?
+    #
+    #       # Asserts that the channel subscribes connection to a stream
+    #       assert_has_stream "chat_1"
+    #
+    #       # Asserts that the channel subscribes connection to a specific
+    #       # stream created for a model
+    #       assert_has_stream_for Room.find(1)
+    #     end
+    #
+    #     def test_does_not_stream_with_incorrect_room_number
+    #       subscribe room_number: -1
+    #
+    #       # Asserts that not streams was started
+    #       assert_no_streams
+    #     end
+    #
+    #     def test_does_not_subscribe_without_room_number
+    #       subscribe
+    #
+    #       # Asserts that the subscription was rejected
+    #       assert subscription.rejected?
+    #     end
+    #   end
+    #
+    # You can also perform actions:
+    #   def test_perform_speak
+    #     subscribe room_number: 1
+    #
+    #     perform :speak, message: "Hello, Rails!"
+    #
+    #     assert_equal "Hello, Rails!", transmissions.last["text"]
+    #   end
+    #
+    # == Special methods
+    #
+    # ActionCable::Channel::TestCase will also automatically provide the following instance
+    # methods for use in the tests:
+    #
+    # <b>connection</b>::
+    #      An ActionCable::Channel::ConnectionStub, representing the current HTTP connection.
+    # <b>subscription</b>::
+    #      An instance of the current channel, created when you call +subscribe+.
+    # <b>transmissions</b>::
+    #      A list of all messages that have been transmitted into the channel.
+    #
+    #
+    # == Channel is automatically inferred
+    #
+    # ActionCable::Channel::TestCase will automatically infer the channel 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 SpecialEdgeCaseChannelTest < ActionCable::Channel::TestCase
+    #     tests SpecialChannel
+    #   end
+    #
+    # == Specifying connection identifiers
+    #
+    # You need to set up your connection manually to provide values for the identifiers.
+    # To do this just use:
+    #
+    #   stub_connection(user: users(:john))
+    #
+    # == Testing broadcasting
+    #
+    # ActionCable::Channel::TestCase enhances ActionCable::TestHelper assertions (e.g.
+    # +assert_broadcasts+) to handle broadcasting to models:
+    #
+    #
+    #  # in your channel
+    #  def speak(data)
+    #    broadcast_to room, text: data["message"]
+    #  end
+    #
+    #  def test_speak
+    #    subscribe room_id: rooms(:chat).id
+    #
+    #    assert_broadcast_on(rooms(:chat), text: "Hello, Rails!") do
+    #      perform :speak, message: "Hello, Rails!"
+    #    end
+    #  end
+    class TestCase < ActiveSupport::TestCase
+      module Behavior
+        extend ActiveSupport::Concern
+
+        include ActiveSupport::Testing::ConstantLookup
+        include ActionCable::TestHelper
+
+        CHANNEL_IDENTIFIER = "test_stub"
+
+        included do
+          class_attribute :_channel_class
+
+          attr_reader :connection, :subscription
+
+          ActiveSupport.run_load_hooks(:action_cable_channel_test_case, self)
+        end
+
+        module ClassMethods
+          def tests(channel)
+            case channel
+            when String, Symbol
+              self._channel_class = channel.to_s.camelize.constantize
+            when Module
+              self._channel_class = channel
+            else
+              raise NonInferrableChannelError.new(channel)
+            end
+          end
+
+          def channel_class
+            if channel = self._channel_class
+              channel
+            else
+              tests determine_default_channel(name)
+            end
+          end
+
+          def determine_default_channel(name)
+            channel = determine_constant_from_test_name(name) do |constant|
+              Class === constant && constant < ActionCable::Channel::Base
+            end
+            raise NonInferrableChannelError.new(name) if channel.nil?
+            channel
+          end
+        end
+
+        # Set up test connection with the specified identifiers:
+        #
+        #   class ApplicationCable < ActionCable::Connection::Base
+        #     identified_by :user, :token
+        #   end
+        #
+        #   stub_connection(user: users[:john], token: 'my-secret-token')
+        def stub_connection(identifiers = {})
+          @connection = ConnectionStub.new(identifiers)
+        end
+
+        # Subscribe to the channel under test. Optionally pass subscription parameters as a Hash.
+        def subscribe(params = {})
+          @connection ||= stub_connection
+          @subscription = self.class.channel_class.new(connection, CHANNEL_IDENTIFIER, params.with_indifferent_access)
+          @subscription.singleton_class.include(ChannelStub)
+          @subscription.subscribe_to_channel
+          @subscription
+        end
+
+        # Unsubscribe the subscription under test.
+        def unsubscribe
+          check_subscribed!
+          subscription.unsubscribe_from_channel
+        end
+
+        # Perform action on a channel.
+        #
+        # NOTE: Must be subscribed.
+        def perform(action, data = {})
+          check_subscribed!
+          subscription.perform_action(data.stringify_keys.merge("action" => action.to_s))
+        end
+
+        # Returns messages transmitted into channel
+        def transmissions
+          # Return only directly sent message (via #transmit)
+          connection.transmissions.map { |data| data["message"] }.compact
+        end
+
+        # Enhance TestHelper assertions to handle non-String
+        # broadcastings
+        def assert_broadcasts(stream_or_object, *args)
+          super(broadcasting_for(stream_or_object), *args)
+        end
+
+        def assert_broadcast_on(stream_or_object, *args)
+          super(broadcasting_for(stream_or_object), *args)
+        end
+
+        # Asserts that no streams have been started.
+        #
+        #   def test_assert_no_started_stream
+        #     subscribe
+        #     assert_no_streams
+        #   end
+        #
+        def assert_no_streams
+          assert subscription.streams.empty?, "No streams started was expected, but #{subscription.streams.count} found"
+        end
+
+        # Asserts that the specified stream has been started.
+        #
+        #   def test_assert_started_stream
+        #     subscribe
+        #     assert_has_stream 'messages'
+        #   end
+        #
+        def assert_has_stream(stream)
+          assert subscription.streams.include?(stream), "Stream #{stream} has not been started"
+        end
+
+        # Asserts that the specified stream for a model has started.
+        #
+        #   def test_assert_started_stream_for
+        #     subscribe id: 42
+        #     assert_has_stream_for User.find(42)
+        #   end
+        #
+        def assert_has_stream_for(object)
+          assert_has_stream(broadcasting_for(object))
+        end
+
+        private
+          def check_subscribed!
+            raise "Must be subscribed!" if subscription.nil? || subscription.rejected?
+          end
+
+          def broadcasting_for(stream_or_object)
+            return stream_or_object if stream_or_object.is_a?(String)
+
+            self.class.channel_class.broadcasting_for(stream_or_object)
+          end
+      end
+
+      include Behavior
+    end
+  end
+end