anycable-rails 1.0.0.preview2 → 1.0.0

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

@@ -15,16 +15,20 @@ module ActionCable
         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)
+          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.loaded?
+        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

@@ -33,6 +33,10 @@ 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, " \
@@ -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,11 +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/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,23 +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
+          end
 
+          if AnyCable::Rails.enabled?
+            require "anycable/rails/actioncable/connection"
             if AnyCable.config.persistent_session_enabled
               require "anycable/rails/actioncable/connection/persistent_session"
-              ::ActionCable::Connection::Base.prepend(
-                ::ActionCable::Connection::PersistentSession
-              )
-            end
-
-            app.config.to_prepare do
-              AnyCable.connection_factory = ActionCable.server.config.connection_class.call
             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

@@ -7,6 +7,11 @@ module AnyCable
         # Find or add a subscription to the list
         def fetch(identifier)
           add("identifier" => identifier) unless subscriptions[identifier]
+
+          unless subscriptions[identifier]
+            raise "Channel not found: #{ActiveSupport::JSON.decode(identifier).fetch("channel")}"
+          end
+
           subscriptions[identifier]
         end
       end

data/lib/anycable/rails/session_proxy.rb

@@ -5,8 +5,6 @@ module AnyCable
     # Wrap `request.session` to lazily load values provided
     # in the RPC call (set by the previous calls)
     class SessionProxy
-      delegate_missing_to :@rack_session
-
       attr_reader :rack_session, :socket_session
 
       def initialize(rack_session, socket_session)
@@ -41,6 +39,25 @@ module AnyCable
         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!

data/lib/anycable/rails/version.rb

@@ -2,6 +2,6 @@
 
 module AnyCable
   module Rails
-    VERSION = "1.0.0.preview2"
+    VERSION = "1.0.0"
   end
 end

data/lib/generators/anycable/download/USAGE

@@ -0,0 +1,14 @@
+Description:
+    Install AnyCable-Go web server locally (the latest version by default).
+
+Example:
+    rails generate anycable:download
+
+    This will ask:
+        Where to store a binary file.
+    This will create:
+        `<bin_path>/anycable-go`.
+
+    rails generate anycable:download --bin-path=/usr/local/bin
+
+    rails generate anycable:download --version=1.0.0

data/lib/generators/anycable/download/download_generator.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "generators/anycable/with_os_helpers"
+
+module AnyCableRailsGenerators
+  # Downloads anycable-go binary
+  class DownloadGenerator < ::Rails::Generators::Base
+    namespace "anycable:download"
+
+    include WithOSHelpers
+
+    VERSION = "latest"
+
+    class_option :bin_path,
+      type: :string,
+      desc: "Where to download AnyCable-Go server binary (default: #{DEFAULT_BIN_PATH})"
+    class_option :version,
+      type: :string,
+      desc: "Specify the AnyCable-Go version (defaults to latest release)"
+
+    def download_bin
+      out = options[:bin_path] || DEFAULT_BIN_PATH
+      version = options[:version] || VERSION
+
+      download_exe(
+        release_url(version),
+        to: out,
+        file_name: "anycable-go"
+      )
+
+      true
+    end
+
+    private
+
+    def release_url(version)
+      return latest_release_url(version) if version == "latest"
+
+      if Gem::Version.new(version).segments.first >= 1
+        new_release_url("v#{version}")
+      else
+        legacy_release_url("v#{version}")
+      end
+    end
+
+    def legacy_release_url(version)
+      "https://github.com/anycable/anycable-go/releases/download/#{version}/" \
+        "anycable-go-v#{version}-#{os_name}-#{cpu_name}"
+    end
+
+    def new_release_url(version)
+      "https://github.com/anycable/anycable-go/releases/download/#{version}/" \
+        "anycable-go-#{os_name}-#{cpu_name}"
+    end
+
+    def latest_release_url(version)
+      "https://github.com/anycable/anycable-go/releases/latest/download/" \
+        "anycable-go-#{os_name}-#{cpu_name}"
+    end
+
+    def download_exe(url, to:, file_name:)
+      file_path = File.join(to, file_name)
+
+      run "#{sudo(to)}curl -L #{url} -o #{file_path}", abort_on_failure: true
+      run "#{sudo(to)}chmod +x #{file_path}", abort_on_failure: true
+      run "#{file_path} -v", abort_on_failure: true
+    end
+
+    def sudo(path)
+      sudo = ""
+      unless File.writable?(path)
+        if yes? "Path is not writable 😕. Do you have sudo privileges?"
+          sudo = "sudo "
+        else
+          say_status :error, "❌ Failed to install AnyCable-Go WebSocket server", :red
+          raise StandardError, "Path #{path} is not writable!"
+        end
+      end
+
+      sudo
+    end
+  end
+end