rage-rb 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7684c979952ee81bee165b9b667dea87199f3fa28dadadc4878b29a12211fdac
-  data.tar.gz: 2428443ee2456ef375990decfbf36a2952670ee517ac07cf4c994f5b9b7076f9
+  metadata.gz: adfca83c806d24e4baf6e3c6401c7268e7e88495eaee9120da3a55fca08400b8
+  data.tar.gz: 7769fd22482975665a66741d0362ce5bf75318192bd6ee2850f98da952f5fe35
 SHA512:
-  metadata.gz: f59da6b77e69fa2b89761b30a497b4c0fa8f02cbabeed65c953b0f5e807b349e5b305bf31564bcc3eaeed4957215766e8781af5a5b8bbd9754e0461fa18f7b87
-  data.tar.gz: 733a15ef91abcbfc079a3bbbb83f82686038059b3c518c1c0a279e8000ad885c65cc5019cc691e2731fa1e59ca1f62e8fe95c8f454837ed0bdc65e181157ffc7
+  metadata.gz: 66667fbd047a4c27ebb840f4fc6fd2f60fb50d90b7f25b38048afeb5a92b1ad6f5310a4f0eacbab42b2d11a0c0de44ff4a131d197737abe13f1817a7b2267147
+  data.tar.gz: e75d8f5c615844fe837015ddaf7d2f9c4a96cdebc321ad63c79a3a1645924f2b3a7ef3fe75007243042a14bae18b001bd6cb0c919754719fb339ae42d0e90075

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 ## [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

data/Gemfile

@@ -8,6 +8,7 @@ gemspec
 gem "rake", "~> 13.0"
 
 gem "rspec", "~> 3.0"
+gem "yard"
 
 gem "pg"
 gem "mysql2"

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.
 
@@ -143,7 +143,7 @@ Version | Changes
 ------- |------------
 0.2 :white_check_mark: | ~~Gem configuration by env.<br>Add `skip_before_action`.<br>Add `rescue_from`.<br>Router updates:<br>&emsp;• make the `root` helper work correctly with `scope`;<br>&emsp;• support the `defaults` option;~~
 0.3 :white_check_mark: | ~~CLI updates:<br>&emsp;• `routes` task;<br>&emsp;• `console` task;<br>Support the `:if` and `:unless` options in `before_action`.<br>Allow to set response headers.~~
-0.4 | 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.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,7 +13,8 @@ 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

data/lib/rage/cli.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 require "thor"
-require "rage"
+require "rage/all"
 require "irb"
 
 module Rage
@@ -15,11 +15,12 @@ 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
 
@@ -30,57 +31,48 @@ module Rage
     option :grep, aliases: "-g", desc: "Filter routes by pattern"
     def routes
       # the result would be something like this:
-      # Action    Verb  Path  Controller#Action
-      # index     GET   /     application#index
+      # 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
 
-      if pattern
-        routes = routes.select do |route|
-          route[:path].match?(pattern) || route[:raw_handler].to_s.match?(pattern) || route[:method].match?(pattern)
+        key = [route[:path], route[:raw_handler]]
+        if memo[key]
+          memo[key][:method] += "|#{route[:method]}"
+        else
+          memo[key] = route
         end
       end
 
-      return puts 'Action    Verb  Path  Controller#Action' if routes.empty?
-  
-      # construct a table
-      table = []
-
-      # longest_path is either the length of the longest path or 5
-      longest_path = routes.map { |route| route[:path].length }.max + 3
-      longest_path = longest_path > 5 ? longest_path : 5
-
-      longest_verb = routes.map { |route| route[:method].length }.max + 3
-      longest_verb = longest_verb > 4 ? longest_verb : 7
-
-      # longest_handler is either the length of the longest handler or 7, since DELETE is the longest HTTP method
-      longest_handler = routes.map { |route| route[:raw_handler].is_a?(Proc) ? 7 : route[:raw_handler].split('#').last.length }.max + 3
-      longest_handler = longest_handler > 7 ? longest_handler : 7
-
-      # longest_controller is either the length of the longest controller or 12, since Controller#{length} is the longest controller
-      longest_controller = routes.map { |route| route[:raw_handler].is_a?(Proc) ? 7 : route[:raw_handler].to_s.length }.max + 3
-      longest_controller = longest_controller > 12 ? longest_controller : 12
-
-      routes.each do |route|
-        table << [
-          format("%- #{longest_handler}s", route[:raw_handler].is_a?(Proc) ? 'Lambda' : route[:raw_handler].split('#').last),
-          format("%- #{longest_verb}s", route[:method]),
-          format("%- #{longest_path}s", route[:path]),
-          format("%- #{longest_controller}s", route[:raw_handler].is_a?(Proc) ? 'Lambda' : route[:raw_handler])
-        ]
+      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
 
-      table.unshift([format("%- #{longest_handler}s", 'Action'), format("%- #{longest_verb}s", 'Verb'), format("%- #{longest_path}s", 'Path'),
-                     format("%- #{longest_path}s", "Controller#Action\n")])
-      # print the table
-      table.each do |row|
-        # this should be changed to use the main logger when added
-        puts row.join
+      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
 

data/lib/rage/controller/api.rb

@@ -103,7 +103,7 @@ 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?
@@ -167,7 +167,7 @@ class RageController::API
         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)
 
@@ -189,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?
 
@@ -221,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
@@ -283,4 +288,47 @@ class RageController::API
     @__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
+
+  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/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/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.3.0"
+  VERSION = "0.4.0"
 end

data/lib/rage-rb.rb

@@ -46,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.3.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Roman Samoilov
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-10-08 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