rackr 0.0.64 → 0.0.67

data/lib/rackr.rb

@@ -1,28 +1,36 @@
 # frozen_string_literal: true
 
+require_relative 'rackr/utils'
 require_relative 'rackr/action'
 require_relative 'rackr/callback'
-require_relative 'rackr/router/errors/dev_html'
 require_relative 'rackr/router'
 
+# Rackr is a simple router for Rack.
 class Rackr
   class NotFound < StandardError; end
 
+  # Dump is a special error that is used to dump the content of a request.
+  class Dump < StandardError
+    attr_reader :content
+
+    def initialize(content)
+      @content = content
+
+      super
+    end
+  end
+
   HTTP_METHODS = %w[GET POST DELETE PUT TRACE OPTIONS PATCH].freeze
 
-  include Action
+  include Callback
+  include Utils
 
   def initialize(config = {}, before: [], after: [])
     @router = Router.new(config, before: before, after: after)
   end
 
-  def call(&block)
-    instance_eval(&block)
-    puts "\n= Routes =============="
-    routes.each_pair { |v| p v }
-    puts "\n= Config =============="
-    puts config
-    puts "\n"
+  def call(&)
+    instance_eval(&)
 
     @router
   end
@@ -40,7 +48,15 @@ class Rackr
   end
 
   def db
-    @router.config.dig(:deps, :db)
+    @router.config&.dig(:deps, :db)
+  end
+
+  def log
+    @router.config&.dig(:deps, :log)
+  end
+
+  def cache
+    @router.config&.dig(:deps, :cache)
   end
 
   def scope(name = '', before: [], after: [], &block)
@@ -62,50 +78,105 @@ class Rackr
     end
   end
 
-  def error(endpoint = -> {}, &block)
+  def error(error_class_or_endpoint = nil, endpoint = nil, &block)
     if block_given?
-      @router.add_error(block)
+      if error_class_or_endpoint
+        @router.add_error(block, error_class_or_endpoint)
+      else
+        @router.add_error(block)
+      end
+    elsif endpoint
+      @router.add_error(endpoint, error_class_or_endpoint)
     else
-      @router.add_error(endpoint)
+      @router.add_error(error_class_or_endpoint)
     end
   end
 
-  def resources(name, id: :id, before: [], after: [], &block)
-    @resource_namespace = (@resource_namespace || []).push([name.to_s.capitalize])
+  def resources(name, id: :id, path: nil, paths: {}, callbacks: [], before: [], after: [], &block)
+    @nested_resources ||= []
+    @nested_resources.push(name)
 
-    get_const = ->(type, action) do
-      if Object.const_defined?("#{type}::#{@resource_namespace.join('::')}::#{action}")
-        Object.const_get("#{type}::#{@resource_namespace.join('::')}::#{action}")
-      end
+    infer_action_const = lambda do |action|
+      scope_parts = @router.not_empty_scopes
+                           .map(&:to_s)
+                           .reject { |s| s.start_with?(':') }
+                           .map(&:capitalize)
+
+      parts = ['Actions'] + scope_parts + [name.to_s.capitalize, action]
+      const_path = parts.join('::')
+
+      Object.const_get(const_path) if Object.const_defined?(const_path)
+    end
+
+    infer_assign_const = lambda do
+      parts = @nested_resources.map { |s| s.to_s.capitalize }
+      const_path = "Callbacks::#{parts.join('::')}::Assign"
+      Object.const_get(const_path) if Object.const_defined?(const_path)
     end
 
     actions = {
-      index: { method: :get, path: nil, action: get_const.call('Actions', 'Index') },
-      new: { method: :get, path: 'new', action: get_const.call('Actions', 'New') },
-      create: { method: :post, path: nil, action: get_const.call('Actions', 'Create') },
+      index: { method: :get, path: nil, action: infer_action_const.call('Index') },
+      new: { method: :get, path: 'new', action: infer_action_const.call('New') },
+      create: { method: :post, path: nil, action: infer_action_const.call('Create') }
     }
 
     actions_for_id = {
-      show: { method: :get, path: nil, action: get_const.call('Actions', 'Show') },
-      edit: { method: :get, path: "edit", action: get_const.call('Actions', 'Edit') },
-      update: { method: :put, path: nil, action: get_const.call('Actions', 'Update') },
-      delete: { method: :delete, path: nil, action: get_const.call('Actions', 'Delete') }
+      show: { method: :get, path: nil, action: infer_action_const.call('Show') },
+      edit: { method: :get, path: 'edit', action: infer_action_const.call('Edit') },
+      update: { method: :put, path: nil, action: infer_action_const.call('Update') },
+      delete: { method: :delete, path: nil, action: infer_action_const.call('Delete') }
     }
 
+    received_callbacks = Hash.new { |h, k| h[k] = { before: [], after: [] } }
+    (callbacks || []).each do |callback_config|
+      ensure_array(callback_config[:actions]).each do |action|
+        received_callbacks[action][:before].concat(ensure_array(callback_config[:before]))
+        received_callbacks[action][:after].concat(ensure_array(callback_config[:after]))
+      end
+    end
+
+    (paths || {}).each do |action, new_path|
+      if actions[action]
+        actions[action][:path] = new_path
+      elsif actions_for_id[action]
+        actions_for_id[action][:path] = new_path
+      end
+    end
+
     block_for_id = proc do
-      actions_for_id.each do |_, definition|
-        send(definition[:method], definition[:path], definition[:action]) if definition[:action]
+      actions_for_id.each do |action_name, definition|
+        next unless definition[:action]
+
+        action_callbacks = received_callbacks[action_name]
+        send(
+          definition[:method],
+          definition[:path],
+          definition[:action],
+          before: action_callbacks[:before],
+          after: action_callbacks[:after]
+        )
       end
 
       instance_eval(&block) if block_given?
     end
 
-    scope(name.to_s, before:, after:) do
-      actions.each do |_, definition|
-        send(definition[:method], definition[:path], definition[:action]) if definition[:action]
+    scope_name = path || name.to_s
+    assign_callback = infer_assign_const.call
+
+    scope(scope_name, before:, after:) do
+      actions.each do |action_name, definition|
+        next unless definition[:action]
+
+        action_callbacks = received_callbacks[action_name]
+        send(
+          definition[:method],
+          definition[:path],
+          definition[:action],
+          before: action_callbacks[:before],
+          after: action_callbacks[:after]
+        )
       end
 
-      assign_callback = get_const.call('Callbacks', 'Assign')
       if assign_callback
         scope(id.to_sym, before: assign_callback, &block_for_id)
       else
@@ -113,7 +184,7 @@ class Rackr
       end
     end
 
-    @resource_namespace = @resource_namespace.first(@resource_namespace.size - 1)
+    @nested_resources.pop
   end
 
   HTTP_METHODS.each do |http_method|

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: rackr
 version: !ruby/object:Gem::Version
-  version: 0.0.64
+  version: 0.0.67
 platform: ruby
 authors:
 - Henrique F. Teixeira
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-12-07 00:00:00.000000000 Z
+date: 2026-01-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: erubi
@@ -58,7 +57,7 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '4.0'
-description: A complete, simple and easy web micro-framework.
+description: A friendly web micro-framework.
 email: hriqueft@gmail.com
 executables: []
 extensions: []
@@ -69,14 +68,17 @@ files:
 - lib/rackr/callback.rb
 - lib/rackr/router.rb
 - lib/rackr/router/build_request.rb
+- lib/rackr/router/dev_html/dump.rb
+- lib/rackr/router/dev_html/errors.rb
+- lib/rackr/router/endpoint.rb
 - lib/rackr/router/errors.rb
-- lib/rackr/router/errors/dev_html.rb
+- lib/rackr/router/path_route.rb
 - lib/rackr/router/route.rb
+- lib/rackr/utils.rb
 homepage: https://github.com/henrique-ft/rackr
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -91,8 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.3
-signing_key: 
+rubygems_version: 3.6.6
 specification_version: 4
-summary: A complete, simple and easy web micro-framework.
+summary: A friendly web micro-framework.
 test_files: []