rage-rb 1.24.0 → 1.25.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b488d2ab6a7ebcc33ae77a768f55e9277b796c39c5a7451e32a823f4e7a8a848
-  data.tar.gz: c1e55ecf8182587ced30f1c0af834136edbd4e06d0466dfaf6685387d0ebb3d6
+  metadata.gz: 177c149ab02c459e231c8853a303f23da977767073611fa1996e3e9b4f3ebd7c
+  data.tar.gz: a28617f5ea6d85f95eb0d900582dddacf2fb83f8190f31e46f84700419ccfdc2
 SHA512:
-  metadata.gz: 0ed0b0e62b74d3847804613ec77da801ceb2784dda9dc81895c93c6438a07377a82a5ff3ac4099bee8d4d9698ef51e2ac12233067d0672f3b5bdf97374e2fbc6
-  data.tar.gz: 6b6b8d71317c165d7ff5d3a1942cd81aeeeb5978f3672fc1de32464f4d4e3ed8f10171345a11db2e3427aff4cd84868403922541701c5464ce4260d96690250b
+  metadata.gz: d1c422f7d8755b56a88203f5669d36d518a1ff69a9bc2fc9e8fbd9e0b628fc25884c44615bfbc7f577e3519e9be3c5499dc4cf7fd136065e6292e95fe1833635
+  data.tar.gz: 10a7692229b832f1eeb540114835c9ac49a317372e796163c3be7eb8d3d906cf89e9e3cd18c033e61834fa8dc192f1dbfc3a25f509f0a6c7496b0be8dcb4e026

data/CHANGELOG.md

@@ -1,5 +1,21 @@
 ## [Unreleased]
 
+## [1.25.0] - 2026-06-03
+
+### Added
+
+- Implement `FiberScheduler#fiber_interrupt` (#283).
+- [OpenAPI] Add Blueprinter parser scaffold and class detection (#287)
+- [OpenAPI] Extend @response / @request tag syntax to accept serializer options (#299)
+- Add `FiberScheduler#blocking_operation_wait` (#303).
+- [OpenAPI] Added static parsing of basic Blueprinter fields (`identifier`, `field`, `fields`) for OpenAPI schema generation. (#289)
+
+### Fixed
+
+- [API] Reject malformed or empty HTTP token authorization headers.
+- [Cookies] Strip the port from `HTTP_HOST` before matching configured cookie domains.
+- [Router] Strip the port from `HTTP_HOST` before matching exact host constraints.
+
 ## [1.24.0] - 2026-05-12
 
 ### Added

data/README.md

@@ -6,9 +6,9 @@
 ![Tests](https://github.com/rage-rb/rage/actions/workflows/main.yml/badge.svg)
 ![Ruby Requirement](https://img.shields.io/badge/Ruby-3.3%2B-%23f40000)
 
-**Rage** is an API-first Ruby framework with a modern, fiber-based runtime that enables transparent, non-blocking concurrency while preserving familiar developer ergonomics. It focuses on **capability and operational simplicity**, letting teams build production-grade systems in a single, coherent runtime.
+**Rage** is an API-first Ruby web framework that combines the developer experience of Rails with fiber-based concurrency. You write standard synchronous Ruby code - Rage handles the concurrency, running APIs, background jobs, and WebSockets in a single process with fewer moving parts.
 
-Rage uses Rails compatibility as a foundation and provides backend primitives optimized for a single-runtime model: background jobs that run in-process, WebSockets without external dependencies, object-oriented domain events, and automatic API documentation.
+Rage uses Rails compatibility as a foundation and provides backend primitives optimized for a single-runtime model: background jobs that run in-process, scalable WebSockets and SSE streams, object-oriented domain events, and automatic API documentation.
 
 ## Why Rage
 
@@ -24,22 +24,73 @@ In the Ruby ecosystem, these concerns typically mean more infrastructure: Redis,
 
 Rage takes a different approach: **collapse backend concerns into a single runtime** by embracing Ruby's fiber-based concurrency model. This reduces operational complexity while keeping familiar Ruby ergonomics.
 
+## Key Capabilities
+
+- **Rails Compatibility** - Familiar controller API, routing DSL, and conventions. Migrate gradually or start fresh.
+- **True Concurrency** - Fiber-based architecture handles I/O without threads, locks, or async/await syntax. Your code looks synchronous but runs concurrently.
+- **Zero-dependency WebSockets** - Action Cable-compatible real-time features that work out-of-the-box, with built-in IPC for multi-process deployments.
+- **Server-Sent Events** - Native SSE streaming with no external dependencies. Built for live feeds, progress updates, and LLM response streaming.
+- **Auto-generated OpenAPI** - Documentation generated from your controllers using simple comment tags.
+- **In-process Background Jobs** - A durable, persistent queue that runs inside your app process. No external dependencies or separate worker processes required.
+- **Built-in Observability** - Track and measure application behavior with `Rage::Telemetry`. Integrate with external monitoring platforms or build custom observability solutions.
+
+## Installation
+
+Install the gem:
+
+```
+$ gem install rage-rb
+```
+
+Create a new app:
+
+```
+$ rage new my_app
+```
+
+Switch to your new application and install dependencies:
+
+```
+$ cd my_app
+$ bundle install
+```
+
+(Optional 🤖) Install agent skills:
+
+```
+$ rage skills install
+```
+
+Start up the server and visit http://localhost:3000.
+
+```
+$ rage s
+```
+
+Start coding!
+
+## How It Works
+
+Rage runs each request in a separate fiber. When your code performs I/O operations - HTTP requests, database queries, file reads - the fiber automatically pauses, and Rage processes other requests. When the I/O completes, the fiber resumes exactly where it left off.
+
+This happens automatically. You write standard Ruby code, and Rage handles the concurrency.
+
 ### Unified Runtime in Action
 
 Here's what single runtime looks like in practice:
 
 ```ruby
 class OrdersController < RageController::API
+  # Create an order record.
+  # @request { amount: Float, product_id: Integer }
+  # @response 201 Order
   def create
     order = Order.create!(order_params)
 
     # Schedule background job - runs in-process, no Redis needed
     SendOrderConfirmation.enqueue(order.id)
 
-    # Publish domain event - subscribers execute immediately or async
-    Rage::Events.publish(OrderPlaced.new(order: order))
-
-    # Broadcast to WebSocket subscribers - no Action Cable/Redis needed
+    # Broadcast to WebSocket subscribers - built in, no external services needed
     Rage::Cable.broadcast("orders", { status: "created", order_id: order.id })
 
     render json: order, status: :created
@@ -55,22 +106,15 @@ class SendOrderConfirmation
     OrderMailer.confirmation(order).deliver
   end
 end
+```
 
-# Domain event - typed, object-oriented
-OrderPlaced = Data.define(:order)
+This all runs in a single process. No external queues, no separate worker dynos, no additional infrastructure.
 
-# Event subscriber
-class UpdateInventory
-  include Rage::Events::Subscriber
-  subscribe_to OrderPlaced
+## Two Ways to Use Rage
 
-  def call(event)
-    Inventory.decrement(event.order.items.length)
-  end
-end
-```
+**Standalone**: Create new services with `rage new`. You get a clean project structure, CLI tools, and everything needed to build production-ready APIs from scratch.
 
-This all runs in a single process. No external queues, no separate worker dynos, no Redis for pub/sub.
+**Rails Integration**: Add Rage to existing Rails applications for gradual migration. Use Rage for new endpoints or high-traffic routes while keeping the rest of your Rails app unchanged. See the [Rails Integration Guide](https://rage-rb.dev/docs/rails) for details.
 
 ## Coming from Rails?
 
@@ -83,7 +127,7 @@ You write familiar synchronous Ruby code. Rage handles the concurrency.
 **What changes:**
 
 - One deployment unit instead of API servers + worker processes
-- No Redis required for jobs or broadcasts
+- No external dependencies for jobs or broadcasts
 - Domain events as objects, not string-based notifications
 - OpenAPI specs generated automatically from your code
 
@@ -95,111 +139,9 @@ You write familiar synchronous Ruby code. Rage handles the concurrency.
 
 Think of Rage as Rails ergonomics with a runtime designed for modern API systems, where operational simplicity is a first-class concern.
 
-## Core Ideas
-
-### 1. Unified Backend Runtime
-
-Rage runs HTTP APIs, background jobs, and WebSockets in the same process by default:
-
-- No separate worker processes
-- No Redis required for jobs or broadcasts
-- One deployment unit for most applications
-
-This simplifies both local development and production setup.
-
-For high-scale scenarios, Rage supports multi-process deployments and allows Rage processes to communicate directly when needed.
-
-### 2. API-First, Rails-Compatible
-
-Rage provides a familiar Rails-like programming model with API-focused improvements:
-
-- Controllers and routing that feel like Rails
-- Active Record compatibility
-- Incremental adoption for existing Rails applications
-- OpenAPI specs auto-generated from your code
-
-Rails compatibility is the foundation. Rage builds on top of that foundation with new primitives designed for high-concurrency, API-first architectures.
-
-### 3. Built-in Asynchronous Execution
-
-Rage ships with **fiber-based, in-process background jobs**:
-
-- Zero setup - no Redis, no configuration
-- Jobs persist across restarts
-- Scheduled and executed within the same runtime using fibers for concurrency
-
-For teams that need distributed job processing, Rage works with existing solutions. But most applications can start simple and stay simple.
-
-### 4. Structured Domain Events
-
-Rage includes a built‑in event bus designed for **object‑oriented domain events**:
-
-* Events are classes with explicit attributes, not hashes or strings
-* Subscribers listen to event classes or mixins
-* Type-safe and refactorable
-
-This encourages clear domain modeling and avoids the brittleness of string-based notification systems.
-
-### 5. Observability by Design
-
-Observability is not an afterthought:
-
-- Structured logging by default
-- Dedicated observability interface for HTTP, background, and real-time features
-- OpenAPI specifications generated automatically from the running application
-
-API contracts stay in sync with code by default - no separate documentation pipelines.
-
-### 6. Performance That Enables Simplicity
-
-Rage's fiber-based concurrency delivers strong performance for I/O-heavy workloads, but performance is a means to an end: operational simplicity.
-
-By handling concurrency efficiently, Rage lets you:
-
-- Run fewer servers
-- Deploy fewer services
-- Reduce infrastructure by handling workloads that traditionally required separate microservices
-
-The goal is to let teams write maintainable Ruby code while natively handling massive concurrency, eliminating the need for premature optimization or infrastructure sprawl.
-
-## Philosophy
-
-Rage is intentionally conservative about change.
-
-The framework prioritizes:
-
-- **Stable public APIs**
-- **Long deprecation cycles**
-- **Minimal external dependencies**
-
-The goal is to let teams build systems that **age well** - without constant rewrites or growing infrastructure complexity.
-
-Our aspiration: the task "Upgrade Rage" never appears in your ticketing system. Most updates should be as simple as `bundle update`.
-
-## What Rage Is (and Isn't)
-
-**Rage is:**
-
-- Focused on backend APIs
-- Opinionated about operational simplicity
-- Designed for long-term stability
-- Rails-compatible but architecturally independent
-
-**Rage is not:**
-
-- A full-stack framework - no view layer, no asset pipeline
-- A Rails clone - compatibility is a bridge, not the destination
-- Trying to do everything - deliberate scope boundaries
-
-## Who Rage Is For
-
-Rage is a good fit if you:
+## Stability
 
-- Build API-only backends in Ruby
-- Care about operational simplicity over maximum flexibility
-- Want fewer moving parts in production
-- Prefer explicit, object-oriented design
-- Value long-term stability over cutting-edge features
+Rage prioritizes stable public APIs, long deprecation cycles, and minimal external dependencies. Our aspiration: the task "Upgrade Rage" never appears in your ticketing system. Most updates should be as simple as `bundle update`.
 
 ## Learn More
 

data/lib/rage/configuration.rb

@@ -281,6 +281,14 @@ class Rage::Configuration
   end
   # @!endgroup
 
+  # @!group Blocking Operation Pool Configuration
+  # Allows configuring the thread pool for offloading native calls.
+  # @return [Rage::Configuration::BlockingOperationPool]
+  def blocking_operation_pool
+    @blocking_operation_pool ||= BlockingOperationPool.new
+  end
+  # @!endgroup
+
   # @private
   def pubsub
     @pubsub ||= PubSub.new
@@ -294,7 +302,7 @@ class Rage::Configuration
   # @private
   def run_after_initialize!
     run_hooks_for!(:after_initialize, self)
-    __finalize
+    __finalize(true)
   end
 
   class LogContext
@@ -1082,6 +1090,31 @@ class Rage::Configuration
     attr_accessor :form_actions
   end
 
+  class BlockingOperationPool
+    # @!attribute enabled
+    #   Enable a background thread pool for offloading native calls that can be executed outside the GVL, freeing
+    #   the main server thread to continue processing other requests. This acts as a preemption mechanism: native calls
+    #   won't stall requests, as the OS will context-switch between the server thread and the worker threads.
+    #   Defaults to `false`.
+    #   @return [Boolean]
+    #   @example Enable the thread pool
+    #     Rage.configure do
+    #       config.blocking_operation_pool.enabled = true
+    #     end
+    #
+    # @!attribute size
+    #   Specify the number of threads in the pool. Defaults to `1`. A single thread is sufficient in most cases
+    #   because the pool's goal is context switching, not parallelization.
+    #   @return [Integer]
+    attr_accessor :enabled, :size
+
+    # @private
+    def initialize
+      @enabled = false
+      @size = 1
+    end
+  end
+
   # @private
   class PubSub
     attr_reader :adapter
@@ -1148,7 +1181,7 @@ class Rage::Configuration
   end
 
   # @private
-  def __finalize
+  def __finalize(before_boot = false)
     if @logger
       @logger.formatter = @log_formatter if @log_formatter
       @logger.level = @log_level if @log_level
@@ -1170,6 +1203,15 @@ class Rage::Configuration
       @logger.dynamic_tags = Rage.__log_processor.dynamic_tags
     end
 
+    if before_boot && @blocking_operation_pool&.enabled
+      if defined?(Rage::FiberScheduler::BlockingOperationWait)
+        Iodine.on_state(:pre_start) { puts "INFO: Using blocking operation pool" }
+        Rage::FiberScheduler.include(Rage::FiberScheduler::BlockingOperationWait)
+      else
+        puts "WARNING: Blocking operation pool is not supported on Ruby #{RUBY_VERSION}"
+      end
+    end
+
     if defined?(::Rack::Events) && middleware.include?(::Rack::Events)
       middleware.delete(Rage::BodyFinalizer)
       middleware.insert_before(::Rack::Events, Rage::BodyFinalizer)

data/lib/rage/controller/api.rb

@@ -558,13 +558,13 @@ class RageController::API
   def authenticate_with_http_token
     auth_header = @__env["HTTP_AUTHORIZATION"]
 
-    payload = if auth_header&.start_with?("Bearer")
+    payload = if auth_header&.start_with?("Bearer ")
       auth_header[7..]
-    elsif auth_header&.start_with?("Token")
+    elsif auth_header&.start_with?("Token ")
       auth_header[6..]
     end
 
-    return unless payload
+    return if payload.nil? || payload.empty?
 
     token = if payload.start_with?("token=")
       payload[6..]
@@ -575,6 +575,8 @@ class RageController::API
     token.delete_prefix!('"')
     token.delete_suffix!('"')
 
+    return if token.empty?
+
     yield token
   end
 

data/lib/rage/cookies.rb

@@ -201,7 +201,7 @@ class Rage::Cookies
     end
 
     if (domain = value[:domain])
-      host = @env["HTTP_HOST"]
+      host = @env["HTTP_HOST"]&.sub(/:\d+\z/, "")
 
       processed_domain = if domain.is_a?(String)
         domain

data/lib/rage/fiber.rb

@@ -111,23 +111,7 @@ class Fiber
   end
 
   # @private
-  def __block_channel(force = false)
-    @__block_channel_i ||= 0
-    @__block_channel_i += 1 if force
-
-    "block:#{object_id}:#{@__block_channel_i}"
-  end
-
-  # @private
-  def __await_channel(force = false)
-    @__fiber_channel_i ||= 0
-    @__fiber_channel_i += 1 if force
-
-    "await:#{object_id}:#{@__fiber_channel_i}"
-  end
-
-  # @private
-  attr_accessor :__awaited_fileno
+  attr_accessor :__awaited_fileno, :__wait_generation, :__block_channel, :__await_channel
 
   # @private
   # pause a fiber and resume in the next iteration of the event loop
@@ -156,7 +140,10 @@ class Fiber
   # @note This method should only be used when multiple fibers have to be processed in parallel. There's no need to use `Fiber.await` for single IO calls.
   def self.await(fibers)
     f, fibers = Fiber.current, Array(fibers)
-    await_channel = f.__await_channel(true)
+
+    f.__wait_generation ||= 0
+    gen = (f.__wait_generation += 1)
+    channel = f.__await_channel = "await:#{f.object_id}:#{gen}"
 
     Rage::Telemetry.tracer.span_core_fiber_await(fibers:) do
       # check which fibers are alive (i.e. have yielded) and which have errored out
@@ -179,17 +166,21 @@ class Fiber
       end
 
       # wait on async fibers; resume right away if one of the fibers errors out
-      Iodine.subscribe(await_channel) do |_, err|
-        if err == AWAIT_ERROR_MESSAGE
-          f.resume
+      Iodine.subscribe(channel) do |_, err|
+        done = if err == AWAIT_ERROR_MESSAGE
+          true
         else
           num_wait_for -= 1
-          f.resume if num_wait_for == 0
+          num_wait_for == 0
+        end
+
+        if done
+          Iodine.defer { Iodine.unsubscribe(channel) }
+          f.resume if f.alive? && gen == f.__wait_generation
         end
       end
 
       Fiber.defer(-1)
-      Iodine.defer { Iodine.unsubscribe(await_channel) }
 
       # if num_wait_for is not 0 means we exited prematurely because of an error
       if num_wait_for > 0

data/lib/rage/fiber_scheduler.rb

@@ -5,14 +5,20 @@ require "resolv"
 class Rage::FiberScheduler
   MAX_READ = 65536
 
+  # Initialize the scheduler, storing the root fiber and an empty DNS cache.
   def initialize
     @root_fiber = Fiber.current
     @dns_cache = {}
   end
 
+  # Wait for I/O events on a file descriptor, yielding the fiber until ready or timeout.
   def io_wait(io, events, timeout = nil)
     f = Fiber.current
-    ::Iodine::Scheduler.attach(io.fileno, events, timeout&.ceil) { |err| f.resume(err) }
+    gen = (f.__wait_generation += 1)
+
+    ::Iodine::Scheduler.attach(io.fileno, events, timeout&.ceil) do |err|
+      f.resume(err) if f.alive? && gen == f.__wait_generation
+    end
 
     err = Fiber.defer(io.fileno)
     if err == false || (err && err < 0)
@@ -22,6 +28,7 @@ class Rage::FiberScheduler
     end
   end
 
+  # Read data from an I/O object into a buffer, pausing the fiber between reads.
   def io_read(io, buffer, length, offset = 0)
     length_to_read = if length == 0
       buffer.size > MAX_READ ? MAX_READ : buffer.size
@@ -51,6 +58,7 @@ class Rage::FiberScheduler
   end
 
   unless ENV["RAGE_DISABLE_IO_WRITE"]
+    # Write data from a buffer to an I/O object.
     def io_write(io, buffer, length, offset = 0)
       bytes_to_write = length
       bytes_to_write = buffer.size if length == 0
@@ -61,6 +69,7 @@ class Rage::FiberScheduler
     end
   end
 
+  # Pause the current fiber for the specified duration.
   def kernel_sleep(duration = nil)
     block(nil, duration || 0)
     Fiber.pause if duration.nil? || duration < 1
@@ -80,6 +89,7 @@ class Rage::FiberScheduler
   #   result
   # end
 
+  # Resolve a hostname to IP addresses, caching results for 60 seconds.
   def address_resolve(hostname)
     @dns_cache[hostname] ||= begin
       ::Iodine.run_after(60_000) do
@@ -90,14 +100,18 @@ class Rage::FiberScheduler
     end
   end
 
+  # Block the current fiber until unblocked or timeout.
   def block(_blocker, timeout = nil)
-    f, fulfilled, channel = Fiber.current, false, Fiber.current.__block_channel(true)
+    f, fulfilled = Fiber.current, false
+
+    gen = (f.__wait_generation += 1)
+    channel = f.__block_channel = "block:#{f.object_id}:#{gen}"
 
     resume_fiber_block = proc do
       unless fulfilled
         fulfilled = true
         ::Iodine.defer { ::Iodine.unsubscribe(channel) }
-        f.resume if f.alive?
+        f.resume if f.alive? && gen == f.__wait_generation
       end
     end
 
@@ -109,10 +123,38 @@ class Rage::FiberScheduler
     Fiber.yield
   end
 
+  # Unblock a fiber by publishing to its block channel.
   def unblock(_blocker, fiber)
-    ::Iodine.publish(fiber.__block_channel, "", Iodine::PubSub::PROCESS)
+    ::Iodine.publish(fiber.__block_channel, "", Iodine::PubSub::PROCESS) if fiber.__block_channel
+  end
+
+  # Interrupt a fiber by incrementing its generation and raising an exception.
+  def fiber_interrupt(fiber, exception)
+    fiber.__wait_generation += 1
+    fiber.raise(exception)
+  end
+
+  if defined?(Iodine::WorkerPool)
+    module BlockingOperationWait
+      # Offload a native call to the worker pool, yielding until complete.
+      def blocking_operation_wait(work)
+        f = Fiber.current
+        gen = (f.__wait_generation += 1)
+
+        worker_pool.enqueue(work) do
+          f.resume if f.alive? && gen == f.__wait_generation
+        end
+
+        Fiber.yield
+      end
+
+      private def worker_pool
+        @worker_pool ||= Iodine::WorkerPool.new(Rage.config.blocking_operation_pool.size)
+      end
+    end
   end
 
+  # Create and schedule a new non-blocking fiber, handling request and user-spawned fibers differently.
   def fiber(&block)
     parent = Fiber.current
 
@@ -131,19 +173,22 @@ class Rage::FiberScheduler
           Fiber.current.__set_result(block.call)
         end
         # send a message for `Fiber.await` to work
-        Iodine.publish(parent.__await_channel, "", Iodine::PubSub::PROCESS) if parent.alive?
+        Iodine.publish(parent.__await_channel, "", Iodine::PubSub::PROCESS) if parent.__await_channel
       rescue Exception => e
         Fiber.current.__set_err(e)
-        Iodine.publish(parent.__await_channel, Fiber::AWAIT_ERROR_MESSAGE, Iodine::PubSub::PROCESS) if parent.alive?
+        Iodine.publish(parent.__await_channel, Fiber::AWAIT_ERROR_MESSAGE, Iodine::PubSub::PROCESS) if parent.__await_channel
       end
     end
 
+    fiber.__wait_generation = 0
     fiber.resume
 
     fiber
   end
 
+  # Clean up by closing the worker pool and Iodine scheduler.
   def close
+    @worker_pool&.close
     ::Iodine::Scheduler.close
   end
 end

data/lib/rage/openapi/openapi.rb

@@ -127,6 +127,37 @@ module Rage::OpenAPI
     end
   end
 
+  # @private
+  # @return [Array<Boolean, String, Hash>] a tuple of (is_collection, serializer, args)
+  def self.__parse_serializer_args(str)
+    is_collection, inner = __try_parse_collection(str)
+
+    if is_collection
+      # discard is_collection since we already know this is a collection from the outer call
+      _, clean_inner, args = __parse_serializer_args(inner)
+      if args.any?
+        [is_collection, clean_inner, args]
+      else
+        [is_collection, clean_inner, {}]
+      end
+    elsif str =~ /^([\w:]+)\(([^)]+)\)$/
+      [is_collection, $1, __parse_keywords($2)]
+    else
+      [is_collection, str, {}]
+    end
+  end
+
+  # @private
+  def self.__parse_keywords(str)
+    return {} if str.nil? || str.empty?
+
+    str.split(",").each_with_object({}) do |part, hash|
+      option = YAML.load(part)
+      return nil unless option.is_a?(Hash)
+      hash.merge!(option.transform_keys!(&:to_sym))
+    end
+  end
+
   # @private
   def self.__module_parent(klass)
     klass.name =~ /::[^:]+\z/ ? Object.const_get($`) : Object
@@ -191,6 +222,7 @@ require_relative "nodes/root"
 require_relative "nodes/parent"
 require_relative "nodes/method"
 require_relative "parsers/ext/alba"
+require_relative "parsers/ext/blueprinter"
 require_relative "parsers/ext/active_record"
 require_relative "parsers/yaml"
 require_relative "parsers/shared_reference"

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+class Rage::OpenAPI::Parsers::Ext::Blueprinter
+  def initialize(namespace: Object, root: Rage::OpenAPI::Nodes::Root.new, **)
+    @namespace = namespace
+    @root = root
+  end
+
+  def known_definition?(str)
+    _, str, _ = Rage::OpenAPI.__parse_serializer_args(str)
+    defined?(Blueprinter::Base) && @namespace.const_get(str).ancestors.include?(Blueprinter::Base)
+  rescue NameError
+    false
+  end
+
+  def parse(klass_str)
+    visitor = __parse(klass_str)
+    visitor.build_schema
+  end
+
+  def __parse(klass_str)
+    is_collection, klass_str, _ = Rage::OpenAPI.__parse_serializer_args(klass_str)
+
+    klass = @namespace.const_get(klass_str)
+    source_path, _ = Object.const_source_location(klass.name)
+    ast = Prism.parse_file(source_path)
+
+    visitor = Visitor.new(self, is_collection)
+    ast.value.accept(visitor)
+
+    visitor
+  end
+
+  class VisitorContext
+    attr_accessor :symbols, :keywords, :strings
+
+    def initialize
+      @symbols = []
+      @strings = []
+      @keywords = {}
+    end
+  end
+
+  class Visitor < Prism::Visitor
+    attr_accessor :schema
+
+    def initialize(parser, is_collection)
+      @parser = parser
+      @is_collection = is_collection
+
+      @context = nil
+      @schema = {}
+      @segment = @schema
+      @identifier = {}
+    end
+
+    def build_schema
+      result = { "type" => "object" }
+
+      properties = {}
+      properties.merge!(@identifier)
+      properties.merge!(@schema.sort.to_h)
+
+      result["properties"] = properties if properties.any?
+      result = { "type" => "array", "items" => result } if @is_collection
+      result
+    end
+
+    def visit_call_node(node)
+      case node.name
+      when :identifier
+        context = with_context { visit(node.arguments) }
+        @identifier[context.symbols.first] = { "type" => "string" }
+
+      when :fields, :field
+        context = with_context { visit(node.arguments) }
+
+        if context.keywords["name"]
+          @segment[context.keywords["name"]] = { "type" => "string" }
+        elsif node.block
+          @segment[context.symbols.first] = { "type" => "string" } if context.symbols.first
+          @segment[context.strings.first] = { "type" => "string" } if context.strings.first
+        else
+          context.symbols.each { |symbol| @segment[symbol] = { "type" => "string" } }
+          context.strings.each { |string| @segment[string] = { "type" => "string" } }
+        end
+      end
+    end
+
+    def visit_assoc_node(node)
+      @context.keywords[node.key.value] = node.value.unescaped
+    end
+
+    def visit_symbol_node(node)
+      @context.symbols << node.value
+    end
+
+    def visit_string_node(node)
+      @context.strings << node.unescaped
+    end
+
+    private
+
+    def with_context
+      @context = VisitorContext.new
+      yield
+      @context
+    end
+  end
+end

data/lib/rage/openapi/parsers/response.rb

@@ -5,6 +5,7 @@ class Rage::OpenAPI::Parsers::Response
     Rage::OpenAPI::Parsers::SharedReference,
     Rage::OpenAPI::Parsers::Ext::ActiveRecord,
     Rage::OpenAPI::Parsers::Ext::Alba,
+    Rage::OpenAPI::Parsers::Ext::Blueprinter,
     Rage::OpenAPI::Parsers::YAML
   ]
 

data/lib/rage/router/constrainer.rb

@@ -69,7 +69,7 @@ class Rage::Router::Constrainer
       # Optimization: inline the derivation for the common built in constraints
       if !strategy.custom?
         if key == :host
-          lines << "   host: env['HTTP_HOST'.freeze],"
+          lines << "   host: env['HTTP_HOST'.freeze]&.sub(/:\\d+\\z/, ''.freeze),"
         else
           raise ArgumentError, "unknown non-custom strategy for compiling constraint derivation function"
         end

data/lib/rage/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rage-rb
 version: !ruby/object:Gem::Version
-  version: 1.24.0
+  version: 1.25.0
 platform: ruby
 authors:
 - Roman Samoilov
@@ -199,6 +199,7 @@ files:
 - lib/rage/openapi/parser.rb
 - lib/rage/openapi/parsers/ext/active_record.rb
 - lib/rage/openapi/parsers/ext/alba.rb
+- lib/rage/openapi/parsers/ext/blueprinter.rb
 - lib/rage/openapi/parsers/request.rb
 - lib/rage/openapi/parsers/response.rb
 - lib/rage/openapi/parsers/shared_reference.rb
@@ -293,5 +294,6 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 3.6.9
 specification_version: 4
-summary: A modern Ruby framework designed for non-blocking I/O and simpler infrastructure
+summary: Fiber-based Ruby web framework combining Rails ergonomics with a unified
+  runtime
 test_files: []