rackr 0.0.64 → 0.0.67

data/lib/rackr/router/route.rb

@@ -2,41 +2,25 @@
 
 class Rackr
   class Router
+    # A Route for Rackr is an object that has endpoint and callbacks (before and after)
     class Route
       attr_reader :endpoint,
-                  :splitted_path,
-                  :has_params,
-                  :has_befores,
                   :befores,
-                  :has_afters,
-                  :afters
+                  :has_befores,
+                  :afters,
+                  :has_afters
 
-      def initialize(path, endpoint, befores: [], afters: [], wildcard: false)
-        @path = path
-        @splitted_path = @path.split('/')
+      def initialize(endpoint, befores: [], afters: [])
         @endpoint = endpoint
-        @params = fetch_params
-        @has_params = @params != []
         @befores = befores
         @has_befores = befores != []
         @afters = afters
         @has_afters = afters != []
-        @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
+      def match? = true
+      def splitted_path = []
+      def has_params = false
     end
   end
 end

data/lib/rackr/router.rb

@@ -1,19 +1,23 @@
 # frozen_string_literal: true
 
 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
-    attr_writer :not_found
-    attr_reader :routes, :config
+    include Rackr::Utils
+
+    attr_writer :default_not_found
+    attr_reader :routes, :config, :not_found_tree, :error_tree, :specific_error_tree
 
     def initialize(config = {}, before: [], after: [])
-      @instance_routes = {}
-      %w[GET POST DELETE PUT TRACE OPTIONS PATCH].each do |method|
-        @instance_routes[method] = { __instances: [] }
-      end
       http_methods = HTTP_METHODS.map { |m| m.downcase.to_sym }
       @routes = Struct.new(*http_methods).new
       http_methods.each do |method|
@@ -28,55 +32,121 @@ class Rackr
       @scopes_befores = {}
       @afters = ensure_array(after)
       @scopes_afters = {}
-      @error = proc { |_req, e| raise e }
-      @not_found = 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(
+        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
 
-      route_instance = match_route(env['REQUEST_METHOD'])
-      return call_endpoint(@not_found, request_builder.call) if route_instance.nil?
+      begin
+        i = 0
+        while i < befores.size
+          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 = request_builder.call(route_instance)
+            return before_result
+          end
 
-      befores = route_instance.befores
-      before_result = nil
-      i = 0
-      while i < befores.size
-        before_result = call_endpoint(befores[i], rack_request)
-        return before_result unless before_result.is_a?(Rack::Request)
+          i += 1
+        end
 
-        rack_request = before_result
+        endpoint_result = Endpoint.call(route_instance.endpoint, before_result || rack_request, @routes, @config)
 
-        i += 1
+        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
+        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
+      )
 
-      endpoint_result = call_endpoint(route_instance.endpoint, before_result || rack_request)
+      call_afters(route_instance, endpoint_result)
 
+      endpoint_result
+    end
+
+    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
-        call_endpoint(afters[i], endpoint_result)
+        Endpoint.call(afters[i], endpoint_result, @routes, @config)
         i += 1
       end
-
-      endpoint_result
-    rescue Rackr::NotFound
-      call_endpoint(@not_found, request_builder.call)
-    rescue Exception => e
-      return @error.call(request_builder.call, e) if !@dev_mode || ENV['RACKR_ERROR_DEV']
-
-      call_endpoint(Errors::DevHtml, env.merge({ 'error' => e }))
     end
 
     def add(method, path, endpoint, as: nil, route_befores: [], route_afters: [])
@@ -89,34 +159,65 @@ 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 =
-        Route.new(
+        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?)
 
-      @instance_routes[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
 
     def add_not_found(endpoint)
-      Errors.check_endpoint(endpoint, 'not_found')
+      Errors.check_endpoint(endpoint, 'not found')
 
-      @not_found = endpoint
+      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(not_found_tree, route_instance) if @scopes.size >= 1
+
+      @default_not_found = route_instance
     end
 
-    def add_error(endpoint)
+    def add_error(endpoint, error_class = nil)
       Errors.check_endpoint(endpoint, 'error')
 
-      @error = endpoint
+      action_befores, action_afters = fetch_endpoint_callbacks(endpoint)
+      route_instance =
+        Route.new(
+          endpoint,
+          befores: @befores + action_befores,
+          afters: @afters + action_afters
+        )
+
+      if error_class
+        return set_to_scope(specific_error_tree[error_class] ||= {}, route_instance) if @scopes.size >= 1
+
+        @specific_errors[error_class] = route_instance
+      else
+        return set_to_scope(error_tree, route_instance) if @scopes.size >= 1
+
+        @default_error = route_instance
+      end
     end
 
     def append_scope(name, scope_befores: [], scope_afters: [])
@@ -144,45 +245,34 @@ class Rackr
       @scopes = @scopes.first(@scopes.size - 1)
     end
 
-    private
+    def not_empty_scopes
+      @scopes.reject { |v| (v == '') }
+    end
 
-    def call_endpoint(endpoint, content)
-      return endpoint.call(content) if endpoint.respond_to?(:call)
+    private
 
-      if endpoint < Rackr::Action || endpoint < Rackr::Callback
-        return endpoint.new(routes: @routes, config: @config).call(content)
+    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
 
-      endpoint.new.call(content)
-    end
-
-    def ensure_array(list)
-      return [] if list.nil?
-      return list if list.is_a?(Array)
-
-      [list]
+      [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)
-      scopes_with_slash = not_empty_scopes + %i[__instances]
-      push_it(@instance_routes[method], *scopes_with_slash, route_instance)
-    end
-
-    def push_it(hash, first_key, *rest_keys, val)
-      if rest_keys.empty?
-        (hash[first_key] ||= []) << val
-      else
-        hash[first_key] = push_it(hash[first_key] ||= {}, *rest_keys, val)
-      end
-      hash
+    def set_to_scope(instances, route_instance)
+      deep_hash_set(instances, not_empty_scopes + %i[__instance], route_instance)
     end
 
     def put_path_slash(path)
@@ -195,52 +285,62 @@ class Rackr
       path
     end
 
-    def not_empty_scopes
-      @scopes.reject { |v| (v == '') }
-    end
+    def match_path_route(request_method, splitted_request_path_info, current_request_path_info)
+      path_routes_tree = @path_routes_tree[request_method]
+      found_scopes = []
 
-    def match_route(request_method)
-      find_instance_in_scope = proc do |request_method, found_scopes|
-        @instance_routes[request_method].dig(
-          *(found_scopes + [:__instances])
-        )&.detect { |route_instance| route_instance.match?(@current_request_path_info) }
+      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
 
-      last_tail = @splitted_request_path_info.drop(1)
-      found_scopes = []
+      route_instance = path_routes_tree[:__instances]&.detect do |route|
+        route.match?(current_request_path_info)
+      end
 
-      instance_routes = @instance_routes[request_method]
+      route_instance = find_not_found_route(found_scopes) if route_instance.nil?
 
-      while last_tail && !last_tail.empty?
-        segment = last_tail.shift
-        found_route = nil
+      [route_instance, found_scopes]
+    end
 
-        instance_routes.each_key do |scope|
-          next if scope == :__instances
+    def find_not_found_route(found_scopes)
+      not_found_route = nil
 
-          if segment == scope
-            found_scopes << scope
-            instance_routes = @instance_routes[request_method].dig(*found_scopes)
-            break
-          elsif scope.start_with?(':')
-            found_route = find_instance_in_scope.(request_method, found_scopes)
-            return found_route if found_route
+      while not_found_route.nil? && !found_scopes.empty?
+        not_found_route = @not_found_tree.dig(*found_scopes, :__instance)
+        break if not_found_route
 
-            found_scopes << scope
-            instance_routes = @instance_routes[request_method].dig(*found_scopes)
-            break
-          end
-        end
+        found_scopes.pop
       end
 
-      result_route = find_instance_in_scope.(request_method, found_scopes)
+      not_found_route || @default_not_found
+    end
 
-      if result_route == nil && !found_scopes.empty?
-        found_scopes.shift
-        result_route = find_instance_in_scope.(request_method, found_scopes)
+    def match_route(found_scopes, instances, default_instance)
+      route_instance = nil
+
+      while route_instance.nil? && found_scopes != []
+        route_instance = instances&.dig(*(found_scopes + [:__instance]))
+        found_scopes.pop
       end
 
-      result_route
+      return default_instance if route_instance.nil?
+
+      route_instance
     end
   end
 end

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