rage-rb 0.5.2 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: abee0787faa5947d8ecb03f9c5851cb669295bc2bd52abe5513e7b10940ddfff
-  data.tar.gz: d167a4d6a48dbced809578f3c3a569c5ccdb913ed7bf51eba3e8d054b61e1c75
+  metadata.gz: 0eed317e69386a2c2cc765df7be687be754934801390e96013902e78670171eb
+  data.tar.gz: 44c899c5843d112ca222df4b863852df9e3728a63954ee3b5ab4ffd2cffd4e2e
 SHA512:
-  metadata.gz: eea4d03aa25b675fdf1f19836037dceaeb7f38e2227af9cafc1609d59b8f322d3e3fa49da7905b4c0dd783615d16ce6e592aa11f2fa934056d711f03aaafbb43
-  data.tar.gz: adf6eaaee9a88eef39631581ce52eaa311b5ac61797f481a95e28502ccabf166615a87e215b5f5b3260ebdfbb5c28f8c32e1e8342566d9d23836e56eb97b14d8
+  metadata.gz: 4e158fd8202e9c6e4f94a7b243383c34f2179306a10724978083b6599197197221915857540ae2beb5ea98a5f602c6507bec89d192a57706b3aae2203c75a8a3
+  data.tar.gz: e9723bb6a0ef7b1a67db08799e3429ae4c2e9f88894afb9e614645673df7cb4e019107f0ca1339eb521fa7958fd259ca032385f98fdbddacd59415d960f0c347

data/CHANGELOG.md

@@ -1,5 +1,18 @@
 ## [Unreleased]
 
+## [0.6.0] - 2023-12-22
+
+### Added
+
+- Implement after actions (#53).
+- Zeitwerk autoloading and reloading by [@alex-rogachev](https://github.com/alex-rogachev) (#54).
+- Support the `environment`, `binding`, `timeout`, and `max_clients` options when using `rage s` (#52).
+- Add CORS middleware (#49).
+
+### Fixed
+
+- Prevent `block` and `sleep` channels from conflicting (#51).
+
 ## [0.5.2] - 2023-12-11
 
 ### Added

data/CODE_OF_CONDUCT.md

@@ -39,7 +39,7 @@ This Code of Conduct applies within all community spaces, and also applies when
 
 ## Enforcement
 
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at roman.samoilov@wework.com. All complaints will be reviewed and investigated promptly and fairly.
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported to the community leaders responsible for enforcement at developers@rage-rb.dev. All complaints will be reviewed and investigated promptly and fairly.
 
 All community leaders are obligated to respect the privacy and security of the reporter of any incident.
 

data/README.md

@@ -52,6 +52,7 @@ Check out in-depth API docs for more information:
 - [Routing API](https://rage-rb.pages.dev/Rage/Router/DSL/Handler)
 - [Fiber API](https://rage-rb.pages.dev/Fiber)
 - [Logger API](https://rage-rb.pages.dev/Rage/Logger)
+- [Configuration API](https://rage-rb.pages.dev/Rage/Configuration)
 
 Also, see the [changelog](https://github.com/rage-rb/rage/blob/master/CHANGELOG.md) and [upcoming-releases](https://github.com/rage-rb/rage#upcoming-releases) for currently supported and planned features.
 

data/lib/rage/all.rb

@@ -9,7 +9,7 @@ require_relative "request"
 require_relative "uploaded_file"
 require_relative "errors"
 require_relative "params_parser"
-require_relative "fiber_wrapper"
+require_relative "code_loader"
 
 require_relative "router/strategies/host"
 require_relative "router/backend"
@@ -23,6 +23,10 @@ require_relative "controller/api"
 require_relative "logger/text_formatter"
 require_relative "logger/logger"
 
+require_relative "middleware/fiber_wrapper"
+require_relative "middleware/cors"
+require_relative "middleware/reloader"
+
 if defined?(Sidekiq)
   require_relative "sidekiq_session"
 end

data/lib/rage/cli.rb

@@ -16,18 +16,23 @@ module Rage
 
     desc "s", "Start the app server."
     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 :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 = app[0] if app.is_a?(Array)
 
-      unless app.is_a?(Rage::FiberWrapper)
-        raise <<-ERR
-          Couldn't find the default middleware. Make sure to add the following line to your config.ru file:
-          Rage.load_middlewares(self)
-        ERR
-      end
+      port = options[:port] || Rage.config.server.port
+      address = options[:binding] || (Rage.env.production? ? "0.0.0.0" : "localhost")
+      timeout = Rage.config.server.timeout
+      max_clients = Rage.config.server.max_clients
 
-      ::Iodine.listen service: :http, handler: app, port: options[:port] || Rage.config.server.port
+      ::Iodine.listen service: :http, handler: app, port: port, address: address, timeout: timeout, max_clients: max_clients
       ::Iodine.threads = Rage.config.server.threads_count
       ::Iodine.workers = Rage.config.server.workers_count
 
@@ -36,12 +41,15 @@ module Rage
 
     desc 'routes', 'List all routes.'
     option :grep, aliases: "-g", desc: "Filter routes by pattern"
+    option :help, aliases: "-h", desc: "Show this message."
     def routes
+      return help("routes") if options.help?
       # the result would be something like this:
       # Verb  Path  Controller#Action
       # GET   /     application#index
 
       # load config/application.rb
+      set_env(options)
       environment
 
       routes = Rage.__router.routes
@@ -90,7 +98,12 @@ module Rage
     end
 
     desc "c", "Start the app console."
+    option :help, aliases: "-h", desc: "Show this message."
     def console
+      return help("console") if options.help?
+
+      set_env(options)
+
       require "irb"
       environment
       ARGV.clear
@@ -102,6 +115,10 @@ module Rage
     def environment
       require File.expand_path("config/application.rb", Dir.pwd)
     end
+
+    def set_env(options)
+      ENV["RAGE_ENV"] = options[:environment] || ENV["RAGE_ENV"] || ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
+    end
   end
 
   class NewAppGenerator < Thor::Group

data/lib/rage/code_loader.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "zeitwerk"
+
+class Rage::CodeLoader
+  def initialize
+    @loader = Zeitwerk::Loader.new
+    @reloading = false
+  end
+
+  def setup
+    autoload_path = "#{Rage.root}/app"
+    enable_reloading = Rage.env.development?
+    enable_eager_loading = !Rage.env.development? && !Rage.env.test?
+
+    @loader.push_dir(autoload_path)
+    # The first level of directories in app directory won't be treated as modules
+    # e.g. app/controllers/pages_controller.rb will be linked to PagesController class
+    # instead of Controllers::PagesController
+    @loader.collapse("#{Rage.root}/app/*")
+    @loader.enable_reloading if enable_reloading
+    @loader.setup
+    @loader.eager_load if enable_eager_loading
+  end
+
+  def reload
+    @reloading = true
+    @loader.reload
+    Rage.__router.reset_routes
+    load("#{Rage.root}/config/routes.rb")
+  end
+
+  def reloading?
+    @reloading
+  end
+end

data/lib/rage/configuration.rb

@@ -1,9 +1,106 @@
+# frozen_string_literal: true
+
+##
+# # General Configuration
+#
+# • _config.logger_
+#
+# > The logger that will be used for `Rage.logger` and any related `Rage` logging. Custom loggers should implement Ruby's {https://ruby-doc.org/3.2.2/stdlibs/logger/Logger.html#class-Logger-label-Entries Logger} interface.
+#
+# • _config.log_formatter_
+#
+# > The formatter of the Rage logger. Built in options include `Rage::TextFormatter` and `Rage::JSONFormatter`. Defaults to an instance of `Rage::TextFormatter`.
+#
+# • _config.log_level_
+#
+# > Defines the verbosity of the Rage logger. This option defaults to `:debug` for all environments except production, where it defaults to `:info`. The available log levels are: `:debug`, `:info`, `:warn`, `:error`, `:fatal`, and `:unknown`.
+#
+# # Middleware Configuration
+#
+# • _config.middleware.use_
+#
+# > Adds a middleware to the top of the middleware stack. **This is the preferred way of adding a middleware.**
+# > ```
+# config.middleware.use Rack::Cors do
+#   allow do
+#     origins "*"
+#     resource "*", headers: :any
+#   end
+# end
+# > ```
+#
+# • _config.middleware.insert_before_
+#
+# > Adds middleware at a specified position before another middleware. The position can be either an index or another middleware.
+#
+# > **_❗️Heads up:_** By default, Rage always uses the `Rage::FiberWrapper` middleware, which wraps every request in a separate fiber. Make sure to always have this middleware in the top of the stack. Placing other middlewares in front may lead to undefined behavior.
+#
+# > ```
+# config.middleware.insert_before Rack::Head, Magical::Unicorns
+# config.middleware.insert_before 0, Magical::Unicorns
+# > ```
+#
+# • _config.middleware.insert_after_
+#
+# > Adds middleware at a specified position after another middleware. The position can be either an index or another middleware.
+#
+# > ```
+# config.middleware.insert_after Rack::Head, Magical::Unicorns
+# > ```
+#
+# # Server Configuration
+#
+# _• config.server.max_clients_
+#
+# > Limits the number of simultaneous connections the server can accept. Defaults to the maximum number of open files.
+#
+# > **_❗️Heads up:_** Decreasing this number is almost never a good idea. Depending on your application specifics, you are encouraged to use other methods to limit the number of concurrent connections:
+#
+# > 1. If your application is exposed to the public, you may want to use a cloud rate limiter, like {https://developers.cloudflare.com/waf Cloudflare WAF} or {https://docs.fastly.com/en/ngwaf Fastly WAF}.
+# > 2. Otherwise, consider using tools like {https://github.com/rack/rack-attack Rack::Attack} or {https://github.com/mperham/connection_pool connection_pool}.
+#
+# > ```
+# # Limit the amount of connections your application can accept
+# config.middleware.use Rack::Attack
+# Rack::Attack.throttle("req/ip", limit: 300, period: 5.minutes) do |req|
+#   req.ip
+# end
+# #
+# # Limit the amount of connections to a specific resource
+# HTTP = ConnectionPool.new(size: 5, timeout: 5) { Net::HTTP }
+# HTTP.with do |conn|
+#   conn.get("/my-resource")
+# end
+# > ```
+#
+# • _config.server.port_
+#
+# > Specifies what port the server will listen on.
+#
+# • _config.server.workers_count_
+#
+# > Specifies the number of server processes to run.
+#
+# • _config.server.timeout_
+#
+# > Specifies connection timeout.
+#
 class Rage::Configuration
-  attr_accessor :logger, :log_formatter, :log_level
+  attr_accessor :logger
+  attr_reader :log_formatter, :log_level
 
   # used in DSL
   def config = self
 
+  def log_formatter=(formatter)
+    raise "Custom log formatter should respond to `#call`" unless formatter.respond_to?(:call)
+    @log_formatter = formatter
+  end
+
+  def log_level=(level)
+    @log_level = level.is_a?(Symbol) ? Logger.const_get(level.to_s.upcase) : level
+  end
+
   def server
     @server ||= Server.new
   end
@@ -13,7 +110,7 @@ class Rage::Configuration
   end
 
   class Server
-    attr_accessor :port, :workers_count
+    attr_accessor :port, :workers_count, :timeout, :max_clients
     attr_reader :threads_count
 
     def initialize
@@ -36,6 +133,9 @@ class Rage::Configuration
 
     def insert_before(existing_middleware, new_middleware, *args, &block)
       index = find_middleware_index(existing_middleware)
+      if index == 0 && @middlewares[0][0] == Rage::FiberWrapper
+        puts("Warning: inserting #{new_middleware} before Rage::FiberWrapper may lead to undefined behavior.")
+      end
       @middlewares = (@middlewares[0...index] + [[new_middleware, args, block]] + @middlewares[index..]).uniq(&:first)
     end
 
@@ -60,9 +160,13 @@ class Rage::Configuration
     end
   end
 
+  # @private
   def __finalize
-    @logger ||= Rage::Logger.new(nil)
-    @logger.formatter = @log_formatter if @logger && @log_formatter
-    @logger.level = @log_level if @logger && @log_level
+    if @logger
+      @logger.formatter = @log_formatter if @log_formatter
+      @logger.level = @log_level if @log_level
+    else
+      @logger = Rage::Logger.new(nil)
+    end
   end
 end

data/lib/rage/controller/api.rb

@@ -8,7 +8,7 @@ class RageController::API
     # sends a correct response down to the server;
     # returns the name of the newly defined method;
     def __register_action(action)
-      raise "The action '#{action}' could not be found for #{self}" unless method_defined?(action)
+      raise Rage::Errors::RouterError, "The action '#{action}' could not be found for #{self}" unless method_defined?(action)
 
       before_actions_chunk = if @__before_actions
         filtered_before_actions = @__before_actions.select do |h|
@@ -25,7 +25,7 @@ class RageController::API
             "unless #{h[:unless]}"
           end
 
-          <<-RUBY
+          <<~RUBY
             #{h[:name]} #{condition}
             return [@__status, @__headers, @__body] if @__rendered
           RUBY
@@ -36,9 +36,34 @@ class RageController::API
         ""
       end
 
+      after_actions_chunk = if @__after_actions
+        filtered_after_actions = @__after_actions.select do |h|
+          (!h[:only] || h[:only].include?(action)) &&
+            (!h[:except] || !h[:except].include?(action))
+        end
+
+        lines = filtered_after_actions.map! do |h|
+          condition = if h[:if] && h[:unless]
+            "if #{h[:if]} && !#{h[:unless]}"
+          elsif h[:if]
+            "if #{h[:if]}"
+          elsif h[:unless]
+            "unless #{h[:unless]}"
+          end
+
+          <<~RUBY
+            #{h[:name]} #{condition}
+          RUBY
+        end
+
+        lines.join("\n")
+      else
+        ""
+      end
+
       rescue_handlers_chunk = if @__rescue_handlers
         lines = @__rescue_handlers.map do |klasses, handler|
-          <<-RUBY
+          <<~RUBY
           rescue #{klasses.join(", ")} => __e
             #{handler}(__e)
             [@__status, @__headers, @__body]
@@ -50,11 +75,18 @@ class RageController::API
         ""
       end
 
-      class_eval <<-RUBY,  __FILE__, __LINE__ + 1
+      class_eval <<~RUBY,  __FILE__, __LINE__ + 1
         def __run_#{action}
           #{before_actions_chunk}
           #{action}
 
+          #{if !after_actions_chunk.empty?
+            <<~RUBY
+              @__rendered = true
+              #{after_actions_chunk}
+            RUBY
+          end}
+
           [@__status, @__headers, @__body]
 
           #{rescue_handlers_chunk}
@@ -63,13 +95,14 @@ class RageController::API
     end
 
     # @private
-    attr_writer :__before_actions, :__rescue_handlers
+    attr_writer :__before_actions, :__after_actions, :__rescue_handlers
 
     # @private
     # pass the variable down to the child; the child will continue to use it until changes need to be made;
     # only then the object will be copied; the frozen state communicates that the object is shared with the parent;
     def inherited(klass)
       klass.__before_actions = @__before_actions.freeze
+      klass.__after_actions = @__after_actions.freeze
       klass.__rescue_handlers = @__rescue_handlers.freeze
     end
 
@@ -148,29 +181,12 @@ class RageController::API
     #   end
     # @note The block form doesn't receive an argument and is executed on the controller level as if it was a regular method.
     def before_action(action_name = nil, **opts, &block)
-      if block_given?
-        action_name = define_tmp_method(block)
-      elsif action_name.nil?
-        raise "No handler provided. Pass the `action_name` parameter or provide a block."
-      end
-
-       _only, _except, _if, _unless = opts.values_at(:only, :except, :if, :unless)
+      action = prepare_action_params(action_name, **opts, &block)
 
       if @__before_actions && @__before_actions.frozen?
         @__before_actions = @__before_actions.dup
       end
 
-      action = {
-        name: action_name,
-        only: _only && Array(_only),
-        except: _except && Array(_except),
-        if: _if,
-        unless: _unless
-      }
-
-      action[:if] = define_tmp_method(action[:if]) if action[:if].is_a?(Proc)
-      action[:unless] = define_tmp_method(action[:unless]) if action[:unless].is_a?(Proc)
-
       if @__before_actions.nil?
         @__before_actions = [action]
       elsif i = @__before_actions.find_index { |a| a[:name] == action_name }
@@ -180,6 +196,22 @@ class RageController::API
       end
     end
 
+    def after_action(action_name = nil, **opts, &block)
+      action = prepare_action_params(action_name, **opts, &block)
+
+      if @__after_actions && @__after_actions.frozen?
+        @__after_actions = @__after_actions.dup
+      end
+
+      if @__after_actions.nil?
+        @__after_actions = [action]
+      elsif i = @__after_actions.find_index { |a| a[:name] == action_name }
+        @__after_actions[i] = action
+      else
+        @__after_actions << action
+      end
+    end
+
     # Prevent a `before_action` hook from running.
     #
     # @param action_name [String] the name of the callback to skip
@@ -208,6 +240,32 @@ class RageController::API
 
       @__before_actions[i] = action
     end
+
+    private
+
+    # used by `before_action` and `after_action`
+    def prepare_action_params(action_name = nil, **opts, &block)
+      if block_given?
+        action_name = define_tmp_method(block)
+      elsif action_name.nil?
+        raise "No handler provided. Pass the `action_name` parameter or provide a block."
+      end
+
+       _only, _except, _if, _unless = opts.values_at(:only, :except, :if, :unless)
+
+      action = {
+        name: action_name,
+        only: _only && Array(_only),
+        except: _except && Array(_except),
+        if: _if,
+        unless: _unless
+      }
+
+      action[:if] = define_tmp_method(action[:if]) if action[:if].is_a?(Proc)
+      action[:unless] = define_tmp_method(action[:unless]) if action[:unless].is_a?(Proc)
+
+      action
+    end
   end # class << self
 
   # @private

data/lib/rage/errors.rb

@@ -1,4 +1,7 @@
 module Rage::Errors
   class BadRequest < StandardError
   end
+
+  class RouterError < StandardError
+  end
 end

data/lib/rage/fiber.rb

@@ -33,6 +33,14 @@ class Fiber
     !@__rage_id.nil?
   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
   # pause a fiber and resume in the next iteration of the event loop
   def self.pause

data/lib/rage/fiber_scheduler.rb

@@ -81,7 +81,7 @@ class Rage::FiberScheduler
   end
 
   def block(_blocker, timeout = nil)
-    f, fulfilled, channel = Fiber.current, false, "unblock:#{Fiber.current.object_id}"
+    f, fulfilled, channel = Fiber.current, false, Fiber.current.__block_channel(true)
 
     resume_fiber_block = proc do
       unless fulfilled
@@ -100,7 +100,7 @@ class Rage::FiberScheduler
   end
 
   def unblock(_blocker, fiber)
-    ::Iodine.publish("unblock:#{fiber.object_id}", "")
+    ::Iodine.publish(fiber.__block_channel, "")
   end
 
   def fiber(&block)

data/lib/rage/logger/logger.rb

@@ -56,8 +56,8 @@ class Rage::Logger
   # @param shift_period_suffix [String] the log file suffix format for daily, weekly or monthly rotation
   # @param binmode sets whether the logger writes in binary mode
   def initialize(log, level: Logger::DEBUG, formatter: Rage::TextFormatter.new, shift_age: 0, shift_size: 104857600, shift_period_suffix: "%Y%m%d", binmode: false)
-    if log && log != File::NULL
-      @logdev = Logger::LogDevice.new(log, shift_age:, shift_size:, shift_period_suffix:, binmode:)
+    @logdev = if log && log != File::NULL
+      Logger::LogDevice.new(log, shift_age:, shift_size:, shift_period_suffix:, binmode:)
     end
 
     @formatter = formatter

data/lib/rage/middleware/cors.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+class Rage::Cors
+  def initialize(app, *, &)
+    @app = app
+    instance_eval(&)
+  end
+
+  def call(env)
+    if env["REQUEST_METHOD"] == "OPTIONS"
+      return (response = @cors_response)
+    end
+
+    response = @app.call(env)
+    response[1]["Access-Control-Allow-Credentials"] = @allow_credentials if @allow_credentials
+    response[1]["Access-Control-Expose-Headers"] = @expose_headers if @expose_headers
+
+    response
+  ensure
+    if origin = @cors_check.call(env)
+      headers = response[1]
+      headers["Access-Control-Allow-Origin"] = origin
+      if @origins != "*"
+        vary = headers["Vary"]
+        if vary.nil?
+          headers["Vary"] = "Origin"
+        elsif vary != "Origin"
+          headers["Vary"] += ", Origin"
+        end
+      end
+    end
+  end
+
+  # Set CORS rules for the application.
+  #
+  # @param origins [String, Regexp, "*"] origins allowed to access the application
+  # @param methods [Array<Symbol>, "*"] allowed methods when accessing the application
+  # @param allow_headers [Array<String>, "*"] indicate which HTTP headers can be used when making the actual request
+  # @param expose_headers [Array<String>, "*"] adds the specified headers to the allowlist that JavaScript in browsers is allowed to access
+  # @param max_age [Integer] indicate how long the results of a preflight request can be cached
+  # @param allow_credentials [Boolean] indicate whether or not the response to the request can be exposed when the `credentials` flag is `true`
+  # @example
+  #   config.middleware.use Rage::Cors do
+  #     allow "localhost:5173", "myhost.com"
+  #   end
+  # @example
+  #   config.middleware.use Rage::Cors do
+  #     allow "*",
+  #       methods: [:get, :post, :put],
+  #       allow_headers: ["x-domain-token"],
+  #       expose: ["Some-Custom-Response-Header"],
+  #       max_age: 600
+  #   end
+  # @note The middleware only supports the basic case of allowing one or several origins for the whole application. Use {https://github.com/cyu/rack-cors Rack::Cors} if you are looking to specify more advanced rules.
+  def allow(*origins, methods: "*", allow_headers: "*", expose_headers: nil, max_age: nil, allow_credentials: false)
+    @allow_headers = Array(allow_headers).join(", ") if allow_headers
+    @expose_headers = Array(expose_headers).join(", ") if expose_headers
+    @max_age = max_age.to_s if max_age
+    @allow_credentials = "true" if allow_credentials
+
+    @default_methods = %w(GET POST PUT PATCH DELETE HEAD OPTIONS)
+    @methods = if methods != "*"
+      methods.map! { |method| method.to_s.upcase }.tap { |m|
+        if (invalid_methods = m - @default_methods).any?
+          raise "Unsupported method passed to Rage::Cors: #{invalid_methods[0]}"
+        end
+      }.join(", ")
+    elsif @allow_credentials
+      @default_methods.join(", ")
+    else
+      "*"
+    end
+
+    if @allow_credentials
+      raise "Rage::Cors requires you to explicitly list allowed headers when using `allow_credentials: true`" if @allow_headers == "*"
+      raise "Rage::Cors requires you to explicitly list exposed headers when using `allow_credentials: true`" if @expose_headers == "*"
+    end
+
+    @origins = []
+    origins.each do |origin|
+      if origin == "*"
+        @origins = "*"
+        break
+      elsif origin.is_a?(Regexp) || origin =~ /^\S+:\/\//
+        @origins << origin
+      else
+        @origins << "https://#{origin}" << "http://#{origin}"
+      end
+    end
+
+    @cors_check = create_cors_proc
+    @cors_response = [204, create_headers, []]
+  end
+
+  private
+
+  def create_headers
+    headers = {
+      "Access-Control-Allow-Origin" => "",
+      "Access-Control-Allow-Methods" => @methods,
+    }
+
+    if @allow_headers
+      headers["Access-Control-Allow-Headers"] = @allow_headers
+    end
+    if @expose_headers
+      headers["Access-Control-Expose-Headers"] = @expose_headers
+    end
+    if @max_age
+      headers["Access-Control-Max-Age"] = @max_age
+    end
+    if @allow_credentials
+      headers["Access-Control-Allow-Credentials"] = @allow_credentials
+    end
+
+    headers
+  end
+
+  def create_cors_proc
+    if @origins == "*"
+      ->(env) { env["HTTP_ORIGIN"] }
+    else
+      origins_eval = @origins.map { |origin|
+        origin.is_a?(Regexp) ?
+          "origin =~ /#{origin.source}/.freeze" :
+          "origin == '#{origin}'.freeze"
+      }.join(" || ")
+
+      eval <<-RUBY
+        ->(env) do
+          origin = env["HTTP_ORIGIN".freeze]
+          origin if #{origins_eval}
+        end
+      RUBY
+    end
+  end
+end

data/lib/rage/{fiber_wrapper.rb → middleware/fiber_wrapper.rb}

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 ##
-# The middleware wraps every request in a Fiber and implements the custom defer protocol with Iodine.
-# Scheduling fibers in a middleware allows the framework to be compatibe with custom Rack middlewares.
+# The middleware wraps every request in a separate Fiber. It should always be on the top of the middleware stack,
+# as it implements a custom defer protocol, which may break middlewares located above.
 #
 class Rage::FiberWrapper
   def initialize(app)
@@ -16,9 +16,11 @@ class Rage::FiberWrapper
     fiber = Fiber.schedule do
       @app.call(env)
     ensure
+      # notify Iodine the request can now be resumed
       Iodine.publish(Fiber.current.__get_id, "", Iodine::PubSub::PROCESS) if Fiber.current.__yielded?
     end
 
+    # the fiber encountered blocking IO and yielded; instruct Iodine to pause the request
     if fiber.alive?
       [:__http_defer__, fiber]
     else

data/lib/rage/middleware/reloader.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+class Rage::Reloader
+  def initialize(app)
+    @app = app
+  end
+
+  def call(env)
+    Rage.code_loader.reload
+    @app.call(env)
+rescue Exception => e
+    exception_str = "#{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}"
+    puts(exception_str)
+    [500, {}, [exception_str]]
+  end
+end

data/lib/rage/router/backend.rb

@@ -14,6 +14,11 @@ class Rage::Router::Backend
     @constrainer = Rage::Router::Constrainer.new({})
   end
 
+  def reset_routes
+    @routes = []
+    @trees = {}
+  end
+
   def mount(path, handler, methods)
     raise "Mount handler should respond to `call`" unless handler.respond_to?(:call)
 
@@ -79,6 +84,9 @@ class Rage::Router::Backend
     end
 
     __on(method, path, handler, constraints, defaults, meta)
+
+  rescue Rage::Errors::RouterError => e
+    raise e unless Rage.code_loader.reloading?
   end
 
   def lookup(env)
@@ -280,7 +288,7 @@ class Rage::Router::Backend
     if Object.const_defined?(klass)
       Object.const_get(klass)
     else
-      raise "Routing error: could not find the #{klass} class"
+      raise Rage::Errors::RouterError, "Routing error: could not find the #{klass} class"
     end
   end
 end

data/lib/rage/setup.rb

@@ -2,22 +2,10 @@ Iodine.patch_rack
 
 require_relative "#{Rage.root}/config/environments/#{Rage.env}"
 
+# Run application initializers
+Dir["#{Rage.root}/config/initializers/**/*.rb"].each { |initializer| load(initializer) }
 
-# load application files
-app, bad = Dir["#{Rage.root}/app/**/*.rb"], []
-
-loop do
-  path = app.shift
-  break if path.nil?
-
-  require_relative path
-
-# push the file to the end of the list in case it depends on another file that has not yet been required;
-# re-raise if only errored out files are left
-rescue NameError
-  raise if (app - bad).empty?
-  app << path
-  bad << path
-end
+# Load application classes
+Rage.code_loader.setup
 
 require_relative "#{Rage.root}/config/routes"

data/lib/rage/templates/config-environments-development.rb

@@ -7,4 +7,6 @@ Rage.configure do
 
   # Specify the logger
   config.logger = Rage::Logger.new(STDOUT)
+
+  config.middleware.use Rage::Reloader
 end

data/lib/rage/version.rb

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

data/lib/rage-rb.rb

@@ -28,7 +28,7 @@ module Rage
   end
 
   def self.env
-    @__env ||= Rage::Env.new(ENV["RAGE_ENV"] || ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development")
+    @__env ||= Rage::Env.new(ENV["RAGE_ENV"])
   end
 
   def self.groups
@@ -49,6 +49,10 @@ module Rage
     end
   end
 
+  def self.code_loader
+    @code_loader ||= Rage::CodeLoader.new
+  end
+
   module Router
     module Strategies
     end

data/rage.gemspec

@@ -30,4 +30,5 @@ Gem::Specification.new do |spec|
   spec.add_dependency "thor", "~> 1.0"
   spec.add_dependency "rack", "~> 2.0"
   spec.add_dependency "rage-iodine", "~> 3.0"
+  spec.add_dependency "zeitwerk", "~> 2.6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rage-rb
 version: !ruby/object:Gem::Version
-  version: 0.5.2
+  version: 0.6.0
 platform: ruby
 authors:
 - Roman Samoilov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-12-11 00:00:00.000000000 Z
+date: 2023-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: zeitwerk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
 description:
 email:
 - rsamoi@icloud.com
@@ -74,15 +88,18 @@ files:
 - lib/rage/all.rb
 - lib/rage/application.rb
 - lib/rage/cli.rb
+- lib/rage/code_loader.rb
 - lib/rage/configuration.rb
 - lib/rage/controller/api.rb
 - lib/rage/env.rb
 - lib/rage/errors.rb
 - lib/rage/fiber.rb
 - lib/rage/fiber_scheduler.rb
-- lib/rage/fiber_wrapper.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/request.rb
 - lib/rage/router/README.md
@@ -101,6 +118,7 @@ files:
 - lib/rage/templates/config-environments-development.rb
 - lib/rage/templates/config-environments-production.rb
 - lib/rage/templates/config-environments-test.rb
+- lib/rage/templates/config-initializers-.keep
 - lib/rage/templates/config-routes.rb
 - lib/rage/templates/config.ru
 - lib/rage/templates/lib-.keep