rage-rb 0.6.0 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0eed317e69386a2c2cc765df7be687be754934801390e96013902e78670171eb
-  data.tar.gz: 44c899c5843d112ca222df4b863852df9e3728a63954ee3b5ab4ffd2cffd4e2e
+  metadata.gz: 1c3041038ae63ae245e261a7a2096195ab56291d236414e086646ae96a4a6d16
+  data.tar.gz: a64817ded16716fe714310c7318d8e1d318454615da43d37055b333e76778fa2
 SHA512:
-  metadata.gz: 4e158fd8202e9c6e4f94a7b243383c34f2179306a10724978083b6599197197221915857540ae2beb5ea98a5f602c6507bec89d192a57706b3aae2203c75a8a3
-  data.tar.gz: e9723bb6a0ef7b1a67db08799e3429ae4c2e9f88894afb9e614645673df7cb4e019107f0ca1339eb521fa7958fd259ca032385f98fdbddacd59415d960f0c347
+  metadata.gz: 350f5150012852a3ca2532c031ce8ef28338da6d985ef66dff59095dea6b3dbbc4498826996876722bc5b7991683fed82c2fd3854313f7ed59f9fff20aaf4315
+  data.tar.gz: 84cd798056a43c8eb0e94809f72f6b0ac602076aa904831a3a049a8ed13352cad9321329233063343b73e65c0fbf1521564b0cee6f3696c89877a0af15191c94

data/CHANGELOG.md

@@ -1,5 +1,11 @@
 ## [Unreleased]
 
+## [0.7.0] - 2024-01-09
+
+- Add conditional GET using `stale?` by [@tonekk](https://github.com/tonekk) (#55).
+- Add Rails integration (#57).
+- Add JSON log formatter (#59).
+
 ## [0.6.0] - 2023-12-22
 
 ### Added

data/README.md

@@ -143,17 +143,17 @@ end
 
 ## Upcoming releases
 
-Version | Changes
-------- |------------
-0.2 :white_check_mark: | ~~Gem configuration by env.<br>Add `skip_before_action`.<br>Add `rescue_from`.<br>Router updates:<br>&emsp;• make the `root` helper work correctly with `scope`;<br>&emsp;• support the `defaults` option;~~
-0.3 :white_check_mark: | ~~CLI updates:<br>&emsp;• `routes` task;<br>&emsp;• `console` task;<br>Support the `:if` and `:unless` options in `before_action`.<br>Allow to set response headers.~~
-0.4 :white_check_mark: | ~~Expose the `params` object.<br>Support header authentication with `authenticate_with_http_token`.<br>Router updates:<br>&emsp;• add the `resources` route helper;<br>&emsp;• add the `namespace` route helper;~~
-0.5 :white_check_mark:  | ~~Add request logging.~~
-0.6 | Automatic code reloading in development with Zeitwerk.
-0.7 | Expose the `send_data` and `send_file` methods.
-0.8 | Support conditional get with `etag` and `last_modified`.
-0.9 | Expose the `cookies` and `session` objects.
-1.0 | Implement Iodine-based equivalent of Action Cable.
+Status | Changes
+-- | ------------
+:white_check_mark: | ~~Gem configuration by env.<br>Add `skip_before_action`.<br>Add `rescue_from`.<br>Router updates:<br>&emsp;• make the `root` helper work correctly with `scope`;<br>&emsp;• support the `defaults` option;~~
+:white_check_mark: | ~~CLI updates:<br>&emsp;• `routes` task;<br>&emsp;• `console` task;<br>Support the `:if` and `:unless` options in `before_action`.<br>Allow to set response headers.~~
+:white_check_mark: | ~~Expose the `params` object.<br>Support header authentication with `authenticate_with_http_token`.<br>Router updates:<br>&emsp;• add the `resources` route helper;<br>&emsp;• add the `namespace` route helper;~~
+:white_check_mark:  | ~~Add request logging.~~
+:white_check_mark: | ~~Automatic code reloading in development with Zeitwerk.~~
+⏳ | Expose the `send_data` and `send_file` methods.
+⏳ | Support conditional get with `etag` and `last_modified`.
+⏳ | Expose the `cookies` and `session` objects.
+⏳ | Implement Iodine-based equivalent of Action Cable.
 
 ## Development
 

data/lib/rage/all.rb

@@ -6,6 +6,7 @@ require_relative "fiber"
 require_relative "fiber_scheduler"
 require_relative "configuration"
 require_relative "request"
+require_relative "response"
 require_relative "uploaded_file"
 require_relative "errors"
 require_relative "params_parser"
@@ -21,6 +22,7 @@ require_relative "router/node"
 require_relative "controller/api"
 
 require_relative "logger/text_formatter"
+require_relative "logger/json_formatter"
 require_relative "logger/logger"
 
 require_relative "middleware/fiber_wrapper"

data/lib/rage/application.rb

@@ -3,6 +3,7 @@
 class Rage::Application
   def initialize(router)
     @router = router
+    @exception_app = build_exception_app
   end
 
   def call(env)
@@ -17,10 +18,11 @@ class Rage::Application
       [404, {}, ["Not Found"]]
     end
 
+  rescue Rage::Errors::BadRequest => e
+    response = @exception_app.call(400, e)
+
   rescue Exception => e
-    exception_str = "#{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}"
-    Rage.logger.error(exception_str)
-    response = [500, {}, [exception_str]]
+    response = @exception_app.call(500, e)
 
   ensure
     finalize_logger(env, response, params)
@@ -50,4 +52,20 @@ class Rage::Application
     Rage.logger.info("")
     logger[:final] = nil
   end
+
+  def build_exception_app
+    if Rage.env.development?
+      ->(status, e) do
+        exception_str = "#{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}"
+        Rage.logger.error(exception_str)
+        [status, {}, [exception_str]]
+      end
+    else
+      ->(status, e) do
+        exception_str = "#{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}"
+        Rage.logger.error(exception_str)
+        [status, {}, []]
+      end
+    end
+  end
 end

data/lib/rage/cli.rb

@@ -18,13 +18,14 @@ module Rage
     option :port, aliases: "-p", desc: "Runs Rage on the specified port - defaults to 3000."
     option :environment, aliases: "-e", desc: "Specifies the environment to run this server under (test/development/production)."
     option :binding, aliases: "-b", desc: "Binds Rails to the specified IP - defaults to 'localhost' in development and '0.0.0.0' in other environments."
+    option :config, aliases: "-c", desc: "Uses a custom rack configuration."
     option :help, aliases: "-h", desc: "Show this message."
     def server
       return help("server") if options.help?
 
       set_env(options)
 
-      app = ::Rack::Builder.parse_file("config.ru")
+      app = ::Rack::Builder.parse_file(options[:config] || "config.ru")
       app = app[0] if app.is_a?(Array)
 
       port = options[:port] || Rage.config.server.port
@@ -114,6 +115,12 @@ module Rage
 
     def environment
       require File.expand_path("config/application.rb", Dir.pwd)
+
+      # in Rails mode we delegate code loading to Rails, and thus need
+      # to manually load application code for CLI utilities to work
+      if Rage.config.internal.rails_mode
+        require "rage/setup"
+      end
     end
 
     def set_env(options)

data/lib/rage/code_loader.rb

@@ -4,11 +4,12 @@ require "zeitwerk"
 
 class Rage::CodeLoader
   def initialize
-    @loader = Zeitwerk::Loader.new
     @reloading = false
   end
 
   def setup
+    @loader = Zeitwerk::Loader.new
+
     autoload_path = "#{Rage.root}/app"
     enable_reloading = Rage.env.development?
     enable_eager_loading = !Rage.env.development? && !Rage.env.test?
@@ -23,13 +24,24 @@ class Rage::CodeLoader
     @loader.eager_load if enable_eager_loading
   end
 
+  # in standalone mode - reload the code and the routes
   def reload
+    return unless @loader
+
     @reloading = true
     @loader.reload
     Rage.__router.reset_routes
     load("#{Rage.root}/config/routes.rb")
   end
 
+  # in Rails mode - reset the routes; everything else will be done by Rails
+  def rails_mode_reload
+    return if @loader
+
+    @reloading = true
+    Rage.__router.reset_routes
+  end
+
   def reloading?
     @reloading
   end

data/lib/rage/configuration.rb

@@ -109,6 +109,10 @@ class Rage::Configuration
     @middleware ||= Middleware.new
   end
 
+  def internal
+    @internal ||= Internal.new
+  end
+
   class Server
     attr_accessor :port, :workers_count, :timeout, :max_clients
     attr_reader :threads_count
@@ -160,6 +164,15 @@ class Rage::Configuration
     end
   end
 
+  # @private
+  class Internal
+    attr_accessor :rails_mode, :rails_console
+
+    def inspect
+      "#<#{self.class.name}>"
+    end
+  end
+
   # @private
   def __finalize
     if @logger

data/lib/rage/controller/api.rb

@@ -75,8 +75,16 @@ class RageController::API
         ""
       end
 
+      activerecord_loaded = Rage.config.internal.rails_mode && defined?(::ActiveRecord)
+
       class_eval <<~RUBY,  __FILE__, __LINE__ + 1
         def __run_#{action}
+          #{if activerecord_loaded
+            <<~RUBY
+              ActiveRecord::Base.connection_pool.enable_query_cache!
+            RUBY
+          end}
+
           #{before_actions_chunk}
           #{action}
 
@@ -90,6 +98,24 @@ class RageController::API
           [@__status, @__headers, @__body]
 
           #{rescue_handlers_chunk}
+
+        ensure
+          #{if activerecord_loaded
+            <<~RUBY
+              ActiveRecord::Base.connection_pool.disable_query_cache!
+              if ActiveRecord::Base.connection_pool.active_connection?
+                ActiveRecord::Base.connection_handler.clear_active_connections!
+              end
+            RUBY
+          end}
+
+          #{if method_defined?(:append_info_to_payload) || private_method_defined?(:append_info_to_payload)
+            <<~RUBY
+              context = {}
+              append_info_to_payload(context)
+              Thread.current[:rage_logger][:context] = context
+            RUBY
+          end}
         end
       RUBY
     end
@@ -196,6 +222,16 @@ class RageController::API
       end
     end
 
+    # Register a new `after_action` hook. Calls with the same `action_name` will overwrite the previous ones.
+    #
+    # @param action_name [String, nil] the name of the callback to add
+    # @param [Hash] opts action options
+    # @option opts [Symbol, Array<Symbol>] :only restrict the callback to run only for specific actions
+    # @option opts [Symbol, Array<Symbol>] :except restrict the callback to run for all actions except specified
+    # @option opts [Symbol, Proc] :if only run the callback if the condition is true
+    # @option opts [Symbol, Proc] :unless only run the callback if the condition is false
+    # @example
+    #   after_action :log_detailed_metrics, only: :create
     def after_action(action_name = nil, **opts, &block)
       action = prepare_action_params(action_name, **opts, &block)
 
@@ -268,22 +304,26 @@ class RageController::API
     end
   end # class << self
 
-  # @private
-  DEFAULT_HEADERS = { "content-type" => "application/json; charset=utf-8" }.freeze
-
   # @private
   def initialize(env, params)
     @__env = env
     @__params = params
-    @__status, @__headers, @__body = 204, DEFAULT_HEADERS, []
+    @__status, @__headers, @__body = 204, { "content-type" => "application/json; charset=utf-8" }, []
     @__rendered = false
   end
 
   # Get the request object. See {Rage::Request}.
+  # @return [Rage::Request]
   def request
     @request ||= Rage::Request.new(@__env)
   end
 
+  # Get the response object. See {Rage::Response}.
+  # @return [Rage::Response]
+  def response
+    @response ||= Rage::Response.new(@__headers, @__body)
+  end
+
   # Send a response to the client.
   #
   # @param json [String, Object] send a json response to the client; objects like arrays will be serialized automatically
@@ -339,11 +379,10 @@ class RageController::API
 
   # Set response headers.
   #
+  # @return [Hash]
   # @example
   #   headers["Content-Type"] = "application/pdf"
   def headers
-    # copy-on-write implementation for the headers object
-    @__headers = {}.merge!(@__headers) if DEFAULT_HEADERS.equal?(@__headers)
     @__headers
   end
 
@@ -357,11 +396,24 @@ class RageController::API
   def authenticate_with_http_token
     auth_header = @__env["HTTP_AUTHORIZATION"]
 
-    if auth_header&.start_with?("Bearer")
-      yield auth_header[7..]
+    payload = if auth_header&.start_with?("Bearer")
+      auth_header[7..]
     elsif auth_header&.start_with?("Token")
-      yield auth_header[6..]
+      auth_header[6..]
     end
+
+    return unless payload
+
+    token = if payload.start_with?("token=")
+      payload[6..]
+    else
+      payload
+    end
+
+    token.delete_prefix!('"')
+    token.delete_suffix!('"')
+
+    yield token
   end
 
   if !defined?(::ActionController::Parameters)
@@ -389,4 +441,40 @@ class RageController::API
       @params ||= ActionController::Parameters.new(@__params)
     end
   end
+
+  # Checks if the request is stale to decide if the action has to be rendered or the cached version is still valid. Use this method to implement conditional GET.
+  #
+  # @param etag [String] The etag of the requested resource.
+  # @param last_modified [Time] The last modified time of the requested resource.
+  # @return [Boolean] True if the response is stale, false otherwise.
+  # @example
+  #  stale?(etag: "123", last_modified: Time.utc(2023, 12, 15))
+  #  stale?(last_modified: Time.utc(2023, 12, 15))
+  #  stale?(etag: "123")
+  # @note `stale?` will set the response status to 304 if the request is fresh. This side effect will cause a double render error, if `render` gets called after this method. Make sure to implement a proper conditional in your action to prevent this from happening:
+  #  ```ruby
+  #  if stale?(etag: "123")
+  #    render json: { hello: "world" }
+  #  end
+  #  ```
+  def stale?(etag: nil, last_modified: nil)
+    still_fresh = request.fresh?(etag:, last_modified:)
+
+    head :not_modified if still_fresh
+    !still_fresh
+  end
+
+  # @private
+  # for comatibility with `Rails.application.routes.recognize_path`
+  def self.binary_params_for?(_)
+    false
+  end
+
+  # @!method append_info_to_payload(payload)
+  #   Define this method to add more information to request logs.
+  #   @param [Hash] payload the payload to add additional information to
+  #   @example
+  #     def append_info_to_payload(payload)
+  #       payload[:response] = response.body
+  #     end
 end

data/lib/rage/logger/json_formatter.rb

@@ -0,0 +1,44 @@
+class Rage::JSONFormatter
+  def initialize
+    @pid = Process.pid.to_s
+    Iodine.on_state(:on_start) do
+      @pid = Process.pid.to_s
+    end
+  end
+
+  def call(severity, timestamp, _, message)
+    logger = Thread.current[:rage_logger]
+    tags, context = logger[:tags], logger[:context]
+
+    if !context.empty?
+      context_msg = ""
+      context.each { |k, v| context_msg << "\"#{k}\":#{v.to_json}," }
+    end
+
+    if final = logger[:final]
+      params, env = final[:params], final[:env]
+      if params
+        return "{\"tags\":[\"#{tags[0]}\"],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"info\",\"method\":\"#{env["REQUEST_METHOD"]}\",\"path\":\"#{env["PATH_INFO"]}\",\"controller\":\"#{params[:controller]}\",\"action\":\"#{params[:action]}\",#{context_msg}\"status\":#{final[:response][0]},\"duration\":#{final[:duration]}}\n"
+      else
+        # no controller/action keys are written if there are no params
+        return "{\"tags\":[\"#{tags[0]}\"],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"info\",\"method\":\"#{env["REQUEST_METHOD"]}\",\"path\":\"#{env["PATH_INFO"]}\",#{context_msg}\"status\":#{final[:response][0]},\"duration\":#{final[:duration]}}\n"
+      end
+    end
+
+    if tags.length == 1
+      tags_msg = "{\"tags\":[\"#{tags[0]}\"],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"#{severity}\""
+    elsif tags.length == 2
+      tags_msg = "{\"tags\":[\"#{tags[0]}\",\"#{tags[1]}\"],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"#{severity}\""
+    else
+      tags_msg = "{\"tags\":[\"#{tags[0]}\",\"#{tags[1]}\""
+      i = 2
+      while i < tags.length
+        tags_msg << ",\"#{tags[i]}\""
+        i += 1
+      end
+      tags_msg << "],\"timestamp\":\"#{timestamp}\",\"pid\":\"#{@pid}\",\"level\":\"#{severity}\""
+    end
+
+    "#{tags_msg},#{context_msg}\"message\":\"#{message}\"}\n"
+  end
+end

data/lib/rage/logger/logger.rb

@@ -128,8 +128,8 @@ class Rage::Logger
             false
           end
         RUBY
-      elsif defined?(IRB)
-        # the call was made from IRB - don't use the formatter
+      elsif (Rage.config.internal.rails_mode ? Rage.config.internal.rails_console : defined?(IRB))
+        # the call was made from the console - don't use the formatter
         <<-RUBY
           def #{level_name}(msg = nil)
             @logdev.write((msg || yield) + "\n")

data/lib/rage/logger/text_formatter.rb

@@ -8,15 +8,20 @@ class Rage::TextFormatter
 
   def call(severity, timestamp, _, message)
     logger = Thread.current[:rage_logger]
-    tags = logger[:tags]
+    tags, context = logger[:tags], logger[:context]
+
+    if !context.empty?
+      context_msg = ""
+      context.each { |k, v| context_msg << "#{k}=#{v} " }
+    end
 
     if final = logger[:final]
       params, env = final[:params], final[:env]
       if params
-        return "[#{tags[0]}] timestamp=#{timestamp} pid=#{@pid} level=info method=#{env["REQUEST_METHOD"]} path=#{env["PATH_INFO"]} controller=#{params[:controller]} action=#{params[:action]} status=#{final[:response][0]} duration=#{final[:duration]}\n"
+        return "[#{tags[0]}] timestamp=#{timestamp} pid=#{@pid} level=info method=#{env["REQUEST_METHOD"]} path=#{env["PATH_INFO"]} controller=#{params[:controller]} action=#{params[:action]} #{context_msg}status=#{final[:response][0]} duration=#{final[:duration]}\n"
       else
         # no controller/action keys are written if there are no params
-        return "[#{tags[0]}] timestamp=#{timestamp} pid=#{@pid} level=info method=#{env["REQUEST_METHOD"]} path=#{env["PATH_INFO"]} status=#{final[:response][0]} duration=#{final[:duration]}\n"
+        return "[#{tags[0]}] timestamp=#{timestamp} pid=#{@pid} level=info method=#{env["REQUEST_METHOD"]} path=#{env["PATH_INFO"]} #{context_msg}status=#{final[:response][0]} duration=#{final[:duration]}\n"
       end
     end
 
@@ -34,13 +39,6 @@ class Rage::TextFormatter
       tags_msg << " timestamp=#{timestamp} pid=#{@pid} level=#{severity}"
     end
 
-    context = logger[:context]
-
-    if !context.empty?
-      context_msg = ""
-      context.each { |k, v| context_msg << "#{k}=#{v} " }
-    end
-
     "#{tags_msg} #{context_msg}message=#{message}\n"
   end
 end

data/lib/rage/middleware/cors.rb

@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
 class Rage::Cors
+  # @private
   def initialize(app, *, &)
     @app = app
     instance_eval(&)
   end
 
+  # @private
   def call(env)
     if env["REQUEST_METHOD"] == "OPTIONS"
       return (response = @cors_response)
@@ -17,7 +19,7 @@ class Rage::Cors
 
     response
   ensure
-    if origin = @cors_check.call(env)
+    if !$! && origin = @cors_check.call(env)
       headers = response[1]
       headers["Access-Control-Allow-Origin"] = origin
       if @origins != "*"

data/lib/rage/rails.rb

@@ -0,0 +1,62 @@
+if Gem::Version.new(Rails.version) < Gem::Version.new(6)
+  fail "Rage is only compatible with Rails 6+. Detected Rails version: #{Rails.version}."
+end
+
+# load the framework
+require "rage/all"
+
+# patch Rack
+Iodine.patch_rack
+
+# configure the framework
+Rage.config.internal.rails_mode = true
+
+# make sure log formatter is not used in console
+Rails.application.console do
+  Rage.config.internal.rails_console = true
+  Rage.logger.level = Rage.logger.level if Rage.logger # trigger redefining log methods
+end
+
+# patch ActiveRecord's connection pool
+if defined?(ActiveRecord)
+  Rails.configuration.after_initialize do
+    module ActiveRecord::ConnectionAdapters
+      class ConnectionPool
+        def connection_cache_key(_)
+          Fiber.current
+        end
+      end
+    end
+  end
+end
+
+# plug into Rails' Zeitwerk instance to reload the code
+Rails.autoloaders.main.on_setup do
+  if Iodine.running?
+    Rage.code_loader.rails_mode_reload
+  end
+end
+
+# patch `ActionDispatch::Reloader` to synchronize `reload!` calls
+Rails.configuration.after_initialize do
+  conditional_mutex = Module.new do
+    def call(env)
+      @mutex ||= Mutex.new
+      if Rails.application.reloader.check!
+        @mutex.synchronize { super }
+      else
+        super
+      end
+    end
+  end
+
+  ActionDispatch::Reloader.prepend(conditional_mutex)
+end
+
+# clone Rails logger
+Rails.configuration.after_initialize do
+  if Rails.logger && !Rage.logger
+    rails_logdev = Rails.logger.instance_variable_get(:@logdev)
+    Rage.config.logger = Rage::Logger.new(rails_logdev) if rails_logdev.is_a?(Logger::LogDevice)
+  end
+end

data/lib/rage/request.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "time"
+
 class Rage::Request
   # @private
   def initialize(env)
@@ -14,6 +16,55 @@ class Rage::Request
     @headers ||= Headers.new(@env)
   end
 
+  # Check if the request is fresh.
+  # @param etag [String] The etag of the requested resource.
+  # @param last_modified [Time] The last modified time of the requested resource.
+  # @return [Boolean] True if the request is fresh, false otherwise.
+  # @example
+  #  request.fresh?(etag: "123", last_modified: Time.utc(2023, 12, 15))
+  #  request.fresh?(last_modified: Time.utc(2023, 12, 15))
+  #  request.fresh?(etag: "123")
+  def fresh?(etag:, last_modified:)
+    # Always render response when no freshness information
+    # is provided in the request.
+    return false unless if_none_match || if_not_modified_since
+
+    etag_matches?(
+      requested_etags: if_none_match, response_etag: etag
+    ) && not_modified?(
+      request_not_modified_since: if_not_modified_since,
+      response_last_modified: last_modified
+    )
+  end
+
+  private
+
+  def if_none_match
+    headers["HTTP_IF_NONE_MATCH"]
+  end
+
+  def if_not_modified_since
+    headers["HTTP_IF_MODIFIED_SINCE"] ? Time.httpdate(headers["HTTP_IF_MODIFIED_SINCE"]) : nil
+  rescue ArgumentError
+    nil
+  end
+
+  def etag_matches?(requested_etags:, response_etag:)
+    requested_etags = requested_etags ? requested_etags.split(",").each(&:strip!) : []
+
+    return true if requested_etags.empty?
+    return false if response_etag.nil?
+
+    requested_etags.include?(response_etag) || requested_etags.include?("*")
+  end
+
+  def not_modified?(request_not_modified_since:, response_last_modified:)
+    return true if request_not_modified_since.nil?
+    return false if response_last_modified.nil?
+
+    request_not_modified_since >= response_last_modified
+  end
+
   # @private
   class Headers
     HTTP = "HTTP_"

data/lib/rage/response.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Rage::Response
+  # @private
+  def initialize(headers, body)
+    @headers = headers
+    @body = body
+  end
+
+  # Returns the content of the response as a string. This contains the contents of any calls to `render`.
+  # @return [String]
+  def body
+    @body[0]
+  end
+
+  # Returns the headers for the response.
+  # @return [Hash]
+  def headers
+    @headers
+  end
+end

data/lib/rage/router/dsl.rb

@@ -7,6 +7,8 @@ class Rage::Router::DSL
 
   def draw(&block)
     Handler.new(@router).instance_eval(&block)
+    # propagate route definitions to Rails for `rails routes` to work
+    Rails.application.routes.draw(&block) if Rage.config.internal.rails_mode
   end
 
   ##
@@ -283,7 +285,7 @@ class Rage::Router::DSL
       end
 
       _module, _path, _only, _except, _param = opts.values_at(:module, :path, :only, :except, :param)
-      raise ":param option can't contain colons" if _param&.include?(":")
+      raise ":param option can't contain colons" if _param.to_s.include?(":")
 
       _only = Array(_only) if _only
       _except = Array(_except) if _except

data/lib/rage/version.rb

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

data/lib/rage-rb.rb

@@ -45,6 +45,24 @@ module Rage
 
   def self.load_middlewares(rack_builder)
     config.middleware.middlewares.each do |middleware, args, block|
+      # in Rails compatibility mode we first check if the middleware is a part of the Rails middleware stack;
+      # if it is - it is expected to be built using `ActionDispatch::MiddlewareStack::Middleware#build`, but Rack
+      # expects the middleware to respond to `#new`, so we wrap the middleware into a helper module
+      if Rage.config.internal.rails_mode
+        rails_middleware = Rails.application.config.middleware.middlewares.find { |m| m.name == middleware.name }
+        if rails_middleware
+          wrapper = Module.new do
+            extend self
+            attr_accessor :middleware
+            def new(app, *, &)
+              middleware.build(app)
+            end
+          end
+          wrapper.middleware = rails_middleware
+          middleware = wrapper
+        end
+      end
+
       rack_builder.use(middleware, *args, &block)
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rage-rb
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.7.0
 platform: ruby
 authors:
 - Roman Samoilov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-12-22 00:00:00.000000000 Z
+date: 2024-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -95,13 +95,16 @@ files:
 - lib/rage/errors.rb
 - lib/rage/fiber.rb
 - lib/rage/fiber_scheduler.rb
+- lib/rage/logger/json_formatter.rb
 - lib/rage/logger/logger.rb
 - lib/rage/logger/text_formatter.rb
 - lib/rage/middleware/cors.rb
 - lib/rage/middleware/fiber_wrapper.rb
 - lib/rage/middleware/reloader.rb
 - lib/rage/params_parser.rb
+- lib/rage/rails.rb
 - lib/rage/request.rb
+- lib/rage/response.rb
 - lib/rage/router/README.md
 - lib/rage/router/backend.rb
 - lib/rage/router/constrainer.rb