rackr 0.0.65 → 0.0.67

data/lib/rackr/router/path_route.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+class Rackr
+  class Router
+    # Path route is a route that has a path value that can be matched, and may have path params
+    class PathRoute < Route
+      attr_reader :splitted_path,
+                  :has_params
+
+      def initialize(path, endpoint, befores: [], afters: [], wildcard: false)
+        super(endpoint, befores:, afters:)
+
+        @path = path
+        @splitted_path = @path.split('/')
+        @params = fetch_params
+        @has_params = @params != []
+        @path_regex = /\A#{path.gsub(/(:\w+)/, '([^/]+)')}\z/
+        @wildcard = wildcard
+      end
+
+      def match?(path_info)
+        return path_info.match?(@path_regex) if @has_params
+        return true if @wildcard
+
+        path_info == @path
+      end
+
+      private
+
+      def fetch_params
+        @splitted_path.select { |value| value.start_with? ':' }
+      end
+    end
+  end
+end

data/lib/rackr/router/route.rb

@@ -2,6 +2,7 @@
 
 class Rackr
   class Router
+    # A Route for Rackr is an object that has endpoint and callbacks (before and after)
     class Route
       attr_reader :endpoint,
                   :befores,

data/lib/rackr/router.rb

@@ -1,27 +1,23 @@
 # frozen_string_literal: true
 
-require_relative 'router/utils'
 require_relative 'router/errors'
 require_relative 'router/endpoint'
 require_relative 'router/route'
 require_relative 'router/path_route'
 require_relative 'router/build_request'
+require_relative 'router/dev_html/errors'
+require_relative 'router/dev_html/dump'
 
 class Rackr
+  # This is the core class of Rackr. This class aggregate the route instance tree, callbacks (before and after) and scopes
+  # then, using the building blocks, match the request and call the endpoints
   class Router
-    include Utils
+    include Rackr::Utils
 
     attr_writer :default_not_found
-    attr_reader :routes, :config, :not_found_instances, :error_instances
+    attr_reader :routes, :config, :not_found_tree, :error_tree, :specific_error_tree
 
     def initialize(config = {}, before: [], after: [])
-      @path_routes_instances = {}
-      %w[GET POST DELETE PUT TRACE OPTIONS PATCH].each do |method|
-        @path_routes_instances[method] = { __instances: [] }
-      end
-      @not_found_instances = {}
-      @error_instances = {}
-
       http_methods = HTTP_METHODS.map { |m| m.downcase.to_sym }
       @routes = Struct.new(*http_methods).new
       http_methods.each do |method|
@@ -36,54 +32,123 @@ class Rackr
       @scopes_befores = {}
       @afters = ensure_array(after)
       @scopes_afters = {}
-      @default_error = Route.new(proc { |_req, e| raise e })
-      @default_not_found = Route.new(proc { [404, {}, ['Not found']] })
-      @splitted_request_path_info = []
-      @current_request_path_info = nil
+      @path_routes_tree = {}
+      %w[GET POST DELETE PUT TRACE OPTIONS PATCH].each do |method|
+        @path_routes_tree[method] = { __instances: [] }
+      end
+      @not_found_tree = {}
+      @default_not_found =
+        Route.new(
+          proc { [404, {}, ['Not found']] },
+          befores: @befores,
+          afters: @afters
+        )
+      @error_tree = {}
+      @default_error =
+        Route.new(
+          proc { |_req, _e| [500, {}, ['Internal server error']] },
+          befores: @befores,
+          afters: @afters
+        )
+      @specific_error_tree = {}
+      @specific_errors = {}
     end
 
     def call(env)
       path_info = env['PATH_INFO']
+      request_method = env['REQUEST_METHOD'] == 'HEAD' ? 'GET' : env['REQUEST_METHOD']
 
-      @splitted_request_path_info = path_info.split('/')
-      @current_request_path_info =
+      splitted_request_path_info = path_info.split('/')
+      current_request_path_info =
         path_info == '/' ? path_info : path_info.chomp('/') # remove trailing "/"
 
-      request_builder = BuildRequest.new(env, @splitted_request_path_info)
-      env['REQUEST_METHOD'] = 'GET' if env['REQUEST_METHOD'] == 'HEAD'
-
-      route_instance, found_scopes = match_path_route(env['REQUEST_METHOD'])
-      rack_request = request_builder.call(route_instance)
+      route_instance, found_scopes = match_path_route(
+        request_method,
+        splitted_request_path_info,
+        current_request_path_info
+      )
+      rack_request = BuildRequest.new(env, splitted_request_path_info).call(route_instance)
       befores = route_instance.befores
       before_result = nil
 
       begin
         i = 0
         while i < befores.size
-          before_result = Endpoint.call(befores[i], rack_request)
-          return before_result unless before_result.is_a?(Rack::Request)
+          before_result = Endpoint.call(befores[i], rack_request, @routes, @config)
+          unless before_result.is_a?(Rack::Request)
+            Errors.check_rack_response(before_result, 'before callback')
 
-          rack_request = before_result
+            return before_result
+          end
 
           i += 1
         end
 
-        endpoint_result = Endpoint.call(route_instance.endpoint, before_result || rack_request)
+        endpoint_result = Endpoint.call(route_instance.endpoint, before_result || rack_request, @routes, @config)
 
         call_afters(route_instance, endpoint_result)
       rescue Rackr::NotFound
         return not_found_fallback(found_scopes, route_instance, before_result || rack_request)
+      rescue Rackr::Dump => e
+        return Endpoint.call(DevHtml::Dump, env.merge({ 'dump' => e }))
+        # rubocop:disable Lint/RescueException
       rescue Exception => e
-        if !@dev_mode || ENV['RACKR_ERROR_DEV']
-          return error_fallback(found_scopes, route_instance, before_result || rack_request, e)
-        end
+        return error_fallback(found_scopes, route_instance, before_result || rack_request, e, env)
+      end
+      # rubocop:enable Lint/RescueException
+
+      Errors.check_rack_response(endpoint_result, 'action')
+      endpoint_result
+    end
+
+    def not_found_fallback(found_scopes, route_instance, request)
+      endpoint_result = Endpoint.call(
+        match_route(
+          found_scopes,
+          not_found_tree,
+          @default_not_found
+        ).endpoint,
+        request,
+        @routes,
+        @config
+      )
+
+      call_afters(route_instance, endpoint_result)
+
+      endpoint_result
+    end
 
-        return Endpoint.call(Errors::DevHtml, env.merge({ 'error' => e }))
+    def error_fallback(found_scopes, route_instance, request, error, env)
+      error_route = match_route(
+        found_scopes,
+        specific_error_tree[error.class] || error_tree,
+        @specific_errors[error.class] || @default_error
+      )
+
+      return Endpoint.call(DevHtml::Errors, env.merge({ 'error' => error })) if @dev_mode && error_route == @default_error
+
+      endpoint_result = Endpoint.call(error_route.endpoint, request, @routes, @config, error)
+
+      if endpoint_result.nil?
+        return Endpoint.call(DevHtml::Errors, env.merge({ 'error' => error })) if @dev_mode
+
+        endpoint_result = Endpoint.call(@default_error.endpoint, request, @routes, @config, error)
       end
 
+      call_afters(route_instance, endpoint_result)
+
       endpoint_result
     end
 
+    def call_afters(route_instance, endpoint_result)
+      afters = route_instance.afters
+      i = 0
+      while i < afters.size
+        Endpoint.call(afters[i], endpoint_result, @routes, @config)
+        i += 1
+      end
+    end
+
     def add(method, path, endpoint, as: nil, route_befores: [], route_afters: [])
       Errors.check_path(path)
       Errors.check_endpoint(endpoint, path)
@@ -94,65 +159,64 @@ class Rackr
       method = :get if method == :head
 
       wildcard = path == '*'
-      path = path.is_a?(Symbol) ? path.inspect : path.sub(%r{\A/}, '')
+      path = path.is_a?(Symbol) ? path.inspect : path.delete_prefix('/')
       path_with_scopes = "/#{not_empty_scopes.join('/')}#{put_path_slash(path)}"
       add_named_route(method, path_with_scopes, as)
+      action_befores, action_afters = fetch_endpoint_callbacks(endpoint)
 
       route_instance =
         PathRoute.new(
           path_with_scopes,
           endpoint,
-          befores: @befores + ensure_array(route_befores),
-          afters: @afters + ensure_array(route_afters),
+          befores: @befores + ensure_array(route_befores) + action_befores,
+          afters: @afters + ensure_array(route_afters) + action_afters,
           wildcard: wildcard
         )
 
-      return push_to_scope(method.to_s.upcase, route_instance) if @scopes.size >= 1
+      path_segments = path_with_scopes.split('/').reject(&:empty?)
 
-      @path_routes_instances[method.to_s.upcase][:__instances].push(route_instance)
+      if path_segments.empty?
+        @path_routes_tree[method.to_s.upcase][:__instances].push(route_instance)
+      else
+        deep_hash_push(@path_routes_tree[method.to_s.upcase], *(path_segments + [:__instances]), route_instance)
+      end
     end
 
-    %i[error not_found].each do |v|
-      define_method("add_#{v}") do |endpoint|
-        Errors.check_endpoint(endpoint, v)
+    def add_not_found(endpoint)
+      Errors.check_endpoint(endpoint, 'not found')
 
-        route_instance =
-          Route.new(
-            endpoint,
-            befores: @befores,
-            afters: @afters
-          )
+      action_befores, action_afters = fetch_endpoint_callbacks(endpoint)
+      route_instance =
+        Route.new(
+          endpoint,
+          befores: @befores + action_befores,
+          afters: @afters + action_afters
+        )
 
-        return set_to_scope(send("#{v}_instances"), route_instance) if @scopes.size >= 1
+      return set_to_scope(not_found_tree, route_instance) if @scopes.size >= 1
 
-        instance_variable_set("@default_#{v}", route_instance)
-      end
+      @default_not_found = route_instance
+    end
 
-      define_method("#{v}_fallback") do |found_scopes, route_instance, request, error = nil|
-        args = [
-          match_route(
-            found_scopes,
-            send("#{v}_instances"),
-            instance_variable_get("@default_#{v}")
-          ).endpoint,
-          request
-        ]
-        args << error if error
+    def add_error(endpoint, error_class = nil)
+      Errors.check_endpoint(endpoint, 'error')
 
-        endpoint_result = Endpoint.call(*args)
+      action_befores, action_afters = fetch_endpoint_callbacks(endpoint)
+      route_instance =
+        Route.new(
+          endpoint,
+          befores: @befores + action_befores,
+          afters: @afters + action_afters
+        )
 
-        call_afters(route_instance, endpoint_result)
+      if error_class
+        return set_to_scope(specific_error_tree[error_class] ||= {}, route_instance) if @scopes.size >= 1
 
-        endpoint_result
-      end
-    end
+        @specific_errors[error_class] = route_instance
+      else
+        return set_to_scope(error_tree, route_instance) if @scopes.size >= 1
 
-    def call_afters(route_instance, endpoint_result)
-      afters = route_instance.afters
-      i = 0
-      while i < afters.size
-        Endpoint.call(afters[i], endpoint_result)
-        i += 1
+        @default_error = route_instance
       end
     end
 
@@ -181,22 +245,34 @@ class Rackr
       @scopes = @scopes.first(@scopes.size - 1)
     end
 
+    def not_empty_scopes
+      @scopes.reject { |v| (v == '') }
+    end
+
     private
 
+    def fetch_endpoint_callbacks(endpoint)
+      action_befores = []
+      action_afters = []
+      if endpoint.is_a?(Class) && endpoint.ancestors.include?(Rackr::Action)
+        action_instance = endpoint.new
+        action_befores = action_instance.befores
+        action_afters = action_instance.afters
+      end
+
+      [action_befores, action_afters]
+    end
+
     def add_named_route(method, path_with_scopes, as)
       return @routes.send(method.downcase)[:root] = path_with_scopes if path_with_scopes == '/'
       return @routes.send(method.downcase)[as] = path_with_scopes unless as.nil?
 
-      key = path_with_scopes.sub('/', '').gsub(':', '').gsub('/', '_')
+      key = path_with_scopes.sub('/', '').delete(':').tr('/', '_')
       @routes.send(method.downcase)[key.to_s.to_sym] = path_with_scopes
     end
 
-    def push_to_scope(method, route_instance)
-      deep_hash_push(@path_routes_instances[method], *(not_empty_scopes + %i[__instances]), route_instance)
-    end
-
     def set_to_scope(instances, route_instance)
-      deep_hash_set(instances, (not_empty_scopes + %i[__instance]), route_instance)
+      deep_hash_set(instances, not_empty_scopes + %i[__instance], route_instance)
     end
 
     def put_path_slash(path)
@@ -209,59 +285,49 @@ class Rackr
       path
     end
 
-    def not_empty_scopes
-      @scopes.reject { |v| (v == '') }
-    end
-
-    def match_path_route(request_method)
-      find_instance_in_scope = proc do |request_method, found_scopes|
-        @path_routes_instances[request_method].dig(
-          *(found_scopes + [:__instances])
-        )&.detect { |route_instance| route_instance.match?(@current_request_path_info) }
-      end
-
-      last_tail = @splitted_request_path_info.drop(1)
+    def match_path_route(request_method, splitted_request_path_info, current_request_path_info)
+      path_routes_tree = @path_routes_tree[request_method]
       found_scopes = []
 
-      path_routes_instances = @path_routes_instances[request_method]
-
-      while last_tail && !last_tail.empty?
-        segment = last_tail.shift
-        found_route = nil
+      i = 1
+      while i < splitted_request_path_info.size
+        segment = splitted_request_path_info[i]
+
+        if path_routes_tree.key?(segment)
+          found_scopes << segment
+          path_routes_tree = path_routes_tree[segment]
+        elsif (param_key = path_routes_tree.keys.find { |k| k.start_with?(':') })
+          found_scopes << param_key
+          path_routes_tree = path_routes_tree[param_key]
+        elsif path_routes_tree.key?('*')
+          path_routes_tree = path_routes_tree['*']
+          break
+        else
+          break
+        end
+        i += 1
+      end
 
-        path_routes_instances.each_key do |scope|
-          next if scope == :__instances
+      route_instance = path_routes_tree[:__instances]&.detect do |route|
+        route.match?(current_request_path_info)
+      end
 
-          if segment == scope
-            found_scopes << scope
-            path_routes_instances = @path_routes_instances[request_method].dig(*found_scopes)
-            break
-          elsif scope.start_with?(':')
-            found_route = find_instance_in_scope.call(request_method, found_scopes)
-            return found_route if found_route
+      route_instance = find_not_found_route(found_scopes) if route_instance.nil?
 
-            found_scopes << scope
-            path_routes_instances = @path_routes_instances[request_method].dig(*found_scopes)
-            break
-          end
-        end
-      end
+      [route_instance, found_scopes]
+    end
 
-      result_route = find_instance_in_scope.call(request_method, found_scopes)
+    def find_not_found_route(found_scopes)
+      not_found_route = nil
 
-      if result_route.nil? && !found_scopes.empty?
-        result_route = find_instance_in_scope.call(request_method, found_scopes[..-2])
-      end
+      while not_found_route.nil? && !found_scopes.empty?
+        not_found_route = @not_found_tree.dig(*found_scopes, :__instance)
+        break if not_found_route
 
-      if result_route.nil?
-        result_route = match_route(
-          found_scopes,
-          @not_found_instances,
-          @default_not_found
-        )
+        found_scopes.pop
       end
 
-      [result_route, found_scopes]
+      not_found_route || @default_not_found
     end
 
     def match_route(found_scopes, instances, default_instance)

data/lib/rackr/utils.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class Rackr
+  # Utils methods for Rackr
+  module Utils
+    def deep_hash_push(hash, first_key, *rest_keys, val)
+      if rest_keys.empty?
+        (hash[first_key] ||= []) << val
+      else
+        hash[first_key] = deep_hash_push(hash[first_key] ||= {}, *rest_keys, val)
+      end
+      hash
+    end
+
+    def ensure_array(list)
+      return [] if list.nil?
+      return list if list.is_a?(Array)
+
+      [list]
+    end
+
+    def deep_hash_set(hash, keys, value)
+      *path, last = keys
+      node = path.inject(hash) { |h, k| h[k] ||= {} }
+      node[last] = value
+    end
+  end
+end

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|