rack-http_router 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5575554ab4629e83f2524f4fe47ff58963909b658452a3646457da97c378d744
+  data.tar.gz: a409c6bdd4df80abba1206e79a4adefd05d75142cbdd775e1418de33bee23ea7
+SHA512:
+  metadata.gz: 13eac202ecb0c2c1bfc1287298cfa45ae202949e6738c8dec1689e8a674a0d8b5b60438a8d990e1dd77159eb75cfea3a90ddd60ab30376aa6f35e21bbc4f1c51
+  data.tar.gz: 8a43962f554a10aef1696ff990cb5096b1a211f3e8f28199b52b7ad36a6c079ad3bf070f51ad0710aec284fdb0156ff50ae7dfcfb0b6e2951cc7f0c17046de17

data/lib/rack-http_router/action.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+require 'erubi'
+require 'json'
+require 'rack'
+
+module Rack
+  class HttpRouter
+    module Action
+      def self.included(base)
+        base.class_eval do
+          attr_reader :route if self != Rack::HttpRouter
+
+          def initialize(route)
+            @route = route
+          end
+
+          def view_response(a_path, a_view_params = {}, status: 200)
+            Rack::HttpRouter::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::HttpRouter::Action.view(
+              a_path,
+              a_view_params,
+              status: status, response_instance: response_instance, route: route
+            )
+          end
+        end
+      end
+
+      def html(content, status: 200)
+        Rack::HttpRouter::Action.html(content, status: status)
+      end
+
+      def html_response(content, status: 200)
+        Rack::HttpRouter::Action.html_response(content, status: status)
+      end
+
+      def json(content = {}, status: 200)
+        Rack::HttpRouter::Action.json(content, status: status)
+      end
+
+      def json_response(content = {}, status: 200)
+        Rack::HttpRouter::Action.json_response(content, status: status)
+      end
+
+      def text(content, status: 200)
+        Rack::HttpRouter::Action.text(content, status: status)
+      end
+
+      def text_response(content, status: 200)
+        Rack::HttpRouter::Action.text_response(content, status: status)
+      end
+
+      def erb(path, view_params = {})
+        Rack::HttpRouter::Action.erb(path, view_params)
+      end
+
+      def redirect_to(url)
+        Rack::HttpRouter::Action.redirect_to(url)
+      end
+
+      def response(body = nil, status = 200, headers = {})
+        Rack::Response.new(body, status, headers)
+      end
+
+      class << self
+        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 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]]
+        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 text_response(content, status: 200)
+          Rack::Response.new(
+            content,
+            status,
+            { 'Content-Type' => 'text/plain' }
+          )
+        end
+
+        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 }, []]
+        end
+
+        def response(body = nil, status = 200, headers = {})
+          Rack::Response.new(body, status, headers)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Rack
+  class HttpRouter
+    class Router
+      class BuildRequest
+        def initialize(env)
+          @env = env
+        end
+
+        def call(route = nil)
+          request = Rack::Request.new(@env)
+
+          return request if route.nil?
+          return request unless route.has_params
+
+          update_request_params(request, route)
+        end
+
+        private
+
+        def update_request_params(request, route)
+          splitted_request_path = request.path.split('/')
+
+          route
+            .splitted_path
+            .each
+            .with_index do |route_word, route_word_position|
+              if route_word.start_with?(':')
+                param = splitted_request_path[route_word_position]
+                param = param.to_i if is_a_integer_string?(param)
+
+                update_request_param(request, route_word, param)
+              end
+            end
+
+          request
+        end
+
+        def is_a_integer_string?(string)
+          string =~ /\A[-+]?[0-9]*\.?[0-9]+\Z/
+        end
+
+        def update_request_param(request, word, param)
+          request.update_param(word.sub(':', '').to_sym, param)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Rack
+  class HttpRouter
+    class Router
+      class Route
+        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
+
+          env['REQUEST_PATH'] == @path
+        end
+
+        private
+
+        def fetch_params
+          @splitted_path.select { |value| value.start_with? ':' }
+        end
+
+        def match_with_params?(env)
+          splitted_request_path = env['REQUEST_PATH'].split('/')
+
+          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
+            end
+
+          !matched_path_pieces.include?(false)
+        end
+      end
+    end
+  end
+end

data/lib/rack-http_router/router.rb

@@ -0,0 +1,137 @@
+# frozen_string_literal: true
+
+require_relative 'router/route'
+require_relative 'router/build_request'
+
+module Rack
+  class HttpRouter
+    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: [] }
+        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)
+        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_instance.nil?
+
+        if route_instance.endpoint.respond_to?(:call)
+          return route_instance.endpoint.call(request_builder.call(route_instance))
+        end
+
+        if route_instance.endpoint.include?(Rack::HttpRouter::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, 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)
+
+        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 add_error(endpoint)
+        @error = endpoint
+      end
+
+      def append_scope(name)
+        @scopes.push(name)
+      end
+
+      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 ['/', ''].include?(path) && @scopes != []
+        return "/#{path}" if @scopes != []
+
+        path
+      end
+
+      def render_not_found(env)
+        return @not_found.call(env) if @not_found.respond_to?(:call)
+
+        @not_found.new.call(env)
+      end
+
+      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
+end

data/lib/rack-http_router.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require_relative 'rack-http_router/router'
+require_relative 'rack-http_router/action'
+
+module Rack
+  class HttpRouter
+    include Action
+
+    def initialize(router: Router.new)
+      @router = router
+    end
+
+    def call(&block)
+      instance_eval(&block)
+
+      @router
+    end
+
+    def route
+      @router.route
+    end
+
+    def scope(name, &block)
+      @router.append_scope(name)
+      instance_eval(&block)
+
+      @router.clear_last_scope
+    end
+
+    def not_found(endpoint = -> {}, &block)
+      if block_given?
+        @router.add_not_found(block)
+      else
+        @router.add_not_found(endpoint)
+      end
+    end
+
+    def error(endpoint = -> {}, &block)
+      if block_given?
+        @router.add_error(block)
+      else
+        @router.add_error(endpoint)
+      end
+    end
+
+    %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

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification
+name: rack-http_router
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Henrique F. Teixeira
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-07-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: erubi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.12'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '2.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: A complete http router solution that fit well with pure rack apps
+email: hriqueft@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rack-http_router.rb
+- lib/rack-http_router/action.rb
+- lib/rack-http_router/router.rb
+- lib/rack-http_router/router/build_request.rb
+- lib/rack-http_router/router/route.rb
+homepage: https://github.com/henriquefernandez/rack-http_router
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.3
+signing_key: 
+specification_version: 4
+summary: '"rack-http_router" come with a router and helper functions to build pure
+  Rack projects.'
+test_files: []