action-cable

What this skill does

# Action Cable

Comprehensive guide to real-time WebSocket communication in Rails.

## Server Setup

### Connection

```ruby
# app/channels/application_cable/connection.rb
module ApplicationCable
  class Connection < ActionCable::Connection::Base
    identified_by :current_user

    def connect
      self.current_user = find_verified_user
    end

    private

    def find_verified_user
      if verified_user = User.find_by(id: cookies.encrypted[:user_id])
        verified_user
      else
        reject_unauthorized_connection
      end
    end
  end
end
```

### Channel Generator

```bash
rails generate channel Chat speak
```

Creates:
- `app/channels/chat_channel.rb`
- `app/javascript/channels/chat_channel.js`

## Channels

### Basic Channel

```ruby
# app/channels/chat_channel.rb
class ChatChannel < ApplicationCable::Channel
  def subscribed
    stream_from "chat_#{params[:room_id]}"
  end

  def unsubscribed
    # Cleanup when channel is unsubscribed
  end

  def speak(data)
    Message.create!(
      content: data["message"],
      user: current_user,
      room_id: params[:room_id]
    )
  end
end
```

### Stream Methods

```ruby
class NotificationsChannel < ApplicationCable::Channel
  def subscribed
    # Stream from string identifier
    stream_from "notifications_#{current_user.id}"

    # Stream for model (uses GlobalID)
    stream_for current_user
  end
end

# Broadcasting to stream_for
NotificationsChannel.broadcast_to(user, { type: "alert", message: "Hello!" })
```

### Rejecting Subscriptions

```ruby
class ChatChannel < ApplicationCable::Channel
  def subscribed
    room = Room.find(params[:room_id])

    if room.accessible_by?(current_user)
      stream_for room
    else
      reject
    end
  end
end
```

## Broadcasting

### From Models

```ruby
class Message < ApplicationRecord
  belongs_to :room
  belongs_to :user

  after_create_commit :broadcast_message

  private

  def broadcast_message
    ActionCable.server.broadcast(
      "chat_#{room_id}",
      { message: content, user: user.name, created_at: created_at }
    )
  end
end
```

### From Controllers

```ruby
class MessagesController < ApplicationController
  def create
    @message = current_user.messages.create!(message_params)

    ActionCable.server.broadcast(
      "chat_#{@message.room_id}",
      render_message(@message)
    )

    head :ok
  end

  private

  def render_message(message)
    ApplicationController.renderer.render(
      partial: "messages/message",
      locals: { message: message }
    )
  end
end
```

### From Jobs

```ruby
class BroadcastMessageJob < ApplicationJob
  queue_as :default

  def perform(message)
    ActionCable.server.broadcast(
      "chat_#{message.room_id}",
      message: render_message(message)
    )
  end

  private

  def render_message(message)
    MessagesController.render(
      partial: "messages/message",
      locals: { message: message }
    )
  end
end
```

### With Turbo Streams

```ruby
class Message < ApplicationRecord
  belongs_to :room
  after_create_commit { broadcast_append_to room }
  after_update_commit { broadcast_replace_to room }
  after_destroy_commit { broadcast_remove_to room }
end
```

## Client-Side (JavaScript)

### Subscription

```javascript
// app/javascript/channels/chat_channel.js
import consumer from "./consumer"

consumer.subscriptions.create(
  { channel: "ChatChannel", room_id: roomId },
  {
    connected() {
      console.log("Connected to chat")
    },

    disconnected() {
      console.log("Disconnected from chat")
    },

    received(data) {
      // Called when data is broadcast
      const messagesContainer = document.getElementById("messages")
      messagesContainer.insertAdjacentHTML("beforeend", data.message)
    },

    speak(message) {
      this.perform("speak", { message: message })
    }
  }
)
```

### Consumer Setup

```javascript
// app/javascript/channels/consumer.js
import { createConsumer } from "@rails/actioncable"

export default createConsumer()

// With custom URL
export default createConsumer("/cable")

// With authentication token
export default createConsumer(`/cable?token=${getToken()}`)
```

### Dynamic Subscriptions

```javascript
// Subscribe dynamically
const subscription = consumer.subscriptions.create(
  { channel: "ChatChannel", room_id: 123 },
  {
    received(data) {
      console.log(data)
    }
  }
)

// Unsubscribe
subscription.unsubscribe()

// Perform action
subscription.perform("speak", { message: "Hello" })
```

## Configuration

### Cable Configuration

```yaml
# config/cable.yml
development:
  adapter: async

test:
  adapter: test

production:
  adapter: redis
  url: <%= ENV.fetch("REDIS_URL") { "redis://localhost:6379/1" } %>
  channel_prefix: myapp_production
```

### Routes

```ruby
# config/routes.rb
Rails.application.routes.draw do
  mount ActionCable.server => "/cable"
end
```

### Allowed Origins

```ruby
# config/environments/production.rb
config.action_cable.allowed_request_origins = [
  "https://example.com",
  /https:\/\/.*\.example\.com/
]

# Or allow all (not recommended for production)
config.action_cable.disable_request_forgery_protection = true
```

### Redis Adapter

```ruby
# Gemfile
gem "redis"

# config/cable.yml
production:
  adapter: redis
  url: <%= ENV["REDIS_URL"] %>
  channel_prefix: myapp_production
```

## Common Patterns

### Presence Tracking

```ruby
class AppearanceChannel < ApplicationCable::Channel
  def subscribed
    stream_from "appearance_channel"
    current_user.appear
  end

  def unsubscribed
    current_user.disappear
  end

  def appear(data)
    current_user.appear(on: data["appearing_on"])
  end

  def away
    current_user.away
  end
end
```

### Typing Indicators

```ruby
class TypingChannel < ApplicationCable::Channel
  def subscribed
    stream_from "typing_#{params[:room_id]}"
  end

  def typing
    ActionCable.server.broadcast(
      "typing_#{params[:room_id]}",
      { user_id: current_user.id, name: current_user.name }
    )
  end

  def stopped_typing
    ActionCable.server.broadcast(
      "typing_#{params[:room_id]}",
      { user_id: current_user.id, stopped: true }
    )
  end
end
```

### Room-Based Chat

```ruby
class RoomChannel < ApplicationCable::Channel
  def subscribed
    @room = Room.find(params[:room_id])
    stream_for @room

    # Notify others user joined
    broadcast_user_joined
  end

  def unsubscribed
    broadcast_user_left if @room
  end

  def speak(data)
    message = @room.messages.create!(
      user: current_user,
      content: data["message"]
    )

    RoomChannel.broadcast_to(@room, {
      type: "message",
      message: render_message(message)
    })
  end

  private

  def broadcast_user_joined
    RoomChannel.broadcast_to(@room, {
      type: "user_joined",
      user: { id: current_user.id, name: current_user.name }
    })
  end

  def broadcast_user_left
    RoomChannel.broadcast_to(@room, {
      type: "user_left",
      user: { id: current_user.id }
    })
  end

  def render_message(message)
    ApplicationController.renderer.render(
      partial: "messages/message",
      locals: { message: message }
    )
  end
end
```

## Testing

### Channel Tests

```ruby
# test/channels/chat_channel_test.rb
require "test_helper"

class ChatChannelTest < ActionCable::Channel::TestCase
  test "subscribes to room stream" do
    subscribe room_id: 1

    assert subscription.confirmed?
    assert_has_stream "chat_1"
  end

  test "rejects without room_id" do
    subscribe

    assert subscription.rejected?
  end
end
```

### Connection Tests

```ruby
# test/channels/application_cable/connection_test.rb
require "test_helper"

class ApplicationCable::ConnectionTest < ActionCable::Connection::TestCase
  test "connects with valid user" do
    user = users(:one)
    cookies.encrypted[:user_id] = user.id

    connect

    assert_equal user, connection.current_user
  end

  test "rejects connection without user" do
    assert_reject_connection { connect }
  end
end
```