rage-rb 1.15.1 → 1.17.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 28c74a202068f676855b6837a45e5c32a614bad76c1af65178e3038f1f976439
-  data.tar.gz: 53d023461db804902636c61711c49c25dde614d2b4d0ca112821ba61af9bdcf4
+  metadata.gz: 85fae5bbf87d602fb9cbde9e8356a6bfdb9d8e92ef02380f9124047a8d90d268
+  data.tar.gz: c6ff4ca55836d379609e07dfd9c2025de38aeccc9a29e14803551350f2348652
 SHA512:
-  metadata.gz: eb4e1169d7a67bb0720f721279de1fd1729f5eb7f75c005b6ca4ecdb54a465bcb4ca97fa16acebc0ff256a1f4ebc7017a29cb00dfc254b6df3a3e8a1535e1e62
-  data.tar.gz: 1133bae6fd831534848873917c61f5340bbe6ec65f446bcc07fa0b25c19c86b495afb03b029505ebe7d9569b50deb62dbca157d681f97fbeafab62a23b158d94
+  metadata.gz: 8d81759ffc54e6ede4b079dfed31dda024f274586451951aff72fa02e5cbf1014f31fc5760f07f7817dbf1db78262c88adeaff393020e54cecfd7126c169e0a2
+  data.tar.gz: fe7a3f9d392ed9343609b0c6c4c80624eb85c2df4be31690247355f11df185af2f9fe8ede04dc01583648f0e7cf75724742f2506a38c804618dbfd53c5fb1dde

data/CHANGELOG.md

@@ -1,5 +1,30 @@
 ## [Unreleased]
 
+## [1.17.0] - 2025-08-20
+
+### Added
+
+- Add `Rage::Deferred` (#164).
+- Add a controller generator by [@alex-rogachev](https://github.com/alex-rogachev) (#160).
+- Update `stale?` to set cache headers by [@serhii-sadovskyi](https://github.com/serhii-sadovskyi) (#159).
+
+### Fixed
+
+- Sub-millisecond sleep results in hang (#161).
+
+## [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

data/Gemfile

@@ -12,6 +12,7 @@ gem "yard"
 gem "rubocop", "~> 1.65.0", require: false
 
 group :test do
+  gem "activesupport"
   gem "http"
   gem "pg"
   gem "mysql2"

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:
 
@@ -62,11 +62,12 @@ Built-in middleware:
 - [CORS](https://rage-rb.pages.dev/Rage/Cors)
 - [RequestId](https://rage-rb.pages.dev/Rage/RequestId)
 
-Also, see the following integration guides:
+Also, see the following guides:
 
 - [Rails Integration](https://github.com/rage-rb/rage/wiki/Rails-integration)
 - [RSpec Integration](https://github.com/rage-rb/rage/wiki/RSpec-integration)
 - [WebSockets Guide](https://github.com/rage-rb/rage/wiki/WebSockets-guide)
+- [Background Tasks Guide](https://github.com/rage-rb/rage/wiki/Background-Tasks-Guide)
 
 If you are a first-time contributor, make sure to check the [overview doc](https://github.com/rage-rb/rage/blob/master/OVERVIEW.md) that shows how Rage's core components interact with each other.
 

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,24 +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 }
-
-    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
 
   # The method is called any time a new WebSocket connection is established.
@@ -148,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
@@ -164,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/cli.rb

@@ -30,6 +30,26 @@ module Rage
       template("model-template/model.rb", "app/models/#{name.singularize.underscore}.rb")
     end
 
+    desc "controller NAME", "Generate a new controller."
+    def controller(name = nil)
+      return help("controller") if name.nil?
+
+      setup
+      unless defined?(ActiveSupport::Inflector)
+        raise LoadError, <<~ERR
+          ActiveSupport::Inflector is required to run this command. Add the following line to your Gemfile:
+          gem "activesupport", require: "active_support/inflector"
+        ERR
+      end
+
+      # remove trailing Controller if already present
+      normalized_name = name.sub(/_?controller$/i, "")
+      @controller_name = "#{normalized_name.camelize}Controller"
+      file_name = "#{normalized_name.underscore}_controller.rb"
+
+      template("controller-template/controller.rb", "app/controllers/#{file_name}")
+    end
+
     private
 
     def setup

data/lib/rage/code_loader.rb

@@ -22,6 +22,8 @@ class Rage::CodeLoader
     @loader.enable_reloading if enable_reloading
     @loader.setup
     @loader.eager_load if enable_eager_loading
+
+    configure_components
   end
 
   # in standalone mode - reload the code and the routes
@@ -34,13 +36,7 @@ class Rage::CodeLoader
     Rage.__router.reset_routes
     load("#{Rage.root}/config/routes.rb")
 
-    unless Rage.autoload?(:Cable) # the `Cable` component is loaded
-      Rage::Cable.__router.reset
-    end
-
-    unless Rage.autoload?(:OpenAPI) # the `OpenAPI` component is loaded
-      Rage::OpenAPI.__reset_data_cache
-    end
+    reload_components
   end
 
   # in Rails mode - reset the routes; everything else will be done by Rails
@@ -50,13 +46,7 @@ class Rage::CodeLoader
     @reloading = true
     Rage.__router.reset_routes
 
-    unless Rage.autoload?(:Cable) # the `Cable` component is loaded
-      Rage::Cable.__router.reset
-    end
-
-    unless Rage.autoload?(:OpenAPI) # the `OpenAPI` component is loaded
-      Rage::OpenAPI.__reset_data_cache
-    end
+    reload_components
   end
 
   def reloading?
@@ -73,4 +63,25 @@ class Rage::CodeLoader
   ensure
     @last_watched, @last_update_at = current_watched, current_update_at
   end
+
+  private
+
+  def configure_components
+    if Rage.env.development? && (Rage.config.deferred.configured? || Rage.config.deferred.has_default_disk_storage?)
+      # if there's at least one task, `Rage::Deferred` will be automatically loaded in production;
+      # in development, however, eager loading is disabled, and we want to automatically load
+      # the module in case it was explicitly configured or if a disk storage exists
+      Rage::Deferred
+    end
+  end
+
+  def reload_components
+    unless Rage.autoload?(:Cable) # the `Cable` component is loaded
+      Rage::Cable.__router.reset
+    end
+
+    unless Rage.autoload?(:OpenAPI) # the `OpenAPI` component is loaded
+      Rage::OpenAPI.__reset_data_cache
+    end
+  end
 end