anycable-rails-core 1.5.3 → 1.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ae33f5aaf1057a1aa63e16280048477ed7f6be5ff403e7a45bd4198aed3ef226
-  data.tar.gz: dfedd48dbeddaf2e722093bec52f459c576c59a3c549e26afe00753ee770496b
+  metadata.gz: ae5f5e00ae334a317de5b59685ff57de668c2f102125f48bc8309a7330787950
+  data.tar.gz: f15f057412a3c0a0dbf759bd8c8d47abee1bee60a9b68ca62983ced577ea9397
 SHA512:
-  metadata.gz: 3e84c51f6fb7b2c7e7a1b1535b2f99b4db0d83ee3235b45104aad07e353924bf2ce91269b4dbb9b992f356a622594f3c2e44941edf60b47be899196ee8adfd83
-  data.tar.gz: 6b9b15397056c29d3cbf01b566ea4282e41dc2065f8af827bb73f102c47e78d429aecbfd11d687660eb4c820225fa3411d9bd7bd4fb39a75155568a0e4e24e05
+  metadata.gz: 8b780c7ca124e8f84d708e94ec78a27b50e9b36cbf524264cea3582bb171b037e40f4f92d8292f115810b988dfe93d45a942c779550943484bfad9810c1865f3
+  data.tar.gz: 916571c822234a92ec9bbb1839c06c8a0cc9a6f434c370c0b9bccd6486a450c2dc2ec88e27069d3b14bff093e245d0a83e6aed71fc7bcd1f20b298ae479edde7

data/CHANGELOG.md

@@ -1,6 +1,36 @@
 # Change log
 
-## master
+## main
+
+## 1.6.2 (2026-04-02)
+
+- Upgrade setup generator. ([@palkan][])
+
+## 1.6.1 (2025-12-18)
+
+- Ensure `bin/dist/anycable-go` has execution permission as part of `bin/anycable-go` ([@dmorgan-fa][])
+
+## 1.6.0 (2025-03-18)
+
+- Update `anycable:download` generator to support v1.6+. ([@palkan][])
+
+- Add `#anycable_token_meta_tag` helper. ([@palkan][])
+
+  It generates a meta tag with the AnyCable JWT token (w/o the URL).
+
+- Add Presence API. ([@palkan][])
+
+## 1.5.5 (2024-12-12)
+
+- Publish RuboCop cops as a separate gem (`rubocop-anycable-rails`). ([@palkan][])
+
+- Upgrade RuboCop cops. ([@palkan][])
+
+## 1.5.4 (2024-10-08)
+
+- Add [actioncable-next](https://github.com/anycable/actioncable-next) support. ([@palkan][])
+
+- Generate `anycable.toml` in `anycable:setup` generator. ([@palkan][])
 
 ## 1.5.3 (2024-09-12)
 

data/README.md

@@ -1,97 +1,32 @@
-[![Gem Version](https://badge.fury.io/rb/anycable-rails.svg)](https://rubygems.org/gems/anycable-rails)
+[![Gem Version](https://badge.fury.io/rb/anycable.svg)](https://rubygems.org/gems/anycable)
 [![Build](https://github.com/anycable/anycable-rails/workflows/Build/badge.svg)](https://github.com/anycable/anycable-rails/actions)
 [![Documentation](https://img.shields.io/badge/docs-link-brightgreen.svg)](https://docs.anycable.io/rails/getting_started)
 
-# AnyCable Rails
+# AnyCable SDK for Ruby on Rails
 
-AnyCable allows you to use any WebSocket server (written in any language) as a replacement for built-in Rails Action Cable server.
+<img align="right" height="150" width="129"
+     title="AnyCable logo" src="https://docs.anycable.io/assets/images/logo.svg">
 
-With AnyCable you can use channels, client-side JS, broadcasting - (almost) all that you can do with Action Cable.
+[AnyCable](https://github.com/anycable/anycable) is an open-source language-agnostic realtime server for reliable two-way communication over WebSockets and SSE.
+This repository contains code for AnyCable Rails SKD that allows you to use AnyCable as a drop-in replacement for Action Cable.
 
-You can even use Action Cable in development and not be afraid of [compatibility issues](#compatibility).
+🌐 [Website](https://anycable.io) · 📚 [Documentation](https://docs.anycable.io/rails/getting_started) · 💾 [Example Rails Application](https://github.com/anycable/anycable_rails_demo)
 
-💾 [Example Application](https://github.com/anycable/anycable_rails_demo)
-
-📑 [Documentation](https://docs.anycable.io/rails/getting_started).
-
-> [AnyCable Pro](https://docs.anycable.io/pro) has been launched 🚀
-
-<a href="https://evilmartians.com/">
-<img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54"></a>
-
-## Requirements
-
-- Ruby >= 2.6
-- Rails >= 6.0 (Rails 5.1 could work but we're no longer enforce compatibility on CI)
-- Redis (see [other options](https://github.com/anycable/anycable/issues/2) for broadcasting)
-
-## Usage
+## Quick Start
 
 Add `anycable-rails` gem to your Gemfile:
 
 ```ruby
 gem "anycable-rails"
-
-# when using Redis broadcast adapter
-gem "redis", ">= 4.0"
 ```
 
-### Interactive set up
-
-After the gem was installed, you can run an interactive wizard to configure your Rails application for using with AnyCable by running a generator:
+Then run our interactive setup command:
 
 ```sh
 bundle exec rails g anycable:setup
 ```
 
-### Manual set up
-
-Specify AnyCable subscription adapter for Action Cable:
-
-```yml
-# config/cable.yml
-development:
-  adapter: any_cable # or anycable
-
-production:
-  adapter: any_cable
-```
-
-and specify AnyCable WebSocket server URL:
-
-```ruby
-# For development it's likely the localhost
-
-# config/environments/development.rb
-config.action_cable.url = "ws://localhost:8080/cable"
-
-# For production it's likely to have a sub-domain and secure connection
-
-# config/environments/production.rb
-config.action_cable.url = "wss://ws.example.com/cable"
-```
-
-Then, run AnyCable RPC server:
-
-```sh
-$ bundle exec anycable
-
-# don't forget to provide Rails env
-
-$ RAILS_ENV=production bundle exec anycable
-```
-
-And, finally, run AnyCable WebSocket server, e.g. [anycable-go](https://docs.anycable.io/anycable-go/getting_started):
-
-```sh
-anycable-go --host=localhost --port=8080
-```
-
-See [documentation](https://docs.anycable.io/rails/getting_started) for more information on AnyCable + Rails usage.
-
-## Action Cable Compatibility
-
-See [documentation](https://docs.anycable.io/rails/compatibility).
+Learn more [here](https://docs.anycable.io/rails/getting_started).
 
 ## Contributing
 

data/lib/anycable/rails/action_cable_ext/channel.rb

@@ -3,17 +3,6 @@
 require "action_cable"
 
 ActionCable::Channel::Base.prepend(Module.new do
-  def subscribe_to_channel
-    super unless anycabled? && !@__anycable_subscribing__
-  end
-
-  def handle_subscribe
-    @__anycable_subscribing__ = true
-    subscribe_to_channel
-  ensure
-    @__anycable_subscribing__ = false
-  end
-
   def start_periodic_timers
     super unless anycabled?
   end
@@ -57,3 +46,23 @@ ActionCable::Channel::Base.prepend(Module.new do
     connection.instance_variable_defined?(:@anycable_socket)
   end
 end)
+
+# Handle $pubsub channel in Subscriptions
+ActionCable::Connection::Subscriptions.prepend(Module.new do
+  # The contents are mostly copied from the original,
+  # there is no good way to configure channels mapping due to #safe_constantize
+  # and the layers of JSON
+  # https://github.com/rails/rails/blob/main/actioncable/lib/action_cable/connection/subscriptions.rb
+  def add(data)
+    id_key = data["identifier"]
+    id_options = ActiveSupport::JSON.decode(id_key).with_indifferent_access
+
+    return if subscriptions.key?(id_key)
+
+    return super unless id_options[:channel] == "$pubsub"
+
+    subscription = AnyCable::Rails::PubSubChannel.new(connection, id_key, id_options)
+    subscriptions[id_key] = subscription
+    subscription.subscribe_to_channel
+  end
+end)

data/lib/anycable/rails/action_cable_ext/remote_connections.rb

@@ -3,20 +3,10 @@
 require "action_cable/remote_connections"
 
 ActionCable::RemoteConnections::RemoteConnection.include(AnyCable::Rails::Connections::SerializableIdentification)
-
 ActionCable::RemoteConnections::RemoteConnection.prepend(Module.new do
-  # Rails <7.1 has no `reconnect` argument
-  if ActionCable::RemoteConnections::RemoteConnection.instance_method(:disconnect).arity == 0
-    def disconnect(reconnect: true)
-      # Legacy Action Cable functionality if case we're not fully migrated yet
-      super() unless AnyCable::Rails.enabled?
-      ::AnyCable.broadcast_adapter.broadcast_command("disconnect", identifier: identifiers_json, reconnect: reconnect)
-    end
-  else
-    def disconnect(reconnect: true)
-      # Legacy Action Cable functionality if case we're not fully migrated yet
-      super unless AnyCable::Rails.enabled?
-      ::AnyCable.broadcast_adapter.broadcast_command("disconnect", identifier: identifiers_json, reconnect: reconnect)
-    end
+  def disconnect(reconnect: true)
+    # Legacy Action Cable functionality if case we're not fully migrated yet
+    return super unless AnyCable::Rails.enabled?
+    ::AnyCable.broadcast_adapter.broadcast_command("disconnect", identifier: identifiers_json, reconnect: reconnect)
   end
 end)

data/lib/anycable/rails/channel/presence.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module Rails
+    module Channel
+      # Presence API for Action Cable channels (backed by AnyCable)
+      module Presence
+        extend ActiveSupport::Concern
+
+        def join_presence(stream = nil, id: user_presence_id, info: user_presence_info)
+          return unless anycabled?
+
+          stream ||= connection.anycable_socket.streams[:start].first || raise(ArgumentError, "Provide a stream name for presence updates")
+
+          connection.anycable_socket.presence_join(stream, id.to_s, info)
+        end
+
+        def leave_presence(id = user_presence_id)
+          return unless anycabled?
+
+          connection.anycable_socket.presence_leave(id)
+        end
+
+        private
+
+        def user_presence_id
+          connection.connection_identifier
+        end
+
+        def user_presence_info
+          # nothing
+        end
+      end
+    end
+  end
+end

data/lib/anycable/rails/channel.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module Rails
+    module Channel
+      autoload :Presence, "anycable/rails/channel/presence"
+    end
+  end
+end

data/lib/anycable/rails/compatibility/rubocop.rb

@@ -1,27 +1,4 @@
 # frozen_string_literal: true
 
-require "rubocop"
-require "pathname"
-
-require_relative "rubocop/cops/anycable/stream_from"
-require_relative "rubocop/cops/anycable/periodical_timers"
-require_relative "rubocop/cops/anycable/instance_vars"
-
-module RuboCop
-  module AnyCable # :nodoc:
-    CONFIG_DEFAULT = Pathname.new(__dir__).join("rubocop", "config", "default.yml").freeze
-
-    # Merge anycable config into default configuration
-    # See https://github.com/backus/rubocop-rspec/blob/master/lib/rubocop/rspec/inject.rb
-    def self.inject!
-      path = CONFIG_DEFAULT.to_s
-      puts "configuration from #{path}" if ConfigLoader.debug?
-      hash = ConfigLoader.send(:load_yaml_configuration, path)
-      config = Config.new(hash, path)
-      config = ConfigLoader.merge_with_default(config, path)
-      ConfigLoader.instance_variable_set(:@default_configuration, config)
-    end
-  end
-end
-
-RuboCop::AnyCable.inject!
+# For backwards compatibility
+require_relative "../rubocop"

data/lib/anycable/rails/compatibility.rb

@@ -8,6 +8,8 @@ module AnyCable
       @active_periodic_timers
       @_streams
       @parameter_filter
+      @whisper_stream
+      @__sid__
     ]
 
     ActionCable::Channel::Base.prepend(Module.new do

data/lib/anycable/rails/config.rb

@@ -9,6 +9,7 @@ require "anyway/rails"
 # - `access_logs_disabled` (defaults to true) — whether to print Started/Finished logs
 # - `persistent_session_enabled` (defaults to false) — whether to store session changes in the connection state
 # - `embedded` (defaults to false) — whether to run RPC server inside a Rails server process
+# - `http_rpc` (default to false) - whether to mount HTTP RPC server or not
 # - `http_rpc_mount_path` (defaults to nil) — path to mount HTTP RPC server
 # - `batch_broadcasts` (defaults to false) — whether to batch broadcasts automatically for code wrapped with Rails executor
 # - `jwt_param` (defaults to 'jid') — the name of the JWT authentication query paramter or header
@@ -18,6 +19,7 @@ AnyCable::Config.attr_config(
   persistent_session_enabled: false,
   embedded: false,
   jwt_param: "jid",
+  http_rpc: false,
   http_rpc_mount_path: nil,
   batch_broadcasts: false,
   socket_id_header: "X-Socket-ID",

data/lib/anycable/rails/connection.rb

@@ -31,15 +31,69 @@ module AnyCable
       end
 
       refine ActionCable::Connection::Subscriptions do
-        # Find or add a subscription to the list
-        def fetch(identifier)
-          add("identifier" => identifier) unless subscriptions[identifier]
+        # Override the original #execute_command to pre-initialize the channel for unsubscribe/message and
+        # return true/false to indicate successful/unsuccessful subscription.
+        # We also must not lose any exceptions raised in the process.
+        def execute_rpc_command(data)
+          # First, verify the channel name
+          raise "Channel not found: #{ActiveSupport::JSON.decode(data["identifier"]).fetch("channel")}" unless subscription_class_from_identifier(data["identifier"])
+
+          if data["command"] == "subscribe"
+            add data
+            subscription = subscriptions[data["identifier"]]
+            return !(subscription.nil? || subscription.rejected?)
+          end
+
+          load(data["identifier"])
+
+          case data["command"]
+          when "unsubscribe"
+            remove data
+          when "message"
+            perform_action data
+          when "whisper"
+            whisper data
+          else
+            raise UnknownCommandError, data["command"]
+          end
 
-          unless subscriptions[identifier]
-            raise "Channel not found: #{ActiveSupport::JSON.decode(identifier).fetch("channel")}"
+          true
+        end
+
+        # Restore channels from the list of identifiers and the state
+        def restore(subscriptions, istate)
+          subscriptions.each do |id|
+            channel = load(id)
+            channel.__istate__ = ActiveSupport::JSON.decode(istate[id]) if istate[id]
           end
+        end
+
+        # Find or create a channel for a given identifier
+        def load(identifier)
+          return subscriptions[identifier] if subscriptions[identifier]
 
-          subscriptions[identifier]
+          subscription = subscription_from_identifier(identifier)
+          raise "Channel not found: #{ActiveSupport::JSON.decode(identifier).fetch("channel")}" unless subscription
+
+          subscriptions[identifier] = subscription
+        end
+
+        def subscription_class_from_identifier(id_key)
+          id_options = ActiveSupport::JSON.decode(id_key).with_indifferent_access
+          if id_options[:channel] == "$pubsub"
+            PubSubChannel
+          else
+            id_options[:channel].safe_constantize
+          end
+        end
+
+        def subscription_from_identifier(id_key)
+          subscription_klass = subscription_class_from_identifier(id_key)
+
+          if subscription_klass && subscription_klass < ActionCable::Channel::Base
+            id_options = ActiveSupport::JSON.decode(id_key).with_indifferent_access
+            subscription_klass.new(connection, id_key, id_options)
+          end
         end
       end
     end)
@@ -74,15 +128,8 @@ module AnyCable
         conn.cached_ids = {}
         conn.anycable_request_builder = self
 
-        return unless subscriptions
-
         # Pre-initialize channels (for disconnect)
-        subscriptions.each do |id|
-          channel = conn.subscriptions.fetch(id)
-          next unless socket.istate[id]
-
-          channel.__istate__ = ActiveSupport::JSON.decode(socket.istate[id])
-        end
+        conn.subscriptions.restore(subscriptions, socket.istate) if subscriptions
       end
 
       def handle_open
@@ -111,26 +158,8 @@ module AnyCable
 
       def handle_channel_command(identifier, command, data)
         conn.run_callbacks :command do
-          # We cannot use subscriptions#execute_command here,
-          # since we MUST return true of false, depending on the status
-          # of execution
-          channel = conn.subscriptions.fetch(identifier)
-          case command
-          when "subscribe"
-            channel.handle_subscribe
-            !channel.rejected?
-          when "unsubscribe"
-            conn.subscriptions.remove_subscription(channel)
-            true
-          when "message"
-            channel.perform_action ActiveSupport::JSON.decode(data)
-            true
-          else
-            false
-          end
+          conn.subscriptions.execute_rpc_command({"command" => command, "identifier" => identifier, "data" => data})
         end
-      # Support rescue_from
-      # https://github.com/rails/rails/commit/d2571e560c62116f60429c933d0c41a0e249b58b
       rescue Exception => e # rubocop:disable Lint/RescueException
         rescue_with_handler(e) || raise
         false

data/lib/anycable/rails/connection_factory.rb

@@ -1,6 +1,25 @@
 # frozen_string_literal: true
 
-require "anycable/rails/connection"
+require "action_cable"
+
+begin
+  ActionCable::Server::Socket
+rescue
+end
+
+if defined?(ActionCable::Server::Socket)
+  require "anycable/rails/next/connection"
+  require "anycable/rails/next/action_cable_ext/connection"
+  require "anycable/rails/next/action_cable_ext/channel"
+else
+  require "anycable/rails/connection"
+
+  require "anycable/rails/action_cable_ext/connection"
+  require "anycable/rails/action_cable_ext/channel"
+end
+
+require "anycable/rails/action_cable_ext/remote_connections"
+require "anycable/rails/action_cable_ext/broadcast_options"
 
 module AnyCable
   module Rails

data/lib/anycable/rails/connections/persistent_session.rb

@@ -2,6 +2,11 @@
 
 require "anycable/rails/connections/session_proxy"
 
+if defined?(ActionCable::Server::Socket)
+  require "anycable/rails/next/connection/persistent_session"
+  return
+end
+
 module AnyCable
   module Rails
     module Connections

data/lib/anycable/rails/connections/serializable_identification.rb

@@ -6,6 +6,20 @@ module AnyCable
       module SerializableIdentification
         extend ActiveSupport::Concern
 
+        module ConnectionGID
+          def connection_identifier
+            unless defined? @connection_identifier
+              @connection_identifier = connection_gid identifiers.filter_map { |id| instance_variable_get(:"@#{id}") || __send__(id) }
+            end
+
+            @connection_identifier
+          end
+        end
+
+        included do
+          prepend ConnectionGID
+        end
+
         class_methods do
           def identified_by(*identifiers)
             super
@@ -32,6 +46,11 @@ module AnyCable
           identifiers_hash.to_json
         end
 
+        def identifiers_json=(val)
+          @cached_ids = {}
+          @serialized_ids = val ? ActiveSupport::JSON.decode(val) : {}
+        end
+
         # Fetch identifier and deserialize if neccessary
         def fetch_identifier(name)
           return unless @cached_ids

data/lib/anycable/rails/connections/session_proxy.rb

@@ -46,9 +46,9 @@ module AnyCable
           rack_session.respond_to?(name, include_private) || super
         end
 
-        def method_missing(method, *args, &block)
+        def method_missing(method, ...)
           if rack_session.respond_to?(method, true)
-            rack_session.send(method, *args, &block)
+            rack_session.send(method, ...)
           else
             super
           end

data/lib/anycable/rails/ext/jwt.rb

@@ -10,7 +10,7 @@ module AnyCable
           super
         rescue AnyCable::JWT::ExpiredSignature
           logger.error "An expired JWT token was rejected"
-          close(reason: "token_expired", reconnect: false) if websocket&.alive?
+          close(reason: "token_expired", reconnect: false)
         end
 
         def anycable_jwt_present?

data/lib/anycable/rails/ext/signed_streams.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "action_cable"
+
+ActionCable::Connection::Base.include(Module.new do
+  # This method is assumed to be overriden in the connection class to enable public
+  # streams
+  def allow_public_streams?
+    false
+  end
+end)
+
+# Handle $pubsub channel in Subscriptions
+ActionCable::Connection::Subscriptions.prepend(Module.new do
+  def subscription_from_identifier(id_key)
+    id_options = ActiveSupport::JSON.decode(id_key).with_indifferent_access
+    return super unless id_options[:channel] == "$pubsub"
+
+    AnyCable::Rails::PubSubChannel.new(connection, id_key, id_options)
+  end
+end)

data/lib/anycable/rails/ext/whisper.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "action_cable"
+
+ActionCable::Channel::Base.prepend(Module.new do
+  attr_accessor :whisper_stream
+
+  def stream_from(broadcasting, _callback = nil, **opts)
+    whispering = opts.delete(:whisper)
+    whispers_to(broadcasting) if whispering
+    super
+  end
+
+  def whispers_to(broadcasting)
+    logger.debug "#{self.class.name} whispers to #{broadcasting}"
+    self.whisper_stream = broadcasting
+  end
+end)
+
+ActionCable::Connection::Subscriptions.prepend(Module.new do
+  def execute_command(data)
+    return whisper(data) if data["command"] == "whisper"
+
+    super
+  end
+
+  def whisper(data)
+    subscription = find(data)
+    stream = subscription.whisper_stream
+    raise "Whispering stream is not set" unless stream
+
+    ::ActionCable.server.broadcast stream, data["data"]
+  end
+end)

data/lib/anycable/rails/ext.rb

@@ -4,7 +4,10 @@ module AnyCable
   module Rails
     module Ext
       autoload :JWT, "anycable/rails/ext/jwt"
-      autoload :SignedStreams, "anycable/rails/ext/signed_streams"
+
+      # These features are included by default
+      require "anycable/rails/ext/signed_streams"
+      require "anycable/rails/ext/whisper"
     end
   end
 end

data/lib/anycable/rails/helper.rb

@@ -22,10 +22,10 @@ module AnyCable
         tag "meta", name: "action-cable-url", content: url
       end
 
-      def any_cable_jwt_meta_tag(**identifiers)
+      def anycable_token_meta_tag(**identifiers)
         token = JWT.encode(identifiers)
 
-        tag "meta", name: "any-cable-jwt", content: token
+        tag "meta", name: "cable-token", content: token
       end
 
       def signed_stream_name(streamables)

data/lib/anycable/rails/next/action_cable_ext/channel.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "action_cable"
+
+ActionCable::Channel::Base.prepend(Module.new do
+  # Whispering support
+  def whispers_to(broadcasting)
+    return super unless anycabled?
+
+    connection.anycable_socket.whisper identifier, broadcasting
+  end
+
+  # Unsubscribing relies on the channel state (which is not persistent in AnyCable).
+  # Thus, we pretend that the stream is registered to make Action Cable do its unsubscribing job.
+  def stop_stream_from(broadcasting)
+    streams[broadcasting] = true if anycabled?
+    super
+  end
+
+  # For AnyCable, unsubscribing from all streams is a separate operation,
+  # so we use a special constant to indicate it.
+  def stop_all_streams
+    if anycabled?
+      streams.clear
+      streams[AnyCable::Rails::Server::PubSub::ALL_STREAMS] = true
+    end
+    super
+  end
+
+  # Make rejected status accessible from outside
+  def rejected? = subscription_rejected?
+
+  private
+
+  def anycabled? = connection.anycabled?
+end)