rackr 0.0.63 → 0.0.65

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0e5510a8382fb76e2ecd76fb38f024753d2bece6771aeac87f4fa8f000e14bb7
-  data.tar.gz: 48e121278f8b5dc8eac591883e9e40d6ecc43f6116dd4ee6abe3130da8956186
+  metadata.gz: 5d146e39fc587acb31017ef9e5b093aba6a8cecadf8fe8beb038ab7804425015
+  data.tar.gz: '04787fa986d2d6f4033114d5bf6a134bd6451e2e7cb0c957ef063ddf7fbb9cf3'
 SHA512:
-  metadata.gz: cbcfc075222a1f7b7b39a2106f6bff6192616f76879bc05515b53db3654ca9733b9003cc8c6fa637b57ac3e0daff4b00489589176ece200820249fae4d8fbe4f
-  data.tar.gz: 4f3314ff137706612f7f0f8e5484236794c65772a4a063c2e327642e6ff4ce7c6dfc8ed1d5a023420f16c77431c4443cb36e0cc559837e4d5d86d654d85aa0a0
+  metadata.gz: 57661323fb8e596afd2833f24145716090db3bd1024bf465ae2388f48c5a2c9cbff4384331368d69337a08f7fd977b5f33dcb275421324748eb783f33d6a877e
+  data.tar.gz: b524b6414b3218cca05f134f81ce03583fac97d38eb4e754c27a754b50fd0d2eaa969b4728304ce6aafe08a45c370ffde59a68d21d76f72634cc43fc74925b9b

data/lib/rackr/action.rb

@@ -6,16 +6,35 @@ require 'rack'
 
 class Rackr
   module Action
-    RENDER = {
+    @@default_headers_for = lambda { |content_type, headers, content|
+      {
+        'content-type' => content_type,
+        'content-length' => content.bytesize.to_s
+      }.merge(headers)
+    }
+
+    @@render = {
       html: lambda do |val, status: 200, headers: {}, html: nil|
-        [status, { 'content-type' => 'text/html', 'content-length' => val.bytesize.to_s }.merge(headers), [val]]
+        [
+          status,
+          @@default_headers_for.call('text/html; charset=utf-8', headers, val),
+          [val]
+        ]
       end,
       text: lambda do |val, status: 200, headers: {}, text: nil|
-        [status, { 'content-type' => 'text/plain', 'content-length' => val.bytesize.to_s }.merge(headers), [val]]
+        [
+          status,
+          @@default_headers_for.call('text/plain', headers, val),
+          [val]
+        ]
       end,
       json: lambda do |val, status: 200, headers: {}, json: nil|
         val = Oj.dump(val, mode: :compat) unless val.is_a?(String)
-        [status, { 'content-type' => 'application/json', 'content-length' => val.bytesize.to_s }.merge(headers), [val]]
+        [
+          status,
+          @@default_headers_for.call('application/json', headers, val),
+          [val]
+        ]
       end,
       res: lambda do |val, status: nil, headers: nil, res: nil|
         val.status = status if status
@@ -31,19 +50,20 @@ class Rackr
 
     def self.included(base)
       base.class_eval do
-        attr_reader :routes, :config, :db if self != Rackr
+        attr_reader :routes, :config, :deps, :db if self != Rackr
 
         def initialize(routes: nil, config: nil)
           @routes = routes
           @config = config
-          @db = config[:db]
+          @deps = config[:deps]
+          @db = config.dig(:deps, :db)
         end
 
         def render(**opts)
           type = opts.keys.first
           content = opts[type]
 
-          Rackr::Action::RENDER[type]&.call(content, **opts) || _render_view(content, **opts)
+          @@render[type]&.call(content, **opts) || _render_view(content, **opts)
         end
 
         def view_response(
@@ -98,12 +118,15 @@ class Rackr
             return Rack::Response.new(
               parsed_erb,
               status,
-              { 'content-type' => 'text/html' }.merge(headers)
+              @@default_headers_for.call('text/html; charset=utf-8', headers, parsed_erb)
             )
           end
 
-          [status, { 'content-type' => 'text/html', 'content-length' => parsed_erb.bytesize.to_s }.merge(headers),
-           [parsed_erb]]
+          [status, @@default_headers_for.call('text/html; charset=utf-8', headers, parsed_erb), [parsed_erb]]
+        end
+
+        def not_found!
+          raise Rackr::NotFound
         end
 
         def load_json(val)
@@ -113,25 +136,16 @@ class Rackr
         end
 
         def html_response(content = '', status: 200, headers: {})
-          Rack::Response.new(content, status,
-                             { 'content-type' => 'text/html', 'content-length' => content.bytesize.to_s }.merge(headers))
+          Rack::Response.new(content, status, @@default_headers_for.call('text/html; charset=utf-8', headers, content))
         end
 
         def json_response(content = {}, status: 200, headers: {})
           content = Oj.dump(content, mode: :compat) unless content.is_a?(String)
-          Rack::Response.new(
-            content,
-            status,
-            { 'content-type' => 'application/json', 'content-length' => content.bytesize.to_s }.merge(headers)
-          )
+          Rack::Response.new(content, status, @@default_headers_for.call('application/json', headers, content))
         end
 
         def text_response(content, status: 200, headers: {})
-          Rack::Response.new(
-            content,
-            status,
-            { 'content-type' => 'text/plain', 'content-length' => content.bytesize.to_s }.merge(headers)
-          )
+          Rack::Response.new(content, status, @@default_headers_for.call('text/plain', headers, content))
         end
 
         def load_erb(content, binding_context: nil)

data/lib/rackr/router/errors/dev_html.rb

@@ -50,7 +50,7 @@ class Rackr
 
         def backtrace(env)
           first, *tail = env['error'].backtrace
-          traceback = String.new("<h2>Traceback <span>(innermost first)</span></h2>")
+          traceback = String.new('<h2>Traceback <span>(innermost first)</span></h2>')
           traceback << "<p class=\"first-p\">#{first}</p><br/>"
 
           line_number = extract_line_number(first)
@@ -61,7 +61,7 @@ class Rackr
             traceback << "<pre>#{slice_around_index(lines, line_number).join('')}</pre>"
           end
 
-          traceback << "<p>#{tail.join("<br>")}</p>"
+          traceback << "<p>#{tail.join('<br>')}</p>"
           traceback
         end
 

data/lib/rackr/router/route.rb

@@ -4,39 +4,22 @@ class Rackr
   class Router
     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,27 @@
 # 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'
 
 class Rackr
   class Router
-    attr_writer :not_found
-    attr_reader :routes, :config
+    include Utils
+
+    attr_writer :default_not_found
+    attr_reader :routes, :config, :not_found_instances, :error_instances
 
     def initialize(config = {}, before: [], after: [])
-      @instance_routes = {}
+      @path_routes_instances = {}
       %w[GET POST DELETE PUT TRACE OPTIONS PATCH].each do |method|
-        @instance_routes[method] = { __instances: [] }
+        @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|
@@ -28,8 +36,8 @@ class Rackr
       @scopes_befores = {}
       @afters = ensure_array(after)
       @scopes_afters = {}
-      @error = proc { |_req, e| raise e }
-      @not_found = proc { [404, {}, ['Not found']] }
+      @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
     end
@@ -44,39 +52,36 @@ class Rackr
       request_builder = BuildRequest.new(env, @splitted_request_path_info)
       env['REQUEST_METHOD'] = 'GET' if env['REQUEST_METHOD'] == 'HEAD'
 
-      route_instance = match_route(env['REQUEST_METHOD'])
-      return call_endpoint(@not_found, request_builder.call) if route_instance.nil?
-
+      route_instance, found_scopes = match_path_route(env['REQUEST_METHOD'])
       rack_request = request_builder.call(route_instance)
-
       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)
 
-        rack_request = before_result
+      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)
 
-        i += 1
-      end
+          rack_request = before_result
 
-      endpoint_result = call_endpoint(route_instance.endpoint, before_result || rack_request)
+          i += 1
+        end
 
-      afters = route_instance.afters
-      i = 0
-      while i < afters.size
-        call_endpoint(afters[i], endpoint_result)
-        i += 1
+        endpoint_result = Endpoint.call(route_instance.endpoint, before_result || rack_request)
+
+        call_afters(route_instance, endpoint_result)
+      rescue Rackr::NotFound
+        return not_found_fallback(found_scopes, route_instance, before_result || rack_request)
+      rescue Exception => e
+        if !@dev_mode || ENV['RACKR_ERROR_DEV']
+          return error_fallback(found_scopes, route_instance, before_result || rack_request, e)
+        end
+
+        return Endpoint.call(Errors::DevHtml, env.merge({ 'error' => e }))
       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: [])
@@ -94,7 +99,7 @@ class Rackr
       add_named_route(method, path_with_scopes, as)
 
       route_instance =
-        Route.new(
+        PathRoute.new(
           path_with_scopes,
           endpoint,
           befores: @befores + ensure_array(route_befores),
@@ -104,19 +109,51 @@ class Rackr
 
       return push_to_scope(method.to_s.upcase, route_instance) if @scopes.size >= 1
 
-      @instance_routes[method.to_s.upcase][:__instances].push(route_instance)
+      @path_routes_instances[method.to_s.upcase][:__instances].push(route_instance)
     end
 
-    def add_not_found(endpoint)
-      Errors.check_endpoint(endpoint, 'not_found')
+    %i[error not_found].each do |v|
+      define_method("add_#{v}") do |endpoint|
+        Errors.check_endpoint(endpoint, v)
 
-      @not_found = endpoint
-    end
+        route_instance =
+          Route.new(
+            endpoint,
+            befores: @befores,
+            afters: @afters
+          )
+
+        return set_to_scope(send("#{v}_instances"), route_instance) if @scopes.size >= 1
 
-    def add_error(endpoint)
-      Errors.check_endpoint(endpoint, 'error')
+        instance_variable_set("@default_#{v}", 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
+
+        endpoint_result = Endpoint.call(*args)
+
+        call_afters(route_instance, endpoint_result)
+
+        endpoint_result
+      end
+    end
 
-      @error = endpoint
+    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
+      end
     end
 
     def append_scope(name, scope_befores: [], scope_afters: [])
@@ -146,23 +183,6 @@ class Rackr
 
     private
 
-    def call_endpoint(endpoint, content)
-      return endpoint.call(content) if endpoint.respond_to?(:call)
-
-      if endpoint < Rackr::Action || endpoint < Rackr::Callback
-        return endpoint.new(routes: @routes, config: @config).call(content)
-      end
-
-      endpoint.new.call(content)
-    end
-
-    def ensure_array(list)
-      return [] if list.nil?
-      return list if list.is_a?(Array)
-
-      [list]
-    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?
@@ -172,17 +192,11 @@ class Rackr
     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)
+      deep_hash_push(@path_routes_instances[method], *(not_empty_scopes + %i[__instances]), 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)
@@ -199,9 +213,9 @@ class Rackr
       @scopes.reject { |v| (v == '') }
     end
 
-    def match_route(request_method)
+    def match_path_route(request_method)
       find_instance_in_scope = proc do |request_method, found_scopes|
-        @instance_routes[request_method].dig(
+        @path_routes_instances[request_method].dig(
           *(found_scopes + [:__instances])
         )&.detect { |route_instance| route_instance.match?(@current_request_path_info) }
       end
@@ -209,38 +223,58 @@ class Rackr
       last_tail = @splitted_request_path_info.drop(1)
       found_scopes = []
 
-      instance_routes = @instance_routes[request_method]
+      path_routes_instances = @path_routes_instances[request_method]
 
       while last_tail && !last_tail.empty?
         segment = last_tail.shift
         found_route = nil
 
-        instance_routes.each_key do |scope|
+        path_routes_instances.each_key do |scope|
           next if scope == :__instances
 
           if segment == scope
             found_scopes << scope
-            instance_routes = @instance_routes[request_method].dig(*found_scopes)
+            path_routes_instances = @path_routes_instances[request_method].dig(*found_scopes)
             break
           elsif scope.start_with?(':')
-            found_route = find_instance_in_scope.(request_method, found_scopes)
+            found_route = find_instance_in_scope.call(request_method, found_scopes)
             return found_route if found_route
 
             found_scopes << scope
-            instance_routes = @instance_routes[request_method].dig(*found_scopes)
+            path_routes_instances = @path_routes_instances[request_method].dig(*found_scopes)
             break
           end
         end
       end
 
-      result_route = find_instance_in_scope.(request_method, found_scopes)
+      result_route = find_instance_in_scope.call(request_method, found_scopes)
+
+      if result_route.nil? && !found_scopes.empty?
+        result_route = find_instance_in_scope.call(request_method, found_scopes[..-2])
+      end
+
+      if result_route.nil?
+        result_route = match_route(
+          found_scopes,
+          @not_found_instances,
+          @default_not_found
+        )
+      end
+
+      [result_route, found_scopes]
+    end
+
+    def match_route(found_scopes, instances, default_instance)
+      route_instance = nil
 
-      if result_route == nil && !found_scopes.empty?
-        found_scopes.shift
-        result_route = find_instance_in_scope.(request_method, found_scopes)
+      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.rb

@@ -18,11 +18,11 @@ class Rackr
 
   def call(&block)
     instance_eval(&block)
-    puts "\n= Routes =============="
-    routes.each_pair { |v| p v }
-    puts "\n= Config =============="
-    puts config
-    puts "\n"
+    #puts "\n= Routes =============="
+    #routes.each_pair { |v| p v }
+    #puts "\n= Config =============="
+    #puts config
+    #puts "\n"
 
     @router
   end
@@ -35,8 +35,12 @@ class Rackr
     @router.config
   end
 
+  def deps
+    @router.config[:deps]
+  end
+
   def db
-    @router.config[:db]
+    @router.config.dig(:deps, :db)
   end
 
   def scope(name = '', before: [], after: [], &block)

metadata

@@ -1,13 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rackr
 version: !ruby/object:Gem::Version
-  version: 0.0.63
+  version: 0.0.65
 platform: ruby
 authors:
 - Henrique F. Teixeira
+autorequire: 
 bindir: bin
 cert_chain: []
-date: 2025-10-14 00:00:00.000000000 Z
+date: 2025-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: erubi
@@ -57,7 +58,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: []
@@ -75,6 +76,7 @@ homepage: https://github.com/henrique-ft/rackr
 licenses:
 - MIT
 metadata: {}
+post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -89,7 +91,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.2
+rubygems_version: 3.3.3
+signing_key: 
 specification_version: 4
-summary: A complete, simple and easy web micro-framework.
+summary: A friendly web micro-framework.
 test_files: []