rackr 0.0.48 → 0.0.50

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 17ea0ba90cd0ee285862c06535ce35a2965a475e0e46994057c40af7631fd082
-  data.tar.gz: 858b1c9b70af9a250ecf46cb7bc7020735bccf6d2c9da9948dc2b60038ce939d
+  metadata.gz: 889c67a66431461f8ef941117b0195498135b5ee0c4b3b75c17f8c784f65678c
+  data.tar.gz: 5482a863b01cf4637824ed7a054da8ac7a339154c8dc2b19faf11576e7585b77
 SHA512:
-  metadata.gz: e3ac8005daa702a46140afeec59bb7cd2f339c6a12dce1468ca8e3c4b447b68ac00068b76807594365db54bc32a0d7ca219d42389098c0fac7d3b53346eb4856
-  data.tar.gz: 57059e5130445514fc26f7972ed9c972835798e666a262372b2f5e1797e938ba01aa5a68649ebcff431afa149e2069b7646212eb6a4ba1a939e35e347b2aca2f
+  metadata.gz: 1f0fb3862cb8f3e50b3aef24c99e0ee9ee2252542d026c4d7d078063d30ccbbd8bed3b0964814d82f95d929cdcb33c29bd639209842666c2af173f17f9d70160
+  data.tar.gz: f5a6835a8b80acd26e8e3ddf8cd38c84b23066319e65727688285c8b51ddcaccab401908e4dff64bcbabe3614ca45ab20a3cd3cc638b434c70cd94f76b33e321

data/lib/rackr/action.rb

@@ -16,11 +16,12 @@ class Rackr
           @db = config[:db]
         end
 
-        def view_response(a_path, a_view_params = {}, status: 200)
+        def view_response(a_path, a_view_params = {}, status: 200, headers: {})
           Rackr::Action.view_response(
             a_path,
             a_view_params,
             status: status,
+            headers: headers,
             config: config,
             routes: routes,
             db: db
@@ -28,12 +29,13 @@ class Rackr
         end
 
         def view(
-          a_path, a_view_params = {}, status: 200, response_instance: false
+          a_path, a_view_params = {}, status: 200, response_instance: false, headers: {}
         )
           Rackr::Action.view(
             a_path,
             a_view_params,
             status: status,
+            headers: headers,
             config: config,
             routes: routes,
             db: db,
@@ -43,44 +45,66 @@ class Rackr
       end
     end
 
-    def layout(layout_path, file_path)
-      Rackr::Action.layout(layout_path, file_path)
-    end
+    def html(content = '', status: 200, headers: {}, &block)
+      if block_given? && respond_to?(:html_slice)
+        if respond_to?(:layout)
+          content = layout(&block)
+        else
+          html_slice(:root, &block)
+          content = html_slice
+        end
+      end
 
-    def html(content, status: 200)
-      Rackr::Action.html(content, status: status)
+      Rackr::Action.html(content, status: status, headers: headers, &block)
     end
 
-    def html_response(content, status: 200)
-      Rackr::Action.html_response(content, status: status)
+    def html_response(content = '', status: 200, headers: {} &block)
+      if block_given? && respond_to?(:html_slice)
+        if respond_to?(:layout)
+          content = layout(&block)
+        else
+          html_slice(:root, &block)
+          content = html_slice
+        end
+      end
+
+      Rackr::Action.html_response(content, status: status, headers: headers, &block)
     end
 
-    def json(content = {}, status: 200)
-      Rackr::Action.json(content, status: status)
+    def json(content = {}, status: 200, headers: {})
+      Rackr::Action.json(content, status: status, headers: headers)
     end
 
-    def json_response(content = {}, status: 200)
-      Rackr::Action.json_response(content, status: status)
+    def json_response(content = {}, status: 200, headers: {})
+      Rackr::Action.json_response(content, status: status, headers: headers)
     end
 
-    def text(content, status: 200)
-      Rackr::Action.text(content, status: status)
+    def text(content, status: 200, headers: {})
+      Rackr::Action.text(content, status: status, headers: headers)
     end
 
-    def text_response(content, status: 200)
-      Rackr::Action.text_response(content, status: status)
+    def text_response(content, status: 200, headers: {})
+      Rackr::Action.text_response(content, status: status, headers: headers)
     end
 
     def erb(content, view_params = {})
       Rackr::Action.erb(content, view_params)
     end
 
-    def redirect_response(url)
-      Rackr::Action.redirect_response(url)
+    def head(status, headers: {})
+      Rackr::Action.head(status, headers: headers)
+    end
+
+    def head_response(status, headers: {})
+      Rackr::Action.head_response(status, headers: headers)
+    end
+
+    def redirect_response(url, headers: {})
+      Rackr::Action.redirect_response(url, headers: headers)
     end
 
-    def redirect_to(url)
-      Rackr::Action.redirect_to(url)
+    def redirect_to(url, headers: {})
+      Rackr::Action.redirect_to(url, headers: headers)
     end
 
     def response(body = nil, status = 200, headers = {})
@@ -92,6 +116,7 @@ class Rackr
         paths,
         view_params = {},
         status: 200,
+        headers: {},
         config: {},
         routes: nil,
         db: nil
@@ -102,6 +127,7 @@ class Rackr
           status: status,
           config: config,
           routes: routes,
+          headers: headers,
           db: db,
           response_instance: true
         )
@@ -111,6 +137,7 @@ class Rackr
         paths,
         view_params = {},
         status: 200,
+        headers: {},
         config: {},
         routes: nil,
         db: nil,
@@ -146,50 +173,60 @@ class Rackr
           return Rack::Response.new(
             erb,
             status,
-            { 'Content-Type' => 'text/html' }
+            { 'Content-Type' => 'text/html' }.merge(headers)
           )
         end
 
-        [status, { 'Content-Type' => 'text/html' }, [erb]]
+        [status, { 'Content-Type' => 'text/html' }.merge(headers), [erb]]
       end
 
-      def layout(layout_path, file_path)
-        [
-          "layout/#{layout_path}/_header",
-          file_path,
-          "layout/#{layout_path}/_footer"
-        ]
-      end
+      def html(content = '', status: 200, headers: {}, &block)
+        if content == '' && block_given? && respond_to?(:html_slice)
+          if respond_to?(:layout)
+            content = layout(&block)
+          else
+            html_slice(:root, &block)
+            content = html_slice
+          end
+        end
 
-      def html(content, status: 200)
-        [status, { 'Content-Type' => 'text/html' }, [content]]
+        [status, { 'Content-Type' => 'text/html' }.merge(headers), [content]]
       end
 
-      def html_response(content, status: 200)
-        Rack::Response.new(content, status, { 'Content-Type' => 'text/html' })
+      def html_response(content = '', status: 200, headers: {}, &block)
+        if content == '' && block_given? && respond_to?(:html_slice)
+          if respond_to?(:layout)
+            content = layout(&block)
+          else
+            html_slice(:root, &block)
+            content = html_slice
+          end
+        end
+
+        Rack::Response.new(content, status, { 'Content-Type' => 'text/html' }.merge(headers))
       end
 
-      def json(content = {}, status: 200)
-        [status, { 'Content-Type' => 'application/json' }, [Oj.dump(content, mode: :compat)]]
+      def json(content = {}, status: 200, headers: {})
+        [status, { 'Content-Type' => 'application/json' }.merge(headers), [Oj.dump(content, mode: :compat)]]
       end
 
-      def json_response(content = {}, status: 200)
+      def json_response(content = {}, status: 200, headers: {})
         Rack::Response.new(
           Oj.dump(content, mode: :compat),
           status,
-          { 'Content-Type' => 'application/json' }
+          { 'Content-Type' => 'application/json' }.merge(headers)
         )
       end
 
-      def text(content, status: 200)
-        [status, { 'Content-Type' => 'text/plain' }, [content]]
+      def text(content, status: 200, headers: {})
+        [status, { 'Content-Type' => 'text/plain' }.merge(headers), [content]]
       end
 
-      def text_response(content, status: 200)
+      def text_response(content, status: 200, headers: {})
         Rack::Response.new(
           content,
           status,
-          { 'Content-Type' => 'text/plain' }
+          { 'Content-Type' => 'text/plain' }.merge(headers)
         )
       end
 
@@ -201,16 +238,24 @@ class Rackr
       end
       # rubocop:enable Lint/UnusedMethodArgument
 
-      def redirect_response(url)
+      def redirect_response(url, headers: {})
         Rack::Response.new(
           nil,
           302,
-          { 'Location' => url }
+          { 'Location' => url }.merge(headers)
         )
       end
 
-      def redirect_to(url)
-        [302, { 'Location' => url }, []]
+      def redirect_to(url, headers: {})
+        [302, { 'Location' => url }.merge(headers), []]
+      end
+
+      def head(status, headers: {})
+        [status, headers, []]
+      end
+
+      def head_response(status, headers: {})
+        Rack::Response.new(nil, status, headers)
       end
 
       def response(body = nil, status = 200, headers = {})

data/lib/rackr/html.rb

@@ -0,0 +1,139 @@
+class Rackr
+  module HTML
+    # HTML as a first-class citizen in ruby code
+    # Faster than ERB.
+
+    TAGS = %i[
+      div
+      title
+      embed
+      meta
+      br
+      a
+      em
+      b
+      i
+      ul
+      ol
+      li
+      img
+      table
+      tbody
+      thead
+      tr
+      th
+      td
+      form
+      input
+      button
+      link
+      h1
+      h2
+      h3
+      h4
+      h5
+      h6
+      hr
+      span
+      label
+      iframe
+      template
+      main
+      footer
+      aside
+      source
+      section
+      small
+      script
+      nav
+      area
+    ]
+
+    EMPTY_TAGS = %i[
+      area
+      br
+      embed
+      hr
+      img
+      input
+      link
+      meta
+      source
+    ].freeze
+
+    def html_layout(&block)
+      html_slice(:root, &block)
+    end
+
+    def html_slice(type = nil, &block)
+      if block_given?
+        if type == :root
+          wrap = ['<!DOCTYPE html><html>', '</html>']
+        else
+          wrap = ['','']
+        end
+        @html_slice = wrap[0]
+        instance_eval(&block)
+        @html_slice << wrap[1]
+      else
+        @html_slice
+      end
+    end
+
+    TAGS.each do |name|
+      define_method name do |*args, &block|
+        tag(name, *args, &block)
+      end
+    end
+
+    def _(content)
+      @html_slice << content.to_s
+    end
+
+    def tag(tag_name, *args, &block)
+      content, attributes = parse_html_tag_arguments(args)
+      generate_and_append_html_tag(tag_name, content, attributes, &block)
+    end
+
+    private
+
+    def parse_html_tag_arguments(args)
+      content = ''
+      attributes = {}
+
+      first_argument = args.shift
+      if first_argument.is_a?(String)
+        content = CGI.escapeHTML(first_argument)
+        attributes = args.pop || {}
+      elsif first_argument.is_a?(Hash)
+        attributes = first_argument
+      end
+
+      [content, attributes]
+    end
+
+    def generate_and_append_html_tag(tag_name, content, attributes, &block)
+      open_tag = build_html_open_tag(tag_name, attributes)
+
+      if block_given?
+        @html_slice << open_tag << ">"
+        instance_eval(&block)
+        @html_slice << "</#{tag_name}>"
+      else
+        if content.empty? && EMPTY_TAGS.include?(tag_name)
+          @html_slice << open_tag << "/>"
+        else
+          @html_slice << open_tag << ">" << content << "</#{tag_name}>"
+        end
+      end
+    end
+
+    def build_html_open_tag(tag_name, attributes)
+      open_tag = "<#{tag_name}"
+      attributes.each do |key, value|
+        open_tag << " #{key.to_s.gsub('_', '-')}='#{value}'"
+      end
+      open_tag
+    end
+  end
+end

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

@@ -0,0 +1,96 @@
+class Rackr
+  class Router
+    module Errors
+      class DevHtml
+        include Rackr::Action
+        include Rackr::HTML
+
+        def call(env)
+          html do
+            tag :head do
+              title 'Application error'
+              tag :style, %q(
+                body {
+                    margin: 0 auto;
+                        width: 98.5%;
+                            font-size: 1.1em;
+                                background-color: #666666;
+                                    font-family: monospace;
+                                        margin-top: 1em;
+                }
+                p {
+                background-color: #000000;
+                    padding: 1em;
+                        font-size: 1.3em;
+                        }
+                div {
+                background-color: #191919;
+                    color: white;
+                        padding: 0em 2em;
+                            border: 5px solid #ffffff;
+                                border-radius: 1em;
+                }
+                h1 {
+                    background-color: #464646;
+                        padding: 1em;
+                            border-radius: 0.2em;
+                }
+              )
+            end
+            tag :body do
+              div do
+                h1 env['error'].inspect
+                backtrace(env)
+              end
+            end
+          end
+        end
+
+        def backtrace(env)
+          first, *tail = env['error'].backtrace
+
+          tag :p, first, class: "first-p"
+
+          line_number = extract_line_number(first)
+          match = first.match(%r{^(\/[\w\/.-]+)})
+          file_path = (match ? match[1] : nil)
+          if file_path != nil
+            lines = []
+            File.open(file_path) do |file|
+              lines = file.readlines
+            end
+
+            lines.map!.with_index do |line, i|
+              "#{i+1}: #{line} \n"
+            end
+
+            tag :pre, slice_around_index(lines, line_number).join("")
+          end
+
+          hr
+          tag :p, tail.join("\n")
+        end
+
+
+        def extract_line_number(input)
+          if match = input.match(/:(\d+):in/)
+            match[1].to_i
+          else
+            nil
+          end
+        end
+
+        def slice_around_index(array, index)
+          return array if index == nil || index < 1
+
+          index -= 1
+          start_index = [index - 2, 0].max
+          end_index = [index + 2, array.size - 1].min
+
+          # Slice the array
+          array[start_index..end_index]
+        end
+      end
+    end
+  end
+end

data/lib/rackr/router/errors.rb

@@ -12,10 +12,16 @@ class Rackr
       class InvalidBranchNameError < Error; end
 
       class << self
-        def check_branch_name(path)
-          return if path.is_a?(String) || path.is_a?(Symbol)
+        def check_scope_name(path)
+          return if path.is_a?(String) || path.is_a?(Symbol) || path == nil
 
-          raise(InvalidBranchNameError, "Route branch name must be a `string` or a `symbol`, got: '#{path}'")
+          raise(InvalidBranchNameError, "Route scope name must be a `string` or a `symbol`, got: '#{path}'")
+        end
+
+        def check_scope_slashes(path)
+          if path.is_a?(String) && path.include?('/')
+            raise(InvalidBranchNameError, "Avoid slashes in scope name, use nested scopes instead, got: '#{path}'")
+          end
         end
 
         def check_path(path)
@@ -28,7 +34,7 @@ class Rackr
           return if as.is_a?(String) || as.is_a?(Symbol) || as.nil?
 
           raise(InvalidNamedRouteError,
-                "as: argument in routes and branches must be a `string` or a `symbol`, got: '#{as}' for '#{path}'")
+                "as: argument in routes and scopes must be a `string` or a `symbol`, got: '#{as}' for '#{path}'")
         end
 
         def check_callbacks(callbacks, path)

data/lib/rackr/router/route.rb

@@ -9,7 +9,7 @@ class Rackr
                   :has_afters,
                   :afters
 
-      def initialize(path, endpoint, befores: [], afters: [])
+      def initialize(path, endpoint, befores: [], afters: [], wildcard: false)
         @path = path
         @splitted_path = @path.split('/')
         @endpoint = endpoint
@@ -20,12 +20,14 @@ class Rackr
         @afters = afters
         @has_afters = afters != []
         @path_regex = /\A#{path.gsub(/(:\w+)/, '([^/]+)')}\z/
+        @wildcard = wildcard
       end
 
-      def match?(env)
-        return env['PATH_INFO'].match?(@path_regex) if @has_params
+      def match?(path_info)
+        return path_info.match?(@path_regex) if @has_params
+        return true if @wildcard
 
-        env['PATH_INFO'] == @path
+        path_info == @path
       end
 
       private

data/lib/rackr/router.rb

@@ -21,27 +21,29 @@ class Rackr
           raise(Errors::UndefinedNamedRouteError, "Undefined named route: '#{key}'")
         end)
       end
-
+      @dev_mode = ENV['RACK_ENV'] == 'development'
       @config = config
-      @branches = []
+      @scopes = []
       @befores = ensure_array(before)
-      @branches_befores = {}
+      @scopes_befores = {}
       @afters = ensure_array(after)
-      @branches_afters = {}
+      @scopes_afters = {}
       @error = proc { |_req, e| raise e }
       @not_found = proc { [404, {}, ['Not found']] }
-      @splitted_request_path = []
+      @splitted_request_path_info = []
+      @current_request_path_info = nil
     end
 
     def call(env)
-      @splitted_request_path = env['PATH_INFO'].split('/')
+      @splitted_request_path_info = env['PATH_INFO'].split('/')
+      @current_request_path_info =
+        (env['PATH_INFO'] == '/') ? env['PATH_INFO'] : env['PATH_INFO'].sub(/\/\z/, '') # remove trailing "/"
 
-      request_builder = BuildRequest.new(env, @splitted_request_path)
+      request_builder = BuildRequest.new(env, @splitted_request_path_info)
       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?
+      return call_endpoint(@not_found, request_builder.call) if route_instance.nil?
 
       rack_request = request_builder.call(route_instance)
 
@@ -68,9 +70,11 @@ class Rackr
 
       endpoint_result
     rescue Rackr::NotFound
-      render_not_found(request_builder.call)
+      call_endpoint(@not_found, request_builder.call)
     rescue Exception => e
-      @error.call(request_builder.call, e)
+      return @error.call(request_builder.call, e) unless @dev_mode
+
+      call_endpoint(Errors::DevHtml, env.merge({'error' => e}))
     end
 
     def add(method, path, endpoint, as: nil, route_befores: [], route_afters: [])
@@ -82,18 +86,21 @@ class Rackr
 
       method = :get if method == :head
 
-      path_with_branches = "/#{@branches.join('/')}#{put_path_slash(path)}"
-      add_named_route(method, path_with_branches, as)
+      wildcard = (path == '*') ? true : false
+      path = path.sub(/\A\//, '')
+      path_with_scopes = "/#{not_empty_scopes.join('/')}#{put_path_slash(path)}"
+      add_named_route(method, path_with_scopes, as)
 
       route_instance =
         Route.new(
-          path_with_branches,
+          path_with_scopes,
           endpoint,
           befores: @befores + ensure_array(route_befores),
-          afters: @afters + ensure_array(route_afters)
+          afters: @afters + ensure_array(route_afters),
+          wildcard: wildcard
         )
 
-      return push_to_branch(method.to_s.upcase, route_instance) if @branches.size >= 1
+      return push_to_scope(method.to_s.upcase, route_instance) if @scopes.size >= 1
 
       @instance_routes[method.to_s.upcase][:__instances].push(route_instance)
     end
@@ -110,28 +117,29 @@ class Rackr
       @error = endpoint
     end
 
-    def append_branch(name, branch_befores: [], branch_afters: [])
-      Errors.check_branch_name(name)
-      Errors.check_callbacks(branch_befores, name)
-      Errors.check_callbacks(branch_afters, name)
+    def append_scope(name, scope_befores: [], scope_afters: [])
+      Errors.check_scope_name(name)
+      Errors.check_scope_slashes(name)
+      Errors.check_callbacks(scope_befores, name)
+      Errors.check_callbacks(scope_afters, name)
 
       name = ":#{name}" if name.is_a? Symbol
 
-      @branches.push(name)
+      @scopes.push(name)
 
-      branch_befores = ensure_array(branch_befores)
-      @befores.concat(branch_befores)
-      @branches_befores[name] = branch_befores
+      scope_befores = ensure_array(scope_befores)
+      @befores.concat(scope_befores)
+      @scopes_befores[name] = scope_befores
 
-      branch_afters = ensure_array(branch_afters)
-      @afters.concat(branch_afters)
-      @branches_afters[name] = branch_afters
+      scope_afters = ensure_array(scope_afters)
+      @afters.concat(scope_afters)
+      @scopes_afters[name] = scope_afters
     end
 
-    def clear_last_branch
-      @befores -= @branches_befores[@branches.last]
-      @afters -= @branches_afters[@branches.last]
-      @branches = @branches.first(@branches.size - 1)
+    def clear_last_scope
+      @befores -= @scopes_befores[@scopes.last]
+      @afters -= @scopes_afters[@scopes.last]
+      @scopes = @scopes.first(@scopes.size - 1)
     end
 
     private
@@ -153,17 +161,17 @@ class Rackr
       [list]
     end
 
-    def add_named_route(method, path_with_branches, as)
-      return @routes.send(method.downcase)[:root] = path_with_branches if path_with_branches == '/'
-      return @routes.send(method.downcase)[as] = path_with_branches unless as.nil?
+    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?
 
-      key = path_with_branches.sub("/","").gsub(":","").gsub("/","_")
-      @routes.send(method.downcase)["#{key}".to_sym] = path_with_branches
+      key = path_with_scopes.sub("/","").gsub(":","").gsub("/","_")
+      @routes.send(method.downcase)["#{key}".to_sym] = path_with_scopes
     end
 
-    def push_to_branch(method, route_instance)
-      branches_with_slash = @branches + %i[__instances]
-      push_it(@instance_routes[method], *branches_with_slash, route_instance)
+    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)
     end
 
     def push_it(hash, first_key, *rest_keys, val)
@@ -176,47 +184,47 @@ class Rackr
     end
 
     def put_path_slash(path)
-      return '' if ['/', ''].include?(path) && @branches != []
-      return "/#{path}" if @branches != []
+      if not_empty_scopes != []
+        return '' if ['/', ''].include?(path)
+        return "/#{path}"
+      end
 
       path
     end
 
-    def render_not_found(env)
-      return @not_found.call(env) if @not_found.respond_to?(:call)
-
-      @not_found.new.call(env)
+    def not_empty_scopes
+      @scopes.reject { |v| (v == '') }
     end
 
-    def match_route(env, last_tail = nil, found_branches = [])
+    def match_route(env, last_tail = nil, found_scopes = [])
       instance_routes =
         if last_tail.nil?
-          last_tail = @splitted_request_path.drop(1)
+          last_tail = @splitted_request_path_info.drop(1)
 
           @instance_routes[env['REQUEST_METHOD']]
         else
-          @instance_routes[env['REQUEST_METHOD']].dig(*found_branches)
+          @instance_routes[env['REQUEST_METHOD']].dig(*found_scopes)
         end
 
       segment, *tail = last_tail
 
-      instance_routes.each do |branch, _v|
-        next if branch == :__instances
+      instance_routes.each do |scope, _v|
+        next if scope == :__instances
 
-        if segment == branch || branch.start_with?(':')
-          found_branches.push(branch)
+        if segment == scope || scope.start_with?(':')
+          found_scopes.push(scope)
           break
         end
       end
 
-      if tail.empty? || found_branches == []
+      if tail.empty? || found_scopes == []
         return @instance_routes[env['REQUEST_METHOD']].dig(
-          *(found_branches << :__instances)
+          *(found_scopes << :__instances)
         )
-          &.detect { |route_instance| route_instance.match?(env) }
+          &.detect { |route_instance| route_instance.match?(@current_request_path_info) }
       end
 
-      match_route(env, tail, found_branches)
+      match_route(env, tail, found_scopes)
     end
   end
 end

data/lib/rackr.rb

@@ -1,8 +1,10 @@
 # frozen_string_literal: true
 
-require_relative 'rackr/router'
 require_relative 'rackr/action'
 require_relative 'rackr/callback'
+require_relative 'rackr/html'
+require_relative 'rackr/router/errors/dev_html'
+require_relative 'rackr/router'
 
 class Rackr
   class NotFound < StandardError; end
@@ -10,6 +12,7 @@ class Rackr
   HTTP_METHODS = %w[GET POST DELETE PUT TRACE OPTIONS PATCH]
 
   include Action
+  include HTML
 
   def initialize(config = {}, before: [], after: [])
     @router = Router.new(config, before: before, after: after)
@@ -33,15 +36,15 @@ class Rackr
     @router.config[:db]
   end
 
-  def r(name, before: [], after: [], &block)
-    @router.append_branch(
+  def scope(name = '', before: [], after: [], &block)
+    @router.append_scope(
       name,
-      branch_befores: before,
-      branch_afters: after,
+      scope_befores: before,
+      scope_afters: after,
     )
     instance_eval(&block)
 
-    @router.clear_last_branch
+    @router.clear_last_scope
   end
 
   def not_found(endpoint = -> {}, &block)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rackr
 version: !ruby/object:Gem::Version
-  version: 0.0.48
+  version: 0.0.50
 platform: ruby
 authors:
 - Henrique F. Teixeira
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-07 00:00:00.000000000 Z
+date: 2024-12-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: erubi
@@ -67,9 +67,11 @@ files:
 - lib/rackr.rb
 - lib/rackr/action.rb
 - lib/rackr/callback.rb
+- lib/rackr/html.rb
 - lib/rackr/router.rb
 - lib/rackr/router/build_request.rb
 - lib/rackr/router/errors.rb
+- lib/rackr/router/errors/dev_html.rb
 - lib/rackr/router/route.rb
 homepage: https://github.com/henrique-ft/rackr
 licenses: