rage-rb 0.3.0 → 0.5.0

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 the 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,120 @@ 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
+
+      at = "/#{at}" unless at.start_with?("/")
+      at = at.delete_suffix("/") if at.end_with?("/")
+
+      http_methods = if via == :all || via.nil?
+        @default_match_methods.map { |method| method.to_s.upcase! }
+      else
+        Array(via).map! do |method|
+          raise ArgumentError, "Invalid HTTP method: #{method}" unless @default_match_methods.include?(method)
+          method.to_s.upcase!
+        end
+      end
+
+      @router.mount(at, app, http_methods)
+    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 +378,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

@@ -22,7 +22,7 @@ class Rage::Router::HandlerStorage
       params: params,
       constraints: constraints,
       handler: route[:handler],
-      create_params_object: compile_create_params_object(params, route[:defaults])
+      create_params_object: compile_create_params_object(params, route[:defaults], route[:meta])
     }
 
     constraints_keys = constraints.keys
@@ -47,16 +47,19 @@ class Rage::Router::HandlerStorage
 
   private
 
-  def compile_create_params_object(param_keys, defaults)
-    lines = []
+  def compile_create_params_object(param_keys, defaults, meta)
+    lines = [
+      ":controller => '#{meta[:controller]}'.freeze",
+      ":action => '#{meta[:action]}'.freeze"
+    ]
 
     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}'.freeze"
       end
     end
 

data/lib/rage/sidekiq_session.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "digest"
+require "base64"
+
+##
+# Used **specifically** for compatibility with Sidekiq's Web interface.
+# Remove once we have real sessions or once Sidekiq's author decides they
+# don't need cookie sessions to protect against CSRF.
+#
+class Rage::SidekiqSession
+  KEY = Digest::SHA2.hexdigest(ENV["SECRET_KEY_BASE"] || File.read("Gemfile.lock") + File.read("config/routes.rb"))
+  SESSION_KEY = "rage.sidekiq.session"
+
+  def self.with_session(env)
+    env["rack.session"] = session = self.new(env)
+    response = yield
+
+    if session.changed
+      Rack::Utils.set_cookie_header!(
+        response[1],
+        SESSION_KEY,
+        { path: env["SCRIPT_NAME"], httponly: true, same_site: true, value: session.dump }
+      )
+    end
+
+    response
+  end
+
+  attr_reader :changed
+
+  def initialize(env)
+    @env = env
+    session = Rack::Utils.parse_cookies(@env)[SESSION_KEY]
+    @data = decode_session(session)
+  end
+
+  def [](key)
+    @data[key]
+  end
+
+  def[]=(key, value)
+    @changed = true
+    @data[key] = value
+  end
+
+  def to_hash
+    @data
+  end
+
+  def dump
+    encoded_data = Marshal.dump(@data)
+    signature = OpenSSL::HMAC.hexdigest("SHA256", KEY, encoded_data)
+
+    Base64.urlsafe_encode64("#{encoded_data}--#{signature}")
+  end
+
+  private
+
+  def decode_session(session)
+    return {} unless session
+
+    encoded_data, signature = Base64.urlsafe_decode64(session).split("--")
+    ref_signature = OpenSSL::HMAC.hexdigest("SHA256", KEY, encoded_data)
+
+    if Rack::Utils.secure_compare(signature, ref_signature)
+      Marshal.load(encoded_data)
+    else
+      {}
+    end
+  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/Rakefile

@@ -0,0 +1 @@
+require_relative "config/application"

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

@@ -1,6 +1,11 @@
 require "bundler/setup"
-
 require "rage"
 Bundler.require(*Rage.groups)
 
+require "rage/all"
+
+Rage.configure do
+  # use this to add settings that are constant across all environments
+end
+
 require "rage/setup"

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

@@ -1,7 +1,10 @@
-Rage.configure do |config|
+Rage.configure do
   # Specify the number of server processes to run. Defaults to number of CPU cores.
-  config.workers_count = 1
+  config.server.workers_count = 1
 
   # Specify the port the server will listen on.
-  config.port = 3000
+  config.server.port = 3000
+
+  # Specify the logger
+  config.logger = Rage::Logger.new(STDOUT)
 end

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

@@ -1,7 +1,11 @@
-Rage.configure do |config|
+Rage.configure do
   # Specify the number of server processes to run. Defaults to number of CPU cores.
-  # config.workers_count = ENV.fetch("WEB_CONCURRENCY", 1)
+  # config.server.workers_count = ENV.fetch("WEB_CONCURRENCY", 1)
 
   # Specify the port the server will listen on.
-  config.port = 3000
+  config.server.port = 3000
+
+  # Specify the logger
+  config.logger = Rage::Logger.new("log/production.log")
+  config.log_level = Logger::INFO
 end

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

@@ -1,7 +1,10 @@
-Rage.configure do |config|
+Rage.configure do
   # Specify the number of server processes to run. Defaults to number of CPU cores.
-  config.workers_count = 1
+  config.server.workers_count = 1
 
   # Specify the port the server will listen on.
-  config.port = 3000
+  config.server.port = 3000
+
+  # Specify the logger
+  config.logger = Rage::Logger.new("log/test.log")
 end

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.5.0"
 end

data/lib/rage-rb.rb

@@ -22,8 +22,9 @@ module Rage
     @config ||= Rage::Configuration.new
   end
 
-  def self.configure
-    yield(config)
+  def self.configure(&)
+    config.instance_eval(&)
+    config.__finalize
   end
 
   def self.env
@@ -38,6 +39,10 @@ module Rage
     @root ||= Pathname.new(".").expand_path
   end
 
+  def self.logger
+    @logger ||= config.logger
+  end
+
   module Router
     module Strategies
     end
@@ -46,17 +51,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.2"
 end