rack-way 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aec7c90f616cb7808ded767c3a85aa7c5859c127711769f5769a1251a2aa751d
-  data.tar.gz: 52c386fb62e85c43c7f1ef9a9d236c1736984fcaf89f041f3e521c3c6249750e
+  metadata.gz: a49ebbc6df20d07f91d19e38ee194c6a2958d397c357b8ab6b262ba7ed256902
+  data.tar.gz: ef3a7824645ef0bea5b2f06a4ea3ca89c5cd5eb5daeea2e1f0028dcbee60676a
 SHA512:
-  metadata.gz: a920776a352b76981d86da5df95e48fdbd1017ec0a436e1c56e6d4205634fb4c9ebb0427766ef69645157d6d7f63c825345b54cb4efc3c26916604c27f16cb45
-  data.tar.gz: 70db0b57ac30337cccdc261d52129dc08dd151f1bb0b4159ccd29b2fadee3e4967eb5fca25d094e652fd400f320318f22e69d706c645e41ddeedcfc4339cea5e
+  metadata.gz: 48802c9548cbdeb967d28dc8a0d543841bcbc0fbb4fc6bdbe9976260df76795060abcc8dce9de3a500aea2dbba0bcdbd5ff55c5c30bc9df2afa65ea28e62049c
+  data.tar.gz: 50e8fb5a03bfdefaa88b5d3b0fabb73bb587b4c2e6c47fe01d787bd4e0898e80bb84e078a61938b0dd169e8ec650c4bbfa99c5e416724dc24f174440eb4b8a21

data/lib/rack-way/action.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'erubi'
 require 'json'
 require 'rack'
@@ -5,6 +7,34 @@ require 'rack'
 module Rack
   class Way
     module Action
+      def self.included(base)
+        base.class_eval do
+          attr_reader :route if self != Rack::Way
+
+          def initialize(route)
+            @route = route
+          end
+
+          def view_response(a_path, a_view_params = {}, status: 200)
+            Rack::Way::Action.view_response(
+              a_path,
+              a_view_params,
+              status: status, route: route
+            )
+          end
+
+          def view(
+            a_path, a_view_params = {}, status: 200, response_instance: false
+          )
+            Rack::Way::Action.view(
+              a_path,
+              a_view_params,
+              status: status, response_instance: response_instance, route: route
+            )
+          end
+        end
+      end
+
       def html(content, status: 200)
         Rack::Way::Action.html(content, status: status)
       end
@@ -13,14 +43,6 @@ module Rack
         Rack::Way::Action.html_response(content, status: status)
       end
 
-      def view_response(path, view_params = {}, status: 200)
-        Rack::Way::Action.view_response(path, view_params, status: status)
-      end
-
-      def view(path, view_params = {}, status: 200, response_instance: false)
-        Rack::Way::Action.view(path, view_params, status: status, response_instance: response_instance)
-      end
-
       def json(content = {}, status: 200)
         Rack::Way::Action.json(content, status: status)
       end
@@ -58,16 +80,27 @@ module Rack
           Rack::Response.new(content, status, { 'Content-Type' => 'text/html' })
         end
 
-        def view_response(paths, view_params = {}, status: 200)
-          view(paths, view_params, status: status, response_instance: true)
+        def view_response(paths, view_params = {}, status: 200, route: nil)
+          view(
+            paths,
+            view_params,
+            status: status, response_instance: true,
+            route: route
+          )
         end
 
-        def view(paths, view_params = {}, status: 200, response_instance: false)
-          if paths.kind_of?(Array)
-            erb = paths.map { |path| erb("views/#{path}", view_params) }.join
-          else
-            erb = erb("views/#{paths}", view_params)
-          end
+        def view(
+          paths,
+          view_params = {},
+          status: 200,
+          response_instance: false,
+          route: nil
+        )
+          erb = if paths.is_a?(Array)
+                  paths.map { |path| erb("views/#{path}", route, view_params) }.join
+                else
+                  erb("views/#{paths}", route, view_params)
+                end
 
           if response_instance
             return Rack::Response.new(
@@ -104,7 +137,7 @@ module Rack
           )
         end
 
-        def erb(path, view_params = {})
+        def erb(path, _route, view_params = {})
           @view = OpenStruct.new(view_params)
 
           eval(Erubi::Engine.new(::File.read("#{path}.html.erb")).src)

data/lib/rack-way/router/build_request.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Rack
   class Way
     class Router
@@ -10,7 +12,7 @@ module Rack
           request = Rack::Request.new(@env)
 
           return request if route.nil?
-          return request unless route.has_params?
+          return request unless route.has_params
 
           update_request_params(request, route)
         end

data/lib/rack-way/router/route.rb

@@ -1,26 +1,25 @@
+# frozen_string_literal: true
+
 module Rack
   class Way
     class Router
       class Route
-        attr_reader :endpoint, :splitted_path
+        attr_reader :endpoint, :splitted_path, :has_params
 
         def initialize(path, endpoint)
           @path = path
           @splitted_path = @path.split('/')
           @endpoint = endpoint
           @params = fetch_params
+          @has_params = @params != []
         end
 
         def match?(env)
-          return match_with_params?(env) if has_params?
+          return match_with_params?(env) if @has_params
 
           env['REQUEST_PATH'] == @path
         end
 
-        def has_params?
-          @params != []
-        end
-
         private
 
         def fetch_params
@@ -30,20 +29,18 @@ module Rack
         def match_with_params?(env)
           splitted_request_path = env['REQUEST_PATH'].split('/')
 
-          if @splitted_path.size != splitted_request_path.size
-            return false
-          end
+          return false if @splitted_path.size != splitted_request_path.size
 
           matched_path_pieces =
             @splitted_path
-              .map
-              .with_index do |segment, i|
-                if segment.start_with?(':')
-                  true
-                else
-                  splitted_request_path[i] == segment
-                end
+            .map
+            .with_index do |segment, i|
+              if segment.start_with?(':')
+                true
+              else
+                splitted_request_path[i] == segment
               end
+            end
 
           !matched_path_pieces.include?(false)
         end

data/lib/rack-way/router.rb

@@ -1,50 +1,61 @@
-require_relative 'router/route.rb'
-require_relative 'router/build_request.rb'
+# frozen_string_literal: true
+
+require_relative 'router/route'
+require_relative 'router/build_request'
 
 module Rack
   class Way
     class Router
+      class UndefinedNamedRoute < StandardError; end
+
       attr_writer :not_found
+      attr_reader :route
 
       def initialize
         @routes = {}
         %w[GET POST DELETE PUT TRACE OPTIONS PATCH].each do |method|
-          @routes[method] = { _instances: [] }
+          @routes[method] = { __instances: [] }
+        end
+        @route = Hash.new do |_hash, key|
+          raise(UndefinedNamedRoute, "Undefined named route: '#{key}'")
         end
         @scopes = []
-        @error = proc { |req, e| raise e }
+        @error = proc { |_req, e| raise e }
         @not_found = proc { [404, {}, ['Not found']] }
       end
 
       def call(env)
         request_builder = BuildRequest.new(env)
-        route = match_route(env)
+        env['REQUEST_METHOD'] = 'GET' if env['REQUEST_METHOD'] == 'HEAD'
 
-        return render_not_found(request_builder.call) if route.nil?
+        route_instance = match_route(env)
+
+        return render_not_found(request_builder.call) if route_instance.nil?
+
+        if route_instance.endpoint.respond_to?(:call)
+          return route_instance.endpoint.call(request_builder.call(route_instance))
+        end
 
-        if route.endpoint.respond_to?(:call)
-          return route.endpoint.call(request_builder.call(route))
+        if route_instance.endpoint.include?(Rack::Way::Action)
+          return route_instance.endpoint.new(@route).call(request_builder.call(route_instance))
         end
 
-        route.endpoint.new.call(request_builder.call(route))
+        route_instance.endpoint.new.call(request_builder.call(route_instance))
       rescue Exception => e
         @error.call(request_builder.call, e)
       end
 
-      def add(method, path, endpoint)
-        joined_scopes = '/' << @scopes.join('/')
+      def add(method, path, endpoint, as = nil)
+        method = :get if method == :head
 
-        route = Route.new("#{joined_scopes}#{put_path_slash(path)}", endpoint)
+        path_with_scopes = "/#{@scopes.join('/')}#{put_path_slash(path)}"
+        @route[as] = path_with_scopes if as
 
-        if @scopes.size >= 1
-          first_level_scope = '/' << @scopes.first
-          if @routes[method.to_s.upcase][first_level_scope] == nil
-            @routes[method.to_s.upcase][first_level_scope] = { _instances: [] }
-          end
-          @routes[method.to_s.upcase][first_level_scope][:_instances].push(route)
-        else
-          @routes[method.to_s.upcase][:_instances].push(route)
-        end
+        route_instance = Route.new(path_with_scopes, endpoint)
+
+        return push_to_scope(method.to_s.upcase, route_instance) if @scopes.size >= 1
+
+        @routes[method.to_s.upcase][:__instances].push(route_instance)
       end
 
       def add_not_found(endpoint)
@@ -65,9 +76,23 @@ module Rack
 
       private
 
+      def push_to_scope(method, route_instance)
+        scopes_with_slash = @scopes + [:__instances]
+        push_it(@routes[method], *scopes_with_slash, route_instance)
+      end
+
+      def push_it(h, first_key, *rest_keys, val)
+        if rest_keys.empty?
+          (h[first_key] ||= []) << val
+        else
+          h[first_key] = push_it(h[first_key] ||= {}, *rest_keys, val)
+        end
+        h
+      end
+
       def put_path_slash(path)
-        return '' if (path == '/' || path == '') && @scopes != []
-        return '/' << path if @scopes != []
+        return '' if ['/', ''].include?(path) && @scopes != []
+        return "/#{path}" if @scopes != []
 
         path
       end
@@ -78,23 +103,34 @@ module Rack
         @not_found.new.call(env)
       end
 
-      def match_route(env)
-        matched_first_level_scope = nil
+      def match_route(env, last_tail = nil, found_scopes = [])
+        routes =
+          if last_tail.nil?
+            last_tail = env['REQUEST_PATH'].split('/').drop(1)
+
+            @routes[env['REQUEST_METHOD']]
+          else
+            @routes[env['REQUEST_METHOD']].dig(*found_scopes)
+          end
 
-        @routes[env['REQUEST_METHOD']].each do |first_level_scope, _v|
-          next if first_level_scope == :_instances
+        segment, *tail = last_tail
 
-          if env['REQUEST_PATH'].start_with?(first_level_scope) || first_level_scope.start_with?('/:')
-            matched_first_level_scope = first_level_scope
+        routes.each do |scope, _v|
+          next if scope == :__instances
+
+          if segment == scope || scope.start_with?(':')
+            found_scopes.push(scope)
             break
           end
         end
 
-        if matched_first_level_scope
-          return @routes[env['REQUEST_METHOD']][matched_first_level_scope][:_instances].detect { |route| route.match?(env) }
+        if tail.empty? || found_scopes == []
+          return @routes[env['REQUEST_METHOD']].dig(*(found_scopes << :__instances)).detect do |route_instance|
+            route_instance.match?(env)
+          end
         end
 
-        @routes[env['REQUEST_METHOD']][:_instances].detect { |route| route.match?(env) }
+        match_route(env, tail, found_scopes)
       end
     end
   end

data/lib/rack-way.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'rack-way/router'
 require_relative 'rack-way/action'
 
@@ -9,12 +11,16 @@ module Rack
       @router = router
     end
 
-    def app(&block)
+    def http_router(&block)
       instance_eval(&block)
 
       @router
     end
 
+    def route
+      @router.route
+    end
+
     def scope(name, &block)
       @router.append_scope(name)
       instance_eval(&block)
@@ -22,15 +28,7 @@ module Rack
       @router.clear_last_scope
     end
 
-    def root(endpoint = -> {  }, &block)
-      if block_given?
-        @router.add('GET', '', block)
-      else
-        @router.add('GET', '', endpoint)
-      end
-    end
-
-    def not_found(endpoint = -> {  }, &block)
+    def not_found(endpoint = -> {}, &block)
       if block_given?
         @router.add_not_found(block)
       else
@@ -38,7 +36,7 @@ module Rack
       end
     end
 
-    def error(endpoint = -> {  }, &block)
+    def error(endpoint = -> {}, &block)
       if block_given?
         @router.add_error(block)
       else
@@ -47,11 +45,11 @@ module Rack
     end
 
     %w[GET POST DELETE PUT TRACE OPTIONS PATCH].each do |http_method|
-      define_method(http_method.downcase.to_sym) do |path, endpoint = -> {  }, &block|
+      define_method(http_method.downcase.to_sym) do |path = '', endpoint = -> {}, as: nil, &block|
         if block.respond_to?(:call)
-          @router.add(http_method, path, block)
+          @router.add(http_method, path, block, as)
         else
-          @router.add(http_method, path, endpoint)
+          @router.add(http_method, path, endpoint, as)
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-way
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Henrique F. Teixeira
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-04-21 00:00:00.000000000 Z
+date: 2023-07-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: erubi
@@ -38,7 +38,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
-description: A little web framework that composes well with Rack gems ecossystem
+description: A router and helper functions to build pure Rack projects.
 email: hriqueft@gmail.com
 executables: []
 extensions: []