rack-way 0.0.1 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 016cf1e2d4ae57cf31b359733bf96c3510667bc9de887322c18a2118dcb54ba9
-  data.tar.gz: b491da7388431e3d6b07a7b904af1d5d6b732b510c44904a0c93cd26978f0b07
+  metadata.gz: a49ebbc6df20d07f91d19e38ee194c6a2958d397c357b8ab6b262ba7ed256902
+  data.tar.gz: ef3a7824645ef0bea5b2f06a4ea3ca89c5cd5eb5daeea2e1f0028dcbee60676a
 SHA512:
-  metadata.gz: c5948a9e5366dab3e86832df6f5fc66a9c837320689c3c6a2507c8f7b7a7c080272388159f44d464e07ba6ec1541377e9021ba83b33cb91958d0ff8005ba35de
-  data.tar.gz: 1694ea321074055bdf57518e8dd6c16cf634b732c87561c4edd2f0a64af0c6ec714373acbfd9bdc59b6459ed9231a4c31f036b0151533aaaf26001ab79f9b538
+  metadata.gz: 48802c9548cbdeb967d28dc8a0d543841bcbc0fbb4fc6bdbe9976260df76795060abcc8dce9de3a500aea2dbba0bcdbd5ff55c5c30bc9df2afa65ea28e62049c
+  data.tar.gz: 50e8fb5a03bfdefaa88b5d3b0fabb73bb587b4c2e6c47fe01d787bd4e0898e80bb84e078a61938b0dd169e8ec650c4bbfa99c5e416724dc24f174440eb4b8a21

data/lib/rack-way/action.rb

@@ -1,60 +1,156 @@
-require 'erubis'
+# frozen_string_literal: true
+
+require 'erubi'
 require 'json'
 require 'rack'
 
 module Rack
   class Way
     module Action
-      def render(content, headers: {"Content-Type" => "text/html"}, status: 200)
-        Rack::Way::Action.render(content, headers: headers, status: status)
+      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
+
+      def html_response(content, status: 200)
+        Rack::Way::Action.html_response(content, status: status)
+      end
+
+      def json(content = {}, status: 200)
+        Rack::Way::Action.json(content, status: status)
+      end
+
+      def json_response(content = {}, status: 200)
+        Rack::Way::Action.json_response(content, status: status)
       end
 
-      def render_erb(path, params = {}, status: 200)
-        Rack::Way::Action.render_erb(path, params, status: status)
+      def text(content, status: 200)
+        Rack::Way::Action.text(content, status: status)
       end
 
-      def render_json(content = {}, status: 200)
-        Rack::Way::Action.render_json(content, status: status)
+      def text_response(content, status: 200)
+        Rack::Way::Action.text_response(content, status: status)
       end
 
-      def erb(path, params = {})
-        Rack::Way::Action.erb(path, params)
+      def erb(path, view_params = {})
+        Rack::Way::Action.erb(path, view_params)
       end
 
       def redirect_to(url)
         Rack::Way::Action.redirect_to(url)
       end
 
+      def response(body = nil, status = 200, headers = {})
+        Rack::Response.new(body, status, headers)
+      end
+
       class << self
-        def render(content, headers: {"Content-Type" => "text/html"}, status: 200)
-          [status, headers, [content]]
+        def html(content, status: 200)
+          [status, { 'Content-Type' => 'text/html' }, [content]]
+        end
+
+        def html_response(content, status: 200)
+          Rack::Response.new(content, status, { 'Content-Type' => 'text/html' })
         end
 
-        def render_erb(paths, params = {}, status: 200)
-          if paths.kind_of?(Array)
-            erb =
-              paths.map { |path| erb(path, params) }.join
-          else
-            erb = erb(paths, params)
+        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,
+          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(
+              erb,
+              status,
+              { 'Content-Type' => 'text/html' }
+            )
           end
 
-          [status, {"Content-Type" => "text/html"}, [erb]]
+          [status, { 'Content-Type' => 'text/html' }, [erb]]
+        end
+
+        def json(content = {}, status: 200)
+          [status, { 'Content-Type' => 'application/json' }, [content.to_json]]
+        end
+
+        def json_response(content = {}, status: 200)
+          Rack::Response.new(
+            content.to_json,
+            status,
+            { 'Content-Type' => 'application/json' }
+          )
+        end
+
+        def text(content, status: 200)
+          [status, { 'Content-Type' => 'text/plain' }, [content]]
         end
 
-        def render_json(content = {}, status: 200)
-          [status, {"Content-Type" => "application/json"}, [content.to_json]]
+        def text_response(content, status: 200)
+          Rack::Response.new(
+            content,
+            status,
+            { 'Content-Type' => 'text/plain' }
+          )
         end
 
-        def erb(path, params = {})
-          Erubis::FastEruby
-              .load_file("#{path}.html.erb")
-              .result(params)
+        def erb(path, _route, view_params = {})
+          @view = OpenStruct.new(view_params)
+
+          eval(Erubi::Engine.new(::File.read("#{path}.html.erb")).src)
         end
 
         def redirect_to(url)
-          [302, {'Location' => url}, []]
+          [302, { 'Location' => url }, []]
+        end
+
+        def response(body = nil, status = 200, headers = {})
+          Rack::Response.new(body, status, headers)
         end
       end
     end
   end
-end
+end

data/lib/rack-way/router/{request_builder.rb → build_request.rb}

@@ -1,7 +1,9 @@
+# frozen_string_literal: true
+
 module Rack
   class Way
     class Router
-      class RequestBuilder
+      class BuildRequest
         def initialize(env)
           @env = env
         end
@@ -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
@@ -45,4 +47,4 @@ module Rack
       end
     end
   end
-end
+end

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

@@ -1,28 +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)
-          if has_params?
-            return match_with_params?(env)
-          end
+          return match_with_params?(env) if @has_params
 
           env['REQUEST_PATH'] == @path
         end
 
-        def has_params?
-          @params != []
-        end
-
         private
 
         def fetch_params
@@ -32,24 +29,22 @@ 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 =
+          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.include?(false)
+          !matched_path_pieces.include?(false)
         end
       end
     end
   end
-end
+end

data/lib/rack-way/router.rb

@@ -1,64 +1,99 @@
-require_relative 'router/route.rb'
-require_relative 'router/request_builder.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 =
-          {
-            'GET' => [],
-            'POST' => [],
-            'DELETE' => [],
-            'PUT' => [],
-            'PATCH' => []
-          }
-
-        @namespaces = []
-
+        @routes = {}
+        %w[GET POST DELETE PUT TRACE OPTIONS PATCH].each do |method|
+          @routes[method] = { __instances: [] }
+        end
+        @route = Hash.new do |_hash, key|
+          raise(UndefinedNamedRoute, "Undefined named route: '#{key}'")
+        end
+        @scopes = []
+        @error = proc { |_req, e| raise e }
         @not_found = proc { [404, {}, ['Not found']] }
       end
 
       def call(env)
-        route = match_route(env)
-        request_builder = RequestBuilder.new(env)
+        request_builder = BuildRequest.new(env)
+        env['REQUEST_METHOD'] = 'GET' if env['REQUEST_METHOD'] == 'HEAD'
+
+        route_instance = match_route(env)
 
-        return render_not_found(request_builder.call) if route.nil?
+        return render_not_found(request_builder.call) if route_instance.nil?
 
-        if route.endpoint.respond_to?(:call)
-          return route.endpoint.call(request_builder.call(route))
+        if route_instance.endpoint.respond_to?(:call)
+          return route_instance.endpoint.call(request_builder.call(route_instance))
         end
 
-        route.endpoint.new.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_instance.endpoint.new.call(request_builder.call(route_instance))
+      rescue Exception => e
+        @error.call(request_builder.call, e)
       end
 
-      def add(method, path, endpoint)
-        route =
-          Route.new("/" + @namespaces.join('/') + put_path_slash(path), endpoint)
+      def add(method, path, endpoint, as = nil)
+        method = :get if method == :head
+
+        path_with_scopes = "/#{@scopes.join('/')}#{put_path_slash(path)}"
+        @route[as] = path_with_scopes if as
+
+        route_instance = Route.new(path_with_scopes, endpoint)
 
-        @routes[method.to_s.upcase].push route
+        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)
         @not_found = endpoint
       end
 
-      def append_namespace(name)
-        @namespaces.push(name)
+      def add_error(endpoint)
+        @error = endpoint
+      end
+
+      def append_scope(name)
+        @scopes.push(name)
       end
 
-      def clear_last_namespace
-        @namespaces =
-          @namespaces.first(@namespaces.size - 1)
+      def clear_last_scope
+        @scopes = @scopes.first(@scopes.size - 1)
       end
 
       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 == '') && @namespaces != []
-        return '/' + path if @namespaces != []
+        return '' if ['/', ''].include?(path) && @scopes != []
+        return "/#{path}" if @scopes != []
+
         path
       end
 
@@ -68,9 +103,34 @@ module Rack
         @not_found.new.call(env)
       end
 
-      def match_route(env)
-        @routes[env["REQUEST_METHOD"]]
-          .detect { |route| route.match?(env) }
+      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
+
+        segment, *tail = last_tail
+
+        routes.each do |scope, _v|
+          next if scope == :__instances
+
+          if segment == scope || scope.start_with?(':')
+            found_scopes.push(scope)
+            break
+          end
+        end
+
+        if tail.empty? || found_scopes == []
+          return @routes[env['REQUEST_METHOD']].dig(*(found_scopes << :__instances)).detect do |route_instance|
+            route_instance.match?(env)
+          end
+        end
+
+        match_route(env, tail, found_scopes)
       end
     end
   end

data/lib/rack-way.rb

@@ -1,53 +1,57 @@
-require 'rack-way/router'
-require 'rack-way/action'
+# frozen_string_literal: true
+
+require_relative 'rack-way/router'
+require_relative 'rack-way/action'
 
 module Rack
   class Way
     include Action
 
-    def initialize
-      @router = Router.new
+    def initialize(router: Router.new)
+      @router = router
     end
 
-    def draw_app(&block)
+    def http_router(&block)
       instance_eval(&block)
 
       @router
     end
 
-    def namespace(name, &block)
-      @router.append_namespace(name)
-      instance_eval(&block)
-
-      @router.clear_last_namespace
-    end
-
-    def root(endpoint)
-      @router.add('GET', '', endpoint)
+    def route
+      @router.route
     end
 
-    def not_found(endpoint)
-      @router.add_not_found(endpoint)
-    end
-
-    def get(path, endpoint)
-      @router.add('GET', path, endpoint)
-    end
+    def scope(name, &block)
+      @router.append_scope(name)
+      instance_eval(&block)
 
-    def post(path, endpoint)
-      @router.add('POST', path, endpoint)
+      @router.clear_last_scope
     end
 
-    def delete(path, endpoint)
-      @router.add('DELETE', path, endpoint)
+    def not_found(endpoint = -> {}, &block)
+      if block_given?
+        @router.add_not_found(block)
+      else
+        @router.add_not_found(endpoint)
+      end
     end
 
-    def put(path, endpoint)
-      @router.add('PUT', path, endpoint)
+    def error(endpoint = -> {}, &block)
+      if block_given?
+        @router.add_error(block)
+      else
+        @router.add_error(endpoint)
+      end
     end
 
-    def patch(path, endpoint)
-      @router.add('PATCH', path, endpoint)
+    %w[GET POST DELETE PUT TRACE OPTIONS PATCH].each do |http_method|
+      define_method(http_method.downcase.to_sym) do |path = '', endpoint = -> {}, as: nil, &block|
+        if block.respond_to?(:call)
+          @router.add(http_method, path, block, as)
+        else
+          @router.add(http_method, path, endpoint, as)
+        end
+      end
     end
   end
 end

metadata

@@ -1,45 +1,44 @@
 --- !ruby/object:Gem::Specification
 name: rack-way
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.3
 platform: ruby
 authors:
-- Henrique Fernandez
+- 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: erubis
+  name: erubi
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.7'
+        version: '1.12'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.7'
+        version: '1.12'
 - !ruby/object:Gem::Dependency
   name: rack
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
+        version: '3.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.0'
-description: A very little framework that encourages ruby developers to build 'pure
-  Rack' applications when working in projects that need high performance.
+        version: '3.0'
+description: A router and helper functions to build pure Rack projects.
 email: hriqueft@gmail.com
 executables: []
 extensions: []
@@ -48,7 +47,7 @@ files:
 - lib/rack-way.rb
 - lib/rack-way/action.rb
 - lib/rack-way/router.rb
-- lib/rack-way/router/request_builder.rb
+- lib/rack-way/router/build_request.rb
 - lib/rack-way/router/route.rb
 homepage: https://github.com/henriquefernandez/rack-way
 licenses:
@@ -69,8 +68,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.4.3
 signing_key: 
 specification_version: 4
-summary: '"rack-way" come with a router and helper functions to build pure rack projects.'
+summary: '"rack-way" come with a router and helper functions to build pure Rack projects.'
 test_files: []