hanami-router 1.3.2 → 2.0.0.alpha1

data/lib/hanami/router/version.rb

@@ -1,6 +1,8 @@
+# frozen_string_literal: true
+
 module Hanami
   class Router
     # @since 0.1.0
-    VERSION = '1.3.2'.freeze
+    VERSION = "2.0.0.alpha1"
   end
 end

data/lib/hanami/routing.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+require "uri"
+require "rack/utils"
+require "mustermann/rails"
+
+# Hanami
+#
+# @since 0.1.0
+module Hanami
+  # Hanami routing
+  #
+  # @since 0.1.0
+  module Routing
+    PATH_INFO      = "PATH_INFO"
+    QUERY_STRING   = "QUERY_STRING"
+    REQUEST_METHOD = "REQUEST_METHOD"
+
+    HTTP_VERBS = %w[get post delete put patch trace options link unlink].freeze
+
+    PARAMS = "router.params"
+
+    def self.http_verbs
+      HTTP_VERBS
+    end
+
+    # @since 0.5.0
+    class Error < ::StandardError
+    end
+
+    # Invalid route
+    # This is raised when the router fails to recognize a route, because of the
+    # given arguments.
+    #
+    # @since 0.1.0
+    class InvalidRouteException < Error
+    end
+
+    # Endpoint not found
+    # This is raised when the router fails to load an endpoint at the runtime.
+    #
+    # @since 0.1.0
+    class EndpointNotFound < Error
+    end
+
+    # @since 2.0.0
+    class NotCallableEndpointError < Error
+      def initialize(endpoint)
+        super("#{endpoint.inspect} isn't compatible with Rack. Please make sure it implements #call.")
+      end
+    end
+
+    # HTTP redirect
+    #
+    # @since 2.0.0
+    # @api private
+    class Redirect
+      # @since 2.0.0
+      # @api private
+      LOCATION = "Location"
+
+      # @since 2.0.0
+      # @api private
+      STATUS_RANGE = (300..399).freeze
+
+      attr_reader :path
+      alias destination_path path
+
+      # Instantiate a new redirect
+      #
+      # @param path [String] a relative or absolute URI
+      # @param status [Integer] a redirect status (an integer between `300` and `399`)
+      #
+      # @return [Hanami::Routing::Redirect] a new instance
+      #
+      # @raise [ArgumentError] if path is nil, or status code isn't a redirect
+      #
+      # @since 2.0.0
+      # @api private
+      def initialize(path, status)
+        raise ArgumentError.new("Path is nil") if path.nil?
+        raise ArgumentError.new("Status code isn't a redirect: #{status.inspect}") unless STATUS_RANGE.include?(status)
+
+        @path   = path
+        @status = status
+        freeze
+      end
+
+      def call(*)
+        [@status, { LOCATION => @path }, []]
+      end
+
+      def redirect?
+        true
+      end
+    end
+
+    # Route
+    #
+    # @since 0.1.0
+    # @api private
+    class Route
+      # @since 0.7.0
+      # @api private
+      def initialize(verb, path, endpoint, constraints)
+        @verb     = verb
+        @path     = Mustermann.new(path, type: :rails, version: "5.0", capture: constraints)
+        @endpoint = endpoint
+        freeze
+      end
+
+      # @since 0.1.0
+      # @api private
+      def call(env)
+        env[PARAMS] ||= {}
+        env[PARAMS].merge!(Rack::Utils.parse_nested_query(env[QUERY_STRING]))
+        env[PARAMS].merge!(@path.params(env[PATH_INFO]))
+        env[PARAMS] = Utils::Hash.deep_symbolize(env[PARAMS])
+
+        @endpoint.call(env)
+      end
+
+      # @since 0.1.0
+      # @api private
+      def path(args)
+        @path.expand(:append, args)
+      rescue Mustermann::ExpandError => e
+        raise Hanami::Routing::InvalidRouteException.new(e.message)
+      end
+
+      # @since 2.0.0
+      # @api private
+      def match?(env)
+        match_path?(env) &&
+          @verb.include?(env[REQUEST_METHOD])
+      end
+
+      # @since 2.0.0
+      # @api private
+      def match_path?(env)
+        @path =~ env[PATH_INFO]
+      end
+    end
+
+    # @since 2.0.0
+    # @api private
+    module Uri
+      # @since 2.0.0
+      # @api private
+      HTTP  = "http"
+
+      # @since 2.0.0
+      # @api private
+      HTTPS = "https"
+
+      # @since 2.0.0
+      # @api private
+      DEFAULT_SCHEME = HTTP
+
+      # Build a URI string from the given arguments
+      #
+      # @param scheme [String] the URI scheme: one of `"http"` or `"https"`
+      # @param host [String] the URI host
+      # @param port [String,Integer] the URI port
+      #
+      # @raise [ArgumentError] if one of `scheme`, `host`, `port` is `nil`, or
+      #   if `scheme` is unknown
+      #
+      # @since 2.0.0
+      # @api private
+      def self.build(scheme:, host:, port:)
+        raise ArgumentError.new("host is nil") if host.nil?
+        raise ArgumentError.new("port is nil") if port.nil?
+
+        case scheme
+        when HTTP
+          URI::HTTP
+        when HTTPS
+          URI::HTTPS
+        else
+          raise ArgumentError.new("Unknown scheme: #{scheme.inspect}")
+        end.build(scheme: scheme, host: host, port: port).to_s
+      end
+    end
+
+    require "hanami/routing/endpoint"
+    require "hanami/routing/prefix"
+    require "hanami/routing/scope"
+    require "hanami/routing/resource"
+    require "hanami/routing/resources"
+    require "hanami/routing/recognized_route"
+  end
+end

data/lib/hanami/routing/endpoint.rb

@@ -1,57 +1,77 @@
-require 'delegate'
-require 'hanami/routing/error'
-require 'hanami/utils/class'
+# frozen_string_literal: true
+
+require "delegate"
+require "hanami/utils/class"
+require "hanami/utils/string"
 
 module Hanami
   module Routing
-    # Endpoint not found
-    # This is raised when the router fails to load an endpoint at the runtime.
-    #
-    # @since 0.1.0
-    class EndpointNotFound < Hanami::Routing::Error
-    end
-
-    # Routing endpoint
-    # This is the object that responds to an HTTP request made against a certain
-    # path.
-    #
-    # The router will use this class for:
-    #
-    #   * Procs and any Rack compatible object (respond to #call)
-    #
-    # @since 0.1.0
+    # Routes endpoint
     #
+    # @since 2.0.0
     # @api private
-    #
-    # @example
-    #   require 'hanami/router'
-    #
-    #   Hanami::Router.new do
-    #     get '/proc',     to: ->(env) { [200, {}, ['This will use Hanami::Routing::Endpoint']] }
-    #     get '/rack-app', to: RackApp.new
-    #   end
-    class Endpoint < SimpleDelegator
-      # @since 0.2.0
+    module Endpoint
+      # @since 2.0.0
       # @api private
-      def inspect
-        case __getobj__
-        when Proc
-          source, line     = __getobj__.source_location
-          lambda_inspector = " (lambda)"  if  __getobj__.lambda?
-
-          "#<Proc@#{ ::File.expand_path(source) }:#{ line }#{ lambda_inspector }>"
-        when Class
-          __getobj__
-        else
-          "#<#{ __getobj__.class }>"
-        end
-      end
+      #
+      # FIXME: Shall this be the default of Utils::Class.load! ?
+      DEFAULT_NAMESPACE = Object
 
-      # @since 1.0.0
+      # Controller / action separator for Hanami
+      #
+      # @since 2.0.0
       # @api private
-      def routable?
-        !__getobj__.nil?
-      rescue ArgumentError
+      #
+      # @example
+      #   require "hanami/router"
+      #
+      #   Hanami::Router.new do
+      #     get "/home", to: "home#index"
+      #   end
+      ACTION_SEPARATOR = "#"
+
+      # Replacement to load an action from the string name.
+      #
+      # Please note that the `"/"` value is required by `Hanami::Utils::String#classify`.
+      #
+      # Given the `"home#index"` string, with the `Web::Controllers` namespace,
+      # it will try to load `Web::Controllers::Home::Index` action.
+      #
+      # @since 2.0.0
+      # @api private
+      ACTION_SEPARATOR_REPLACEMENT = "/"
+
+      # Find an endpoint for the given name
+      #
+      # @param name [String,Class,Proc,Object] the endpoint expressed as name
+      #   (`String`), as a Rack class application (`Class`), as a Rack
+      #   compatible proc (`Proc`), or as any other Rack compatible object
+      #   (`Object`)
+      # @param namespace [Module] the Ruby module where to lookup the endpoint
+      # @param configuration [Hanami::Controller::Configuration] the action
+      #   configuration
+      #
+      # @raise [Hanami::Routing::NotCallableEndpointError] if the found object
+      #   doesn't implement Rack protocol (`#call`)
+      #
+      # @return [Object, Hanami::Routing::LazyEndpoint] a Rack compatible
+      #   endpoint
+      #
+      # @since 2.0.0
+      # @api private
+      def self.find(name, namespace, configuration = nil)
+        endpoint = case name
+                   when String
+                     find_string(name, namespace || DEFAULT_NAMESPACE, configuration)
+                   when Class
+                     name.respond_to?(:call) ? name : name.new
+                   else
+                     name
+                   end
+
+        raise NotCallableEndpointError.new(endpoint) unless endpoint.respond_to?(:call)
+
+        endpoint
       end
 
       # @since 1.0.1
@@ -64,42 +84,47 @@ module Hanami
       # @api private
       def destination_path
       end
-    end
 
-    # Routing endpoint
-    # This is the object that responds to an HTTP request made against a certain
-    # path.
-    #
-    # The router will use this class for:
-    #
-    #   * Classes
-    #   * Hanami::Action endpoints referenced as a class
-    #   * Hanami::Action endpoints referenced a string
-    #   * RESTful resource(s)
-    #
-    # @since 0.1.0
-    #
-    # @api private
-    #
-    # @example
-    #   require 'hanami/router'
-    #
-    #   Hanami::Router.new do
-    #     get '/class',               to: RackMiddleware
-    #     get '/hanami-action-class',  to: Dashboard::Index
-    #     get '/hanami-action-string', to: 'dashboard#index'
-    #
-    #     resource  'identity'
-    #     resources 'articles'
-    #   end
-    class ClassEndpoint < Endpoint
-      # Rack interface
+      # Find an endpoint from its name
       #
-      # @since 0.1.0
+      # @param name [String] the endpoint name
+      # @param namespace [Module] the Ruby module where to lookup the endpoint
+      # @param configuration [Hanami::Controller::Configuration] the action
+      #   configuration
+      #
+      # @return [Object, Hanami::Routing::LazyEndpoint] a Rack compatible
+      #   endpoint
+      #
+      # @since 2.0.0
       # @api private
-      def call(env)
-        __getobj__.new.call(env)
+      #
+      # @example Basic Usage
+      #   Hanami::Routing::Endpoint.find("MyMiddleware")
+      #     # => #<MyMiddleware:0x007ff6df06f468>
+      #
+      # @example Hanami Action
+      #   Hanami::Routing::Endpoint.find("home#index", Web::Controllers)
+      #     # => #<Web::Controllers::Home::Index:0x007ff6df06f468>
+      def self.find_string(name, namespace, configuration)
+        n     = Utils::String.new(name.sub(ACTION_SEPARATOR, ACTION_SEPARATOR_REPLACEMENT)).classify.to_s
+        klass = Utils::Class.load!(n, namespace)
+
+        if hanami_action?(name, n)
+          klass.new(configuration: configuration)
+        else
+          klass.new
+        end
+      rescue NameError
+        Hanami::Routing::LazyEndpoint.new(n, namespace)
       end
+
+      private_class_method :find_string
+
+      def self.hanami_action?(name, endpoint)
+        name != endpoint
+      end
+
+      private_class_method :hanami_action?
     end
 
     # Routing endpoint
@@ -121,13 +146,14 @@ module Hanami
     # @api private
     #
     # @see Hanami::Routing::ClassEndpoint
-    class LazyEndpoint < Endpoint
+    class LazyEndpoint < SimpleDelegator
       # Initialize the lazy endpoint
       #
       # @since 0.1.0
       # @api private
       def initialize(name, namespace)
-        @name, @namespace = name, namespace
+        @name      = name
+        @namespace = namespace
       end
 
       # Rack interface
@@ -143,19 +169,32 @@ module Hanami
       # @since 0.2.0
       # @api private
       def inspect
-        # TODO review this implementation once the namespace feature will be
+        # TODO: review this implementation once the namespace feature will be
         # cleaned up.
-        result = klass rescue nil
+        result = begin
+                   klass
+                 rescue
+                   nil
+                 end
 
         if result.nil?
           result = @name
-          result = "#{ @namespace }::#{ result }" if @namespace != Object
+          result = "#{@namespace}::#{result}" if @namespace != Object
         end
 
         result
       end
 
+      # @since 1.0.0
+      # @api private
+      def routable?
+        !__getobj__.nil?
+      rescue ArgumentError
+        false
+      end
+
       private
+
       # @since 0.1.0
       # @api private
       def obj
@@ -170,26 +209,5 @@ module Hanami
         raise EndpointNotFound.new(e.message)
       end
     end
-
-    # @since 1.0.1
-    # @api private
-    class RedirectEndpoint < Endpoint
-      # @since 1.0.1
-      # @api private
-      attr_reader :destination_path
-
-      # @since 1.0.1
-      # @api private
-      def initialize(destination_path, destination)
-        @destination_path = destination_path
-        super(destination)
-      end
-
-      # @since 1.0.1
-      # @api private
-      def redirect?
-        true
-      end
-    end
   end
 end