rage-rb 0.5.1 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 15d0d4682a307384b3e291b5b9d2f4f0323fc5ca74966b06a856a1f1367da01d
-  data.tar.gz: 4a5d0f7ef64f5b70615e0b1f43a170ba7072b0b44d908858cf43d5dc4cc3fb2d
+  metadata.gz: 0eed317e69386a2c2cc765df7be687be754934801390e96013902e78670171eb
+  data.tar.gz: 44c899c5843d112ca222df4b863852df9e3728a63954ee3b5ab4ffd2cffd4e2e
 SHA512:
-  metadata.gz: d7c3a2cf837d4038618e925508af8b536040927cc9506beaed3f312f1176903dc5a0a1141c47321eb5b7f2ba20a21e4e9e635d54e098ed7b4e04ec93fba08da0
-  data.tar.gz: e48c1bf19c83f09a21f5b0c8c731db109a24fe0c37de870454b2b155c5d85be98c890d555bec1b78a00c19f91e7a25a3cbc99df6937561d30a88e96027d10e4d
+  metadata.gz: 4e158fd8202e9c6e4f94a7b243383c34f2179306a10724978083b6599197197221915857540ae2beb5ea98a5f602c6507bec89d192a57706b3aae2203c75a8a3
+  data.tar.gz: e9723bb6a0ef7b1a67db08799e3429ae4c2e9f88894afb9e614645673df7cb4e019107f0ca1339eb521fa7958fd259ca032385f98fdbddacd59415d960f0c347

data/CHANGELOG.md

@@ -1,5 +1,28 @@
 ## [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
+
+- Add env class (#43).
+
+### Changed
+
+- Schedule request Fibers in a separate middleware (#48).
+
 ## [0.5.1] - 2023-12-01
 
 ### Fixed

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

@@ -4,6 +4,8 @@
 
 [![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)
+
 
 Inspired by [Deno](https://deno.com) and built on top of [Iodine](https://github.com/rage-rb/iodine), this is a Ruby web framework that is based on the following design principles:
 
@@ -11,7 +13,7 @@ Inspired by [Deno](https://deno.com) and built on top of [Iodine](https://github
 
 * **High performance** - some think performance is not a major metric for a framework, but it's not true. Poor performance is a risk, and in today's world, companies refuse to use risky technologies.
 
-* **API-only** - the only technology we should be using to create web UI is JavaScript. Using native technologies is always the most flexible, scalable, and simple solution in the long run. Check out [Vite](https://vitejs.dev) if you don't know where to start.
+* **API-only** - separation of concerns is one of the most fundamental principles in software development. Backend and frontend are very different layers with different goals and paths to those goals. Separating BE code from FE code results in a much more sustainable architecture compared with classic Rails monoliths.
 
 * **Acceptance of modern Ruby** - the framework includes a fiber scheduler, which means your code never blocks while waiting on IO.
 
@@ -50,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,6 +9,7 @@ require_relative "request"
 require_relative "uploaded_file"
 require_relative "errors"
 require_relative "params_parser"
+require_relative "code_loader"
 
 require_relative "router/strategies/host"
 require_relative "router/backend"
@@ -22,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/application.rb

@@ -2,41 +2,28 @@
 
 class Rage::Application
   def initialize(router)
-    Iodine.on_state(:on_start)  do
-      Fiber.set_scheduler(Rage::FiberScheduler.new)
-    end
     @router = router
   end
 
   def call(env)
-    fiber = Fiber.schedule do
-      init_logger
-
-      handler = @router.lookup(env)
+    init_logger
 
-      response = if handler
-        params = Rage::ParamsParser.prepare(env, handler[:params])
-        handler[:handler].call(env, params)
-      else
-        [404, {}, ["Not Found"]]
-      end
+    handler = @router.lookup(env)
 
-    rescue Exception => e
-      exception_str = "#{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}"
-      Rage.logger.error(exception_str)
-      response = [500, {}, [exception_str]]
-
-    ensure
-      finalize_logger(env, response, params)
-      Iodine.publish(env["IODINE_REQUEST_ID"], "") # notify Iodine the request can now be served
-    end
-
-    # the fiber encountered blocking IO and yielded; instruct Iodine to pause the request;
-    if fiber.alive?
-      [:__http_defer__, fiber]
+    response = if handler
+      params = Rage::ParamsParser.prepare(env, handler[:params])
+      handler[:handler].call(env, params)
     else
-      fiber.__get_result
+      [404, {}, ["Not Found"]]
     end
+
+  rescue Exception => e
+    exception_str = "#{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}"
+    Rage.logger.error(exception_str)
+    response = [500, {}, [exception_str]]
+
+  ensure
+    finalize_logger(env, response, params)
   end
 
   private

data/lib/rage/cli.rb

@@ -16,11 +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)
 
-      ::Iodine.listen service: :http, handler: app, port: options[:port] || Rage.config.server.port
+      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: port, address: address, timeout: timeout, max_clients: max_clients
       ::Iodine.threads = Rage.config.server.threads_count
       ::Iodine.workers = Rage.config.server.workers_count
 
@@ -29,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
@@ -83,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
@@ -95,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,15 +1,116 @@
+# 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
 
+  def middleware
+    @middleware ||= Middleware.new
+  end
+
   class Server
-    attr_accessor :port, :workers_count
+    attr_accessor :port, :workers_count, :timeout, :max_clients
     attr_reader :threads_count
 
     def initialize
@@ -19,9 +120,53 @@ class Rage::Configuration
     end
   end
 
+  class Middleware
+    attr_reader :middlewares
+
+    def initialize
+      @middlewares = [[Rage::FiberWrapper]]
+    end
+
+    def use(new_middleware, *args, &block)
+      insert_after(@middlewares.length - 1, new_middleware, *args, &block)
+    end
+
+    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
+
+    def insert_after(existing_middleware, new_middleware, *args, &block)
+      index = find_middleware_index(existing_middleware)
+      @middlewares = (@middlewares[0..index] + [[new_middleware, args, block]] + @middlewares[index + 1..]).uniq(&:first)
+    end
+
+    private
+
+    def find_middleware_index(middleware)
+      if middleware.is_a?(Integer)
+        if middleware < 0 || middleware >= @middlewares.length
+          raise ArgumentError, "Middleware index should be in the (0...#{@middlewares.length}) range"
+        end
+        middleware
+      else
+        @middlewares.index { |m, _, _| m == middleware }.tap do |i|
+          raise ArgumentError, "Couldn't find #{middleware} in the middleware stack" unless i
+        end
+      end
+    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/env.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Rage::Env
+  STANDARD_ENVS = %w(development test staging production)
+
+  def initialize(env)
+    @env = env
+
+    STANDARD_ENVS.each do |standard_env|
+      self.class.define_method("#{standard_env}?") { false } if standard_env != @env
+    end
+    self.class.define_method("#{@env}?") { true }
+  end
+
+  def method_missing(method_name, *, &)
+    method_name.end_with?("?") ? false : super
+  end
+
+  def respond_to_missing?(method_name, include_private = false)
+    method_name.end_with?("?")
+  end
+
+  def ==(other)
+    @env == other
+  end
+
+  def to_sym
+    @env.to_sym
+  end
+
+  def to_s
+    @env
+  end
+end

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

@@ -23,6 +23,24 @@ class Fiber
     @__err
   end
 
+   # @private
+  def __get_id
+    @__rage_id ||= object_id.to_s
+  end
+
+  # @private
+  def __yielded?
+    !@__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/middleware/fiber_wrapper.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+##
+# 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)
+    Iodine.on_state(:on_start) do
+      Fiber.set_scheduler(Rage::FiberScheduler.new)
+    end
+    @app = app
+  end
+
+  def call(env)
+    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
+      fiber.__get_result
+    end
+  end
+end

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/templates/config.ru

@@ -1,3 +1,4 @@
 require_relative "config/application"
 
 run Rage.application
+Rage.load_middlewares(self)

data/lib/rage/version.rb

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

data/lib/rage-rb.rb

@@ -28,7 +28,7 @@ module Rage
   end
 
   def self.env
-    @__env ||= ENV["RAGE_ENV"] || ENV["RAILS_ENV"] || ENV["RACK_ENV"] || "development"
+    @__env ||= Rage::Env.new(ENV["RAGE_ENV"])
   end
 
   def self.groups
@@ -43,6 +43,16 @@ module Rage
     @logger ||= config.logger
   end
 
+  def self.load_middlewares(rack_builder)
+    config.middleware.middlewares.each do |middleware, args, block|
+      rack_builder.use(middleware, *args, &block)
+    end
+  end
+
+  def self.code_loader
+    @code_loader ||= Rage::CodeLoader.new
+  end
+
   module Router
     module Strategies
     end
@@ -51,3 +61,5 @@ end
 
 module RageController
 end
+
+require_relative "rage/env"

data/rage.gemspec

@@ -29,5 +29,6 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "thor", "~> 1.0"
   spec.add_dependency "rack", "~> 2.0"
-  spec.add_dependency "rage-iodine", "~> 2.2"
+  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.1
+  version: 0.6.0
 platform: ruby
 authors:
 - Roman Samoilov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-12-01 00:00:00.000000000 Z
+date: 2023-12-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -44,14 +44,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.2'
+        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,13 +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/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
@@ -99,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