rackr 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: cdefbf566acec64232a4dc955298b3790f174884219515361cc41392191182ba
+  data.tar.gz: 06552a5aa5dae83ce342c31df357a1e805150ecd31cbb356f76281cecec73617
+SHA512:
+  metadata.gz: 926c42e1321efc1bb16fb1b8a7b40ddb81e59c57f6f79174ed619ed8aed6ca788523cc3ad6f7224ca2c78c99b1e174cd4617929a8836fa1678bde0504445ea0c
+  data.tar.gz: 8d10b27258450d640dfd413554dd4dd4cc0e3cc153992929f89c96265df2005b6d7d46ce4a86549e46814499de740011d3d74442ce78fbd9e932ade9361f4e49

data/lib/rackr/action.rb

@@ -0,0 +1,221 @@
+# frozen_string_literal: true
+
+require 'erubi'
+require 'oj'
+require 'rack'
+
+class Rackr
+  module Action
+    def self.included(base)
+      base.class_eval do
+        attr_reader :route, :config, :db if self != Rackr
+
+        def initialize(route: nil, config: nil)
+          @route = route
+          @config = config
+          @db = config[:db]
+        end
+
+        def view_response(a_path, a_view_params = {}, status: 200)
+          Rackr::Action.view_response(
+            a_path,
+            a_view_params,
+            status: status,
+            config: config,
+            route: route,
+            db: db
+          )
+        end
+
+        def view(
+          a_path, a_view_params = {}, status: 200, response_instance: false
+        )
+          Rackr::Action.view(
+            a_path,
+            a_view_params,
+            status: status,
+            config: config,
+            route: route,
+            db: db,
+            response_instance: response_instance
+          )
+        end
+      end
+    end
+
+    def layout(layout_path, file_path)
+      Rackr::Action.layout(layout_path, file_path)
+    end
+
+    def html(content, status: 200)
+      Rackr::Action.html(content, status: status)
+    end
+
+    def html_response(content, status: 200)
+      Rackr::Action.html_response(content, status: status)
+    end
+
+    def json(content = {}, status: 200)
+      Rackr::Action.json(content, status: status)
+    end
+
+    def json_response(content = {}, status: 200)
+      Rackr::Action.json_response(content, status: status)
+    end
+
+    def text(content, status: 200)
+      Rackr::Action.text(content, status: status)
+    end
+
+    def text_response(content, status: 200)
+      Rackr::Action.text_response(content, status: status)
+    end
+
+    def erb(content, view_params = {})
+      Rackr::Action.erb(content, view_params)
+    end
+
+    def redirect_response(url)
+      Rackr::Action.redirect_response(url)
+    end
+
+    def redirect_to(url)
+      Rackr::Action.redirect_to(url)
+    end
+
+    def response(body = nil, status = 200, headers = {})
+      Rack::Response.new(body, status, headers)
+    end
+
+    class << self
+      def view_response(
+        paths,
+        view_params = {},
+        status: 200,
+        config: {},
+        route: nil,
+        db: nil
+      )
+        view(
+          paths,
+          view_params,
+          status: status,
+          config: config,
+          route: route,
+          db: db,
+          response_instance: true
+        )
+      end
+
+      def view(
+        paths,
+        view_params = {},
+        status: 200,
+        config: {},
+        route: nil,
+        db: nil,
+        response_instance: false
+      )
+        base_path = config.dig(:views, :path) || "views"
+
+        file_or_nil = lambda do |path|
+          ::File.read(path)
+        rescue Errno::ENOENT
+          nil
+        end
+
+        file_content = if paths.is_a?(Array)
+                         paths.map { |path| ::File.read("#{base_path}/#{path}.html.erb") }.join
+                       else
+                         ::File.read("#{base_path}/#{paths}.html.erb")
+                       end
+
+        erb = erb(
+          [
+            file_or_nil.call("#{base_path}/layout/_header.html.erb"),
+            file_content,
+            file_or_nil.call("#{base_path}/layout/_footer.html.erb")
+          ].join,
+          view_params,
+          config: config,
+          route: route,
+          db: db
+        )
+
+        if response_instance
+          return Rack::Response.new(
+            erb,
+            status,
+            { 'Content-Type' => 'text/html' }
+          )
+        end
+
+        [status, { 'Content-Type' => 'text/html' }, [erb]]
+      end
+
+      def layout(layout_path, file_path)
+        [
+          "layout/#{layout_path}/_header",
+          file_path,
+          "layout/#{layout_path}/_footer"
+        ]
+      end
+
+      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 json(content = {}, status: 200)
+        [status, { 'Content-Type' => 'application/json' }, [Oj.dump(content, mode: :compat)]]
+      end
+
+      def json_response(content = {}, status: 200)
+        Rack::Response.new(
+          Oj.dump(content, mode: :compat),
+          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
+
+      # rubocop:disable Lint/UnusedMethodArgument
+      def erb(content, view_params = {}, config: nil, route: nil, db: nil)
+        @view = OpenStruct.new(view_params)
+
+        eval(Erubi::Engine.new(content).src)
+      end
+      # rubocop:enable Lint/UnusedMethodArgument
+
+      def redirect_response(url)
+        Rack::Response.new(
+          nil,
+          302,
+          { 'Location' => url }
+        )
+      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

data/lib/rackr/callback.rb

@@ -0,0 +1,21 @@
+class Rackr
+  module Callback
+    def self.included(base)
+      base.class_eval do
+        include Rackr::Action
+      end
+    end
+
+    def assign(obj, hash)
+      Rackr::Callback.assign(obj, hash)
+    end
+
+    def self.assign(obj, hash)
+      hash.each do |k, v|
+        obj.define_singleton_method(k) { v }
+      end
+
+      obj
+    end
+  end
+end

data/lib/rackr/router/build_request.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+class Rackr
+  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('/')
+
+        i = 0
+
+        while i < route.splitted_path.size
+          route_word = route.splitted_path[i]
+          if route_word.start_with?(':')
+            param = splitted_request_path[i]
+            param = param.to_i if is_a_integer_string?(param)
+
+            update_request_param(request, route_word, param)
+          end
+
+          i += 1
+        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

data/lib/rackr/router/route.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+class Rackr
+  class Router
+    class Route
+      attr_reader :endpoint, :splitted_path, :has_params, :has_befores, :befores
+
+      def initialize(path, endpoint, befores = [])
+        @path = path
+        @splitted_path = @path.split('/')
+        @endpoint = endpoint
+        @params = fetch_params
+        @has_params = @params != []
+        @befores = befores
+        @has_befores = befores != []
+      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

data/lib/rackr/router.rb

@@ -0,0 +1,192 @@
+require_relative 'router/errors'
+require_relative 'router/route'
+require_relative 'router/build_request'
+
+class Rackr
+  class Router
+    attr_writer :not_found
+    attr_reader :route, :config
+
+    def initialize(config = {})
+      @routes = {}
+      %w[GET POST DELETE PUT TRACE OPTIONS PATCH].each do |method|
+        @routes[method] = { __instances: [] }
+      end
+      @route =
+        Hash.new do |_hash, key|
+          raise(Errors::UndefinedNamedRouteError, "Undefined named route: '#{key}'")
+        end
+      @config = config
+      @branches = []
+      @befores = []
+      @branches_befores = {}
+      @nameds_as = []
+      @branches_named_as = {}
+      @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?
+
+      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)
+
+        i += 1
+      end
+
+      call_endpoint(route_instance.endpoint, before_result || rack_request)
+    rescue Exception => e
+      @error.call(request_builder.call, e)
+    end
+
+    def add(method, path, endpoint, as = nil, route_befores = [])
+      Errors.check_path(path)
+      Errors.check_endpoint(endpoint, path)
+      Errors.check_as(as, path)
+      Errors.check_callbacks(route_befores, path)
+
+      method = :get if method == :head
+
+      path_with_branches = "/#{@branches.join('/')}#{put_path_slash(path)}"
+      add_named_route(path_with_branches, as)
+
+      route_instance =
+        Route.new(path_with_branches, endpoint, @befores + ensure_array(route_befores))
+
+      if @branches.size >= 1
+        return push_to_branch(method.to_s.upcase, route_instance)
+      end
+
+      @routes[method.to_s.upcase][:__instances].push(route_instance)
+    end
+
+    def add_not_found(endpoint)
+      Errors.check_endpoint(endpoint, 'not_found')
+
+      @not_found = endpoint
+    end
+
+    def add_error(endpoint)
+      Errors.check_endpoint(endpoint, 'error')
+
+      @error = endpoint
+    end
+
+    def append_branch(name, branch_befores = [], as = nil)
+      Errors.check_branch_name(name)
+      Errors.check_as(as, @branches.join('/'))
+      Errors.check_callbacks(branch_befores, name)
+
+      @branches.push(name)
+
+      branch_befores = ensure_array(branch_befores)
+      @befores.concat(branch_befores)
+      @branches_befores[name] = branch_befores
+
+      @nameds_as.push(as)
+      @branches_named_as[name] = as
+    end
+
+    def clear_last_branch
+      @befores -= @branches_befores[@branches.last]
+      @nameds_as -= [@branches_named_as[@branches.last]]
+      @branches = @branches.first(@branches.size - 1)
+    end
+
+    private
+
+    def call_endpoint(endpoint, rack_request)
+      return endpoint.call(rack_request) if endpoint.respond_to?(:call)
+
+      if endpoint.include?(Rackr::Action)
+        return endpoint.new(route: @route, config: @config).call(rack_request)
+      end
+
+      endpoint.new.call(rack_request)
+    end
+
+    def ensure_array(list)
+      return [] if list.nil?
+      return list if list.is_a?(Array)
+
+      [list]
+    end
+
+    def add_named_route(path_with_branches, as)
+      nameds_as = [@nameds_as.last].push(as).compact
+      return if nameds_as.empty?
+
+      @route[nameds_as.join('_').to_sym] = path_with_branches
+    end
+
+    def push_to_branch(method, route_instance)
+      branches_with_slash = @branches + %i[__instances]
+      push_it(@routes[method], *branches_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
+    end
+
+    def put_path_slash(path)
+      return '' if ['/', ''].include?(path) && @branches != []
+      return "/#{path}" if @branches != []
+
+      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_branches = [])
+      routes =
+        if last_tail.nil?
+          last_tail = env['REQUEST_PATH'].split('/').drop(1)
+
+          @routes[env['REQUEST_METHOD']]
+        else
+          @routes[env['REQUEST_METHOD']].dig(*found_branches)
+        end
+
+      segment, *tail = last_tail
+
+      routes.each do |branch, _v|
+        next if branch == :__instances
+
+        if segment == branch || branch.start_with?(':')
+          found_branches.push(branch)
+          break
+        end
+      end
+
+      if tail.empty? || found_branches == []
+        return @routes[env['REQUEST_METHOD']].dig(
+          *(found_branches << :__instances)
+        )
+          &.detect { |route_instance| route_instance.match?(env) }
+      end
+
+      match_route(env, tail, found_branches)
+    end
+  end
+end

data/lib/rackr.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative 'rackr/router'
+require_relative 'rackr/action'
+require_relative 'rackr/callback'
+
+class Rackr
+  include Action
+
+  def initialize(config = {})
+    @router = Router.new(config)
+  end
+
+  def call(&block)
+    instance_eval(&block)
+
+    @router
+  end
+
+  def route
+    @router.route
+  end
+
+  def config
+    @router.config
+  end
+
+  def db
+    @router.config[:db]
+  end
+
+  def r(name, before: [], as: nil, &block)
+    @router.append_branch(name, before, as)
+    instance_eval(&block)
+
+    @router.clear_last_branch
+  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, before: nil, &block|
+      if block.respond_to?(:call)
+        @router.add(http_method, path, block, as, before)
+      else
+        @router.add(http_method, path, endpoint, as, before)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: rackr
+version: !ruby/object:Gem::Version
+  version: 0.0.4
+platform: ruby
+authors:
+- Henrique F. Teixeira
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2023-08-09 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: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.15'
+- !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/rackr.rb
+- lib/rackr/action.rb
+- lib/rackr/callback.rb
+- lib/rackr/router.rb
+- lib/rackr/router/build_request.rb
+- lib/rackr/router/route.rb
+homepage: https://github.com/henrique-ft/rackr
+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: A complete http router solution that fit well with pure rack apps.
+test_files: []