anycable-rails 0.6.5 → 1.0.0.rc3

data/lib/anycable/rails/actioncable/connection/persistent_session.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ActionCable
+  module Connection
+    module PersistentSession
+      def handle_open
+        super.tap { commit_session! }
+      end
+
+      def handle_channel_command(*)
+        super.tap { commit_session! }
+      end
+
+      def build_rack_request
+        return super unless socket.session
+
+        super.tap do |req|
+          req.env[Rack::RACK_SESSION] =
+            AnyCable::Rails::SessionProxy.new(req.env[Rack::RACK_SESSION], socket.session)
+        end
+      end
+
+      def commit_session!
+        return unless request_loaded? && request.session.respond_to?(:loaded?) && request.session.loaded?
+
+        socket.session = request.session.to_json
+      end
+    end
+  end
+end
+
+::ActionCable::Connection::Base.prepend(
+  ::ActionCable::Connection::PersistentSession
+)

data/lib/anycable/rails/actioncable/connection/serializable_identification.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ActionCable
+  module Connection
+    module SerializableIdentification
+      extend ActiveSupport::Concern
+
+      class_methods do
+        def identified_by(*identifiers)
+          super
+          Array(identifiers).each do |identifier|
+            define_method(identifier) do
+              instance_variable_get(:"@#{identifier}") || fetch_identifier(identifier)
+            end
+          end
+        end
+      end
+
+      # Generate identifiers info.
+      # Converts GlobalID compatible vars to corresponding global IDs params.
+      def identifiers_hash
+        identifiers.each_with_object({}) do |id, acc|
+          obj = instance_variable_get("@#{id}")
+          next unless obj
+
+          acc[id] = AnyCable::Rails.serialize(obj)
+        end.compact
+      end
+
+      def identifiers_json
+        identifiers_hash.to_json
+      end
+
+      # Fetch identifier and deserialize if neccessary
+      def fetch_identifier(name)
+        @cached_ids[name] ||= @cached_ids.fetch(name) do
+          AnyCable::Rails.deserialize(ids[name.to_s])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "action_cable/remote_connections"
+
+ActionCable::RemoteConnections::RemoteConnection.include(ActionCable::Connection::SerializableIdentification)
+
+ActionCable::RemoteConnections::RemoteConnection.prepend(Module.new do
+  def disconnect(reconnect: true)
+    ::AnyCable.broadcast_adapter.broadcast_command("disconnect", identifier: identifiers_json, reconnect: reconnect)
+  end
+end)

data/lib/anycable/rails/actioncable/testing.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# This file contains patches to Action Cable testing modules
+
+# Trigger autoload (if constant is defined)
+begin
+  ActionCable::Channel::TestCase # rubocop:disable Lint/Void
+  ActionCable::Connection::TestCase # rubocop:disable Lint/Void
+rescue NameError
+  return
+end
+
+ActionCable::Channel::ChannelStub.prepend(Module.new do
+  def subscribe_to_channel
+    # allocate @streams
+    streams
+    handle_subscribe
+  end
+end)
+
+ActionCable::Channel::ConnectionStub.prepend(Module.new do
+  def socket
+    @socket ||= AnyCable::Socket.new(env: {})
+  end
+
+  alias_method :anycable_socket, :socket
+end)
+
+ActionCable::Connection::TestConnection.prepend(Module.new do
+  def initialize(request)
+    @request = request
+    @cached_ids = {}
+    super
+  end
+end)

data/lib/anycable/rails/channel_state.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module Rails
+    module ChannelState
+      module ClassMethods
+        def state_attr_accessor(*names)
+          names.each do |name|
+            channel_state_attributes << name
+            class_eval <<~RUBY, __FILE__, __LINE__ + 1
+              def #{name}
+                return @#{name} if instance_variable_defined?(:@#{name})
+                @#{name} = AnyCable::Rails.deserialize(connection.socket.istate["#{name}"], json: true) if connection.anycable_socket
+              end
+
+              def #{name}=(val)
+                connection.socket.istate["#{name}"] = AnyCable::Rails.serialize(val, json: true) if connection.anycable_socket
+                instance_variable_set(:@#{name}, val)
+              end
+            RUBY
+          end
+        end
+
+        def channel_state_attributes
+          return @channel_state_attributes if instance_variable_defined?(:@channel_state_attributes)
+
+          @channel_state_attributes =
+            if superclass.respond_to?(:channel_state_attributes)
+              superclass.channel_state_attributes.dup
+            else
+              []
+            end
+        end
+      end
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+    end
+  end
+end
+
+ActiveSupport.on_load(:action_cable) do
+  # `state_attr_accessor` must be available in Action Cable
+  ::ActionCable::Channel::Base.include(AnyCable::Rails::ChannelState)
+end

data/lib/anycable/rails/compatibility.rb

@@ -12,7 +12,7 @@ module AnyCable
 
         if callback.present? || block_given?
           raise AnyCable::CompatibilityError,
-                "Custom stream callbacks are not supported by AnyCable"
+            "Custom stream callbacks are not supported by AnyCable"
         end
 
         super
@@ -33,10 +33,14 @@ module AnyCable
         res = yield
         diff = instance_variables - was_ivars
 
+        if self.class.respond_to?(:channel_state_attributes)
+          diff.delete_if { |ivar| self.class.channel_state_attributes.include?(:"#{ivar.to_s.sub(/^@/, "")}") }
+        end
+
         unless diff.empty?
           raise AnyCable::CompatibilityError,
-                "Channel instance variables are not supported by AnyCable, " \
-                "but were set: #{diff.join(', ')}"
+            "Channel instance variables are not supported by AnyCable, " \
+            "but were set: #{diff.join(", ")}"
         end
 
         res
@@ -48,12 +52,5 @@ module AnyCable
         raise AnyCable::CompatibilityError, "Periodical timers are not supported by AnyCable"
       end
     end)
-
-    ActionCable::RemoteConnections::RemoteConnection.prepend(Module.new do
-      def disconnect
-        raise AnyCable::CompatibilityError,
-              "Disconnecting remote clients is not supported by AnyCable yet"
-      end
-    end)
   end
 end

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

@@ -4,7 +4,6 @@ require "rubocop"
 require "pathname"
 
 require_relative "rubocop/cops/anycable/stream_from"
-require_relative "rubocop/cops/anycable/remote_disconnect"
 require_relative "rubocop/cops/anycable/periodical_timers"
 require_relative "rubocop/cops/anycable/instance_vars"
 

data/lib/anycable/rails/compatibility/rubocop/config/default.yml

@@ -1,12 +1,14 @@
 AnyCable/InstanceVars:
+  Enabled: true
   Include:
     - "**/channels/**/*.rb"
 
 AnyCable/StreamFrom:
+  Enabled: true
   Include:
     - "**/channels/**/*.rb"
 
 AnyCable/PeriodicalTimers:
+  Enabled: true
   Include:
     - "**/channels/**/*.rb"
-    

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

@@ -25,7 +25,7 @@ module RuboCop
       #   end
       #
       class InstanceVars < RuboCop::Cop::Cop
-        MSG = "Channel instance variables are not supported in AnyCable"
+        MSG = "Channel instance variables are not supported in AnyCable. Use `state_attr_accessor` instead"
 
         def on_class(node)
           find_nested_ivars(node) do |nested_ivar|

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

@@ -11,7 +11,7 @@ module RuboCop
       #   # bad
       #   class MyChannel < ApplicationCable::Channel
       #     def follow
-      #       stream_from("all") {}
+      #       stream_for(room) {}
       #     end
       #   end
       #
@@ -36,15 +36,15 @@ module RuboCop
       #
       class StreamFrom < RuboCop::Cop::Cop
         def_node_matcher :stream_from_with_block?, <<-PATTERN
-          (block (send _ :stream_from ...) ...)
+          (block {(send _ :stream_from ...) (send _ :stream_for ...)} ...)
         PATTERN
 
         def_node_matcher :stream_from_with_callback?, <<-PATTERN
-          (send _ :stream_from str_type? (block (send nil? :lambda) ...))
+          {(send _ :stream_from str_type? (block (send nil? :lambda) ...)) (send _ :stream_for ... (block (send nil? :lambda) ...))}
         PATTERN
 
         def_node_matcher :args_of_stream_from, <<-PATTERN
-          (send _ :stream_from str_type? $...)
+          {(send _ :stream_from str_type? $...)  (send _ :stream_for $...)}
         PATTERN
 
         def_node_matcher :coder_symbol?, "(pair (sym :coder) ...)"

data/lib/anycable/rails/config.rb

@@ -2,7 +2,11 @@
 
 require "anycable/config"
 
-# Extend AnyCable configuration with
-# `access_logs_disabled` options (defaults to true)
-AnyCable::Config.attr_config access_logs_disabled: true
-AnyCable::Config.ignore_options :access_logs_disabled
+# Extend AnyCable configuration with:
+# - `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
+AnyCable::Config.attr_config(
+  access_logs_disabled: true,
+  persistent_session_enabled: false
+)
+AnyCable::Config.ignore_options :access_logs_disabled, :persistent_session_enabled

data/lib/anycable/rails/rack.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require "rails/configuration"
+require "action_dispatch/middleware/stack"
+
+module AnyCable
+  module Rails
+    # Rack middleware stack to modify the HTTP request object.
+    #
+    # AnyCable Websocket server does not use Rack middleware processing mechanism (which Rails uses
+    # when Action Cable is mounted into the main app).
+    #
+    # Some middlewares could enhance request env with useful information.
+    #
+    # For instance, consider the Rails session middleware: it's responsible for restoring the
+    # session data from cookies.
+    #
+    # AnyCable adds session middelware by default to its own stack.
+    #
+    # You can also use any Rack/Rails middleware you want. For example, to enable Devise/Warden
+    # you can add the following code to an initializer or any other configuration file:
+    #
+    #   AnyCable::Rails::Rack.middleware.use Warden::Manager do |config|
+    #     Devise.warden_config = config
+    #   end
+    module Rack
+      def self.app_build_lock
+        @app_build_lock
+      end
+
+      @app_build_lock = Mutex.new
+
+      def self.middleware
+        @middleware ||= ::Rails::Configuration::MiddlewareStackProxy.new
+      end
+
+      def self.default_middleware_stack
+        config = ::Rails.application.config
+
+        ActionDispatch::MiddlewareStack.new do |middleware|
+          middleware.use(config.session_store, config.session_options)
+        end
+      end
+
+      def self.app
+        @rack_app || app_build_lock.synchronize do
+          @rack_app ||= begin
+            stack = default_middleware_stack
+            @middleware = middleware.merge_into(stack)
+            middleware.build { [-1, {}, []] }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/anycable/rails/railtie.rb

@@ -1,23 +1,24 @@
 # frozen_string_literal: true
 
+require "anycable/rails/channel_state"
+
 module AnyCable
   module Rails
     class Railtie < ::Rails::Railtie # :nodoc:
       initializer "anycable.disable_action_cable_mount", after: "action_cable.set_configs" do |app|
-        # Disable Action Cable default route when AnyCable adapter is used
-        adapter = ::ActionCable.server.config.cable&.fetch("adapter", nil)
-        next unless AnyCable::Rails.compatible_adapter?(adapter)
+        next unless AnyCable::Rails.enabled?
 
         app.config.action_cable.mount_path = nil
       end
 
       initializer "anycable.logger", after: "action_cable.logger" do |_app|
-        AnyCable.logger = ActiveSupport::TaggedLogging.new(::ActionCable.server.config.logger)
+        AnyCable.logger = ::ActionCable.server.config.logger
 
-        # Broadcast server logs to STDOUT in development
-        if ::Rails.env.development? &&
-           !ActiveSupport::Logger.logger_outputs_to?(::Rails.logger, STDOUT)
-          AnyCable.configure_server do
+        AnyCable.configure_server do
+          AnyCable.logger = ActiveSupport::TaggedLogging.new(::ActionCable.server.config.logger)
+          # Broadcast server logs to STDOUT in development
+          if ::Rails.env.development? &&
+              !ActiveSupport::Logger.logger_outputs_to?(::Rails.logger, STDOUT)
             console = ActiveSupport::Logger.new(STDOUT)
             console.formatter = ::Rails.logger.formatter
             console.level = ::Rails.logger.level
@@ -42,16 +43,30 @@ module AnyCable
 
       initializer "anycable.connection_factory", after: "action_cable.set_configs" do |app|
         ActiveSupport.on_load(:action_cable) do
-          adapter = ::ActionCable.server.config.cable&.fetch("adapter", nil)
-          if AnyCable::Rails.compatible_adapter?(adapter)
-            require "anycable/rails/actioncable/connection"
+          # Add AnyCable patch method stub (we use it in ChannelState to distinguish between Action Cable and AnyCable)
+          # NOTE: Method could be already defined if patch was loaded manually
+          ActionCable::Connection::Base.attr_reader(:anycable_socket) unless ActionCable::Connection::Base.method_defined?(:anycable_socket)
 
-            app.config.to_prepare do
-              AnyCable.connection_factory = ActionCable.server.config.connection_class.call
+          app.config.to_prepare do
+            AnyCable.connection_factory = ActionCable.server.config.connection_class.call
+          end
+
+          if AnyCable::Rails.enabled?
+            require "anycable/rails/actioncable/connection"
+            if AnyCable.config.persistent_session_enabled
+              require "anycable/rails/actioncable/connection/persistent_session"
             end
           end
         end
       end
+
+      initializer "anycable.testing" do |app|
+        next unless ::Rails.env.test?
+
+        ActiveSupport.on_load(:action_cable) do
+          require "anycable/rails/actioncable/testing"
+        end
+      end
     end
   end
 end

data/lib/anycable/rails/refinements/subscriptions.rb

@@ -9,7 +9,7 @@ module AnyCable
           add("identifier" => identifier) unless subscriptions[identifier]
 
           unless subscriptions[identifier]
-            raise "Channel not found: #{ActiveSupport::JSON.decode(identifier).fetch('channel')}"
+            raise "Channel not found: #{ActiveSupport::JSON.decode(identifier).fetch("channel")}"
           end
 
           subscriptions[identifier]

data/lib/anycable/rails/session_proxy.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module AnyCable
+  module Rails
+    # Wrap `request.session` to lazily load values provided
+    # in the RPC call (set by the previous calls)
+    class SessionProxy
+      attr_reader :rack_session, :socket_session
+
+      def initialize(rack_session, socket_session)
+        @rack_session = rack_session
+        @socket_session = JSON.parse(socket_session).with_indifferent_access
+      end
+
+      %i[has_key? [] []= fetch delete dig].each do |mid|
+        class_eval <<~CODE, __FILE__, __LINE__ + 1
+          def #{mid}(*args, **kwargs, &block)
+            restore_key! args.first
+            rack_session.#{mid}(*args, **kwargs, &block)
+          end
+        CODE
+      end
+
+      alias include? has_key?
+      alias key? has_key?
+
+      %i[update merge! to_hash].each do |mid|
+        class_eval <<~CODE, __FILE__, __LINE__ + 1
+          def #{mid}(*args, **kwargs, &block)
+            restore!
+            rack_session.#{mid}(*args, **kwargs, &block)
+          end
+        CODE
+      end
+
+      alias to_h to_hash
+
+      def keys
+        rack_session.keys + socket_session.keys
+      end
+
+      # Delegate both publuc and private methods to rack_session
+      def respond_to_missing?(name, include_private = false)
+        return false if name == :marshal_dump || name == :_dump
+        rack_session.respond_to?(name, include_private) || super
+      end
+
+      def method_missing(method, *args, &block)
+        if rack_session.respond_to?(method, true)
+          rack_session.send(method, *args, &block)
+        else
+          super
+        end
+      end
+
+      # This method is used by StimulusReflex to obtain `@by`
+      def instance_variable_get(name)
+        super || rack_session.instance_variable_get(name)
+      end
+
+      private
+
+      def restore!
+        socket_session.keys.each(&method(:restore_key!))
+      end
+
+      def restore_key!(key)
+        return unless socket_session.key?(key)
+        val = socket_session.delete(key)
+        rack_session[key] =
+          if val.is_a?(String)
+            GlobalID::Locator.locate(val) || val
+          else
+            val
+          end
+      end
+    end
+  end
+end