rage-rb 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7684c979952ee81bee165b9b667dea87199f3fa28dadadc4878b29a12211fdac
-  data.tar.gz: 2428443ee2456ef375990decfbf36a2952670ee517ac07cf4c994f5b9b7076f9
+  metadata.gz: 22f98c39badb0c2128b270ce3092d183f62db4bead34e8df627cf322a3697c71
+  data.tar.gz: ea49aeae3da7630f52e8c704bc042752a66b0fefc03a67d713ead33eec1fd006
 SHA512:
-  metadata.gz: f59da6b77e69fa2b89761b30a497b4c0fa8f02cbabeed65c953b0f5e807b349e5b305bf31564bcc3eaeed4957215766e8781af5a5b8bbd9754e0461fa18f7b87
-  data.tar.gz: 733a15ef91abcbfc079a3bbbb83f82686038059b3c518c1c0a279e8000ad885c65cc5019cc691e2731fa1e59ca1f62e8fe95c8f454837ed0bdc65e181157ffc7
+  metadata.gz: e9e57e1eafda6e41112b8af0cc8d23eac629e0964b441622c48173f936f45aac95d0482b3545c5feb047dee755889c30ac63d0f63332e59d36cdff5cb1800198
+  data.tar.gz: 481b9e52062350a9923c3b0195aea555ca0b8cb0c95fa95e76d3e7cd45a27e21a817ad259aed6e1cf9d90c74c17e99b8398066e84deda7e422247a1ea59254b9

data/CHANGELOG.md

@@ -1,14 +1,44 @@
 ## [Unreleased]
 
+## [0.5.0] - 2023-11-25
+
+### Added
+
+- Add sessions for compatibility with `Sidekiq::Web` (#35).
+- Add logger (#33).
+
+### Fixed
+
+- Fixes for `FiberScheduler#io_wait` and `FiberScheduler#io_read` (#32).
+- Correctly handle exceptions in inner fibers (#34).
+- Fixes for `FiberScheduler#kernel_sleep` (#36).
+
+### Changed
+
+- Use config namespaces (#25).
+- Update `Fiber.await` signature (#36).
+
+## [0.4.0] - 2023-10-31
+
+### Added
+
+- Expose the `params` object (#23).
+- Support header authentication with `authenticate_with_http_token` (#21).
+- Add the `resources` route helper (#20).
+- Add the `namespace` route helper by [@arikarim](https://github.com/arikarim) (#17).
+- Add the `mount` and `match` route helpers by [@arikarim](https://github.com/arikarim) (#18) (#14).
+- Allow to access request headers by [@arikarim](https://github.com/arikarim) (#15).
+- 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`.
+- CLI `routes` task by [@arikarim](https://github.com/arikarim) (#9).
+- CLI `console` task (#12).
+- `:if` and `:unless` options in `before_action` (#10).
+- Allow to set response headers (#11).
+- Block version of `before_action` by [@heysyam99](https://github.com/heysyam99) (#8).
 
 ## [0.2.0] - 2023-09-27
 

data/Gemfile

@@ -8,6 +8,9 @@ gemspec
 gem "rake", "~> 13.0"
 
 gem "rspec", "~> 3.0"
+gem "http"
+gem "yard"
 
 gem "pg"
 gem "mysql2"
+gem "connection_pool", "~> 2.0"

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,10 @@ 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)
+- [Logger API](https://rage-rb.pages.dev/Rage/Logger)
 
 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.
 
@@ -98,10 +99,10 @@ require "net/http"
 
 class PagesController < RageController::API
   def index
-    pages = Fiber.await(
+    pages = Fiber.await([
       Fiber.schedule { Net::HTTP.get(URI("https://httpbin.org/json")) },
       Fiber.schedule { Net::HTTP.get(URI("https://httpbin.org/html")) },
-    )
+    ])
 
     render json: { pages: pages }
   end
@@ -143,12 +144,13 @@ 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.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.
-0.8 | Collect app metrics.
-0.9 | Automatic code reloading in development.
+0.4 :white_check_mark: | ~~Expose the `params` object.<br>Support header authentication with `authenticate_with_http_token`.<br>Router updates:<br>&emsp;• add the `resources` route helper;<br>&emsp;• add the `namespace` route helper;~~
+0.5 :white_check_mark:  | ~~Add request logging.~~
+0.6 | Automatic code reloading in development with Zeitwerk.
+0.7 | Expose the `send_data` and `send_file` methods.
+0.8 | Support conditional get with `etag` and `last_modified`.
+0.9 | Expose the `cookies` and `session` objects.
+1.0 | Implement Iodine-based equivalent of Action Cable.
 
 ## Development
 

data/lib/rage/all.rb

@@ -0,0 +1,27 @@
+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"
+
+require_relative "logger/text_formatter"
+require_relative "logger/logger"
+
+if defined?(Sidekiq)
+  require_relative "sidekiq_session"
+end

data/lib/rage/application.rb

@@ -10,20 +10,25 @@ class Rage::Application
 
   def call(env)
     fiber = Fiber.schedule do
+      init_logger
+
       handler = @router.lookup(env)
 
-      if handler
-        handler[:handler].call(env, handler[:params])
+      response = if handler
+        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")}"]]
+    rescue Exception => e
+      exception_str = "#{e.class} (#{e.message}):\n#{e.backtrace.join("\n")}"
+      Rage.logger.error(exception_str)
+      response = [500, {}, [exception_str]]
 
     ensure
-      # notify Iodine the request can now be served
-      Iodine.publish(env["IODINE_REQUEST_ID"], "")
+      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;
@@ -33,4 +38,28 @@ class Rage::Application
       fiber.__get_result
     end
   end
+
+  private
+
+  DEFAULT_LOG_CONTEXT = {}.freeze
+  private_constant :DEFAULT_LOG_CONTEXT
+
+  def init_logger
+    Thread.current[:rage_logger] = {
+      tags: [Iodine::Rack::Utils.gen_request_tag],
+      context: DEFAULT_LOG_CONTEXT,
+      request_start: Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    }
+  end
+
+  def finalize_logger(env, response, params)
+    logger = Thread.current[:rage_logger]
+
+    duration = (
+      (Process.clock_gettime(Process::CLOCK_MONOTONIC) - logger[:request_start]) * 1000
+    ).round(2)
+
+    logger[:final] = { env:, params:, response:, duration: }
+    Rage.logger.info("")
+  end
 end

data/lib/rage/cli.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 require "thor"
-require "rage"
-require "irb"
+require "rack"
 
 module Rage
   class CLI < Thor
@@ -11,17 +10,19 @@ module Rage
 
     desc "new PATH", "Create a new application."
     def new(path)
+      require "rage/all"
       NewAppGenerator.start([path])
     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.threads = Rage.config.threads_count
-      ::Iodine.workers = Rage.config.workers_count
+      ::Iodine.listen service: :http, handler: app, port: options[:port] || Rage.config.server.port
+      ::Iodine.threads = Rage.config.server.threads_count
+      ::Iodine.workers = Rage.config.server.workers_count
 
       ::Iodine.start
     end
@@ -30,62 +31,60 @@ 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", meta: { raw_handler: "Controller#Action" } })
 
-      if pattern
-        routes = routes.select do |route|
-          route[:path].match?(pattern) || route[:raw_handler].to_s.match?(pattern) || route[:method].match?(pattern)
+      grouped_routes = routes.each_with_object({}) do |route, memo|
+        if pattern && !memo.empty?
+          next unless route[:path].match?(pattern) || route[:meta][:raw_handler].to_s.match?(pattern) || route[:method].match?(pattern)
+        end
+
+        key = [route[:path], route[:meta][:raw_handler]]
+
+        if route[:meta][:mount]
+          memo[key] = route.merge(method: "") unless route[:path].end_with?("*")
+          next
+        end
+
+        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[:meta][: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
+      require "irb"
       environment
       ARGV.clear
       IRB.start

data/lib/rage/configuration.rb

@@ -1,10 +1,26 @@
 class Rage::Configuration
-  attr_accessor :port, :workers_count
-  attr_reader :threads_count
+  attr_accessor :logger, :log_formatter, :log_level
 
-  def initialize
-    @threads_count = 1
-    @workers_count = -1
-    @port = 3000
+  # used in DSL
+  def config = self
+
+  def server
+    @server ||= Server.new
+  end
+
+  class Server
+    attr_accessor :port, :workers_count
+    attr_reader :threads_count
+
+    def initialize
+      @threads_count = 1
+      @workers_count = -1
+      @port = 3000
+    end
+  end
+
+  def __finalize
+    @logger.formatter = @log_formatter if @logger && @log_formatter
+    @logger.level = @log_level if @logger && @log_level
   end
 end

data/lib/rage/controller/api.rb

@@ -50,7 +50,7 @@ class RageController::API
         ""
       end
 
-      class_eval <<-RUBY
+      class_eval <<-RUBY,  __FILE__, __LINE__ + 1
         def __run_#{action}
           #{before_actions_chunk}
           #{action}
@@ -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/fiber.rb

@@ -1,4 +1,8 @@
+# frozen_string_literal: true
+
 class Fiber
+  AWAIT_ERROR_MESSAGE = "err"
+
   # @private
   def __set_result(result)
     @__result = result
@@ -9,30 +13,74 @@ class Fiber
     @__result
   end
 
+  # @private
+  def __set_err(err)
+    @__err = err
+  end
+
+  # @private
+  def __get_err
+    @__err
+  end
+
+  # @private
+  # pause a fiber and resume in the next iteration of the event loop
+  def self.pause
+    f = Fiber.current
+    Iodine.defer { f.resume }
+    Fiber.yield
+  end
+
   # Wait on several fibers at the same time. Calling this method will automatically pause the current fiber, allowing the
   #   server to process other requests. Once all fibers have completed, the current fiber will be automatically resumed.
   #
   # @param fibers [Fiber, Array<Fiber>] one or several fibers to wait on. The fibers must be created using the `Fiber.schedule` call.
   # @example
-  #   Fiber.await(
+  #   Fiber.await([
   #     Fiber.schedule { request_1 },
   #     Fiber.schedule { request_2 },
-  #   )
+  #   ])
   # @note This method should only be used when multiple fibers have to be processed in parallel. There's no need to use `Fiber.await` for single IO calls.
-  def self.await(*fibers)
-    f = Fiber.current
+  def self.await(fibers)
+    f, fibers = Fiber.current, Array(fibers)
 
-    num_wait_for = fibers.count(&:alive?)
-    return fibers.map(&:__get_result) if num_wait_for == 0
+    # check which fibers are alive (i.e. have yielded) and which have errored out
+    i, err, num_wait_for = 0, nil, 0
+    while i < fibers.length
+      if fibers[i].alive?
+        num_wait_for += 1
+      else
+        err = fibers[i].__get_err
+        break if err
+      end
+      i += 1
+    end
+
+    # raise if one of the fibers has errored out or return the result if none have yielded
+    if err
+      raise err
+    elsif num_wait_for == 0
+      return fibers.map!(&:__get_result)
+    end
 
-    Iodine.subscribe("await:#{f.object_id}") do
-      num_wait_for -= 1
-      f.resume if num_wait_for == 0
+    # wait on async fibers; resume right away if one of the fibers errors out
+    Iodine.subscribe("await:#{f.object_id}") do |_, err|
+      if err == AWAIT_ERROR_MESSAGE
+        f.resume
+      else
+        num_wait_for -= 1
+        f.resume if num_wait_for == 0
+      end
     end
 
     Fiber.yield
     Iodine.defer { Iodine.unsubscribe("await:#{f.object_id}") }
 
-    fibers.map(&:__get_result)
+    # if num_wait_for is not 0 means we exited prematurely because of an error
+    if num_wait_for > 0
+      raise fibers.find(&:__get_err).__get_err
+    else
+      fibers.map!(&:__get_result)
+    end
   end
 end