rackr 0.0.49 → 0.0.51

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f92461b0ae4b6cab185bc30a250bc4155995b75509c66303abdf4cc1448770aa
-  data.tar.gz: d5e3ac4c8555803763a3dcb9b1db3f0d6659e5b5be63dc23624cab75b15d8bb5
+  metadata.gz: 5349fb78d9228c927c1a13e4870dbe7797ed9dd9f2c6e6868c48ea21cb6a30d1
+  data.tar.gz: e343559e578fff15af1d85254d315f6999ca119fc9452899cc0b0d04835638be
 SHA512:
-  metadata.gz: 37a468ee044c2628c810e783735d19bef979ed8ddbe1b62c52e856f992a9cf731b4e25f0785eb2570f47438ab43f4ed1842011aa570b85a5d786f65f1b0cfe7e
-  data.tar.gz: 253aff88e9aa466796f7657477c1fef6fe43c2b743a8400e9fca31a66667144c52eca7a981b65fb07f58f4ff89e67ee79f569a6ac8f7ea535c774806d187152b
+  metadata.gz: 2485768ddeba8f7460bc3d1cef02e3b931f0d3ff611d2418601298e73c62d114e8c9fb559f1e75dbd3788c8a64b3cb170c6a1d8118aec0246c03bcc818a5f89d
+  data.tar.gz: 55a73f398a954e32c9c4b83f3ff131ce57b80ac1da445c199d32a413f47ab877ebbdba5b70e3a06d1cb7cf90ff4280cb7db59d6fbaefdcb5843cdb0727e3187e

data/lib/rackr/action.rb

@@ -16,211 +16,142 @@ class Rackr
           @db = config[:db]
         end
 
-        def view_response(a_path, a_view_params = {}, status: 200, headers: {})
-          Rackr::Action.view_response(
-            a_path,
-            a_view_params,
+        def view_response(
+          paths,
+          status: 200,
+          headers: {},
+          layout_path: 'layout'
+        )
+          view(
+            paths,
             status: status,
             headers: headers,
-            config: config,
-            routes: routes,
-            db: db
+            layout_path: layout_path,
+            response_instance: true
           )
         end
 
         def view(
-          a_path, a_view_params = {}, status: 200, response_instance: false, headers: {}
+          paths,
+          status: 200,
+          headers: {},
+          layout_path: 'layout',
+          response_instance: false
         )
-          Rackr::Action.view(
-            a_path,
-            a_view_params,
-            status: status,
-            headers: headers,
-            config: config,
-            routes: routes,
-            db: db,
-            response_instance: response_instance
-          )
+          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
+
+          layout_content = file_or_nil.("#{base_path}/#{layout_path}.html.erb")
+
+          parsed_erb =
+            if layout_content
+              erb(layout_content) do
+                erb(file_content, binding_context: binding)
+              end
+            else
+              erb(file_content, binding_context: binding)
+            end
+
+          if response_instance
+            return Rack::Response.new(
+              parsed_erb,
+              status,
+              { 'content-type' => 'text/html' }.merge(headers)
+            )
+          end
+
+          [status, { 'content-type' => 'text/html' }.merge(headers), [parsed_erb]]
         end
       end
     end
 
-    def layout(layout_path, file_path)
-      Rackr::Action.layout(layout_path, file_path)
-    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_layout(&block)
+          content = html_slice
+        end
+      end
 
-    def html(content, status: 200, headers: {})
-      Rackr::Action.html(content, status: status, headers: headers)
+      [status, { 'content-type' => 'text/html' }.merge(headers), [content]]
     end
 
-    def html_response(content, status: 200)
-      Rackr::Action.html_response(content, status: status, headers: headers)
+    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_layout(&block)
+          content = html_slice
+        end
+      end
+
+      Rack::Response.new(content, status, { 'content-type' => 'text/html' }.merge(headers))
     end
 
     def json(content = {}, status: 200, headers: {})
-      Rackr::Action.json(content, status: status, headers: headers)
+      [status, { 'content-type' => 'application/json' }.merge(headers), [Oj.dump(content, mode: :compat)]]
     end
 
     def json_response(content = {}, status: 200, headers: {})
-      Rackr::Action.json_response(content, status: status, headers: headers)
+      Rack::Response.new(
+        Oj.dump(content, mode: :compat),
+        status,
+        { 'content-type' => 'application/json' }.merge(headers)
+      )
     end
 
     def text(content, status: 200, headers: {})
-      Rackr::Action.text(content, status: status, headers: headers)
+      [status, { 'content-type' => 'text/plain' }.merge(headers), [content]]
     end
 
     def text_response(content, status: 200, headers: {})
-      Rackr::Action.text_response(content, status: status, headers: headers)
+      Rack::Response.new(
+        content,
+        status,
+        { 'content-type' => 'text/plain' }.merge(headers)
+      )
+    end
+
+    def erb(content, binding_context: nil, &block)
+      eval(Erubi::Engine.new(content).src, binding_context)
     end
 
-    def erb(content, view_params = {})
-      Rackr::Action.erb(content, view_params)
+    def head(status, headers: {})
+      [status, headers, []]
+    end
+
+    def head_response(status, headers: {})
+      Rack::Response.new(nil, status, headers)
     end
 
     def redirect_response(url, headers: {})
-      Rackr::Action.redirect_response(url, headers: headers, headers: headers)
+      Rack::Response.new(
+        nil,
+        302,
+        { 'location' => url }.merge(headers)
+      )
     end
 
     def redirect_to(url, headers: {})
-      Rackr::Action.redirect_to(url, headers: headers, headers: headers)
+      [302, { 'location' => url }.merge(headers), []]
     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,
-        headers: {},
-        config: {},
-        routes: nil,
-        db: nil
-      )
-        view(
-          paths,
-          view_params,
-          status: status,
-          config: config,
-          routes: routes,
-          headers: headers,
-          db: db,
-          response_instance: true
-        )
-      end
-
-      def view(
-        paths,
-        view_params = {},
-        status: 200,
-        headers: {},
-        config: {},
-        routes: 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,
-          routes: routes,
-          db: db
-        )
-
-        if response_instance
-          return Rack::Response.new(
-            erb,
-            status,
-            { 'Content-Type' => 'text/html' }.merge(headers)
-          )
-        end
-
-        [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: {})
-        [status, { 'Content-Type' => 'text/html' }.merge(headers), [content]]
-      end
-
-      def html_response(content, status: 200, headers: {})
-        Rack::Response.new(content, status, { 'Content-Type' => 'text/html' }.merge(headers))
-      end
-
-      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, headers: {})
-        Rack::Response.new(
-          Oj.dump(content, mode: :compat),
-          status,
-          { 'Content-Type' => 'application/json' }.merge(headers)
-        )
-      end
-
-      def text(content, status: 200, headers: {})
-        [status, { 'Content-Type' => 'text/plain' }.merge(headers), [content]]
-      end
-
-      def text_response(content, status: 200, headers: {})
-        Rack::Response.new(
-          content,
-          status,
-          { 'Content-Type' => 'text/plain' }.merge(headers)
-        )
-      end
-
-      # rubocop:disable Lint/UnusedMethodArgument
-      def erb(content, view_params = {}, config: nil, routes: nil, db: nil)
-        @view = OpenStruct.new(view_params)
-
-        eval(Erubi::Engine.new(content).src)
-      end
-      # rubocop:enable Lint/UnusedMethodArgument
-
-      def redirect_response(url, headers: {})
-        Rack::Response.new(
-          nil,
-          302,
-          { 'Location' => url }.merge(headers)
-        )
-      end
-
-      def redirect_to(url, headers: {})
-        [302, { 'Location' => url }.merge(headers), []]
-      end
-
-      def response(body = nil, status = 200, headers = {})
-        Rack::Response.new(body, status, headers)
-      end
-    end
   end
 end

data/lib/rackr/html.rb

@@ -0,0 +1,7 @@
+class Rackr
+  module HTML
+    def self.included(base)
+      base.class_eval { include ::HtmlSlice }
+    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,11 @@
 # frozen_string_literal: true
 
-require_relative 'rackr/router'
 require_relative 'rackr/action'
 require_relative 'rackr/callback'
+require 'html_slice'
+require_relative 'rackr/html'
+require_relative 'rackr/router/errors/dev_html'
+require_relative 'rackr/router'
 
 class Rackr
   class NotFound < StandardError; end
@@ -10,6 +13,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 +37,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.49
+  version: 0.0.51
 platform: ruby
 authors:
 - Henrique F. Teixeira
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-10 00:00:00.000000000 Z
+date: 2025-01-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: erubi
@@ -58,6 +58,26 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: html_slice
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: A complete http router solution that fit well with pure rack apps.
 email: hriqueft@gmail.com
 executables: []
@@ -67,9 +87,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: