hanami-router 1.3.2 → 2.0.0.alpha5

data/lib/hanami/router/block.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Router
+    # Block endpoint
+    #
+    # @api private
+    # @since 2.0.0
+    class Block
+      # Context to handle a single incoming HTTP request for a block endpoint
+      #
+      # @since 2.0.0
+      class Context
+        # @api private
+        # @since 2.0.0
+        def initialize(blk, env)
+          @blk = blk
+          @env = env
+        end
+
+        # Rack env
+        #
+        # @return [Hash] the Rack env
+        #
+        # @since 2.0.0
+        attr_reader :env
+
+        # @overload status
+        #   Gets the current HTTP status code
+        #   @return [Integer] the HTTP status code
+        # @overload status(value)
+        #   Sets the HTTP status
+        #   @param value [Integer] the HTTP status code
+        def status(value = nil)
+          if value
+            @status = value
+          else
+            @status ||= 200
+          end
+        end
+
+        # @overload headers
+        #   Gets the current HTTP headers code
+        #   @return [Integer] the HTTP headers code
+        # @overload headers(value)
+        #   Sets the HTTP headers
+        #   @param value [Integer] the HTTP headers code
+        def headers(value = nil)
+          if value
+            @headers = value
+          else
+            @headers ||= {}
+          end
+        end
+
+        # HTTP Params from URL variables and HTTP body parsing
+        #
+        # @return [Hash] the HTTP params
+        #
+        # @since 2.0.0
+        def params
+          env["router.params"]
+        end
+
+        # @api private
+        # @since 2.0.0
+        def call
+          body = instance_exec(&@blk)
+          [status, headers, [body]]
+        end
+      end
+
+      # @api private
+      # @since 2.0.0
+      def initialize(context_class, blk)
+        @context_class = context_class || Context
+        @blk = blk
+        freeze
+      end
+
+      # @api private
+      # @since 2.0.0
+      def call(env)
+        @context_class.new(@blk, env).call
+      end
+    end
+  end
+end

data/lib/hanami/router/error.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Router
+    # Base error
+    #
+    # @since 0.5.0
+    class Error < StandardError
+    end
+
+    # Missing endpoint error. It's raised when the route definition is missing `to:` endpoint and a block.
+    #
+    # @since 2.0.0
+    class MissingEndpointError < Error
+      def initialize(path)
+        super("missing endpoint for #{path.inspect}")
+      end
+    end
+
+    # Invalid route exception. It's raised when the router cannot recognize a route
+    #
+    # @since 2.0.0
+    class InvalidRouteException < Error
+      def initialize(name)
+        super("No route could be generated for #{name.inspect} - please check given arguments")
+      end
+    end
+
+    # Invalid route expansion exception. It's raised when the router recognizes
+    # a route but given variables cannot be expanded into a path/url
+    #
+    # @since 2.0.0
+    #
+    # @see Hanami::Router#path
+    # @see Hanami::Router#url
+    class InvalidRouteExpansionException < Error
+      def initialize(name, message)
+        super("No route could be generated for `#{name.inspect}': #{message}")
+      end
+    end
+
+    # Handle unknown HTTP status codes
+    #
+    # @since 2.0.0
+    class UnknownHTTPStatusCodeError < Error
+      def initialize(code)
+        super("Unknown HTTP status code: #{code.inspect}")
+      end
+    end
+
+    # This error is raised when <tt>#call</tt> is invoked on a non-routable
+    # recognized route.
+    #
+    # @since 0.5.0
+    #
+    # @see Hanami::Router#recognize
+    # @see Hanami::Router::RecognizedRoute
+    # @see Hanami::Router::RecognizedRoute#call
+    # @see Hanami::Router::RecognizedRoute#routable?
+    class NotRoutableEndpointError < Error
+      # @since 0.5.0
+      def initialize(env)
+        super %(Cannot find routable endpoint for: #{env['REQUEST_METHOD']} #{env['PATH_INFO']})
+      end
+    end
+  end
+end

data/lib/hanami/router/inspector.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Router
+    # Routes inspector
+    #
+    # @api private
+    # @since 2.0.0
+    class Inspector
+      # @api private
+      # @since 2.0.0
+      def initialize(routes: [])
+        @routes = routes
+      end
+
+      # @param route [Hash] serialized route
+      #
+      # @api private
+      # @since 2.0.0
+      def add_route(route)
+        @routes.push(route)
+      end
+
+      # @return [String] The inspected routes
+      #
+      # @api private
+      # @since 2.0.0
+      def call(*)
+        @routes.map(&:to_inspect).join(NEW_LINE)
+      end
+
+      # @api private
+      # @since 2.0.0
+      NEW_LINE = $/
+      private_constant :NEW_LINE
+    end
+  end
+end

data/lib/hanami/router/node.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "hanami/router/segment"
+
+module Hanami
+  class Router
+    # Trie node
+    #
+    # @api private
+    # @since 2.0.0
+    class Node
+      # @api private
+      # @since 2.0.0
+      attr_reader :to
+
+      # @api private
+      # @since 2.0.0
+      def initialize
+        @variable = nil
+        @fixed = nil
+        @to = nil
+      end
+
+      # @api private
+      # @since 2.0.0
+      def put(segment, constraints)
+        if variable?(segment)
+          @variable ||= {}
+          @variable[segment_for(segment, constraints)] ||= self.class.new
+        else
+          @fixed ||= {}
+          @fixed[segment] ||= self.class.new
+        end
+      end
+
+      # @api private
+      # @since 2.0.0
+      #
+      def get(segment) # rubocop:disable Metrics/PerceivedComplexity
+        return unless @variable || @fixed
+
+        found = nil
+        captured = nil
+
+        found = @fixed&.fetch(segment, nil)
+        return [found, nil] if found
+
+        @variable&.each do |matcher, node|
+          break if found
+
+          captured = matcher.match(segment)
+          found = node if captured
+        end
+
+        [found, captured&.named_captures]
+      end
+
+      # @api private
+      # @since 2.0.0
+      def leaf?
+        @to
+      end
+
+      # @api private
+      # @since 2.0.0
+      def leaf!(to)
+        @to = to
+      end
+
+      private
+
+      # @api private
+      # @since 2.0.0
+      def variable?(segment)
+        /:/.match?(segment)
+      end
+
+      # @api private
+      # @since 2.0.0
+      def segment_for(segment, constraints)
+        Segment.fabricate(segment, **constraints)
+      end
+
+      # @api private
+      # @since 2.0.0
+      def fixed?(matcher)
+        matcher.names.empty?
+      end
+    end
+  end
+end

data/lib/hanami/router/params.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Router
+    # Params utilities
+    #
+    # @since 2.0.0
+    # @api private
+    class Params
+      # Deep symbolize Hash params
+      #
+      # @param params [Hash] the params to symbolize
+      #
+      # @return [Hash] the symbolized params
+      #
+      # @api private
+      # @since 2.0.0
+      def self.deep_symbolize(params)
+        params.each_with_object({}) do |(key, value), output|
+          output[key.to_sym] =
+            case value
+            when ::Hash
+              deep_symbolize(value)
+            when Array
+              value.map do |item|
+                item.is_a?(::Hash) ? deep_symbolize(item) : item
+              end
+            else
+              value
+            end
+        end
+      end
+    end
+  end
+end

data/lib/hanami/router/prefix.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Router
+    # URL Path prefix
+    #
+    # @since 2.0.0
+    # @api private
+    class Prefix
+      # @since 2.0.0
+      # @api private
+      def initialize(prefix)
+        @prefix = prefix
+      end
+
+      # @since 2.0.0
+      # @api private
+      def join(path)
+        self.class.new(
+          _join(path)
+        )
+      end
+
+      # @since 2.0.0
+      # @api private
+      def relative_join(path, separator = DEFAULT_SEPARATOR)
+        _join(path.to_s)
+          .gsub(DEFAULT_SEPARATOR_REGEXP, separator)[1..]
+      end
+
+      # @since 2.0.0
+      # @api private
+      def to_s
+        @prefix
+      end
+
+      # @since 2.0.0
+      # @api private
+      def to_sym
+        @prefix.to_sym
+      end
+
+      private
+
+      # @since 2.0.0
+      # @api private
+      DEFAULT_SEPARATOR = "/"
+
+      # @since 2.0.0
+      # @api private
+      DEFAULT_SEPARATOR_REGEXP = /\//.freeze
+
+      # @since 2.0.0
+      # @api private
+      DOUBLE_DEFAULT_SEPARATOR_REGEXP = /\/{2,}/.freeze
+
+      # @since 2.0.0
+      # @api private
+      def _join(path)
+        return @prefix if path == DEFAULT_SEPARATOR
+
+        (@prefix + DEFAULT_SEPARATOR + path)
+          .gsub(DOUBLE_DEFAULT_SEPARATOR_REGEXP, DEFAULT_SEPARATOR)
+      end
+    end
+  end
+end

data/lib/hanami/router/recognized_route.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Hanami
+  class Router
+    # Represents a result of router path recognition.
+    #
+    # @since 0.5.0
+    #
+    # @see Hanami::Router#recognize
+    class RecognizedRoute
+      def initialize(endpoint, env)
+        @endpoint = endpoint
+        @env = env
+      end
+
+      # Rack protocol compatibility
+      #
+      # @param env [Hash] Rack env
+      #
+      # @return [Array] serialized Rack response
+      #
+      # @raise [Hanami::Router::NotRoutableEndpointError] if not routable
+      #
+      # @since 0.5.0
+      # @api public
+      #
+      # @see Hanami::Router::RecognizedRoute#routable?
+      # @see Hanami::Router::NotRoutableEndpointError
+      def call(env)
+        if routable?
+          @endpoint.call(env)
+        else
+          raise NotRoutableEndpointError.new(@env)
+        end
+      end
+
+      # HTTP verb (aka method)
+      #
+      # @return [String]
+      #
+      # @since 0.5.0
+      # @api public
+      def verb
+        @env["REQUEST_METHOD"]
+      end
+
+      # Relative URL (path)
+      #
+      # @return [String]
+      #
+      # @since 0.7.0
+      # @api public
+      def path
+        @env["PATH_INFO"]
+      end
+
+      # @since 0.7.0
+      # @api public
+      def params
+        @env["router.params"]
+      end
+
+      # @since 0.7.0
+      # @api public
+      def endpoint
+        return nil if redirect?
+
+        @endpoint
+      end
+
+      # @since 0.7.0
+      # @api public
+      def routable?
+        !@endpoint.nil?
+      end
+
+      # @since 0.7.0
+      # @api public
+      def redirect?
+        @endpoint.is_a?(Redirect)
+      end
+
+      # @since 0.7.0
+      # @api public
+      def redirection_path
+        return nil unless redirect?
+
+        @endpoint.destination
+      end
+    end
+  end
+end