actioncable 6.0.0

data/lib/action_cable/connection/tagged_logger_proxy.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ActionCable
+  module Connection
+    # Allows the use of per-connection tags against the server logger. This wouldn't work using the traditional
+    # <tt>ActiveSupport::TaggedLogging</tt> enhanced Rails.logger, as that logger will reset the tags between requests.
+    # The connection is long-lived, so it needs its own set of tags for its independent duration.
+    class TaggedLoggerProxy
+      attr_reader :tags
+
+      def initialize(logger, tags:)
+        @logger = logger
+        @tags = tags.flatten
+      end
+
+      def add_tags(*tags)
+        @tags += tags.flatten
+        @tags = @tags.uniq
+      end
+
+      def tag(logger)
+        if logger.respond_to?(:tagged)
+          current_tags = tags - logger.formatter.current_tags
+          logger.tagged(*current_tags) { yield }
+        else
+          yield
+        end
+      end
+
+      %i( debug info warn error fatal unknown ).each do |severity|
+        define_method(severity) do |message|
+          log severity, message
+        end
+      end
+
+      private
+        def log(type, message) # :doc:
+          tag(@logger) { @logger.send type, message }
+        end
+    end
+  end
+end

data/lib/action_cable/connection/test_case.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+require "active_support"
+require "active_support/test_case"
+require "active_support/core_ext/hash/indifferent_access"
+require "action_dispatch"
+require "action_dispatch/http/headers"
+require "action_dispatch/testing/test_request"
+
+module ActionCable
+  module Connection
+    class NonInferrableConnectionError < ::StandardError
+      def initialize(name)
+        super "Unable to determine the connection to test from #{name}. " +
+          "You'll need to specify it using `tests YourConnection` in your " +
+          "test case definition."
+      end
+    end
+
+    module Assertions
+      # Asserts that the connection is rejected (via +reject_unauthorized_connection+).
+      #
+      #   # Asserts that connection without user_id fails
+      #   assert_reject_connection { connect params: { user_id: '' } }
+      def assert_reject_connection(&block)
+        assert_raises(Authorization::UnauthorizedError, "Expected to reject connection but no rejection was made", &block)
+      end
+    end
+
+    # We don't want to use the whole "encryption stack" for connection
+    # unit-tests, but we want to make sure that users test against the correct types
+    # of cookies (i.e. signed or encrypted or plain)
+    class TestCookieJar < ActiveSupport::HashWithIndifferentAccess
+      def signed
+        self[:signed] ||= {}.with_indifferent_access
+      end
+
+      def encrypted
+        self[:encrypted] ||= {}.with_indifferent_access
+      end
+    end
+
+    class TestRequest < ActionDispatch::TestRequest
+      attr_accessor :session, :cookie_jar
+    end
+
+    module TestConnection
+      attr_reader :logger, :request
+
+      def initialize(request)
+        inner_logger = ActiveSupport::Logger.new(StringIO.new)
+        tagged_logging = ActiveSupport::TaggedLogging.new(inner_logger)
+        @logger = ActionCable::Connection::TaggedLoggerProxy.new(tagged_logging, tags: [])
+        @request = request
+        @env = request.env
+      end
+    end
+
+    # Unit test Action Cable connections.
+    #
+    # Useful to check whether a connection's +identified_by+ gets assigned properly
+    # and that any improper connection requests are rejected.
+    #
+    # == Basic example
+    #
+    # Unit tests are written as follows:
+    #
+    # 1. Simulate a connection attempt by calling +connect+.
+    # 2. Assert state, e.g. identifiers, has been assigned.
+    #
+    #
+    #   class ApplicationCable::ConnectionTest < ActionCable::Connection::TestCase
+    #     def test_connects_with_proper_cookie
+    #       # Simulate the connection request with a cookie.
+    #       cookies["user_id"] = users(:john).id
+    #
+    #       connect
+    #
+    #       # Assert the connection identifier matches the fixture.
+    #       assert_equal users(:john).id, connection.user.id
+    #     end
+    #
+    #     def test_rejects_connection_without_proper_cookie
+    #       assert_reject_connection { connect }
+    #     end
+    #   end
+    #
+    # +connect+ accepts additional information the HTTP request with the
+    # +params+, +headers+, +session+ and Rack +env+ options.
+    #
+    #   def test_connect_with_headers_and_query_string
+    #     connect params: { user_id: 1 }, headers: { "X-API-TOKEN" => "secret-my" }
+    #
+    #     assert_equal "1", connection.user.id
+    #     assert_equal "secret-my", connection.token
+    #   end
+    #
+    #   def test_connect_with_params
+    #     connect params: { user_id: 1 }
+    #
+    #     assert_equal "1", connection.user.id
+    #   end
+    #
+    # You can also setup the correct cookies before the connection request:
+    #
+    #   def test_connect_with_cookies
+    #     # Plain cookies:
+    #     cookies["user_id"] = 1
+    #
+    #     # Or signed/encrypted:
+    #     # cookies.signed["user_id"] = 1
+    #     # cookies.encrypted["user_id"] = 1
+    #
+    #     connect
+    #
+    #     assert_equal "1", connection.user_id
+    #   end
+    #
+    # == Connection is automatically inferred
+    #
+    # ActionCable::Connection::TestCase will automatically infer the connection under test
+    # from the test class name. If the channel cannot be inferred from the test
+    # class name, you can explicitly set it with +tests+.
+    #
+    #   class ConnectionTest < ActionCable::Connection::TestCase
+    #     tests ApplicationCable::Connection
+    #   end
+    #
+    class TestCase < ActiveSupport::TestCase
+      module Behavior
+        extend ActiveSupport::Concern
+
+        DEFAULT_PATH = "/cable"
+
+        include ActiveSupport::Testing::ConstantLookup
+        include Assertions
+
+        included do
+          class_attribute :_connection_class
+
+          attr_reader :connection
+
+          ActiveSupport.run_load_hooks(:action_cable_connection_test_case, self)
+        end
+
+        module ClassMethods
+          def tests(connection)
+            case connection
+            when String, Symbol
+              self._connection_class = connection.to_s.camelize.constantize
+            when Module
+              self._connection_class = connection
+            else
+              raise NonInferrableConnectionError.new(connection)
+            end
+          end
+
+          def connection_class
+            if connection = self._connection_class
+              connection
+            else
+              tests determine_default_connection(name)
+            end
+          end
+
+          def determine_default_connection(name)
+            connection = determine_constant_from_test_name(name) do |constant|
+              Class === constant && constant < ActionCable::Connection::Base
+            end
+            raise NonInferrableConnectionError.new(name) if connection.nil?
+            connection
+          end
+        end
+
+        # Performs connection attempt to exert #connect on the connection under test.
+        #
+        # Accepts request path as the first argument and the following request options:
+        #
+        # - params – URL parameters (Hash)
+        # - headers – request headers (Hash)
+        # - session – session data (Hash)
+        # - env – additional Rack env configuration (Hash)
+        def connect(path = ActionCable.server.config.mount_path, **request_params)
+          path ||= DEFAULT_PATH
+
+          connection = self.class.connection_class.allocate
+          connection.singleton_class.include(TestConnection)
+          connection.send(:initialize, build_test_request(path, request_params))
+          connection.connect if connection.respond_to?(:connect)
+
+          # Only set instance variable if connected successfully
+          @connection = connection
+        end
+
+        # Exert #disconnect on the connection under test.
+        def disconnect
+          raise "Must be connected!" if connection.nil?
+
+          connection.disconnect if connection.respond_to?(:disconnect)
+          @connection = nil
+        end
+
+        def cookies
+          @cookie_jar ||= TestCookieJar.new
+        end
+
+        private
+          def build_test_request(path, params: nil, headers: {}, session: {}, env: {})
+            wrapped_headers = ActionDispatch::Http::Headers.from_hash(headers)
+
+            uri = URI.parse(path)
+
+            query_string = params.nil? ? uri.query : params.to_query
+
+            request_env = {
+              "QUERY_STRING" => query_string,
+              "PATH_INFO" => uri.path
+            }.merge(env)
+
+            if wrapped_headers.present?
+              ActionDispatch::Http::Headers.from_hash(request_env).merge!(wrapped_headers)
+            end
+
+            TestRequest.create(request_env).tap do |request|
+              request.session = session.with_indifferent_access
+              request.cookie_jar = cookies
+            end
+          end
+      end
+
+      include Behavior
+    end
+  end
+end

data/lib/action_cable/connection/web_socket.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "websocket/driver"
+
+module ActionCable
+  module Connection
+    # Wrap the real socket to minimize the externally-presented API
+    class WebSocket # :nodoc:
+      def initialize(env, event_target, event_loop, protocols: ActionCable::INTERNAL[:protocols])
+        @websocket = ::WebSocket::Driver.websocket?(env) ? ClientSocket.new(env, event_target, event_loop, protocols) : nil
+      end
+
+      def possible?
+        websocket
+      end
+
+      def alive?
+        websocket && websocket.alive?
+      end
+
+      def transmit(data)
+        websocket.transmit data
+      end
+
+      def close
+        websocket.close
+      end
+
+      def protocol
+        websocket.protocol
+      end
+
+      def rack_response
+        websocket.rack_response
+      end
+
+      private
+        attr_reader :websocket
+    end
+  end
+end

data/lib/action_cable/engine.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "rails"
+require "action_cable"
+require "action_cable/helpers/action_cable_helper"
+require "active_support/core_ext/hash/indifferent_access"
+
+module ActionCable
+  class Engine < Rails::Engine # :nodoc:
+    config.action_cable = ActiveSupport::OrderedOptions.new
+    config.action_cable.mount_path = ActionCable::INTERNAL[:default_mount_path]
+
+    config.eager_load_namespaces << ActionCable
+
+    initializer "action_cable.helpers" do
+      ActiveSupport.on_load(:action_view) do
+        include ActionCable::Helpers::ActionCableHelper
+      end
+    end
+
+    initializer "action_cable.logger" do
+      ActiveSupport.on_load(:action_cable) { self.logger ||= ::Rails.logger }
+    end
+
+    initializer "action_cable.set_configs" do |app|
+      options = app.config.action_cable
+      options.allowed_request_origins ||= /https?:\/\/localhost:\d+/ if ::Rails.env.development?
+
+      app.paths.add "config/cable", with: "config/cable.yml"
+
+      ActiveSupport.on_load(:action_cable) do
+        if (config_path = Pathname.new(app.config.paths["config/cable"].first)).exist?
+          self.cable = Rails.application.config_for(config_path).with_indifferent_access
+        end
+
+        previous_connection_class = connection_class
+        self.connection_class = -> { "ApplicationCable::Connection".safe_constantize || previous_connection_class.call }
+
+        options.each { |k, v| send("#{k}=", v) }
+      end
+    end
+
+    initializer "action_cable.routes" do
+      config.after_initialize do |app|
+        config = app.config
+        unless config.action_cable.mount_path.nil?
+          app.routes.prepend do
+            mount ActionCable.server => config.action_cable.mount_path, internal: true
+          end
+        end
+      end
+    end
+
+    initializer "action_cable.set_work_hooks" do |app|
+      ActiveSupport.on_load(:action_cable) do
+        ActionCable::Server::Worker.set_callback :work, :around, prepend: true do |_, inner|
+          app.executor.wrap do
+            # If we took a while to get the lock, we may have been halted
+            # in the meantime. As we haven't started doing any real work
+            # yet, we should pretend that we never made it off the queue.
+            unless stopping?
+              inner.call
+            end
+          end
+        end
+
+        wrap = lambda do |_, inner|
+          app.executor.wrap(&inner)
+        end
+        ActionCable::Channel::Base.set_callback :subscribe, :around, prepend: true, &wrap
+        ActionCable::Channel::Base.set_callback :unsubscribe, :around, prepend: true, &wrap
+
+        app.reloader.before_class_unload do
+          ActionCable.server.restart
+        end
+      end
+    end
+  end
+end

data/lib/action_cable/gem_version.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActionCable
+  # Returns the version of the currently loaded Action Cable as a <tt>Gem::Version</tt>.
+  def self.gem_version
+    Gem::Version.new VERSION::STRING
+  end
+
+  module VERSION
+    MAJOR = 6
+    MINOR = 0
+    TINY  = 0
+    PRE   = nil
+
+    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
+  end
+end

data/lib/action_cable/helpers/action_cable_helper.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ActionCable
+  module Helpers
+    module ActionCableHelper
+      # Returns an "action-cable-url" meta tag with the value of the URL specified in your
+      # configuration. Ensure this is above your JavaScript tag:
+      #
+      #   <head>
+      #     <%= action_cable_meta_tag %>
+      #     <%= javascript_include_tag 'application', 'data-turbolinks-track' => 'reload' %>
+      #   </head>
+      #
+      # 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:
+      #
+      #   #= require cable
+      #   @App = {}
+      #   App.cable = Cable.createConsumer()
+      #
+      # Make sure to specify the correct server location in each of your environment
+      # config files:
+      #
+      #   config.action_cable.mount_path = "/cable123"
+      #   <%= action_cable_meta_tag %> would render:
+      #   => <meta name="action-cable-url" content="/cable123" />
+      #
+      #   config.action_cable.url = "ws://actioncable.com"
+      #   <%= action_cable_meta_tag %> would render:
+      #   => <meta name="action-cable-url" content="ws://actioncable.com" />
+      #
+      def action_cable_meta_tag
+        tag "meta", name: "action-cable-url", content: (
+          ActionCable.server.config.url ||
+          ActionCable.server.config.mount_path ||
+          raise("No Action Cable URL configured -- please configure this at config.action_cable.url")
+        )
+      end
+    end
+  end
+end