hanami-router 2.0.0.alpha3 → 2.0.0

data/lib/hanami/middleware/body_parser/parser.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Middleware
+    class BodyParser
+      # Body parser abstract class
+      #
+      # @since 2.0.0
+      class Parser
+        DEFAULT_MIME_TYPES = [].freeze
+
+        # Return supported mime types
+        #
+        # @return [Array<String>] supported MIME types
+        #
+        # @abstract
+        # @since 2.0.0
+        #
+        # @example
+        #   require "hanami/middleware/body_parser"
+        #
+        #   class XMLParser < Hanami::Middleware::BodyParser::Parser
+        #     def self.mime_types
+        #       ["application/xml", "text/xml"]
+        #     end
+        #   end
+        attr_reader :mime_types
+
+        # @api private
+        def initialize(mime_types: DEFAULT_MIME_TYPES)
+          @mime_types = self.class.mime_types + mime_types
+        end
+
+        # Parse raw HTTP request body
+        #
+        # @param body [String] HTTP request body
+        #
+        # @return [Hash] the result of the parsing
+        #
+        # @raise [Hanami::Middleware::BodyParser::BodyParsingError] the error
+        #   that must be raised if the parsing cannot be accomplished
+        #
+        # @abstract
+        # @since 2.0.0
+        #
+        # @example
+        #   require "hanami/middleware/body_parser"
+        #
+        #   class XMLParser < Hanami::Middleware::BodyParser::Parser
+        #     def parse(body)
+        #       # XML parsing
+        #       # ...
+        #     rescue => exception
+        #       raise Hanami::Middleware::BodyParser::BodyParsingError.new(exception.message)
+        #     end
+        #   end
+        def parse(body) # rubocop:disable Lint/UnusedMethodArgument
+          raise NoMethodError
+        end
+      end
+    end
+  end
+end

data/lib/hanami/middleware/body_parser.rb

@@ -2,20 +2,23 @@
 
 require "hanami/router/params"
 require "hanami/middleware/error"
-require_relative "body_parser/class_interface"
+require_relative "../router/constants"
 
 module Hanami
   module Middleware
     # @since 1.3.0
     # @api private
     class BodyParser
+      require_relative "body_parser/class_interface"
+      require_relative "body_parser/parser"
+
       # @since 1.3.0
       # @api private
       CONTENT_TYPE = "CONTENT_TYPE"
 
       # @since 1.3.0
       # @api private
-      MEDIA_TYPE_MATCHER = /\s*[;,]\s*/.freeze
+      MEDIA_TYPE_MATCHER = /\s*[;,]\s*/
 
       # @since 1.3.0
       # @api private
@@ -25,9 +28,6 @@ module Hanami
       # @api private
       ROUTER_PARAMS = "router.params"
 
-      # @api private
-      ROUTER_PARSED_BODY = "router.parsed_body"
-
       # @api private
       FALLBACK_KEY = "_"
 
@@ -35,7 +35,7 @@ module Hanami
 
       def initialize(app, parsers)
         @app = app
-        @parsers = build_parsers(parsers)
+        @parsers = parsers
       end
 
       def call(env)
@@ -45,8 +45,8 @@ module Hanami
         env[RACK_INPUT].rewind # somebody might try to read this stream
 
         if (parser = @parsers[media_type(env)])
-          env[ROUTER_PARSED_BODY] = parser.parse(body)
-          env[ROUTER_PARAMS] = _symbolize(env[ROUTER_PARSED_BODY])
+          env[Router::ROUTER_PARSED_BODY] = parser.parse(body)
+          env[ROUTER_PARAMS] = _symbolize(env[Router::ROUTER_PARSED_BODY])
         end
 
         @app.call(env)
@@ -54,25 +54,12 @@ module Hanami
 
       private
 
-      def build_parsers(parser_names)
-        parser_names = Array(parser_names)
-        return {} if parser_names.empty?
-
-        parser_names.each_with_object({}) do |name, parsers|
-          parser = self.class.for(name)
-
-          parser.mime_types.each do |mime|
-            parsers[mime] = parser
-          end
-        end
-      end
-
       # @api private
       def _symbolize(body)
         if body.is_a?(::Hash)
           Router::Params.deep_symbolize(body)
         else
-          { FALLBACK_KEY => body }
+          {FALLBACK_KEY => body}
         end
       end
 

data/lib/hanami/middleware/error.rb

@@ -5,7 +5,7 @@ module Hanami
   #
   # @since 1.3.0
   module Middleware
-    unless defined?(Error)
+    unless defined?(::Hanami::Middleware::Error)
       # Base error for Rack middleware
       #
       # @since 2.0.0

data/lib/hanami/middleware/node.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Hanami
+  module Middleware
+    # Trie node to register scopes with custom Rack middleware
+    #
+    # @api private
+    # @since 2.0.0
+    class Node
+      # @api private
+      # @since 2.0.0
+      attr_reader :app
+
+      # @api private
+      # @since 2.0.0
+      def initialize
+        @app = nil
+        @children = {}
+      end
+
+      # @api private
+      # @since 2.0.0
+      def freeze
+        @children.freeze
+        super
+      end
+
+      # @api private
+      # @since 2.0.0
+      def put(segment)
+        @children[segment] ||= self.class.new
+      end
+
+      # @api private
+      # @since 2.0.0
+      def get(segment)
+        @children.fetch(segment) { self if leaf? }
+      end
+
+      # @api private
+      # @since 2.0.0
+      def app!(app)
+        @app = app
+      end
+
+      # @api private
+      # @since 2.0.0
+      def app?
+        !@app.nil?
+      end
+
+      # @api private
+      # @since 2.0.0
+      def leaf?
+        @children.empty?
+      end
+    end
+  end
+end

data/lib/hanami/middleware/trie.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative "./node"
+
+module Hanami
+  module Middleware
+    # Trie to register scopes with custom Rack middleware
+    #
+    # @api private
+    # @since 2.0.0
+    class Trie
+      # @api private
+      # @since 2.0.0
+      def initialize(app)
+        @app = app
+        @root = Node.new
+      end
+
+      # @api private
+      # @since 2.0.0
+      def freeze
+        @root.freeze
+        super
+      end
+
+      # @api private
+      # @since 2.0.0
+      def add(path, app)
+        node = @root
+        for_each_segment(path) do |segment|
+          node = node.put(segment)
+        end
+
+        node.app!(app)
+      end
+
+      # @api private
+      # @since 2.0.0
+      def find(path)
+        node = @root
+
+        for_each_segment(path) do |segment|
+          break unless node
+
+          node = node.get(segment)
+        end
+
+        return node.app if node&.app?
+
+        @root.app || @app
+      end
+
+      # @api private
+      # @since 2.0.0
+      def empty?
+        @root.leaf?
+      end
+
+      private
+
+      # @api private
+      # @since 2.0.0
+      def for_each_segment(path, &blk)
+        _, *segments = path.split(/\//)
+        segments.each(&blk)
+      end
+    end
+  end
+end

data/lib/hanami/router/block.rb

@@ -35,7 +35,7 @@ module Hanami
           if value
             @status = value
           else
-            @status ||= 200
+            @status ||= Router::HTTP_STATUS_OK
           end
         end
 
@@ -59,7 +59,7 @@ module Hanami
         #
         # @since 2.0.0
         def params
-          env["router.params"]
+          env[Router::PARAMS]
         end
 
         # @api private

data/lib/hanami/router/constants.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Router
+    # @api private
+    # @since 2.0.0
+    ROUTER_PARSED_BODY = "router.parsed_body"
+  end
+end

data/lib/hanami/router/errors.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Router
+    # Base class for all Hanami::Router errors.
+    #
+    # @since 0.5.0
+    # @api public
+    class Error < StandardError
+    end
+
+    # Error raised when no endpoint is specified for a route.
+    #
+    # Endpoints must be specified by `to:` or a block.
+    #
+    # @since 2.0.0
+    # @api public
+    class MissingEndpointError < Error
+      # @since 2.0.0
+      # @api private
+      def initialize(path)
+        super("missing endpoint for #{path.inspect}")
+      end
+    end
+
+    # Error raised when a named route could not be found.
+    #
+    # @see Hanami::Router#path
+    # @see Hanami::Router#url
+    #
+    # @since 2.0.0
+    # @api public
+    class MissingRouteError < Error
+      # @since 2.0.0
+      # @api private
+      def initialize(name)
+        super("No route could be found with name #{name.inspect}")
+      end
+    end
+
+    # Error raised when variables given for route cannot be expanded into a full path.
+    #
+    # @see Hanami::Router#path
+    # @see Hanami::Router#url
+    #
+    # @since 2.0.0
+    # @api public
+    class InvalidRouteExpansionError < Error
+      # @since 2.0.0
+      # @api private
+      def initialize(name, message)
+        super("No route could be generated for `#{name.inspect}': #{message}")
+      end
+    end
+
+    # Error raised when an unknown HTTP status code is given.
+    #
+    # @see Hanami::Router#redirect
+    #
+    # @since 2.0.0
+    # @api public
+    class UnknownHTTPStatusCodeError < Error
+      # @since 2.0.0
+      # @api private
+      def initialize(code)
+        super("Unknown HTTP status code: #{code.inspect}")
+      end
+    end
+
+    # Error raised when a recognized route is called but has no callable endpoint.
+    #
+    # @see Hanami::Router#recognize
+    # @see Hanami::Router::RecognizedRoute#call
+    #
+    # @since 0.5.0
+    # @api public
+    class NotRoutableEndpointError < Error
+      # @since 0.5.0
+      # @api private
+      def initialize(env)
+        super %(Cannot find routable endpoint for: #{env[::Rack::REQUEST_METHOD]} #{env[::Rack::PATH_INFO]})
+      end
+    end
+  end
+end

data/lib/hanami/router/formatter/csv.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "csv"
+
+module Hanami
+  class Router
+    # Renders a CSV representation of the routes
+    #
+    # You can forward [CSV generation
+    # options](https://ruby-doc.org/stdlib-3.1.0/libdoc/csv/rdoc/CSV.html#class-CSV-label-Options+for+Generating]
+    # when calling it:
+    #
+    # ```
+    # require "hanami/router/inspector"
+    # require "hanami/router/formatter/csv"
+    #
+    # Hanami::Router::Inspector.new(
+    #   routes: Router.routes,
+    #   formatter: Hanami::Router::Formatter::CSV.new
+    # ).call(write_headers: false)
+    # ```
+    #
+    # @api private
+    # @since 2.0.0
+    module Formatter
+      class CSV
+        # @api private
+        # @since 2.0.0
+        DEFAULT_OPTIONS = {
+          write_headers: true
+        }.freeze
+
+        # @api private
+        # @since 2.0.0
+        HEADERS = %w[METHOD PATH TO AS CONSTRAINTS].freeze
+
+        # @api private
+        # @since 2.0.0
+        def call(routes, **csv_opts)
+          ::CSV.generate(**DEFAULT_OPTIONS.merge(csv_opts)) do |csv|
+            csv << HEADERS if csv.write_headers?
+            routes.reduce(csv) do |acc, route|
+              route.head? ? acc : acc << row(route)
+            end
+          end
+        end
+
+        private
+
+        def row(route)
+          [
+            route.http_method.to_s,
+            route.path,
+            route.inspect_to,
+            route.as? ? route.inspect_as : "",
+            route.constraints? ? route.inspect_constraints : ""
+          ]
+        end
+      end
+    end
+  end
+end

data/lib/hanami/router/formatter/human_friendly.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Router
+    # Renders a human friendly representation of the routes
+    #
+    # @api private
+    # @since 2.0.0
+    module Formatter
+      class HumanFriendly
+        # @api private
+        # @since 2.0.0
+        NEW_LINE = $/
+        private_constant :NEW_LINE
+
+        # @api private
+        # @since 2.0.0
+        SMALL_STRING_JUSTIFY_AMOUNT = 8
+        private_constant :SMALL_STRING_JUSTIFY_AMOUNT
+
+        # @api private
+        # @since 2.0.0
+        MEDIUM_STRING_JUSTIFY_AMOUNT = 20
+        private_constant :MEDIUM_STRING_JUSTIFY_AMOUNT
+
+        # @api private
+        # @since 2.0.0
+        LARGE_STRING_JUSTIFY_AMOUNT = 30
+        private_constant :LARGE_STRING_JUSTIFY_AMOUNT
+
+        # @api private
+        # @since 2.0.0
+        EXTRA_LARGE_STRING_JUSTIFY_AMOUNT = 40
+        private_constant :EXTRA_LARGE_STRING_JUSTIFY_AMOUNT
+
+        # @api private
+        # @since 2.0.0
+        def call(routes)
+          routes.filter_map(&method(:format_route_unless_head)).join(NEW_LINE)
+        end
+
+        private
+
+        def format_route_unless_head(route)
+          !route.head? &&
+            [
+              route.http_method.to_s.ljust(SMALL_STRING_JUSTIFY_AMOUNT),
+              route.path.ljust(LARGE_STRING_JUSTIFY_AMOUNT),
+              route.inspect_to.ljust(LARGE_STRING_JUSTIFY_AMOUNT),
+              route.as? ? "as #{route.inspect_as}".ljust(MEDIUM_STRING_JUSTIFY_AMOUNT) : "",
+              route.constraints? ? "(#{route.inspect_constraints})".ljust(EXTRA_LARGE_STRING_JUSTIFY_AMOUNT) : ""
+            ].join
+        end
+      end
+    end
+  end
+end

data/lib/hanami/router/inspector.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require "hanami/router/formatter/human_friendly"
+
+module Hanami
+  class Router
+    # Builds a representation of an array of routes according to a given formatter.
+    #
+    # @see Router.new
+    #
+    # @since 2.0.0
+    # @api private
+    class Inspector
+      # @param routes [Array<Hanami::Route>]
+      # @param formatter [#call] routes formatter, taking routes as an argument and returning its
+      #   own representation (typically a string). Defaults to {Formatter::HumanFriendly}.
+      #
+      # @since 2.0.0
+      # @api public
+      def initialize(routes: [], formatter: Formatter::HumanFriendly.new)
+        @routes = routes
+        @formatter = formatter
+      end
+
+      # Adds a route to be inspected.
+      #
+      # @param route [Route]
+      #
+      # @since 2.0.0
+      # @api public
+      def add_route(route)
+        @routes.push(route)
+      end
+
+      # Calls the formatter for all added routes.
+      #
+      # @return [Any] Formatted routes
+      #
+      # @since 2.0.0
+      # @api public
+      def call(...)
+        @formatter.call(@routes, ...)
+      end
+    end
+  end
+end

data/lib/hanami/router/node.rb

@@ -36,8 +36,7 @@ module Hanami
       # @api private
       # @since 2.0.0
       #
-      # rubocop:disable Metrics/MethodLength
-      def get(segment)
+      def get(segment) # rubocop:disable Metrics/PerceivedComplexity
         return unless @variable || @fixed
 
         found = nil
@@ -55,7 +54,6 @@ module Hanami
 
         [found, captured&.named_captures]
       end
-      # rubocop:enable Metrics/MethodLength
 
       # @api private
       # @since 2.0.0
@@ -74,7 +72,7 @@ module Hanami
       # @api private
       # @since 2.0.0
       def variable?(segment)
-        /:/.match?(segment)
+        Router::ROUTE_VARIABLE_MATCHER.match?(segment)
       end
 
       # @api private

data/lib/hanami/router/params.rb

@@ -15,7 +15,7 @@ module Hanami
       #
       # @api private
       # @since 2.0.0
-      def self.deep_symbolize(params) # rubocop:disable Metrics/MethodLength
+      def self.deep_symbolize(params)
         params.each_with_object({}) do |(key, value), output|
           output[key.to_sym] =
             case value

data/lib/hanami/router/prefix.rb

@@ -25,7 +25,7 @@ module Hanami
       # @api private
       def relative_join(path, separator = DEFAULT_SEPARATOR)
         _join(path.to_s)
-          .gsub(DEFAULT_SEPARATOR_REGEXP, separator)[1..-1]
+          .gsub(DEFAULT_SEPARATOR_REGEXP, separator)[1..]
       end
 
       # @since 2.0.0
@@ -48,11 +48,11 @@ module Hanami
 
       # @since 2.0.0
       # @api private
-      DEFAULT_SEPARATOR_REGEXP = /\//.freeze
+      DEFAULT_SEPARATOR_REGEXP = /\//
 
       # @since 2.0.0
       # @api private
-      DOUBLE_DEFAULT_SEPARATOR_REGEXP = /[\/]{2,}/.freeze
+      DOUBLE_DEFAULT_SEPARATOR_REGEXP = /\/{2,}/
 
       # @since 2.0.0
       # @api private