rage-rb 1.15.0 → 1.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 537238bd77a6af0c53b59def61a4b94616ca11b8e0bb3f31613d06198c8da2f5
-  data.tar.gz: 4597f16d331862d871aeacf18e701406b825e8208e8d41ec4d29f47d8ce6ce5e
+  metadata.gz: bf740bcbb20d075fa39c87bf6b97b10daf6f2a92daf6bcf7a12a03f04dbf5621
+  data.tar.gz: 7fd73455dfd6cb646d52d2e6f798b558e62ffe343d3156901a867af53179e973
 SHA512:
-  metadata.gz: 7c841546ab6547df2e3846000c2f47089e01d08f8702597df835a4b0d6a9920a9be4a65151e017d59e42c0c922d67887ae4d9403f4a2ae2fb048bddc54520c2a
-  data.tar.gz: '0701518f1f90e2bb6e800272a7054aaec3f401b73002733d4b216febf3758aa2a480a1920d19160779efc7450e6dcd12c0ca97392c6c08a325c6617f39147a0e'
+  metadata.gz: 0d74c740eec61265329a2f7623e3fa053d1d3bb07c3da7162b7551beded19bb3f6dc855cf5f92ec8acc501446ab72ee8d147904794f8892d967ceba939b3a10e
+  data.tar.gz: 169cab9535c8dc1ec9d99614dc8201e3cc2215126669965809618ae2effdd9384a6a4ab121913ce149d299111fce7f39eef8a00a2ba362abee755514f5b5c099

data/CHANGELOG.md

@@ -1,5 +1,24 @@
 ## [Unreleased]
 
+## [1.16.0] - 2025-05-20
+
+### Added
+
+- [Cable] Add the `RawJSON` protocol (#150).
+- Add the `after_initialize` hook by [@serhii-sadovskyi](https://github.com/serhii-sadovskyi) (#149).
+
+### Fixed
+
+- Correctly parse plaintext responses in RSpec (#151).
+- [OpenAPI] Correctly handle `root_key!` (#148).
+- [OpenAPI] Correctly handle the `key` option in associations (#147).
+
+## [1.15.1] - 2025-04-17
+
+### Fixed
+
+- [Cable] Create a subscription only when the reactor is started (#146).
+
 ## [1.15.0] - 2025-04-02
 
 ### Added

data/OVERVIEW.md

@@ -1,10 +1,18 @@
-### Boot sequence and request lifecycle
+### Table of Contents
+
+[API Workflow](#api-workflow)<br>
+[Executing Controller Actions](#executing-controller-actions)<br>
+[Cable Workflow](#cable-workflow)<br>
+[OpenAPI Workflow](#openapi-workflow)<br>
+[Design Principles](#design-principles)<br>
+
+### API Workflow
 
 The following diagram describes some of Rage's internal components and the way they interact with each other:
 
 ![overview](https://github.com/rage-rb/rage/assets/2270393/0d45bbe3-622c-4b17-b8d8-552c567fecb3)
 
-### Executing controller actions
+### Executing Controller Actions
 
 When `Rage::Router::DSL` parses the `config/routes.rb` file and calls the `Rage::Router::Backend` class, it registers actions and stores handler procs.
 
@@ -51,3 +59,25 @@ After that, Rage will create and store a handler proc that will look exactly lik
 ```
 
 All of this happens at boot time. Once the request comes in at runtime, Rage will only need to retrieve the handler proc defined earlier and call it.
+
+### Cable Workflow
+
+The following diagram describes the components of a `Rage::Cable` application:
+
+![cable](https://github.com/user-attachments/assets/86db2091-f93a-44f8-9512-c4701770d09e)
+
+### OpenAPI Workflow
+
+The following diagram describes the flow of `Rage::OpenAPI`:
+
+<img width="800" src="https://github.com/user-attachments/assets/b4a87b1e-9a0f-4432-a3e9-0106ff546f3f" />
+
+### Design Principles
+
+* **Lean Happy Path:** we try to execute as many operations as possible during server initialization to minimize workload during request processing. Additionally, new features should be designed to avoid impacting the framework performance for users who do not utilize those features.
+
+* **Performance Over Code Style:** we recognize the distinct requirements of framework and client code. Testability, readability, and maintainability are crucial for client code used in application development. Conversely, library code addresses different tasks and should be designed with different objectives. In library code, performance and abstraction to enable future modifications while maintaining backward compatibility take precedence over typical client code concerns, though testability and readability remain important.
+
+* **Rails Compatibility:** Rails compatibility is a key objective to ensure a seamless transition for developers. While it may not be feasible to replicate every method implemented in Rails, the framework should function in a familiar and expected manner.
+
+* **Single-Threaded Fiber-Based Approach:** each request is processed in a separate, isolated execution context (Fiber), pausing whenever it encounters blocking I/O. This single-threaded approach eliminates thread synchronization overhead, leading to enhanced performance and simplified code.

data/README.md

@@ -4,7 +4,7 @@
 
 [![Gem Version](https://badge.fury.io/rb/rage-rb.svg)](https://badge.fury.io/rb/rage-rb)
 ![Tests](https://github.com/rage-rb/rage/actions/workflows/main.yml/badge.svg)
-![Ruby Requirement](https://img.shields.io/badge/Ruby-3.1%2B-%23f40000)
+![Ruby Requirement](https://img.shields.io/badge/Ruby-3.2%2B-%23f40000)
 
 Rage is a high-performance framework compatible with Rails, featuring [WebSocket](https://github.com/rage-rb/rage/wiki/WebSockets-guide) support and automatic generation of [OpenAPI](https://github.com/rage-rb/rage/wiki/OpenAPI-Guide) documentation for your APIs. The framework is built on top of [Iodine](https://github.com/rage-rb/iodine) and is based on the following design principles:
 

data/lib/rage/all.rb

@@ -1,6 +1,7 @@
 require_relative "../rage-rb"
 
 require_relative "version"
+require_relative "hooks"
 require_relative "application"
 require_relative "fiber"
 require_relative "fiber_scheduler"

data/lib/rage/cable/adapters/redis.rb

@@ -107,7 +107,7 @@ class Rage::Cable::Adapters::Redis < Rage::Cable::Adapters::Base
         if data
           data[@redis_stream].each do |id, (_, stream_name, _, serialized_data, _, broadcaster_uuid, _, message_uuid)|
             if broadcaster_uuid != @server_uuid && message_uuid != last_message_uuid
-              Rage.config.cable.protocol.broadcast(stream_name, JSON.parse(serialized_data))
+              Rage.cable.__protocol.broadcast(stream_name, JSON.parse(serialized_data))
             end
 
             last_id = id

data/lib/rage/cable/cable.rb

@@ -36,6 +36,7 @@ module Rage::Cable
     @__protocol ||= Rage.config.cable.protocol.tap { |protocol| protocol.init(__router) }
   end
 
+  # @private
   def self.__adapter
     @__adapter ||= Rage.config.cable.adapter
   end
@@ -136,11 +137,15 @@ module Rage::Cable
     autoload :Redis, "rage/cable/adapters/redis"
   end
 
-  module Protocol
+  module Protocols
   end
+
+  Protocol = Protocols
 end
 
-require_relative "protocol/actioncable_v1_json"
+require_relative "protocols/base"
+require_relative "protocols/actioncable_v1_json"
+require_relative "protocols/raw_web_socket_json"
 require_relative "channel"
 require_relative "connection"
 require_relative "router"

data/lib/rage/cable/channel.rb

@@ -1,5 +1,3 @@
-require "set"
-
 class Rage::Cable::Channel
   # @private
   INTERNAL_ACTIONS = [:subscribed, :unsubscribed]
@@ -18,6 +16,8 @@ class Rage::Cable::Channel
         public_instance_methods(true) - Rage::Cable::Channel.public_instance_methods(true)
       ).reject { |m| m.start_with?("__rage_tmp") || m.start_with?("__run") }
 
+      actions.reject! { |m| m != :receive } unless Rage.cable.__protocol.supports_rpc?
+
       @__prepared_actions = (INTERNAL_ACTIONS + actions).each_with_object({}) do |action_name, memo|
         memo[action_name] = __register_action_proc(action_name)
       end
@@ -406,7 +406,7 @@ class Rage::Cable::Channel
   #
   # @param stream [String] the name of the stream
   def stream_from(stream)
-    Rage.config.cable.protocol.subscribe(@__connection, stream, @__params)
+    Rage.cable.__protocol.subscribe(@__connection, stream, @__params)
   end
 
   # Broadcast data to all the clients subscribed to a stream.
@@ -429,7 +429,7 @@ class Rage::Cable::Channel
   #     transmit({ message: "Hello!" })
   #   end
   def transmit(data)
-    message = Rage.config.cable.protocol.serialize(@__params, data)
+    message = Rage.cable.__protocol.serialize(@__params, data)
 
     if @__is_subscribing
       # we expect a confirmation message to be sent as a result of a successful subscribe call;

data/lib/rage/cable/{protocol → protocols}/actioncable_v1_json.rb

@@ -1,29 +1,39 @@
 # frozen_string_literal: true
 
-require "zlib"
-require "set"
-
 ##
-# A protocol defines the structure, rules and semantics for exchanging data between the client and the server.
-# The class that defines a protocol should respond to the following methods:
+# This is an implementation of the `Action Cable` protocol. Clients are expected to use
+# {https://www.npmjs.com/package/@rails/actioncable @rails/actioncable} to connect to the server.
+#
+# @see Rage::Cable::Protocols::Base
+#
+# @example Server side
+#   class TodoItemsChannel
+#     def subscribed
+#       stream_from "todo-items"
+#     end
 #
-# * `protocol_definition`
-# * `init`
-# * `on_open`
-# * `on_message`
-# * `serialize`
-# * `subscribe`
-# * `broadcast`
+#     def add_item(data)
+#       puts "Adding Todo item: #{data}"
+#     end
 #
-# The two optional methods are:
+#     def remove_item(data)
+#       puts "Removing Todo item: #{data}"
+#     end
+#   end
 #
-# * `on_shutdown`
-# * `on_close`
+# @example Client side
+#   import { createConsumer } from '@rails/actioncable'
 #
-# It is likely that all logic around `@subscription_identifiers` has nothing to do with the protocol itself and
-# should be extracted into another class. We'll refactor this once we start working on a new protocol.
+#   const cable = createConsumer('ws://localhost:3000/cable')
 #
-class Rage::Cable::Protocol::ActioncableV1Json
+#   const channel = cable.subscriptions.create('TodoItemsChannel', {
+#     connected: () => console.log('connected')
+#   })
+#
+#   channel.perform('add_item', { item: 'New Item' })
+#   channel.perform('remove_item', { item_id: 123 })
+#
+class Rage::Cable::Protocols::ActioncableV1Json < Rage::Cable::Protocols::Base
   module TYPE
     WELCOME = "welcome"
     DISCONNECT = "disconnect"
@@ -59,7 +69,7 @@ class Rage::Cable::Protocol::ActioncableV1Json
   #
   # @param router [Rage::Cable::Router]
   def self.init(router)
-    @router = router
+    super
 
     Iodine.on_state(:on_start) do
       ping_counter = Time.now.to_i
@@ -69,22 +79,6 @@ class Rage::Cable::Protocol::ActioncableV1Json
         Iodine.publish("cable:ping", { type: TYPE::PING, message: ping_counter }.to_json, Iodine::PubSub::PROCESS)
       end
     end
-
-    # Hash<String(stream name) => Set<Hash>(subscription params)>
-    @subscription_identifiers = Hash.new { |hash, key| hash[key] = Set.new }
-
-    # this is a fallback to synchronize subscription identifiers across different worker processes;
-    # we expect connections to be distributed among all workers, so this code will almost never be called;
-    # we also synchronize subscriptions with the master process so that the forks that are spun up instead
-    # of the crashed ones also had access to the identifiers;
-    Iodine.subscribe("cable:synchronize") do |_, subscription_msg|
-      stream_name, params = Rage::ParamsParser.json_parse(subscription_msg)
-      @subscription_identifiers[stream_name] << params
-    end
-
-    Iodine.on_state(:on_finish) do
-      Iodine.unsubscribe("cable:synchronize")
-    end
   end
 
   # The method is called any time a new WebSocket connection is established.
@@ -146,7 +140,7 @@ class Rage::Cable::Protocol::ActioncableV1Json
     end
   end
 
-  # The method should process client disconnections and call {Rage::Cable::Router#process_message}.
+  # The method should process client disconnections and call {Rage::Cable::Router#process_disconnection}.
   #
   # @note This method is optional.
   # @param connection [Rage::Cable::WebSocketConnection] the connection object
@@ -162,28 +156,4 @@ class Rage::Cable::Protocol::ActioncableV1Json
   def self.serialize(params, data)
     { identifier: params.to_json, message: data }.to_json
   end
-
-  # Subscribe to a stream.
-  #
-  # @param connection [Rage::Cable::WebSocketConnection] the connection object
-  # @param name [String] the stream name
-  # @param params [Hash] parameters associated with the client
-  def self.subscribe(connection, name, params)
-    connection.subscribe("cable:#{name}:#{Zlib.crc32(params.to_s)}")
-
-    unless @subscription_identifiers[name].include?(params)
-      @subscription_identifiers[name] << params
-      ::Iodine.publish("cable:synchronize", [name, params].to_json)
-    end
-  end
-
-  # Broadcast data to all clients connected to a stream.
-  #
-  # @param name [String] the stream name
-  # @param data [Object] the data to send
-  def self.broadcast(name, data)
-    @subscription_identifiers[name].each do |params|
-      ::Iodine.publish("cable:#{name}:#{Zlib.crc32(params.to_s)}", serialize(params, data))
-    end
-  end
 end

data/lib/rage/cable/protocols/base.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "digest"
+
+##
+# A protocol defines the structure, rules and semantics for exchanging data between the client and the server.
+# A protocol class should inherit from {Rage::Cable::Protocols::Base} and implement the following methods:
+#
+# * `on_open`
+# * `on_message`
+# * `serialize`
+#
+# The optional methods are:
+#
+# * `protocol_definition`
+# * `on_shutdown`
+# * `on_close`
+#
+class Rage::Cable::Protocols::Base
+  # @private
+  HANDSHAKE_HEADERS = {}
+
+  class << self
+    # @param router [Rage::Cable::Router]
+    def init(router)
+      @router = router
+
+      # Hash<String(stream name) => Set<Hash>(subscription params)>
+      @subscription_identifiers = Hash.new { |hash, key| hash[key] = Set.new }
+
+      Iodine.on_state(:pre_start) do
+        # this is a fallback to synchronize subscription identifiers across different worker processes;
+        # we expect connections to be distributed among all workers, so this code will almost never be called;
+        # we also synchronize subscriptions with the master process so that the forks that are spun up instead
+        # of the crashed ones also had access to the identifiers;
+        Iodine.subscribe("cable:synchronize") do |_, subscription_msg|
+          stream_name, params = Rage::ParamsParser.json_parse(subscription_msg)
+          @subscription_identifiers[stream_name] << params
+        end
+      end
+
+      Iodine.on_state(:on_finish) do
+        Iodine.unsubscribe("cable:synchronize")
+      end
+    end
+
+    def protocol_definition
+      HANDSHAKE_HEADERS
+    end
+
+    # Subscribe to a stream.
+    #
+    # @param connection [Rage::Cable::WebSocketConnection] the connection object
+    # @param name [String] the stream name
+    # @param params [Hash] parameters associated with the client
+    def subscribe(connection, name, params)
+      connection.subscribe("cable:#{name}:#{stream_id(params)}")
+
+      unless @subscription_identifiers[name].include?(params)
+        @subscription_identifiers[name] << params
+        ::Iodine.publish("cable:synchronize", [name, params].to_json)
+      end
+    end
+
+    # Broadcast data to all clients connected to a stream.
+    #
+    # @param name [String] the stream name
+    # @param data [Object] the data to send
+    def broadcast(name, data)
+      @subscription_identifiers[name].each do |params|
+        ::Iodine.publish("cable:#{name}:#{stream_id(params)}", serialize(params, data))
+      end
+    end
+
+    # Whether the protocol allows remote procedure calls.
+    #
+    # @return [Boolean]
+    def supports_rpc?
+      true
+    end
+
+    private
+
+    def stream_id(params)
+      Digest::MD5.hexdigest(params.to_s)
+    end
+  end # class << self
+end

data/lib/rage/cable/protocols/raw_web_socket_json.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+##
+# The `RawWebSocketJson` protocol allows a direct connection to a {Rage::Cable} application using the native
+# `WebSocket` object. With this protocol, each WebSocket connection directly corresponds to a single
+# channel subscription. As a result, clients are automatically subscribed to a channel as soon as
+# they establish a connection.
+#
+# Heartbeats are also supported - the server will respond with `pong` to every `ping` message. Additionally,
+# all ping messages are buffered and processed once a second, which means it can take up to a second for
+# the server to respond to a `ping`.
+#
+# @see Rage::Cable::Protocols::Base
+#
+# @example Server side
+#   class TodoItemsChannel
+#     def subscribed
+#       stream_from "todo-items-#{params[:user_id]}"
+#     end
+#
+#     def receive(data)
+#       puts "New Todo item: #{data}"
+#     end
+#   end
+#
+# @example Client side
+#   socket = new WebSocket("ws://localhost:3000/cable/todo_items?user_id=123")
+#   socket.send(JSON.stringify({ item: "New Item" }))
+#
+class Rage::Cable::Protocols::RawWebSocketJson < Rage::Cable::Protocols::Base
+  # identifiers are used to distinguish between different channels that share a single connection;
+  # since the raw protocol uses a single connection for each channel, identifiers are not necessary
+  IDENTIFIER = ""
+  private_constant :IDENTIFIER
+
+  module MESSAGES
+    UNAUTHORIZED = { err: "unauthorized" }.to_json
+    REJECTED = { err: "subscription rejected" }.to_json
+    INVALID = { err: "invalid channel name" }.to_json
+    UNKNOWN = { err: "unknown action" }.to_json
+  end
+  private_constant :MESSAGES
+
+  DEFAULT_PARAMS = {}.freeze
+  private_constant :DEFAULT_PARAMS
+
+  def self.init(router)
+    super
+
+    @ping_connections = Set.new
+
+    Iodine.on_state(:on_start) do
+      Iodine.run_every(1_000) do
+        @ping_connections.each_slice(500) do |slice|
+          Iodine.defer { slice.each { |connection| connection.write("pong") } }
+        end
+
+        @ping_connections.clear
+      end
+    end
+  end
+
+  # @param connection [Rage::Cable::WebSocketConnection] the connection object
+  def self.on_open(connection)
+    accepted = @router.process_connection(connection)
+
+    unless accepted
+      connection.write(MESSAGES::UNAUTHORIZED)
+      connection.close
+      return
+    end
+
+    channel_id = connection.env["PATH_INFO"].split("/")[-1]
+
+    channel_name = if channel_id.end_with?("Channel")
+      channel_id
+    else
+      if channel_id.include?("_")
+        tmp = ""
+        channel_id.split("_") { |segment| tmp += segment.capitalize! || segment }
+        channel_id = tmp
+      else
+        channel_id.capitalize!
+      end
+
+      "#{channel_id}Channel"
+    end
+
+    query_string = connection.env["QUERY_STRING"]
+    params = query_string == "" ? DEFAULT_PARAMS : Iodine::Rack::Utils.parse_nested_query(query_string)
+
+    status = @router.process_subscription(connection, IDENTIFIER, channel_name, params)
+
+    if status == :rejected
+      connection.write(MESSAGES::REJECTED)
+      connection.close
+    elsif status == :invalid
+      connection.write(MESSAGES::INVALID)
+      connection.close
+    end
+  end
+
+  # @param connection [Rage::Cable::WebSocketConnection] the connection object
+  # @param raw_data [String] the message body
+  def self.on_message(connection, raw_data)
+    if raw_data == "ping"
+      @ping_connections << connection
+      return
+    end
+
+    data = JSON.parse(raw_data)
+
+    message_status = @router.process_message(connection, IDENTIFIER, :receive, data)
+    unless message_status == :processed
+      connection.write(MESSAGES::UNKNOWN)
+    end
+  end
+
+  # @param connection [Rage::Cable::WebSocketConnection] the connection object
+  def self.on_close(connection)
+    @router.process_disconnection(connection)
+  end
+
+  # @param data [Object] the object to serialize
+  def self.serialize(_, data)
+    data.to_json
+  end
+
+  # @return [Boolean]
+  def self.supports_rpc?
+    false
+  end
+
+  # @private
+  # The base implementation groups connection subscriptions by `params`;
+  # however, with `RawWebSocketJson`, params are not part of the payload (see {serialize})
+  # and we can disable grouping in exchange for better performance
+  #
+  # @param connection [Rage::Cable::WebSocketConnection] the connection object
+  # @param name [String] the stream name
+  def self.subscribe(connection, name, _)
+    super(connection, name, "")
+  end
+end

data/lib/rage/configuration.rb

@@ -35,6 +35,15 @@ require "erb"
 #
 # > Defines one or several old secrets that need to be rotated. Can accept a single key or an array of keys. Rage will fall back to the `FALLBACK_SECRET_KEY_BASE` environment variable if this is not set.
 #
+# • _config.after_initialize_
+#
+# > Schedule a block of code to run after Rage has finished loading the application code. Use this to reference application-level constants during the initialization process.
+# > ```
+# Rage.config.after_initialize do
+#   SUPER_USER = User.find_by!(super: true)
+# end
+# > ```
+#
 # # Middleware Configuration
 #
 # • _config.middleware.use_
@@ -115,7 +124,7 @@ require "erb"
 #
 # • _config.cable.protocol_
 #
-# > Specifies the protocol the server will use. The only value currently supported is `Rage::Cable::Protocol::ActioncableV1Json`. The client application will need to use [@rails/actioncable](https://www.npmjs.com/package/@rails/actioncable) to talk to the server.
+# > Specifies the protocol the server will use. Supported values include {Rage::Cable::Protocols::ActioncableV1Json :actioncable_v1_json} and {Rage::Cable::Protocols::RawWebSocketJson :raw_websocket_json}. Defaults to {Rage::Cable::Protocols::ActioncableV1Json :actioncable_v1_json}.
 #
 # • _config.cable.allowed_request_origins_
 #
@@ -153,6 +162,8 @@ require "erb"
 # > Instructs Rage to not reuse Active Record connections between different fibers.
 #
 class Rage::Configuration
+  include Hooks
+
   attr_accessor :logger
   attr_reader :log_formatter, :log_level
   attr_writer :secret_key_base, :fallback_secret_key_base
@@ -201,6 +212,14 @@ class Rage::Configuration
     @internal ||= Internal.new
   end
 
+  def after_initialize(&block)
+    push_hook(block, :after_initialize)
+  end
+
+  def run_after_initialize!
+    run_hooks_for!(:after_initialize, self)
+  end
+
   class Server
     attr_accessor :port, :workers_count, :timeout, :max_clients
     attr_reader :threads_count
@@ -257,15 +276,29 @@ class Rage::Configuration
   end
 
   class Cable
-    attr_accessor :protocol, :allowed_request_origins, :disable_request_forgery_protection
+    attr_accessor :allowed_request_origins, :disable_request_forgery_protection
+    attr_reader :protocol
 
     def initialize
-      @protocol = Rage::Cable::Protocol::ActioncableV1Json
+      @protocol = Rage::Cable::Protocols::ActioncableV1Json
       @allowed_request_origins = if Rage.env.development? || Rage.env.test?
         /localhost/
       end
     end
 
+    def protocol=(protocol)
+      @protocol = case protocol
+      when Class
+        protocol
+      when :actioncable_v1_json
+        Rage::Cable::Protocols::ActioncableV1Json
+      when :raw_websocket_json
+        Rage::Cable::Protocols::RawWebSocketJson
+      else
+        raise ArgumentError, "Unknown protocol. Supported values are `:actioncable_v1_json` and `:raw_websocket_json`."
+      end
+    end
+
     # @private
     def middlewares
       @middlewares ||= begin

data/lib/rage/hooks.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Hooks
+  def hooks
+    @hooks ||= Hash.new { |h, k| h[k] = [] }
+  end
+
+  def push_hook(callback, hook_family)
+    hooks[hook_family] << callback if callback.is_a?(Proc)
+  end
+
+  def run_hooks_for!(hook_family, context = nil)
+    hooks[hook_family].each do |callback|
+      if context
+        context.instance_exec(&callback)
+      else
+        callback.call
+      end
+    end
+
+    @hooks[hook_family] = []
+
+    true
+  end
+end

data/lib/rage/openapi/parsers/ext/alba.rb

@@ -20,7 +20,7 @@ class Rage::OpenAPI::Parsers::Ext::Alba
 
   def __parse_nested(klass_str)
     __parse(klass_str).tap { |visitor|
-      visitor.root_key = visitor.root_key_for_collection = visitor.key_transformer = nil
+      visitor.root_key = visitor.root_key_for_collection = visitor.root_key_proc = visitor.key_transformer = nil
     }.build_schema
   end
 
@@ -50,7 +50,7 @@ class Rage::OpenAPI::Parsers::Ext::Alba
   end
 
   class Visitor < Prism::Visitor
-    attr_accessor :schema, :root_key, :root_key_for_collection, :key_transformer, :collection_key, :meta
+    attr_accessor :schema, :root_key, :root_key_for_collection, :root_key_proc, :key_transformer, :collection_key, :meta
 
     def initialize(parser, is_collection)
       @parser = parser
@@ -64,6 +64,7 @@ class Rage::OpenAPI::Parsers::Ext::Alba
       @self_name = nil
       @root_key = nil
       @root_key_for_collection = nil
+      @root_key_proc = nil
       @key_transformer = nil
       @collection_key = false
       @meta = {}
@@ -74,7 +75,7 @@ class Rage::OpenAPI::Parsers::Ext::Alba
 
       if node.name =~ /Resource$|Serializer$/ && node.superclass
         visitor = @parser.__parse(node.superclass.name)
-        @root_key, @root_key_for_collection = visitor.root_key, visitor.root_key_for_collection
+        @root_key, @root_key_for_collection, @root_key_proc = visitor.root_key, visitor.root_key_for_collection, visitor.root_key_proc
         @key_transformer, @collection_key, @meta = visitor.key_transformer, visitor.collection_key, visitor.meta
         @schema.merge!(visitor.schema)
       end
@@ -87,6 +88,13 @@ class Rage::OpenAPI::Parsers::Ext::Alba
 
       result["properties"] = @schema if @schema.any?
 
+      if @root_key_proc
+        dynamic_root_key, dynamic_root_key_for_collection = @root_key_proc.call(@self_name)
+
+        @root_key = dynamic_root_key
+        @root_key_for_collection = dynamic_root_key_for_collection
+      end
+
       if @is_collection
         result = if @collection_key && @root_key_for_collection
           { "type" => "object", "properties" => { @root_key_for_collection => { "type" => "object", "additionalProperties" => result }, **@meta } }
@@ -109,6 +117,7 @@ class Rage::OpenAPI::Parsers::Ext::Alba
     def visit_call_node(node)
       case node.name
       when :root_key
+        @root_key_proc = nil
         context = with_context { visit(node.arguments) }
         @root_key, @root_key_for_collection = context.symbols
 
@@ -135,12 +144,13 @@ class Rage::OpenAPI::Parsers::Ext::Alba
       when :many, :has_many, :one, :has_one, :association
         is_array = node.name == :many || node.name == :has_many
         context = with_context { visit(node.arguments) }
-        key = context.keywords["key"] || context.symbols[0]
+        association = context.symbols[0]
+        key = context.keywords["key"] || association
 
         if node.block
           with_inner_segment(key, is_array:) { visit(node.block) }
         else
-          resource = context.keywords["resource"] || (::Alba.inflector && "#{::Alba.inflector.classify(key.to_s)}Resource")
+          resource = context.keywords["resource"] || (::Alba.inflector && "#{::Alba.inflector.classify(association.to_s)}Resource")
           is_valid_resource = @parser.namespace.const_get(resource) rescue false
 
           @segment[key] = if is_array
@@ -159,10 +169,14 @@ class Rage::OpenAPI::Parsers::Ext::Alba
 
       when :root_key!
         if (inflector = ::Alba.inflector)
-          suffix = @self_name.end_with?("Resource") ? "Resource" : "Serializer"
-          name = inflector.demodulize(@self_name).delete_suffix(suffix)
-          @root_key = inflector.underscore(name)
-          @root_key_for_collection = inflector.pluralize(@root_key) if @is_collection
+          @root_key, @root_key_for_collection = nil
+
+          @root_key_proc = ->(resource_name) do
+            suffix = resource_name.end_with?("Resource") ? "Resource" : "Serializer"
+            name = inflector.demodulize(resource_name).delete_suffix(suffix)
+
+            inflector.underscore(name).yield_self { |key| [key, inflector.pluralize(key)] }
+          end
         end
       end
     end

data/lib/rage/request.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "time"
-require "set" # required for ruby 3.1
 
 class Rage::Request
   # @private

data/lib/rage/router/constrainer.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
-
 class Rage::Router::Constrainer
   attr_reader :strategies
 

data/lib/rage/router/node.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "set"
-
 module Rage::Router
   class Node
     STATIC = 0

data/lib/rage/rspec.rb

@@ -101,7 +101,7 @@ end
 # patch MockResponse class
 class Rack::MockResponse
   def parsed_body
-    if headers["content-type"].start_with?("application/json")
+    if headers["content-type"]&.start_with?("application/json")
       JSON.parse(body)
     else
       body

data/lib/rage/setup.rb

@@ -14,4 +14,7 @@ require "rage/ext/setup"
 # Load application classes
 Rage.code_loader.setup
 
+# Run after_initialize hooks
+Rage.config.run_after_initialize!
+
 require_relative "#{Rage.root}/config/routes"

data/lib/rage/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rage
-  VERSION = "1.15.0"
+  VERSION = "1.16.0"
 end

data/lib/rage-rb.rb

@@ -107,6 +107,10 @@ module Rage
     end
   end
 
+  class << self
+    alias_method :configuration, :config
+  end
+
   module Router
     module Strategies
     end

data/rage.gemspec

@@ -11,7 +11,7 @@ Gem::Specification.new do |spec|
   spec.summary = "Fast web framework compatible with Rails."
   spec.homepage = "https://github.com/rage-rb/rage"
   spec.license = "MIT"
-  spec.required_ruby_version = ">= 3.1.0"
+  spec.required_ruby_version = ">= 3.2.0"
 
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = "https://github.com/rage-rb/rage"

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rage-rb
 version: !ruby/object:Gem::Version
-  version: 1.15.0
+  version: 1.16.0
 platform: ruby
 authors:
 - Roman Samoilov
-autorequire:
 bindir: exe
 cert_chain: []
-date: 2025-04-02 00:00:00.000000000 Z
+date: 2025-05-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -94,7 +93,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '12.0'
-description:
 email:
 - rsamoi@icloud.com
 executables:
@@ -121,7 +119,9 @@ files:
 - lib/rage/cable/cable.rb
 - lib/rage/cable/channel.rb
 - lib/rage/cable/connection.rb
-- lib/rage/cable/protocol/actioncable_v1_json.rb
+- lib/rage/cable/protocols/actioncable_v1_json.rb
+- lib/rage/cable/protocols/base.rb
+- lib/rage/cable/protocols/raw_web_socket_json.rb
 - lib/rage/cable/router.rb
 - lib/rage/cli.rb
 - lib/rage/code_loader.rb
@@ -134,6 +134,7 @@ files:
 - lib/rage/ext/setup.rb
 - lib/rage/fiber.rb
 - lib/rage/fiber_scheduler.rb
+- lib/rage/hooks.rb
 - lib/rage/logger/json_formatter.rb
 - lib/rage/logger/logger.rb
 - lib/rage/logger/text_formatter.rb
@@ -208,7 +209,6 @@ licenses:
 metadata:
   homepage_uri: https://github.com/rage-rb/rage
   source_code_uri: https://github.com/rage-rb/rage
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -216,15 +216,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 3.1.0
+      version: 3.2.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.10
-signing_key:
+rubygems_version: 3.6.2
 specification_version: 4
 summary: Fast web framework compatible with Rails.
 test_files: []