rage-rb 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4570bfdf4f86125be1d6c35b9ccba08a956fe8a20dac392e5ae914db347ad396
-  data.tar.gz: '019e919339f97e641e65f9aecc91c02740875ebcbe71edf14a07144950e47f07'
+  metadata.gz: adfca83c806d24e4baf6e3c6401c7268e7e88495eaee9120da3a55fca08400b8
+  data.tar.gz: 7769fd22482975665a66741d0362ce5bf75318192bd6ee2850f98da952f5fe35
 SHA512:
-  metadata.gz: 9ad7b89eb46407831ae723c1c15b87ea12b898ae1784989374b07fcffcc3afcff2a237861c94565afe4c5f486b99edb15022b539ab9cad142778e4b2718b92ea
-  data.tar.gz: 471cb6bcbf294d9a4eb3e5fd69827f26661effafc1df20447b8e7eddd0816aff411266d22104988978c46318dc08c4fa753f1e1a4fa1327268a5f24d8851ac5a
+  metadata.gz: 66667fbd047a4c27ebb840f4fc6fd2f60fb50d90b7f25b38048afeb5a92b1ad6f5310a4f0eacbab42b2d11a0c0de44ff4a131d197737abe13f1817a7b2267147
+  data.tar.gz: e75d8f5c615844fe837015ddaf7d2f9c4a96cdebc321ad63c79a3a1645924f2b3a7ef3fe75007243042a14bae18b001bd6cb0c919754719fb339ae42d0e90075

data/CHANGELOG.md

@@ -1,5 +1,26 @@
 ## [Unreleased]
 
+## [0.4.0] - 2023-10-31
+
+### Added
+
+- Expose the `params` object.
+- Support header authentication with `authenticate_with_http_token`.
+- Add the `resources` and `namespace` route helpers.
+- Add the `mount` and `match` route helpers.
+- Allow to access request headers.
+- Support custom ports when starting the app with `rage s`.
+
+## [0.3.0] - 2023-10-08
+
+### Added
+
+- CLI `routes` task.
+- CLI `console` task.
+- `:if` and `:unless` options in `before_action`.
+- Allow to set response headers.
+- Block version of `before_action`.
+
 ## [0.2.0] - 2023-09-27
 
 ### Added

data/Gemfile

@@ -8,9 +8,7 @@ gemspec
 gem "rake", "~> 13.0"
 
 gem "rspec", "~> 3.0"
+gem "yard"
 
 gem "pg"
 gem "mysql2"
-
-gem "benchmark-ips"
-gem "mustache"

data/README.md

@@ -11,7 +11,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. Check out [Vite](https://vitejs.dev) if you don't know where to start.
+* **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.
 
 * **Acceptance of modern Ruby** - the framework includes a fiber scheduler, which means your code never blocks while waiting on IO.
 
@@ -46,9 +46,9 @@ This gem is designed to be a drop-in replacement for Rails in API mode. Public A
 
 Check out in-depth API docs for more information:
 
-- [Controller API](https://rage-rb.github.io/rage/RageController/API.html)
-- [Routing API](https://rage-rb.github.io/rage/Rage/Router/DSL/Handler.html)
-- [Fiber API](https://rage-rb.github.io/rage/Fiber.html)
+- [Controller API](https://rage-rb.pages.dev/RageController/API)
+- [Routing API](https://rage-rb.pages.dev/Rage/Router/DSL/Handler)
+- [Fiber API](https://rage-rb.pages.dev/Fiber)
 
 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.
 
@@ -142,8 +142,8 @@ end
 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 | 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 | 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;<br>&emsp;• support regexp constraints;
+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;<br>~~&emsp;• support regexp constraints (postponed)
 0.5 | Implement Iodine-based equivalent of `ActionController::Live`.<br>Use `ActionDispatch::RemoteIp`.
 0.6 | Expose the `cookies` object.<br>Expose the `send_data` and `send_file` methods.<br>Support conditional get with `etag` and `last_modified`.
 0.7 | Add request logging.

data/lib/rage/all.rb

@@ -0,0 +1,20 @@
+require_relative "../rage-rb"
+
+require_relative "version"
+require_relative "application"
+require_relative "fiber"
+require_relative "fiber_scheduler"
+require_relative "configuration"
+require_relative "request"
+require_relative "uploaded_file"
+require_relative "errors"
+require_relative "params_parser"
+
+require_relative "router/strategies/host"
+require_relative "router/backend"
+require_relative "router/constrainer"
+require_relative "router/dsl"
+require_relative "router/handler_storage"
+require_relative "router/node"
+
+require_relative "controller/api"

data/lib/rage/application.rb

@@ -13,13 +13,14 @@ class Rage::Application
       handler = @router.lookup(env)
 
       if handler
-        handler[:handler].call(env, handler[:params])
+        params = Rage::ParamsParser.prepare(env, handler[:params])
+        handler[:handler].call(env, params)
       else
         [404, {}, ["Not Found"]]
       end
 
     rescue => e
-      [500, {}, ["#{e.class}:#{e.message}\n\n#{e.backtrace.join("\n")}"]] # TODO: check Rage.env
+      [500, {}, ["#{e.class}:#{e.message}\n\n#{e.backtrace.join("\n")}"]]
 
     ensure
       # notify Iodine the request can now be served

data/lib/rage/cli.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
-
 require "thor"
-require "rage"
+require "rage/all"
+require "irb"
 
 module Rage
   class CLI < Thor
@@ -15,21 +15,83 @@ module Rage
     end
 
     desc "s", "Start the app server."
+    option :port, aliases: "-p", desc: "Runs Rage on the specified port - defaults to 3000."
     def server
       app = ::Rack::Builder.parse_file("config.ru")
       app = app[0] if app.is_a?(Array)
 
-      ::Iodine.listen service: :http, handler: app, port: Rage.config.port
+      ::Iodine.listen service: :http, handler: app, port: options[:port] || Rage.config.port
       ::Iodine.threads = Rage.config.threads_count
       ::Iodine.workers = Rage.config.workers_count
 
       ::Iodine.start
     end
+
+    desc 'routes', 'List all routes.'
+    option :grep, aliases: "-g", desc: "Filter routes by pattern"
+    def routes
+      # the result would be something like this:
+      # Verb  Path  Controller#Action
+      # GET   /     application#index
+
+      # load config/application.rb
+      environment
+
+      routes = Rage.__router.routes
+      pattern = options[:grep]
+      routes.unshift({ method: "Verb", path: "Path", raw_handler: "Controller#Action" })
+
+      grouped_routes = routes.each_with_object({}) do |route, memo|
+        if pattern && !memo.empty?
+          next unless route[:path].match?(pattern) || route[:raw_handler].to_s.match?(pattern) || route[:method].match?(pattern)
+        end
+
+        key = [route[:path], route[:raw_handler]]
+        if memo[key]
+          memo[key][:method] += "|#{route[:method]}"
+        else
+          memo[key] = route
+        end
+      end
+
+      longest_path = longest_method = 0
+      grouped_routes.each do |_, route|
+        longest_path = route[:path].length if route[:path].length > longest_path
+        longest_method = route[:method].length if route[:method].length > longest_method
+      end
+
+      margin = 3
+      longest_path += margin
+      longest_method += margin
+
+      grouped_routes.each_with_index do |(_, route), i|
+        meta = route[:constraints]
+        meta.merge!(route[:defaults]) if route[:defaults]
+
+        handler = route[:raw_handler]
+        handler = "#{handler} #{meta}" unless meta&.empty?
+
+        puts format("%-#{longest_method}s%-#{longest_path}s%s", route[:method], route[:path], handler)
+        puts "\n" if i == 0
+      end
+    end
+
+    desc "c", "Start the app console."
+    def console
+      environment
+      ARGV.clear
+      IRB.start
+    end
+
+    private
+
+    def environment
+      require File.expand_path("config/application.rb", Dir.pwd)
+    end
   end
 
   class NewAppGenerator < Thor::Group
     include Thor::Actions
-
     argument :path, type: :string
 
     def self.source_root

data/lib/rage/controller/api.rb

@@ -12,13 +12,21 @@ class RageController::API
 
       before_actions_chunk = if @__before_actions
         filtered_before_actions = @__before_actions.select do |h|
-          (h[:only].nil? || h[:only].include?(action)) &&
-            (h[:except].nil? || !h[:except].include?(action))
+          (!h[:only] || h[:only].include?(action)) &&
+            (!h[:except] || !h[:except].include?(action))
         end
 
         lines = filtered_before_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]}
+            #{h[:name]} #{condition}
             return [@__status, @__headers, @__body] if @__rendered
           RUBY
         end
@@ -65,6 +73,16 @@ class RageController::API
       klass.__rescue_handlers = @__rescue_handlers.freeze
     end
 
+    # @private
+    @@__tmp_name_seed = ("a".."i").to_a.permutation
+
+    # @private
+    # define temporary method based on a block
+    def define_tmp_method(block)
+      name = @@__tmp_name_seed.next.join
+      define_method("__rage_tmp_#{name}", block)
+    end
+
     ############
     #
     # PUBLIC API
@@ -85,12 +103,11 @@ class RageController::API
     #   rescue_from User::NotAuthorized do |_|
     #     head :forbidden
     #   end
-    # @note Unlike Rails, the handler must always take an argument. Use `_` if you don't care about the actual exception.
+    # @note Unlike in Rails, the handler must always take an argument. Use `_` if you don't care about the actual exception.
     def rescue_from(*klasses, with: nil, &block)
       unless with
         if block_given?
-          name = ("a".."z").to_a.sample(15).join
-          with = define_method("__#{name}", &block)
+          with = define_tmp_method(block)
         else
           raise "No handler provided. Pass the `with` keyword argument or provide a block."
         end
@@ -107,21 +124,53 @@ class RageController::API
 
     # Register a new `before_action` hook. Calls with the same `action_name` will overwrite the previous ones.
     #
-    # @param action_name [String] the name of the callback to add
-    # @param only [Symbol, Array<Symbol>] restrict the callback to run only for specific actions
-    # @param except [Symbol, Array<Symbol>] restrict the callback to run for all actions except specified
+    # @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
     #   before_action :find_photo, only: :show
     #
     #   def find_photo
     #     Photo.first
     #   end
-    def before_action(action_name, only: nil, except: nil)
+    # @example
+    #   before_action :require_user, unless: :logged_in?
+    # @example
+    #   before_action :set_locale, if: -> { params[:locale] != "en-US" }
+    # @example
+    #   before_action do
+    #     unless logged_in? # would be `controller.send(:logged_in?)` in Rails
+    #       head :unauthorized
+    #     end
+    #   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)
+
       if @__before_actions && @__before_actions.frozen?
         @__before_actions = @__before_actions.dup
       end
 
-      action = { name: action_name, only: only && Array(only), except: except && Array(except) }
+      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 }
@@ -140,7 +189,7 @@ class RageController::API
     #   skip_before_action :find_photo, only: :create
     def skip_before_action(action_name, only: nil, except: nil)
       i = @__before_actions&.find_index { |a| a[:name] == action_name }
-      raise "The following action was specified to be skipped but cannot be found: #{self}##{action_name}" unless i
+      raise "The following action was specified to be skipped but couldn't be found: #{self}##{action_name}" unless i
 
       @__before_actions = @__before_actions.dup if @__before_actions.frozen?
 
@@ -172,6 +221,11 @@ class RageController::API
     @__rendered = false
   end
 
+  # Get the request object. See {Rage::Request}.
+  def request
+    @request ||= Rage::Request.new(@__env)
+  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
@@ -192,7 +246,7 @@ class RageController::API
       @__body << if json
         json.is_a?(String) ? json : json.to_json
       else
-        __set_header("content-type", "text/plain; charset=utf-8")
+        headers["content-type"] = "text/plain; charset=utf-8"
         plain.to_s
       end
 
@@ -225,11 +279,56 @@ class RageController::API
     end
   end
 
-  private
+  # Set response headers.
+  #
+  # @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
+
+  # Authenticate using an HTTP Bearer token. Returns the value of the block if a token is found. Returns `nil` if no token is found.
+  #
+  # @yield [token] token value extracted from the `Authorization` header
+  # @example
+  #   user = authenticate_with_http_token do |token|
+  #     User.find_by(key: token)
+  #   end
+  def authenticate_with_http_token
+    auth_header = @__env["HTTP_AUTHORIZATION"]
+
+    if auth_header&.start_with?("Bearer")
+      yield auth_header[7..]
+    elsif auth_header&.start_with?("Token")
+      yield auth_header[6..]
+    end
+  end
 
-  # copy-on-write implementation for the headers object
-  def __set_header(key, value)
-    @__headers = @__headers.dup if DEFAULT_HEADERS.equal?(@__headers)
-    @__headers[key] = value
+  if !defined?(::ActionController::Parameters)
+    # Get the request data. The keys inside the hash are symbols, so `params.keys` returns an array of `Symbol`.<br>
+    # You can also load Strong Params to have Rage automatically wrap `params` in an instance of `ActionController::Parameters`.<br>
+    # At the same time, if you are not implementing complex filtering rules or working with nested structures, consider using native `Hash#fetch` and `Hash#slice` instead.
+    #
+    # For multipart file uploads, the uploaded files are represented by an instance of {Rage::UploadedFile}.
+    #
+    # @return [Hash{Symbol=>String,Array,Hash,Numeric,NilClass,TrueClass,FalseClass}]
+    # @example
+    #   # make sure to load strong params before the `require "rage/all"` call
+    #   require "active_support/all"
+    #   require "action_controller/metal/strong_parameters"
+    #
+    #   params.permit(:user).require(:full_name, :dob)
+    # @example
+    #   # without strong params
+    #   params.fetch(:user).slice(:full_name, :dob)
+    def params
+      @__params
+    end
+  else
+    def params
+      @params ||= ActionController::Parameters.new(@__params)
+    end
   end
 end

data/lib/rage/errors.rb

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

data/lib/rage/params_parser.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class Rage::ParamsParser
+  def self.prepare(env, url_params)
+    has_body, query_string, content_type = env["IODINE_HAS_BODY"], env["QUERY_STRING"], env["CONTENT_TYPE"]
+
+    query_params = Iodine::Rack::Utils.parse_nested_query(query_string) if query_string != ""
+    unless has_body
+      if query_params
+        return query_params.merge!(url_params)
+      else
+        return url_params
+      end
+    end
+
+    request_params = if content_type.start_with?("application/json")
+      json_parse(env["rack.input"].read)
+    elsif content_type.start_with?("application/x-www-form-urlencoded")
+      Iodine::Rack::Utils.parse_urlencoded_nested_query(env["rack.input"].read)
+    else
+      Iodine::Rack::Utils.parse_multipart(env["rack.input"], content_type)
+    end
+
+    if request_params && !query_params
+      request_params.merge!(url_params)
+    elsif request_params && query_params
+      request_params.merge!(query_params, url_params)
+    else
+      url_params
+    end
+
+  rescue => e
+    raise Rage::Errors::BadRequest
+  end
+
+  if defined?(::FastJsonparser)
+    def self.json_parse(json)
+      FastJsonparser.parse(json, symbolize_keys: true)
+    end
+  else
+    def self.json_parse(json)
+      JSON.parse(json, symbolize_names: true)
+    end
+  end
+end

data/lib/rage/request.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+class Rage::Request
+  # @private
+  def initialize(env)
+    @env = env
+  end
+
+  # Get the request headers.
+  # @example
+  #   request.headers["Content-Type"] # => "application/json"
+  #   request.headers["Connection"] # => "keep-alive"
+  def headers
+    @headers ||= Headers.new(@env)
+  end
+
+  # @private
+  class Headers
+    HTTP = "HTTP_"
+
+    def initialize(env)
+      @env = env
+    end
+
+    def [](requested_header)
+      if requested_header.start_with?(HTTP)
+        @env[requested_header]
+      else
+        (requested_header = requested_header.tr("-", "_")).upcase!
+
+        if "CONTENT_TYPE" == requested_header || "CONTENT_LENGTH" == requested_header
+          @env[requested_header]
+        else
+          @env["#{HTTP}#{requested_header}"]
+        end
+      end
+    end
+
+    def inspect
+      headers = @env.select { |k| k == "CONTENT_TYPE" || k == "CONTENT_LENGTH" || k.start_with?(HTTP) }
+      "#<#{self.class.name} @headers=#{headers.inspect}"
+    end
+  end # class Headers
+end

data/lib/rage/router/backend.rb

@@ -3,6 +3,8 @@
 require "uri"
 
 class Rage::Router::Backend
+  attr_reader :routes
+
   OPTIONAL_PARAM_REGEXP = /\/?\(\/?(:\w+)\/?\)/
   STRING_HANDLER_REGEXP = /^([a-z0-9_\/]+)#([a-z_]+)$/
 
@@ -13,6 +15,7 @@ class Rage::Router::Backend
   end
 
   def on(method, path, handler, constraints: {}, defaults: nil)
+    raw_handler = handler
     raise "Path could not be empty" if path&.empty?
 
     if match_index = (path =~ OPTIONAL_PARAM_REGEXP)
@@ -42,7 +45,7 @@ class Rage::Router::Backend
       handler = ->(env, _params) { orig_handler.call(env) }
     end
 
-    __on(method, path, handler, constraints, defaults)
+    __on(method, path, handler, raw_handler, constraints, defaults)
   end
 
   def lookup(env)
@@ -52,7 +55,7 @@ class Rage::Router::Backend
 
   private
 
-  def __on(method, path, handler, constraints, defaults)
+  def __on(method, path, handler, raw_handler, constraints, defaults)
     @constrainer.validate_constraints(constraints)
     # Let the constrainer know if any constraints are being used now
     @constrainer.note_usage(constraints)
@@ -159,7 +162,7 @@ class Rage::Router::Backend
       end
     end
 
-    route = { method: method, path: path, pattern: pattern, params: params, constraints: constraints, handler: handler, defaults: defaults }
+    route = { method: method, path: path, pattern: pattern, params: params, constraints: constraints, handler: handler, raw_handler: raw_handler, defaults: defaults }
     @routes << route
     current_node.add_route(route, @constrainer)
   end

data/lib/rage/router/dsl.rb

@@ -9,14 +9,54 @@ class Rage::Router::DSL
     Handler.new(@router).instance_eval(&block)
   end
 
+  ##
+  # This class implements routing logic for your application, providing API similar to Rails.
+  #
+  # Compared to Rails router, the most notable difference is that a wildcard segment can only be in the last section of the path and cannot be named.
+  # Example:
+  # ```ruby
+  # get "/photos/*"
+  # ```
+  #
+  # Also, as this is an API-only framework, route helpers, like `photos_path` or `photos_url` are not being generated.
+  #
+  # #### Constraints
+  #
+  # Currently, the only constraint supported is the `host` constraint. The constraint value can be either string or a regular expression.
+  # Example:
+  # ```ruby
+  # get "/photos", to: "photos#index", constraints: { host: "myhost.com" }
+  # ```
+  #
+  # Parameter constraints are likely to be added in the future versions. Custom/lambda constraints are unlikely to be ever added.
+  #
+  # @example Set up a root handler
+  #   root to: "pages#main"
+  # @example Set up multiple resources
+  #   resources :magazines do
+  #     resources :ads
+  #   end
+  # @example Scope a set of routes to the given default options.
+  #   scope path: ":account_id" do
+  #     resources :projects
+  #   end
+  # @example Scope routes to a specific namespace.
+  #   namespace :admin do
+  #     resources :posts
+  #   end
   class Handler
     # @private
     def initialize(router)
       @router = router
 
+      @default_actions = %i(index create show update destroy)
+      @default_match_methods = %i(get post put patch delete head)
+      @scope_opts = %i(module path controller)
+
       @path_prefixes = []
       @module_prefixes = []
       @defaults = []
+      @controllers = []
     end
 
     # Register a new GET route.
@@ -29,7 +69,7 @@ class Rage::Router::DSL
     #   get "/photos/:id", to: "photos#show", constraints: { host: /myhost/ }
     # @example
     #   get "/photos(/:id)", to: "photos#show", defaults: { id: "-1" }
-    def get(path, to:, constraints: nil, defaults: nil)
+    def get(path, to: nil, constraints: nil, defaults: nil)
       __on("GET", path, to, constraints, defaults)
     end
 
@@ -43,7 +83,7 @@ class Rage::Router::DSL
     #   post "/photos", to: "photos#create", constraints: { host: /myhost/ }
     # @example
     #   post "/photos", to: "photos#create", defaults: { format: "jpg" }
-    def post(path, to:, constraints: nil, defaults: nil)
+    def post(path, to: nil, constraints: nil, defaults: nil)
       __on("POST", path, to, constraints, defaults)
     end
 
@@ -57,7 +97,7 @@ class Rage::Router::DSL
     #   put "/photos/:id", to: "photos#update", constraints: { host: /myhost/ }
     # @example
     #   put "/photos(/:id)", to: "photos#update", defaults: { id: "-1" }
-    def put(path, to:, constraints: nil, defaults: nil)
+    def put(path, to: nil, constraints: nil, defaults: nil)
       __on("PUT", path, to, constraints, defaults)
     end
 
@@ -71,7 +111,7 @@ class Rage::Router::DSL
     #   patch "/photos/:id", to: "photos#update", constraints: { host: /myhost/ }
     # @example
     #   patch "/photos(/:id)", to: "photos#update", defaults: { id: "-1" }
-    def patch(path, to:, constraints: nil, defaults: nil)
+    def patch(path, to: nil, constraints: nil, defaults: nil)
       __on("PATCH", path, to, constraints, defaults)
     end
 
@@ -85,7 +125,7 @@ class Rage::Router::DSL
     #   delete "/photos/:id", to: "photos#destroy", constraints: { host: /myhost/ }
     # @example
     #   delete "/photos(/:id)", to: "photos#destroy", defaults: { id: "-1" }
-    def delete(path, to:, constraints: nil, defaults: nil)
+    def delete(path, to: nil, constraints: nil, defaults: nil)
       __on("DELETE", path, to, constraints, defaults)
     end
 
@@ -98,6 +138,70 @@ class Rage::Router::DSL
       __on("GET", "/", to, nil, nil)
     end
 
+    # Match a URL pattern to one or more routes.
+    #
+    # @param path [String] the path for the route handler
+    # @param to [String, #call] the route handler in the format of "controller#action" or a callable
+    # @param constraints [Hash] a hash of constraints for the route
+    # @param defaults [Hash] a hash of default parameters for the route
+    # @param via [Symbol, Array<Symbol>] an array of HTTP methods to accept
+    # @example
+    #   match "/photos/:id", to: "photos#show", via: [:get, :post]
+    # @example
+    #   match "/photos/:id", to: "photos#show", via: :all
+    # @example
+    #   match "/health", to: -> (env) { [200, {}, ["healthy"]] }
+    def match(path, to:, constraints: {}, defaults: nil, via: :all)
+      # via is either nil, or an array of symbols or its :all
+      http_methods = via
+      # if its :all or nil, then we use the default HTTP methods
+      if via == :all || via.nil?
+        http_methods = @default_match_methods
+      else
+        # if its an array of symbols, then we use the symbols as HTTP methods
+        http_methods = Array(via)
+        # then we check if the HTTP methods are valid
+        http_methods.each do |method|
+          raise ArgumentError, "Invalid HTTP method: #{method}" unless @default_match_methods.include?(method)
+        end
+      end
+
+      http_methods.each do |method|
+        __on(method.to_s.upcase, path, to, constraints, defaults)
+      end
+    end
+
+    # Register a new namespace.
+    #
+    # @param path [String] the path for the namespace
+    # @param options [Hash] a hash of options for the namespace
+    # @option options [String] :module the module name for the namespace
+    # @option options [String] :path the path for the namespace
+    # @example
+    #   namespace :admin do
+    #     get "/photos", to: "photos#index"
+    #   end
+    # @example
+    #   namespace :admin, path: "panel" do
+    #     get "/photos", to: "photos#index"
+    #   end
+    # @example
+    #   namespace :admin, module: "admin" do
+    #     get "/photos", to: "photos#index"
+    #   end
+    def namespace(path, **options, &block)
+      path_prefix = options[:path] || path
+      module_prefix = options[:module] || path
+
+      @path_prefixes << path_prefix
+      @module_prefixes << module_prefix
+
+      instance_eval &block
+
+      @path_prefixes.pop
+      @module_prefixes.pop
+    end
+
     # Scopes a set of routes to the given default options.
     #
     # @param [Hash] opts scope options.
@@ -120,15 +224,17 @@ class Rage::Router::DSL
     #     end
     #   end
     def scope(opts, &block)
-      raise ArgumentError, "only 'module' and 'path' options are accepted" if (opts.keys - %i(module path)).any?
+      raise ArgumentError, "only :module, :path, and :controller options are accepted" if (opts.keys - @scope_opts).any?
 
       @path_prefixes << opts[:path].delete_prefix("/").delete_suffix("/") if opts[:path]
       @module_prefixes << opts[:module] if opts[:module]
+      @controllers << opts[:controller] if opts[:controller]
 
       instance_eval &block
 
       @path_prefixes.pop if opts[:path]
       @module_prefixes.pop if opts[:module]
+      @controllers.pop if opts[:controller]
     end
 
     # Specify default parameters for a set of routes.
@@ -144,14 +250,109 @@ class Rage::Router::DSL
       @defaults.pop
     end
 
+    # Add a route to the collection.
+    #
+    # @example Add a `photos/search` path instead of `photos/:photo_id/search`
+    #   resources :photos do
+    #     collection do
+    #       get "search"
+    #     end
+    #   end
+    def collection(&block)
+      orig_path_prefixes = @path_prefixes
+      @path_prefixes = @path_prefixes[0...-1] if @path_prefixes.last&.start_with?(":")
+      instance_eval &block
+      @path_prefixes = orig_path_prefixes
+    end
+
+    # Automatically create REST routes for a resource.
+    #
+    # @example Create five REST routes, all mapping to the `Photos` controller:
+    #   resources :photos
+    #   # GET       /photos       => photos#index
+    #   # POST      /photos       => photos#create
+    #   # GET       /photos/:id   => photos#show
+    #   # PATCH/PUT /photos/:id   => photos#update
+    #   # DELETE    /photos/:id   => photos#destroy
+    # @note This helper doesn't generate the `new` and `edit` routes.
+    def resources(*_resources, **opts, &block)
+      # support calls with multiple resources, e.g. `resources :albums, :photos`
+      if _resources.length > 1
+        _resources.each { |_resource| resources(_resource, **opts, &block) }
+        return
+      end
+
+      _module, _path, _only, _except, _param = opts.values_at(:module, :path, :only, :except, :param)
+      raise ":param option can't contain colons" if _param&.include?(":")
+
+      _only = Array(_only) if _only
+      _except = Array(_except) if _except
+      actions = @default_actions.select do |action|
+        (_only.nil? || _only.include?(action)) && (_except.nil? || !_except.include?(action))
+      end
+
+      resource = _resources[0].to_s
+      _path ||= resource
+      _param ||= "id"
+
+      scope_opts = { path: _path }
+      scope_opts[:module] = _module if _module
+
+      scope(scope_opts) do
+        get("/", to: "#{resource}#index") if actions.include?(:index)
+        post("/", to: "#{resource}#create") if actions.include?(:create)
+        get("/:#{_param}", to: "#{resource}#show") if actions.include?(:show)
+        patch("/:#{_param}", to: "#{resource}#update") if actions.include?(:update)
+        put("/:#{_param}", to: "#{resource}#update") if actions.include?(:update)
+        delete("/:#{_param}", to: "#{resource}#destroy") if actions.include?(:destroy)
+
+        scope(path: ":#{to_singular(resource)}_#{_param}", controller: resource, &block) if block
+      end
+    end
+
+    # Mount a Rack-based application to be used within the application.
+    #
+    # @example
+    #   mount Sidekiq::Web => "/sidekiq"
+    # @example
+    #   mount Sidekiq::Web, at: "/sidekiq", via: :get
+    def mount(*args)
+      if args.first.is_a?(Hash)
+        app = args.first.keys.first
+        at = args.first.values.first
+        via = args[0][:via]
+      else
+        app = args.first
+        at = args[1][:at]
+        via = args[1][:via]
+      end
+
+      # Use match with via: :all to mount the Rack-based application
+      match(at, to: app, via:)
+    end
+
     private
 
     def __on(method, path, to, constraints, defaults)
+      # handle calls without controller inside resources:
+      #   resources :comments do
+      #     post :like
+      #   end
+      if !to
+        if @controllers.any?
+          to = "#{@controllers.last}##{path}"
+        else
+          raise "Missing :to key on routes definition, please check your routes."
+        end
+      end
+
+      # process path to ensure it starts with "/" and doesn't end with "/"
       if path != "/"
         path = "/#{path}" unless path.start_with?("/")
         path = path.delete_suffix("/") if path.end_with?("/")
       end
 
+      # correctly process root helpers inside `scope` calls
       if path == "/" && @path_prefixes.any?
         path = ""
       end
@@ -166,5 +367,23 @@ class Rage::Router::DSL
         @router.on(method, "#{path_prefix}#{path}", to, constraints: constraints || {}, defaults: defaults)
       end
     end
+
+    def to_singular(str)
+      @active_support_loaded ||= str.respond_to?(:singularize) || :false
+      return str.singularize if @active_support_loaded != :false
+
+      @endings ||= {
+        "ves" => "fe",
+        "ies" => "y",
+        "i" => "us",
+        "zes" => "ze",
+        "ses" => "s",
+        "es" => "",
+        "s" => ""
+      }
+      @regexp ||= Regexp.new("(#{@endings.keys.join("|")})$")
+
+      str.sub(@regexp, @endings)
+    end
   end
 end

data/lib/rage/router/handler_storage.rb

@@ -51,12 +51,12 @@ class Rage::Router::HandlerStorage
     lines = []
 
     param_keys.each_with_index do |key, i|
-      lines << "'#{key}' => param_values[#{i}]"
+      lines << ":#{key} => param_values[#{i}]"
     end
 
     if defaults
       defaults.except(*param_keys.map(&:to_sym)).each do |key, value|
-        lines << "'#{key}' => '#{value}'"
+        lines << ":#{key} => '#{value}'"
       end
     end
 

data/lib/rage/setup.rb

@@ -1,7 +1,23 @@
 Iodine.patch_rack
 
-project_root = Pathname.new(".").expand_path
+require_relative "#{Rage.root}/config/environments/#{Rage.env}"
 
-require_relative "#{project_root}/config/environments/#{Rage.env}"
-Dir["#{project_root}/app/**/*.rb"].each { |path| require_relative path }
-require_relative "#{project_root}/config/routes"
+
+# 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
+
+require_relative "#{Rage.root}/config/routes"

data/lib/rage/templates/Gemfile

@@ -1,6 +1,10 @@
 source "https://rubygems.org"
 
-gem "rage-rb"
+gem "rage-rb", "<%= Rage::VERSION %>"
 
 # Build JSON APIs with ease
 # gem "alba"
+
+# Get 50% to 150% boost when parsing JSON.
+# Rage will automatically use FastJsonparser if it is available.
+# gem "fast_jsonparser"

data/lib/rage/templates/config-application.rb

@@ -1,6 +1,6 @@
 require "bundler/setup"
-
-require "rage"
 Bundler.require(*Rage.groups)
 
+require "rage/all"
+
 require "rage/setup"

data/lib/rage/uploaded_file.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+##
+# Models uploaded files.
+#
+# The actual file is accessible via the `file` accessor, though some
+# of its interface is available directly for convenience.
+#
+# Rage will automatically unlink the files, so there is no need to clean them with a separate maintenance task.
+class Rage::UploadedFile
+  # The basename of the file in the client.
+  attr_reader :original_filename
+
+  # A string with the MIME type of the file.
+  attr_reader :content_type
+
+  # A `File` object with the actual uploaded file. Note that some of its interface is available directly.
+  attr_reader :file
+  alias_method :tempfile, :file
+
+  def initialize(file, original_filename, content_type)
+    @file = file
+    @original_filename = original_filename
+    @content_type = content_type
+  end
+
+  # Shortcut for `file.read`.
+  def read(length = nil, buffer = nil)
+    @file.read(length, buffer)
+  end
+
+  # Shortcut for `file.open`.
+  def open
+    @file.open
+  end
+
+  # Shortcut for `file.close`.
+  def close(unlink_now = false)
+    @file.close(unlink_now)
+  end
+
+  # Shortcut for `file.path`.
+  def path
+    @file.path
+  end
+
+  # Shortcut for `file.to_path`.
+  def to_path
+    @file.to_path
+  end
+
+  # Shortcut for `file.rewind`.
+  def rewind
+    @file.rewind
+  end
+
+  # Shortcut for `file.size`.
+  def size
+    @file.size
+  end
+
+  # Shortcut for `file.eof?`.
+  def eof?
+    @file.eof?
+  end
+
+  def to_io
+    @file.to_io
+  end
+end

data/lib/rage/version.rb

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

data/lib/rage-rb.rb

@@ -3,6 +3,7 @@
 require "rack"
 require "json"
 require "iodine"
+require "pathname"
 
 module Rage
   def self.application
@@ -33,6 +34,10 @@ module Rage
     [:default, Rage.env.to_sym]
   end
 
+  def self.root
+    @root ||= Pathname.new(".").expand_path
+  end
+
   module Router
     module Strategies
     end
@@ -41,17 +46,3 @@ end
 
 module RageController
 end
-
-require_relative "rage/application"
-require_relative "rage/fiber"
-require_relative "rage/fiber_scheduler"
-require_relative "rage/configuration"
-
-require_relative "rage/router/strategies/host"
-require_relative "rage/router/backend"
-require_relative "rage/router/constrainer"
-require_relative "rage/router/dsl"
-require_relative "rage/router/handler_storage"
-require_relative "rage/router/node"
-
-require_relative "rage/controller/api"

data/rage.gemspec

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rage-rb
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Roman Samoilov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-27 00:00:00.000000000 Z
+date: 2023-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '2.0'
 description:
 email:
 - rsamoi@icloud.com
@@ -71,12 +71,16 @@ files:
 - exe/rage
 - lib/rage-rb.rb
 - lib/rage.rb
+- lib/rage/all.rb
 - lib/rage/application.rb
 - lib/rage/cli.rb
 - lib/rage/configuration.rb
 - lib/rage/controller/api.rb
+- lib/rage/errors.rb
 - lib/rage/fiber.rb
 - lib/rage/fiber_scheduler.rb
+- lib/rage/params_parser.rb
+- lib/rage/request.rb
 - lib/rage/router/README.md
 - lib/rage/router/backend.rb
 - lib/rage/router/constrainer.rb
@@ -96,6 +100,7 @@ files:
 - lib/rage/templates/lib-.keep
 - lib/rage/templates/log-.keep
 - lib/rage/templates/public-.keep
+- lib/rage/uploaded_file.rb
 - lib/rage/version.rb
 - rage.gemspec
 homepage: https://github.com/rage-rb/rage