actioncable 5.0.0.beta2 → 5.0.0.beta3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 666a8feb5df8f5f6a523f81a826c1a2fbd23a1c3
-  data.tar.gz: 85b3d45b716f55eed7b2b8aad82e69dd7f00c1e7
+  metadata.gz: e3e7b9ae96c4f9f359281abaa75f8b909a8fb04f
+  data.tar.gz: 41a9536aea144e25988a510069c3b07b0250aa5b
 SHA512:
-  metadata.gz: be0531d119c3792067b0cc54609830700ea1eacb28dd6199775e13b3914a83a90cdbc6e44d10d434a14dabc159e7dc2d7df0b984e3a3e748b4e8ec42ea554def
-  data.tar.gz: 75e01690a3a351949df277f14492b79f050518a9c8f5e5a72a68df0f83595df635b9bfedea7f53e9882e0d0bac302fed69c5f79ce535ae765d22da607dc65fce
+  metadata.gz: 6f1879623b43518932a8c295c72acc97b7dd97008d1925dc3130f0398fbaa68a22d4bb0f6ad9f86b9d85e36c8a88e0070c235e4ac79480079d1cec546651e87e
+  data.tar.gz: a7c49b2304c60bb4d50674a457164a14b9d5f4ae0dc4aaabf65569bdf2a7f493ad6e5938162b017e9f0ff80cf2cd8fa028590b00a32ccbe14837d4ebf5d638c0

data/CHANGELOG.md

@@ -1,3 +1,12 @@
+## Rails 5.0.0.beta3 (February 24, 2016) ##
+
+*  Added ActionCable::SubscriptionAdapter::EventedRedis.em_redis_connector/redis_connector and
+   ActionCable::SubscriptionAdapter::Redis.redis_connector factory methods for redis connections, 
+   so you can overwrite with your own initializers. This is used when you want to use different-than-standard Redis adapters,
+   like for Makara distributed Redis.
+
+   *DHH*
+
 ## Rails 5.0.0.beta2 (February 01, 2016) ##
 
 *   Support PostgreSQL pubsub adapter.

data/README.md

@@ -17,7 +17,7 @@ The client of a WebSocket connection is called the consumer.
 
 Each consumer can in turn subscribe to multiple cable channels. Each channel encapsulates
 a logical unit of work, similar to what a controller does in a regular MVC setup. For example,
-you could have a `ChatChannel` and a `AppearancesChannel`, and a consumer could be subscribed to either
+you could have a `ChatChannel` and an `AppearancesChannel`, and a consumer could be subscribed to either
 or to both of these channels. At the very least, a consumer should be subscribed to one channel.
 
 When the consumer is subscribed to a channel, they act as a subscriber. The connection between
@@ -39,7 +39,7 @@ reflections of each unit.
 ### A full-stack example
 
 The first thing you must do is define your `ApplicationCable::Connection` class in Ruby. This
-is the place where you authorize the incoming connection, and proceed to establish it
+is the place where you authorize the incoming connection, and proceed to establish it,
 if all is well. Here's the simplest example starting with the server-side connection class:
 
 ```ruby
@@ -73,7 +73,7 @@ use that to set the `current_user`. By identifying the connection by this same c
 you're also ensuring that you can later retrieve all open connections by a given user (and
 potentially disconnect them all if the user is deleted or deauthorized).
 
-Then you should define your `ApplicationCable::Channel` class in Ruby. This is the place where you put
+Next, you should define your `ApplicationCable::Channel` class in Ruby. This is the place where you put
 shared logic between your channels.
 
 ```ruby
@@ -94,7 +94,7 @@ The client-side needs to setup a consumer instance of this connection. That's do
 App.cable = ActionCable.createConsumer("ws://cable.example.com")
 ```
 
-The ws://cable.example.com address must point to your set of Action Cable servers, and it
+The `ws://cable.example.com` address must point to your Action Cable server(s), and it
 must share a cookie namespace with the rest of the application (which may live under http://example.com).
 This ensures that the signed cookie will be correctly sent.
 
@@ -105,8 +105,8 @@ is defined by declaring channels on the server and allowing the consumer to subs
 
 ### Channel example 1: User appearances
 
-Here's a simple example of a channel that tracks whether a user is online or not and what page they're on.
-(This is useful for creating presence features like showing a green dot next to a user name if they're online).
+Here's a simple example of a channel that tracks whether a user is online or not, and also what page they are currently on.
+(This is useful for creating presence features like showing a green dot next to a user's name if they're online).
 
 First you declare the server-side channel:
 
@@ -180,7 +180,7 @@ App.cable.subscriptions.create "AppearanceChannel",
 Simply calling `App.cable.subscriptions.create` will setup the subscription, which will call `AppearanceChannel#subscribed`,
 which in turn is linked to original `App.cable` -> `ApplicationCable::Connection` instances.
 
-We then link the client-side `appear` method to `AppearanceChannel#appear(data)`. This is possible because the server-side
+Next, we link the client-side `appear` method to `AppearanceChannel#appear(data)`. This is possible because the server-side
 channel instance will automatically expose the public methods declared on the class (minus the callbacks), so that these
 can be reached as remote procedure calls via a subscription's `perform` method.
 
@@ -188,7 +188,7 @@ can be reached as remote procedure calls via a subscription's `perform` method.
 
 The appearance example was all about exposing server functionality to client-side invocation over the WebSocket connection.
 But the great thing about WebSockets is that it's a two-way street. So now let's show an example where the server invokes
-action on the client.
+an action on the client.
 
 This is a web notification channel that allows you to trigger client-side web notifications when you broadcast to the right
 streams:
@@ -215,7 +215,7 @@ ActionCable.server.broadcast \
   "web_notifications_#{current_user.id}", { title: 'New things!', body: 'All the news that is fit to print' }
 ```
 
-The `ActionCable.server.broadcast` call places a message in the Redis' pubsub queue under a separate broadcasting name for each user. For a user with an ID of 1, the broadcasting name would be `web_notifications_1`.
+The `ActionCable.server.broadcast` call places a message in the Action Cable pubsub queue under a separate broadcasting name for each user. For a user with an ID of 1, the broadcasting name would be `web_notifications_1`.
 The channel has been instructed to stream everything that arrives at `web_notifications_1` directly to the client by invoking the
 `#received(data)` callback. The data is the hash sent as the second parameter to the server-side broadcast call, JSON encoded for the trip
 across the wire, and unpacked for the data argument arriving to `#received`.
@@ -234,7 +234,7 @@ class ChatChannel < ApplicationCable::Channel
 end
 ```
 
-Pass an object as the first argument to `subscriptions.create`, and that object will become your params hash in your cable channel. The keyword `channel` is required.
+If you pass an object as the first argument to `subscriptions.create`, that object will become the params hash in your cable channel. The keyword `channel` is required.
 
 ```coffeescript
 # Client-side, which assumes you've already requested the right to send web notifications
@@ -293,27 +293,29 @@ The rebroadcast will be received by all connected clients, _including_ the clien
 
 ### More complete examples
 
-See the [rails/actioncable-examples](http://github.com/rails/actioncable-examples) repository for a full example of how to setup Action Cable in a Rails app and adding channels.
+See the [rails/actioncable-examples](http://github.com/rails/actioncable-examples) repository for a full example of how to setup Action Cable in a Rails app, and how to add channels.
 
 
 ## Configuration
 
-Action Cable has three required configurations: the Redis connection, allowed request origins, and the cable server url (which can optionally be set on the client side).
+Action Cable has three required configurations: a subscription adapter, allowed request origins, and the cable server URL (which can optionally be set on the client side).
 
 ### Redis
 
 By default, `ActionCable::Server::Base` will look for a configuration file in `Rails.root.join('config/cable.yml')`.
-This file must specify a Redis url for each Rails environment. It may use the following format:
+This file must specify an adapter and a URL for each Rails environment. It may use the following format:
 
 ```yaml
 production: &production
+  adapter: redis
   url: redis://10.10.3.153:6381
 development: &development
+  adapter: redis
   url: redis://localhost:6379
 test: *development
 ```
 
-You can also change the location of the Redis config file in a Rails initializer with something like:
+You can also change the location of the Action Cable config file in a Rails initializer with something like:
 
 ```ruby
 Rails.application.paths.add "config/cable", with: "somewhere/else/cable.yml"
@@ -324,7 +326,7 @@ Rails.application.paths.add "config/cable", with: "somewhere/else/cable.yml"
 Action Cable will only accept requests from specified origins, which are passed to the server config as an array. The origins can be instances of strings or regular expressions, against which a check for match will be performed.
 
 ```ruby
-ActionCable.server.config.allowed_request_origins = ['http://rubyonrails.com', /http:\/\/ruby.*/]
+Rails.application.config.action_cable.allowed_request_origins = ['http://rubyonrails.com', /http:\/\/ruby.*/]
 ```
 
 When running in the development environment, this defaults to "http://localhost:3000".
@@ -332,7 +334,7 @@ When running in the development environment, this defaults to "http://localhost:
 To disable and allow requests from any origin:
 
 ```ruby
-ActionCable.server.config.disable_request_forgery_protection = true
+Rails.application.config.action_cable.disable_request_forgery_protection = true
 ```
 
 ### Consumer Configuration
@@ -347,11 +349,11 @@ something like: `App.cable = ActionCable.createConsumer("/cable")`.
 The second option is to pass the server url through the `action_cable_meta_tag` in your layout.
 This uses a url or path typically set via `config.action_cable.url` in the environment configuration files, or defaults to "/cable".
 
-This method is especially useful if your websocket url might change between environments. If you host your production server via https, you will need to use the wss scheme
-for your ActionCable server, but development might remain http and use the ws scheme. You might use localhost in development and your
+This method is especially useful if your WebSocket url might change between environments. If you host your production server via https, you will need to use the wss scheme
+for your Action Cable server, but development might remain http and use the ws scheme. You might use localhost in development and your
 domain in production.
 
-In any case, to vary the websocket url between environments, add the following configuration to each environment:
+In any case, to vary the WebSocket url between environments, add the following configuration to each environment:
 
 ```ruby
 config.action_cable.url = "ws://example.com:28080"
@@ -374,7 +376,7 @@ App.cable = ActionCable.createConsumer()
 The other common option to configure is the log tags applied to the per-connection logger. Here's close to what we're using in Basecamp:
 
 ```ruby
-ActionCable.server.config.log_tags = [
+Rails.application.config.action_cable.log_tags = [
   -> request { request.env['bc.account_id'] || "no-account" },
   :action_cable,
   -> request { request.uuid }
@@ -389,7 +391,7 @@ Also note that your server must provide at least the same number of database con
 ## Running the cable server
 
 ### Standalone
-The cable server(s) is separated from your normal application server. It's still a rack application, but it is its own rack
+The cable server(s) is separated from your normal application server. It's still a Rack application, but it is its own Rack
 application. The recommended basic setup is as follows:
 
 ```ruby
@@ -410,7 +412,7 @@ The above will start a cable server on port 28080.
 
 ### In app
 
-If you are using a threaded server like Puma or Thin, the current implementation of ActionCable can run side-along with your Rails application. For example, to listen for WebSocket requests on `/cable`, mount the server at that path:
+If you are using a threaded server like Puma or Thin, the current implementation of Action Cable can run side-along with your Rails application. For example, to listen for WebSocket requests on `/cable`, mount the server at that path:
 
 ```ruby
 # config/routes.rb
@@ -419,7 +421,7 @@ Example::Application.routes.draw do
 end
 ```
 
-For every instance of your server you create and for every worker your server spawns, you will also have a new instance of ActionCable, but the use of Redis keeps messages synced across connections.
+For every instance of your server you create and for every worker your server spawns, you will also have a new instance of Action Cable, but the use of Redis keeps messages synced across connections.
 
 ### Notes
 
@@ -431,25 +433,31 @@ The WebSocket server doesn't have access to the session, but it has access to th
 
 ## Dependencies
 
-Action Cable is currently tied to Redis through its use of the pubsub feature to route
-messages back and forth over the WebSocket cable connection. This dependency may well
-be alleviated in the future, but for the moment that's what it is. So be sure to have
-Redis installed and running.
+Action Cable provides a subscription adapter interface to process its pubsub internals. By default, asynchronous, inline, PostgreSQL, evented Redis, and non-evented Redis adapters are included. The default adapter in new Rails applications is the asynchronous (`async`) adapter. To create your own adapter, you can look at `ActionCable::SubscriptionAdapter::Base` for all methods that must be implemented, and any of the adapters included within Action Cable as example implementations.
 
-The Ruby side of things is built on top of [faye-websocket](https://github.com/faye/faye-websocket-ruby) and [concurrent-ruby](https://github.com/ruby-concurrency/concurrent-ruby).
+The Ruby side of things is built on top of [websocket-driver](https://github.com/faye/websocket-driver-ruby), [nio4r](https://github.com/celluloid/nio4r), and [concurrent-ruby](https://github.com/ruby-concurrency/concurrent-ruby).
 
 
 ## Deployment
 
-Action Cable is powered by a combination of websockets and threads. All of the
+Action Cable is powered by a combination of WebSockets and threads. All of the
 connection management is handled internally by utilizing Ruby’s native thread
 support, which means you can use all your regular Rails models with no problems
 as long as you haven’t committed any thread-safety sins.
 
 But this also means that Action Cable needs to run in its own server process.
 So you'll have one set of server processes for your normal web work, and another
-set of server processes for the Action Cable. The former can be single-threaded,
-like Unicorn, but the latter must be multi-threaded, like Puma.
+set of server processes for the Action Cable.
+
+The Action Cable server does _not_ need to be a multi-threaded application server.
+This is because Action Cable uses the [Rack socket hijacking API](http://old.blog.phusion.nl/2013/01/23/the-new-rack-socket-hijacking-api/)
+to take over control of connections from the application server. Action Cable
+then manages connections internally, in a multithreaded manner, regardless of
+whether the application server is multi-threaded or not. So Action Cable works
+with all the popular application servers -- Unicorn, Puma and Passenger.
+
+Action Cable does not work with WEBrick, because WEBrick does not support the
+Rack socket hijacking API.
 
 ## License
 

data/lib/action_cable/channel/base.rb

@@ -32,8 +32,11 @@ module ActionCable
     #
     # == Action processing
     #
-    # Unlike Action Controllers, channels do not follow a REST constraint form for its actions. It's a 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.
+    # 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.
     #
     # Example:
     #
@@ -60,18 +63,22 @@ module ActionCable
     #       end
     #   end
     #
-    # In this example, subscribed/unsubscribed are not callable methods, as they were already declared in ActionCable::Channel::Base, but #appear/away
-    # are. #generate_connection_token is also not callable as its 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, it's simply a trigger action.
+    # 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.
     #
-    # 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.
+    # 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.
     #
     # == Rejecting subscription requests
     #
-    # A channel can reject a subscription request in the #subscribed callback by invoking #reject!
-    #
-    # Example:
+    # A channel can reject a subscription request in the #subscribed callback by
+    # invoking the #reject method:
     #
     #   class ChatChannel < ApplicationCable::Channel
     #     def subscribed
@@ -80,8 +87,10 @@ module ActionCable
     #     end
     #   end
     #
-    # In this example, the subscription will be rejected if the current_user does not have access to the chat room.
-    # On the client-side, Channel#rejected callback will get invoked when the server rejects the subscription request.
+    # 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.
     class Base
       include Callbacks
       include PeriodicTimers
@@ -116,7 +125,7 @@ module ActionCable
         protected
           # 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
+          # you run action_methods, they will be recalculated.
           def clear_action_methods!
             @action_methods = nil
           end
@@ -157,9 +166,9 @@ module ActionCable
         end
       end
 
-      # Called by the cable connection when its cut so the channel has a chance to cleanup with callbacks.
+      # Called by the cable connection when its cut, so the channel has a chance to cleanup with callbacks.
       # This method is not intended to be called directly by the user. Instead, overwrite the #unsubscribed callback.
-      def unsubscribe_from_channel
+      def unsubscribe_from_channel # :nodoc:
         run_callbacks :unsubscribe do
           unsubscribed
         end
@@ -174,7 +183,7 @@ module ActionCable
         end
 
         # Called once a consumer has cut its cable connection. Can be used for cleaning up connections or marking
-        # people as offline or the like.
+        # users as offline or the like.
         def unsubscribed
           # Override in subclasses
         end
@@ -182,7 +191,7 @@ module ActionCable
         # 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}".tap { |m| m << " (via #{via})" if via }
+          logger.info "#{self.class.name} transmitting #{data.inspect.truncate(300)}".tap { |m| m << " (via #{via})" if via }
           connection.transmit ActiveSupport::JSON.encode(identifier: @identifier, message: data)
         end
 
@@ -215,7 +224,6 @@ module ActionCable
           end
         end
 
-
         def subscribe_to_channel
           run_callbacks :subscribe do
             subscribed
@@ -228,7 +236,6 @@ module ActionCable
           end
         end
 
-
         def extract_action(data)
           (data['action'].presence || :receive).to_sym
         end

data/lib/action_cable/channel/periodic_timers.rb

@@ -12,7 +12,7 @@ module ActionCable
       end
 
       module ClassMethods
-        # Allow you to call a private method <tt>every</tt> so often seconds. This periodic timer can be useful
+        # Allows you to call a private method <tt>every</tt> so often seconds. This periodic timer can be useful
         # for sending a steady flow of updates to a client based off an object that was configured on subscription.
         # It's an alternative to using streams if the channel is able to do the work internally.
         def periodically(callback, every:)

data/lib/action_cable/channel/streams.rb

@@ -1,8 +1,8 @@
 module ActionCable
   module Channel
     # Streams allow channels to route broadcastings to the subscriber. A broadcasting is, as discussed elsewhere, a pub/sub queue where any data
-    # put into it is automatically sent to the clients that are connected at that time. It's purely an online queue, though. If you're not
-    # streaming a broadcasting at the very moment it sends out an update, you'll not get that update when connecting later.
+    # placed into it is automatically sent to the clients that are connected at that time. It's purely an online queue, though. If you're not
+    # streaming a broadcasting at the very moment it sends out an update, you will not get that update, if you connect after it has been sent.
     #
     # Most commonly, the streamed broadcast is sent straight to the subscriber on the client-side. The channel just acts as a connector between
     # the two parties (the broadcaster and the channel subscriber). Here's an example of a channel that allows subscribers to get all new
@@ -18,8 +18,10 @@ module ActionCable
     #     end
     #   end
     #
-    # So 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.
-    # That looks like so from that side of things:
+    # 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.
+    #
+    # An example broadcasting for this channel looks like so:
     #
     #   ActionCable.server.broadcast "comments_for_45", author: 'DHH', content: 'Rails is just swell'
     #
@@ -37,26 +39,27 @@ module ActionCable
     #
     #   CommentsChannel.broadcast_to(@post, @comment)
     #
-    # If you don't just want to parlay the broadcast unfiltered to the subscriber, you can supply a callback that lets you alter what goes out.
-    # Example below shows how you can use this to provide performance introspection in the process:
+    # If you don't just want to parlay the broadcast unfiltered to the subscriber, you can also supply a callback that lets you alter what is sent out.
+    # The below example shows how you can use this to provide performance introspection in the process:
     #
     #   class ChatChannel < ApplicationCable::Channel
-    #    def subscribed
-    #      @room = Chat::Room[params[:room_number]]
+    #     def subscribed
+    #       @room = Chat::Room[params[:room_number]]
     #
-    #      stream_for @room, -> (encoded_message) do
-    #        message = ActiveSupport::JSON.decode(encoded_message)
+    #       stream_for @room, -> (encoded_message) do
+    #         message = ActiveSupport::JSON.decode(encoded_message)
     #
-    #        if message['originated_at'].present?
-    #          elapsed_time = (Time.now.to_f - message['originated_at']).round(2)
+    #         if message['originated_at'].present?
+    #           elapsed_time = (Time.now.to_f - message['originated_at']).round(2)
     #
-    #          ActiveSupport::Notifications.instrument :performance, measurement: 'Chat.message_delay', value: elapsed_time, action: :timing
-    #          logger.info "Message took #{elapsed_time}s to arrive"
-    #        end
+    #           ActiveSupport::Notifications.instrument :performance, measurement: 'Chat.message_delay', value: elapsed_time, action: :timing
+    #           logger.info "Message took #{elapsed_time}s to arrive"
+    #         end
     #
-    #        transmit message
-    #      end
-    #    end
+    #         transmit message
+    #       end
+    #     end
+    #   end
     #
     # You can stop streaming from all broadcasts by calling #stop_all_streams.
     module Streams
@@ -69,7 +72,7 @@ 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.
       def stream_from(broadcasting, callback = nil)
-        # Hold off the confirmation until pubsub#subscribe is successful
+        # Don't send the confirmation until pubsub#subscribe is successful
         defer_subscription_confirmation!
 
         callback ||= default_stream_callback(broadcasting)
@@ -90,6 +93,7 @@ module ActionCable
         stream_from(broadcasting_for([ channel_name, model ]), callback)
       end
 
+      # Unsubscribes all streams associated with this channel from the pubsub queue.
       def stop_all_streams
         streams.each do |broadcasting, callback|
           pubsub.unsubscribe broadcasting, callback

data/lib/action_cable/connection/base.rb

@@ -2,9 +2,9 @@ require 'action_dispatch'
 
 module ActionCable
   module Connection
-    # For every WebSocket the cable server is accepting, a Connection object will be instantiated. This instance becomes the parent
-    # of all the channel subscriptions that are created from there on. Incoming messages are then routed to these channel subscriptions
-    # based on an identifier sent by the cable consumer. The Connection itself does not deal with any specific application logic beyond
+    # For every WebSocket the Action Cable server accepts, a Connection object will be instantiated. This instance becomes the parent
+    # of all of the channel subscriptions that are created from there on. Incoming messages are then routed to these channel subscriptions
+    # based on an identifier sent by the Action Cable consumer. The Connection itself does not deal with any specific application logic beyond
     # authentication and authorization.
     #
     # Here's a basic example:
@@ -33,9 +33,9 @@ module ActionCable
     #     end
     #   end
     #
-    # First, we declare that this connection can be identified by its current_user. This allows us later to be able to find all connections
-    # established for that current_user (and potentially disconnect them if the user was removed from an account). You can declare as many
-    # identification indexes as you like. Declaring an identification means that a attr_accessor is automatically set for that key.
+    # First, we declare that this connection can be identified by its current_user. This allows us to later be able to find all connections
+    # established for that current_user (and potentially disconnect them). You can declare as many
+    # identification indexes as you like. Declaring an identification means that an attr_accessor is automatically set for that key.
     #
     # Second, we rely on the fact that the WebSocket connection is established with the cookies from the domain being sent along. This makes
     # it easy to use signed cookies that were set when logging in via a web interface to authorize the WebSocket connection.
@@ -65,8 +65,8 @@ module ActionCable
       end
 
       # Called by the server when a new WebSocket connection is established. This configures the callbacks intended for overwriting by the user.
-      # This method should not be called directly. Rely on the #connect (and #disconnect) callback instead.
-      def process
+      # This method should not be called directly -- instead rely upon on the #connect (and #disconnect) callbacks.
+      def process # :nodoc:
         logger.info started_request_message
 
         if websocket.possible? && allow_request_origin?
@@ -76,7 +76,7 @@ module ActionCable
         end
       end
 
-      # Data received over the cable is handled by this method. It's expected that everything inbound is JSON encoded.
+      # Data received over the WebSocket connection is handled by this method. It's expected that everything inbound is JSON encoded.
       # The data is routed to the proper channel that the connection has subscribed to.
       def receive(data_in_json)
         if websocket.alive?
@@ -88,7 +88,7 @@ module ActionCable
 
       # Send raw data straight back down the WebSocket. This is not intended to be called directly. Use the #transmit available on the
       # Channel instead, as that'll automatically address the correct subscriber and wrap the message in JSON.
-      def transmit(data)
+      def transmit(data) # :nodoc:
         websocket.transmit data
       end
 
@@ -154,7 +154,7 @@ module ActionCable
         def handle_open
           connect if respond_to?(:connect)
           subscribe_to_internal_channel
-          beat
+          confirm_connection_monitor_subscription
 
           message_buffer.process!
           server.add_connection(self)
@@ -173,6 +173,13 @@ module ActionCable
           disconnect if respond_to?(:disconnect)
         end
 
+        def confirm_connection_monitor_subscription
+          # Send confirmation message to the internal connection monitor channel.
+          # This ensures the connection monitor state is reset after a successful
+          # websocket connection.
+          transmit ActiveSupport::JSON.encode(identifier: ActionCable::INTERNAL[:identifiers][:ping], type: ActionCable::INTERNAL[:message_types][:confirmation])
+        end
+
         def allow_request_origin?
           return true if server.config.disable_request_forgery_protection
 
@@ -185,12 +192,14 @@ module ActionCable
         end
 
         def respond_to_successful_request
+          logger.info successful_request_message
           websocket.rack_response
         end
 
         def respond_to_invalid_request
           close if websocket.alive?
 
+          logger.error invalid_request_message
           logger.info finished_request_message
           [ 404, { 'Content-Type' => 'text/plain' }, [ 'Page not found' ] ]
         end
@@ -205,7 +214,7 @@ module ActionCable
           'Started %s "%s"%s for %s at %s' % [
             request.request_method,
             request.filtered_path,
-            websocket.possible? ? ' [WebSocket]' : '',
+            websocket.possible? ? ' [WebSocket]' : '[non-WebSocket]',
             request.ip,
             Time.now.to_s ]
         end
@@ -213,10 +222,22 @@ module ActionCable
         def finished_request_message
           'Finished "%s"%s for %s at %s' % [
             request.filtered_path,
-            websocket.possible? ? ' [WebSocket]' : '',
+            websocket.possible? ? ' [WebSocket]' : '[non-WebSocket]',
             request.ip,
             Time.now.to_s ]
         end
+
+        def invalid_request_message
+          'Failed to upgrade to WebSocket (REQUEST_METHOD: %s, HTTP_CONNECTION: %s, HTTP_UPGRADE: %s)' % [
+            env["REQUEST_METHOD"], env["HTTP_CONNECTION"], env["HTTP_UPGRADE"]
+          ]
+        end
+
+        def successful_request_message
+          'Successfully upgraded to WebSocket (REQUEST_METHOD: %s, HTTP_CONNECTION: %s, HTTP_UPGRADE: %s)' % [
+            env["REQUEST_METHOD"], env["HTTP_CONNECTION"], env["HTTP_UPGRADE"]
+          ]
+        end
     end
   end
 end

data/lib/action_cable/connection/client_socket.rb

@@ -132,11 +132,8 @@ module ActionCable
           @ready_state = CLOSING
           @close_params = [reason, code]
 
-          if @stream
-            @stream.shutdown
-          else
-            finalize_close
-          end
+          @stream.shutdown if @stream
+          finalize_close
         end
 
         def finalize_close

data/lib/action_cable/connection/identification.rb

@@ -12,7 +12,7 @@ module ActionCable
 
       class_methods do
         # Mark a key as being a connection identifier index that can then be used to find the specific connection again later.
-        # Common identifiers are current_user and current_account, but could be anything really.
+        # Common identifiers are current_user and current_account, but could be anything, really.
         #
         # Note that anything marked as an identifier will automatically create a delegate by the same name on any
         # channel instances created off the connection.

data/lib/action_cable/connection/message_buffer.rb

@@ -1,8 +1,7 @@
 module ActionCable
   module Connection
-    # Allows us to buffer messages received from the WebSocket before the Connection has been fully initialized and is ready to receive them.
-    # Entirely internal operation and should not be used directly by the user.
-    class MessageBuffer
+    # Allows us to buffer messages received from the WebSocket before the Connection has been fully initialized, and is ready to receive them.
+    class MessageBuffer # :nodoc:
       def initialize(connection)
         @connection = connection
         @buffered_messages = []

data/lib/action_cable/connection/subscriptions.rb

@@ -3,8 +3,8 @@ require 'active_support/core_ext/hash/indifferent_access'
 module ActionCable
   module Connection
     # Collection class for all the channel subscriptions established on a given connection. Responsible for routing incoming commands that arrive on
-    # the connection to the proper channel. Should not be used directly by the user.
-    class Subscriptions
+    # the connection to the proper channel.
+    class Subscriptions # :nodoc:
       def initialize(connection)
         @connection = connection
         @subscriptions = {}
@@ -54,7 +54,7 @@ module ActionCable
       end
 
       def unsubscribe_from_all
-        subscriptions.each { |id, channel| channel.unsubscribe_from_channel }
+        subscriptions.each { |id, channel| remove_subscription(channel) }
       end
 
       protected

data/lib/action_cable/engine.rb

@@ -31,6 +31,12 @@ module ActionCable
           self.cable = Rails.application.config_for(config_path).with_indifferent_access
         end
 
+        if 'ApplicationCable::Connection'.safe_constantize
+          self.connection_class = ApplicationCable::Connection
+        end
+
+        self.channel_paths = Rails.application.paths['app/channels'].existent
+
         options.each { |k,v| send("#{k}=", v) }
       end
     end

data/lib/action_cable/gem_version.rb

@@ -8,7 +8,7 @@ module ActionCable
     MAJOR = 5
     MINOR = 0
     TINY  = 0
-    PRE   = "beta2"
+    PRE   = "beta3"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/action_cable/helpers/action_cable_helper.rb

@@ -9,7 +9,7 @@ module ActionCable
       #     <%= javascript_include_tag 'application', 'data-turbolinks-track' => true %>
       #   </head>
       #
-      # This is then used by ActionCable to determine the url of your websocket server.
+      # This is then used by Action Cable to determine the url of your WebSocket server.
       # Your CoffeeScript can then connect to the server without needing to specify the
       # url directly:
       #

data/lib/action_cable/remote_connections.rb

@@ -1,6 +1,7 @@
 module ActionCable
-  # If you need to disconnect a given connection, you go through the RemoteConnections. You find the connections you're looking for by
-  # searching the identifier declared on the connection. Example:
+  # 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
@@ -11,8 +12,9 @@ module ActionCable
   #
   #   ActionCable.server.remote_connections.where(current_user: User.find(1)).disconnect
   #
-  # That 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 these servers are subscribed to).
+  # 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.
   class RemoteConnections
     attr_reader :server
 
@@ -25,7 +27,7 @@ module ActionCable
     end
 
     private
-      # Represents a single remote connection found via ActionCable.server.remote_connections.where(*).
+      # Represents a single remote connection found via <tt>ActionCable.server.remote_connections.where(*)</tt>.
       # Exists for the solely for the purpose of calling #disconnect on that connection.
       class RemoteConnection
         class InvalidIdentifiersError < StandardError; end

data/lib/action_cable/server/base.rb

@@ -2,10 +2,10 @@ require 'thread'
 
 module ActionCable
   module Server
-    # A singleton ActionCable::Server instance is available via ActionCable.server. It's used by the rack process that starts the cable server, but
-    # also by the user to reach the RemoteConnections instead for finding and disconnecting connections across all servers.
+    # 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 details.
+    # Also, this is the server instance used for broadcasting. See Broadcasting for more information.
     class Base
       include ActionCable::Server::Broadcasting
       include ActionCable::Server::Connections
@@ -19,11 +19,10 @@ module ActionCable
 
       def initialize
         @mutex = Mutex.new
-
         @remote_connections = @stream_event_loop = @worker_pool = @channel_classes = @pubsub = nil
       end
 
-      # Called by rack to setup the server.
+      # Called by Rack to setup the server.
       def call(env)
         setup_heartbeat_timer
         config.connection_class.new(self, env).process
@@ -48,7 +47,7 @@ module ActionCable
         @worker_pool || @mutex.synchronize { @worker_pool ||= ActionCable::Server::Worker.new(max_size: config.worker_pool_size) }
       end
 
-      # Requires and returns a hash of all the channel class constants keyed by name.
+      # Requires and returns a hash of all of the channel class constants, which are keyed by name.
       def channel_classes
         @channel_classes || @mutex.synchronize do
           @channel_classes ||= begin
@@ -63,7 +62,7 @@ module ActionCable
         @pubsub || @mutex.synchronize { @pubsub ||= config.pubsub_adapter.new(self) }
       end
 
-      # All 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.identifiers
       end

data/lib/action_cable/server/broadcasting.rb

@@ -1,29 +1,29 @@
 module ActionCable
   module Server
-    # Broadcasting is how other parts of your application can send messages to the channel subscribers. As explained in Channel, most of the time, these
+    # 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}"
-    #      end
-    #    end
+    #     def subscribed
+    #       stream_from "web_notifications_#{current_user.id}"
+    #     end
+    #   end
     #
-    #    # Somewhere in your app this is called, perhaps from a NewCommentJob
-    #    ActionCable.server.broadcast \
-    #      "web_notifications_1", { title: 'New things!', body: 'All shit 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 coffescript, 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>. It'll automatically be JSON encoded.
+      # Broadcast a hash directly to a named <tt>broadcasting</tt>. This will later be JSON encoded.
       def broadcast(broadcasting, message)
         broadcaster_for(broadcasting).broadcast(message)
       end
 
-      # Returns a broadcaster for a named <tt>broadcasting</tt> that can be reused. Useful when you have a object that
+      # 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.
       def broadcaster_for(broadcasting)
         Broadcaster.new(self, broadcasting)

data/lib/action_cable/server/configuration.rb

@@ -1,31 +1,24 @@
 module ActionCable
   module Server
-    # An instance of this configuration object is available via ActionCable.server.config, which allows you to tweak the configuration points
+    # An instance of this configuration object is available via ActionCable.server.config, which allows you to tweak Action Cable configuration
     # in a Rails config initializer.
     class Configuration
       attr_accessor :logger, :log_tags
       attr_accessor :connection_class, :worker_pool_size
-      attr_accessor :channel_load_paths
       attr_accessor :disable_request_forgery_protection, :allowed_request_origins
       attr_accessor :cable, :url
 
+      attr_accessor :channel_paths # :nodoc:
+
       def initialize
         @log_tags = []
 
-        @connection_class  = ApplicationCable::Connection
-        @worker_pool_size  = 100
-
-        @channel_load_paths = [Rails.root.join('app/channels')]
+        @connection_class = ActionCable::Connection::Base
+        @worker_pool_size = 100
 
         @disable_request_forgery_protection = false
       end
 
-      def channel_paths
-        @channel_paths ||= channel_load_paths.flat_map do |path|
-          Dir["#{path}/**/*_channel.rb"]
-        end
-      end
-
       def channel_class_names
         @channel_class_names ||= channel_paths.collect do |channel_path|
           Pathname.new(channel_path).basename.to_s.split('.').first.camelize

data/lib/action_cable/server/connections.rb

@@ -1,9 +1,8 @@
 module ActionCable
   module Server
-    # Collection class for all the connections that's been established on this specific server. Remember, usually you'll run many cable servers, so
-    # you can't use this collection as an full list of all the connections established against your application. Use RemoteConnections for that.
-    # As such, this is primarily for internal use.
-    module Connections
+    # Collection class for all the connections that have been established on this specific server. Remember, usually you'll run many Action Cable servers, so
+    # you can't use this collection as a full list of all of the connections established against your application. Instead, use RemoteConnections for that.
+    module Connections # :nodoc:
       BEAT_INTERVAL = 3
 
       def connections
@@ -19,7 +18,7 @@ module ActionCable
       end
 
       # WebSocket connection implementations differ on when they'll mark a connection as stale. We basically never want a connection to go stale, as you
-      # then can't rely on being able to receive and send to it. So there's a 3 second heartbeat running on all connections. If the beat fails, we automatically
+      # then can't rely on being able to communicate with the connection. To solve this, a 3 second heartbeat runs on all connections. If the beat fails, we automatically
       # disconnect.
       def setup_heartbeat_timer
         @heartbeat_timer ||= Concurrent::TimerTask.new(execution_interval: BEAT_INTERVAL) do

data/lib/action_cable/server/worker.rb

@@ -4,8 +4,8 @@ require 'concurrent'
 
 module ActionCable
   module Server
-    # Worker used by Server.send_async to do connection work in threads. Only for internal use.
-    class Worker
+    # Worker used by Server.send_async to do connection work in threads.
+    class Worker # :nodoc:
       include ActiveSupport::Callbacks
 
       thread_mattr_accessor :connection

data/lib/action_cable/server/worker/active_record_connection_management.rb

@@ -1,7 +1,7 @@
 module ActionCable
   module Server
     class Worker
-      # Clear active connections between units of work so the long-running channel or connection processes do not hoard connections.
+      # Clear active connections between units of work so that way long-running channels or connection processes do not hoard connections.
       module ActiveRecordConnectionManagement
         extend ActiveSupport::Concern
 
@@ -19,4 +19,4 @@ module ActionCable
       end
     end
   end
-end
+end

data/lib/action_cable/subscription_adapter/evented_redis.rb

@@ -13,6 +13,14 @@ module ActionCable
     class EventedRedis < Base # :nodoc:
       @@mutex = Mutex.new
 
+      # Overwrite this factory method for EventMachine Redis connections if you want to use a different Redis connection library than EM::Hiredis.
+      # This is needed, for example, when using Makara proxies for distributed Redis.
+      cattr_accessor(:em_redis_connector) { ->(config) { EM::Hiredis.connect(config[:url]) } }
+
+      # Overwrite this factory method for Redis connections if you want to use a different Redis connection library than Redis.
+      # This is needed, for example, when using Makara proxies for distributed Redis.
+      cattr_accessor(:redis_connector) { ->(config) { ::Redis.new(url: config[:url]) } }
+
       def initialize(*)
         super
         @redis_connection_for_broadcasts = @redis_connection_for_subscriptions = nil
@@ -41,7 +49,7 @@ module ActionCable
         def redis_connection_for_subscriptions
           ensure_reactor_running
           @redis_connection_for_subscriptions || @server.mutex.synchronize do
-            @redis_connection_for_subscriptions ||= EM::Hiredis.connect(@server.config.cable[:url]).tap do |redis|
+            @redis_connection_for_subscriptions ||= self.class.em_redis_connector.call(@server.config.cable).tap do |redis|
               redis.on(:reconnect_failed) do
                 @logger.info "[ActionCable] Redis reconnect failed."
               end
@@ -51,7 +59,7 @@ module ActionCable
 
         def redis_connection_for_broadcasts
           @redis_connection_for_broadcasts || @server.mutex.synchronize do
-            @redis_connection_for_broadcasts ||= ::Redis.new(@server.config.cable)
+            @redis_connection_for_broadcasts ||= self.class.redis_connector.call(@server.config.cable)
           end
         end
 

data/lib/action_cable/subscription_adapter/redis.rb

@@ -6,6 +6,10 @@ require 'redis'
 module ActionCable
   module SubscriptionAdapter
     class Redis < Base # :nodoc:
+      # Overwrite this factory method for redis connections if you want to use a different Redis library than Redis.
+      # This is needed, for example, when using Makara proxies for distributed Redis.
+      cattr_accessor(:redis_connector) { ->(config) { ::Redis.new(url: config[:url]) } }
+
       def initialize(*)
         super
         @listener = nil
@@ -39,7 +43,7 @@ module ActionCable
 
         def redis_connection_for_broadcasts
           @redis_connection_for_broadcasts || @server.mutex.synchronize do
-            @redis_connection_for_broadcasts ||= ::Redis.new(@server.config.cable)
+            @redis_connection_for_broadcasts ||= self.class.redis_connector.call(@server.config.cable)
           end
         end
 

data/lib/assets/compiled/action_cable.js

@@ -1,4 +1,6 @@
 (function() {
+  var slice = [].slice;
+
   this.ActionCable = {
     INTERNAL: {
       "identifiers": {
@@ -31,6 +33,20 @@
       } else {
         return url;
       }
+    },
+    startDebugging: function() {
+      return this.debugging = true;
+    },
+    stopDebugging: function() {
+      return this.debugging = null;
+    },
+    log: function() {
+      var messages;
+      messages = 1 <= arguments.length ? slice.call(arguments, 0) : [];
+      if (this.debugging) {
+        messages.push(Date.now());
+        return console.log.apply(console, ["[ActionCable]"].concat(slice.call(messages)));
+      }
     }
   };
 
@@ -62,9 +78,14 @@
     };
 
     Connection.prototype.open = function() {
-      if (this.webSocket && !this.isState("closed")) {
+      if (this.isAlive()) {
+        ActionCable.log("Attemped to open WebSocket, but existing socket is " + (this.getState()));
         throw new Error("Existing connection must be closed before opening");
       } else {
+        ActionCable.log("Opening WebSocket, current state is " + (this.getState()));
+        if (this.webSocket != null) {
+          this.uninstallEventHandlers();
+        }
         this.webSocket = new WebSocket(this.consumer.url);
         this.installEventHandlers();
         return true;
@@ -77,14 +98,20 @@
     };
 
     Connection.prototype.reopen = function() {
-      if (this.isState("closed")) {
-        return this.open();
-      } else {
+      var error, error1;
+      ActionCable.log("Reopening WebSocket, current state is " + (this.getState()));
+      if (this.isAlive()) {
         try {
           return this.close();
+        } catch (error1) {
+          error = error1;
+          return ActionCable.log("Failed to reopen WebSocket", error);
         } finally {
+          ActionCable.log("Reopening WebSocket in " + this.constructor.reopenDelay + "ms");
           setTimeout(this.open, this.constructor.reopenDelay);
         }
+      } else {
+        return this.open();
       }
     };
 
@@ -92,6 +119,10 @@
       return this.isState("open");
     };
 
+    Connection.prototype.isAlive = function() {
+      return (this.webSocket != null) && !this.isState("closing", "closed");
+    };
+
     Connection.prototype.isState = function() {
       var ref, states;
       states = 1 <= arguments.length ? slice.call(arguments, 0) : [];
@@ -117,6 +148,13 @@
       }
     };
 
+    Connection.prototype.uninstallEventHandlers = function() {
+      var eventName;
+      for (eventName in this.events) {
+        this.webSocket["on" + eventName] = function() {};
+      }
+    };
+
     Connection.prototype.events = {
       message: function(event) {
         var identifier, message, ref, type;
@@ -131,13 +169,16 @@
         }
       },
       open: function() {
+        ActionCable.log("WebSocket onopen event");
         this.disconnected = false;
         return this.consumer.subscriptions.reload();
       },
       close: function() {
+        ActionCable.log("WebSocket onclose event");
         return this.disconnect();
       },
       error: function() {
+        ActionCable.log("WebSocket onerror event");
         return this.disconnect();
       }
     };
@@ -180,7 +221,8 @@
     ConnectionMonitor.prototype.connected = function() {
       this.reset();
       this.pingedAt = now();
-      return delete this.disconnectedAt;
+      delete this.disconnectedAt;
+      return ActionCable.log("ConnectionMonitor connected");
     };
 
     ConnectionMonitor.prototype.disconnected = function() {
@@ -200,12 +242,14 @@
       delete this.stoppedAt;
       this.startedAt = now();
       this.poll();
-      return document.addEventListener("visibilitychange", this.visibilityDidChange);
+      document.addEventListener("visibilitychange", this.visibilityDidChange);
+      return ActionCable.log("ConnectionMonitor started, pollInterval is " + (this.getInterval()) + "ms");
     };
 
     ConnectionMonitor.prototype.stop = function() {
       this.stoppedAt = now();
-      return document.removeEventListener("visibilitychange", this.visibilityDidChange);
+      document.removeEventListener("visibilitychange", this.visibilityDidChange);
+      return ActionCable.log("ConnectionMonitor stopped");
     };
 
     ConnectionMonitor.prototype.poll = function() {
@@ -228,8 +272,12 @@
 
     ConnectionMonitor.prototype.reconnectIfStale = function() {
       if (this.connectionIsStale()) {
+        ActionCable.log("ConnectionMonitor detected stale connection, reconnectAttempts = " + this.reconnectAttempts);
         this.reconnectAttempts++;
-        if (!this.disconnectedRecently()) {
+        if (this.disconnectedRecently()) {
+          return ActionCable.log("ConnectionMonitor skipping reopen because recently disconnected at " + this.disconnectedAt);
+        } else {
+          ActionCable.log("ConnectionMonitor reopening");
           return this.consumer.connection.reopen();
         }
       }
@@ -249,6 +297,7 @@
         return setTimeout((function(_this) {
           return function() {
             if (_this.connectionIsStale() || !_this.consumer.connection.isOpen()) {
+              ActionCable.log("ConnectionMonitor reopening stale connection after visibilitychange to " + document.visibilityState);
               return _this.consumer.connection.reopen();
             }
           };

data/lib/rails/generators/channel/channel_generator.rb

@@ -15,12 +15,29 @@ module Rails
         if options[:assets]
           template "assets/channel.coffee", File.join('app/assets/javascripts/channels', class_path, "#{file_name}.coffee")
         end
+
+        generate_application_cable_files
       end
 
       protected
         def file_name
           @_file_name ||= super.gsub(/\_channel/i, '')
         end
+
+        # FIXME: Change these files to symlinks once RubyGems 2.5.0 is required.
+        def generate_application_cable_files
+          return if self.behavior != :invoke
+
+          files = [
+            'application_cable/channel.rb',
+            'application_cable/connection.rb'
+          ]
+
+          files.each do |name|
+            path = File.join('app/channels/', name)
+            template(name, path) if !File.exist?(path)
+          end
+        end
     end
   end
 end

data/lib/rails/generators/channel/templates/application_cable/channel.rb

@@ -0,0 +1,5 @@
+# Be sure to restart your server when you modify this file. Action Cable runs in a loop that does not support auto reloading.
+module ApplicationCable
+  class Channel < ActionCable::Channel::Base
+  end
+end

data/lib/rails/generators/channel/templates/application_cable/connection.rb

@@ -0,0 +1,5 @@
+# Be sure to restart your server when you modify this file. Action Cable runs in a loop that does not support auto reloading.
+module ApplicationCable
+  class Connection < ActionCable::Connection::Base
+  end
+end

data/lib/rails/generators/channel/templates/channel.rb

@@ -1,4 +1,4 @@
-# Be sure to restart your server when you modify this file. Action Cable runs in an EventMachine loop that does not support auto reloading.
+# Be sure to restart your server when you modify this file. Action Cable runs in a loop that does not support auto reloading.
 <% module_namespacing do -%>
 class <%= class_name %>Channel < ApplicationCable::Channel
   def subscribed

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: actioncable
 version: !ruby/object:Gem::Version
-  version: 5.0.0.beta2
+  version: 5.0.0.beta3
 platform: ruby
 authors:
 - Pratik Naik
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-02-01 00:00:00.000000000 Z
+date: 2016-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: actionpack
@@ -17,14 +17,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.0.0.beta2
+        version: 5.0.0.beta3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 5.0.0.beta2
+        version: 5.0.0.beta3
 - !ruby/object:Gem::Dependency
   name: nio4r
   requirement: !ruby/object:Gem::Requirement
@@ -108,6 +108,8 @@ files:
 - lib/assets/compiled/action_cable.js
 - lib/rails/generators/channel/USAGE
 - lib/rails/generators/channel/channel_generator.rb
+- lib/rails/generators/channel/templates/application_cable/channel.rb
+- lib/rails/generators/channel/templates/application_cable/connection.rb
 - lib/rails/generators/channel/templates/assets/channel.coffee
 - lib/rails/generators/channel/templates/channel.rb
 homepage: http://rubyonrails.org
@@ -130,9 +132,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: WebSocket framework for Rails.
 test_files: []
-has_rdoc: