hanami-router 0.0.0 → 0.6.0

data/lib/hanami/router/version.rb

@@ -1,5 +1,6 @@
 module Hanami
-  module Router
-    VERSION = "0.0.0"
+  class Router
+    # @since 0.1.0
+    VERSION = '0.6.0'.freeze
   end
 end

data/lib/hanami/routing/endpoint.rb

@@ -0,0 +1,151 @@
+require 'delegate'
+require 'hanami/routing/error'
+require 'hanami/utils/class'
+
+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
+    #
+    # @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
+      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
+    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
+      #
+      # @since 0.1.0
+      def call(env)
+        __getobj__.new.call(env)
+      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 the same use cases of `ClassEndpoint`,
+    # but when the target class can't be found, instead of raise a `LoadError`
+    # we reference in a lazy endpoint.
+    #
+    # For each incoming HTTP request, it will look for the referenced class,
+    # then it will instantiate and invoke #call on the object.
+    #
+    # This behavior is required to solve a chicken-egg situation when we try
+    # to load the router first and then the application with all its endpoints.
+    #
+    # @since 0.1.0
+    #
+    # @api private
+    #
+    # @see Hanami::Routing::ClassEndpoint
+    class LazyEndpoint < Endpoint
+      # Initialize the lazy endpoint
+      #
+      # @since 0.1.0
+      def initialize(name, namespace)
+        @name, @namespace = name, namespace
+      end
+
+      # Rack interface
+      #
+      # @raise [EndpointNotFound] when the endpoint can't be found.
+      #
+      # @since 0.1.0
+      def call(env)
+        obj.call(env)
+      end
+
+      # @since 0.2.0
+      def inspect
+        # TODO review this implementation once the namespace feature will be
+        # cleaned up.
+        result = klass rescue nil
+
+        if result.nil?
+          result = @name
+          result = "#{ @namespace }::#{ result }" if @namespace != Object
+        end
+
+        result
+      end
+
+      private
+      # @since 0.1.0
+      # @api private
+      def obj
+        klass.new
+      end
+
+      # @since 0.2.0
+      # @api private
+      def klass
+        Utils::Class.load!(@name, @namespace)
+      rescue NameError => e
+        raise EndpointNotFound.new(e.message)
+      end
+    end
+  end
+end

data/lib/hanami/routing/endpoint_resolver.rb

@@ -0,0 +1,225 @@
+require 'hanami/utils/string'
+require 'hanami/utils/class'
+require 'hanami/routing/endpoint'
+
+module Hanami
+  module Routing
+    # Resolve duck-typed endpoints
+    #
+    # @since 0.1.0
+    #
+    # @api private
+    class EndpointResolver
+      # @since 0.2.0
+      # @api private
+      NAMING_PATTERN = '%{controller}::%{action}'.freeze
+
+      # Default separator for controller and action.
+      # A different separator can be passed to #initialize with the `:separator` option.
+      #
+      # @see #initialize
+      # @see #resolve
+      #
+      # @since 0.1.0
+      #
+      # @example
+      #   require 'hanami/router'
+      #
+      #   router = Hanami::Router.new do
+      #     get '/', to: 'articles#show'
+      #   end
+      ACTION_SEPARATOR = '#'.freeze
+
+      attr_reader :action_separator
+
+      # Initialize an endpoint resolver
+      #
+      # @param options [Hash] the options used to customize lookup behavior
+      #
+      # @option options [Class] :endpoint the endpoint class that is returned
+      #   by `#resolve`. (defaults to `Hanami::Routing::Endpoint`)
+      #
+      # @option options [Class,Module] :namespace the Ruby namespace where to
+      #   lookup for controllers and actions. (defaults to `Object`)
+      #
+      # @option options [String] :pattern the string to interpolate in order
+      #   to return an action name. This string SHOULD contain
+      #   <tt>'%{controller}'</tt> and <tt>'%{action}'</tt>, all the other keys
+      #   will be ignored.
+      #   See the examples below.
+      #
+      # @option options [String] :action_separator the sepatator between controller and
+      #   action name. (defaults to `ACTION_SEPARATOR`)
+      #
+      # @return [Hanami::Routing::EndpointResolver] self
+      #
+      # @since 0.1.0
+      #
+      # @example Specify custom endpoint class
+      #   require 'hanami/router'
+      #
+      #   resolver = Hanami::Routing::EndpointResolver.new(endpoint: CustomEndpoint)
+      #   router   = Hanami::Router.new(resolver: resolver)
+      #
+      #   router.get('/', to: endpoint).dest # => #<CustomEndpoint:0x007f97f3359570 ...>
+      #
+      # @example Specify custom Ruby namespace
+      #   require 'hanami/router'
+      #
+      #   resolver = Hanami::Routing::EndpointResolver.new(namespace: MyApp)
+      #   router   = Hanami::Router.new(resolver: resolver)
+      #
+      #   router.get('/', to: 'articles#show')
+      #     # => Will look for: MyApp::Articles::Show
+      #
+      #
+      #
+      # @example Specify custom pattern
+      #   require 'hanami/router'
+      #
+      #   resolver = Hanami::Routing::EndpointResolver.new(pattern: '%{controller}Controller::%{action}')
+      #   router   = Hanami::Router.new(resolver: resolver)
+      #
+      #   router.get('/', to: 'articles#show')
+      #     # => Will look for: ArticlesController::Show
+      #
+      #
+      #
+      # @example Specify custom controller-action separator
+      #   require 'hanami/router'
+      #
+      #   resolver = Hanami::Routing::EndpointResolver.new(separator: '@')
+      #   router   = Hanami::Router.new(resolver: resolver)
+      #
+      #   router.get('/', to: 'articles@show')
+      #     # => Will look for: Articles::Show
+      def initialize(options = {})
+        @endpoint_class   = options[:endpoint]         || Endpoint
+        @namespace        = options[:namespace]        || Object
+        @action_separator = options[:action_separator] || ACTION_SEPARATOR
+        @pattern          = options[:pattern]          || NAMING_PATTERN
+      end
+
+      # Resolve the given set of HTTP verb, path, endpoint and options.
+      # If it fails to resolve, it will mount the default endpoint to the given
+      # path, which returns an 404 (Not Found).
+      #
+      # @param options [Hash] the options required to resolve the endpoint
+      #
+      # @option options [String,Proc,Class,Object#call] :to the endpoint
+      # @option options [String] :namespace an optional routing namespace
+      #
+      # @return [Endpoint] this may vary according to the :endpoint option
+      #   passed to #initialize
+      #
+      # @since 0.1.0
+      #
+      # @see #initialize
+      # @see #find
+      #
+      # @example Resolve to a Proc
+      #   require 'hanami/router'
+      #
+      #   router = Hanami::Router.new
+      #   router.get '/', to: ->(env) { [200, {}, ['Hi!']] }
+      #
+      # @example Resolve to a class
+      #   require 'hanami/router'
+      #
+      #   router = Hanami::Router.new
+      #   router.get '/', to: RackMiddleware
+      #
+      # @example Resolve to a Rack compatible object (respond to #call)
+      #   require 'hanami/router'
+      #
+      #   router = Hanami::Router.new
+      #   router.get '/', to: AnotherMiddleware.new
+      #
+      # @example Resolve to a Hanami::Action from a string (see Hanami::Controller framework)
+      #   require 'hanami/router'
+      #
+      #   router = Hanami::Router.new
+      #   router.get '/', to: 'articles#show'
+      #
+      # @example Resolve to a Hanami::Action (see Hanami::Controller framework)
+      #   require 'hanami/router'
+      #
+      #   router = Hanami::Router.new
+      #   router.get '/', to: Articles::Show
+      #
+      # @example Resolve a redirect with a namespace
+      #   require 'hanami/router'
+      #
+      #   router = Hanami::Router.new
+      #   router.namespace 'users' do
+      #     get '/home',           to: ->(env) { ... }
+      #     redirect '/dashboard', to: '/home'
+      #   end
+      #
+      #   # GET /users/dashboard => 301 Location: "/users/home"
+      def resolve(options, &endpoint)
+        result = endpoint || find(options)
+        resolve_callable(result) || resolve_matchable(result) || default
+      end
+
+      # Finds a path from the given options.
+      #
+      # @param options [Hash] the path description
+      # @option options [String,Proc,Class,Object#call] :to the endpoint
+      # @option options [String] :namespace an optional namespace
+      #
+      # @since 0.1.0
+      #
+      # @return [Object]
+      def find(options)
+        options[:to]
+      end
+
+      protected
+      def default
+        @endpoint_class.new(
+          ->(env) { [404, {'X-Cascade' => 'pass'}, 'Not Found'] }
+        )
+      end
+
+      def constantize(string)
+        klass = Utils::Class.load!(string, @namespace)
+        if klass.respond_to?(:call)
+          Endpoint.new(klass)
+        else
+          ClassEndpoint.new(klass)
+        end
+      rescue NameError
+        LazyEndpoint.new(string, @namespace)
+      end
+
+      def classify(string)
+        Utils::String.new(string).classify
+      end
+
+      private
+      def resolve_callable(callable)
+        if callable.respond_to?(:call)
+          @endpoint_class.new(callable)
+        elsif callable.is_a?(Class) && callable.instance_methods.include?(:call)
+          @endpoint_class.new(callable.new)
+        end
+      end
+
+      def resolve_matchable(matchable)
+        if matchable.respond_to?(:match)
+          constantize(
+            resolve_action(matchable) || classify(matchable)
+          )
+        end
+      end
+
+      def resolve_action(string)
+        if string.match(action_separator)
+          controller, action = string.split(action_separator).map {|token| classify(token) }
+          @pattern % {controller: controller, action: action}
+        end
+      end
+    end
+  end
+end

data/lib/hanami/routing/error.rb

@@ -0,0 +1,7 @@
+module Hanami
+  module Routing
+    # @since 0.5.0
+    class Error < ::StandardError
+    end
+  end
+end

data/lib/hanami/routing/force_ssl.rb

@@ -0,0 +1,209 @@
+require 'rack/request'
+
+module Hanami
+  module Routing
+    # Force ssl
+    #
+    # Redirect response to the secure equivalent resource (https)
+    #
+    # @since 0.4.1
+    # @api private
+    class ForceSsl
+      # Https scheme
+      #
+      # @since 0.4.1
+      # @api private
+      SSL_SCHEME = 'https'.freeze
+
+      # @since 0.4.1
+      # @api private
+      HTTPS = 'HTTPS'.freeze
+
+      # @since 0.4.1
+      # @api private
+      ON    = 'on'.freeze
+
+      # Location header
+      #
+      # @since 0.4.1
+      # @api private
+      LOCATION_HEADER = 'Location'.freeze
+
+      # Default http port
+      #
+      # @since 0.4.1
+      # @api private
+      DEFAULT_HTTP_PORT = 80
+
+      # Default ssl port
+      #
+      # @since 0.4.1
+      # @api private
+      DEFAULT_SSL_PORT = 443
+
+      # Moved Permanently http code
+      #
+      # @since 0.4.1
+      # @api private
+      MOVED_PERMANENTLY_HTTP_CODE = 301
+
+      # Temporary Redirect http code
+      #
+      # @since 0.4.1
+      # @api private
+      TEMPORARY_REDIRECT_HTTP_CODE = 307
+
+      # @since 0.4.1
+      # @api private
+      HTTP_X_FORWARDED_SSL = 'HTTP_X_FORWARDED_SSL'.freeze
+
+      # @since 0.4.1
+      # @api private
+      HTTP_X_FORWARDED_SCHEME = 'HTTP_X_FORWARDED_SCHEME'.freeze
+
+      # @since 0.4.1
+      # @api private
+      HTTP_X_FORWARDED_PROTO = 'HTTP_X_FORWARDED_PROTO'.freeze
+
+      # @since 0.4.1
+      # @api private
+      HTTP_X_FORWARDED_PROTO_SEPARATOR = ','.freeze
+
+      # @since 0.4.1
+      # @api private
+      RACK_URL_SCHEME = 'rack.url_scheme'.freeze
+
+      # @since 0.4.1
+      # @api private
+      REQUEST_METHOD = 'REQUEST_METHOD'.freeze
+
+      # @since 0.4.1
+      # @api private
+      IDEMPOTENT_METHODS = ['GET', 'HEAD'].freeze
+
+      EMPTY_BODY = [].freeze
+
+      # Initialize ForceSsl.
+      #
+      # @param active [Boolean] activate redirection to SSL
+      # @param options [Hash] set of options
+      # @option options [String] :host
+      # @option options [Integer] :port
+      #
+      # @since 0.4.1
+      # @api private
+      def initialize(active, options = {})
+        @active = active
+        @host   = options[:host]
+        @port   = options[:port]
+
+        _redefine_call
+      end
+
+      # Set 301 status and Location header if this feature is activated.
+      #
+      # @param env [Hash] a Rack env instance
+      #
+      # @return [Array]
+      #
+      # @see Hanami::Routing::HttpRouter#call
+      #
+      # @since 0.4.1
+      # @api private
+      def call(env)
+      end
+
+      # Check if router has to force the response with ssl
+      #
+      # @return [Boolean]
+      #
+      # @since 0.4.1
+      # @api private
+      def force?(env)
+        !ssl?(env)
+      end
+
+      private
+
+      # @since 0.4.1
+      # @api private
+      attr_reader :host
+
+      # Return full url to redirect
+      #
+      # @param env [Hash] Rack env
+      #
+      # @return [String]
+      #
+      # @since 0.4.1
+      # @api private
+      def full_url(env)
+        "#{ SSL_SCHEME }://#{ host }:#{ port }#{ ::Rack::Request.new(env).fullpath }"
+      end
+
+      # Return redirect code
+      #
+      # @param env [Hash] Rack env
+      #
+      # @return [Integer]
+      #
+      # @since 0.4.1
+      # @api private
+      def redirect_code(env)
+        if IDEMPOTENT_METHODS.include?(env[REQUEST_METHOD])
+          MOVED_PERMANENTLY_HTTP_CODE
+        else
+          TEMPORARY_REDIRECT_HTTP_CODE
+        end
+      end
+
+      # Return correct default port for full url
+      #
+      # @return [Integer]
+      #
+      # @since 0.4.1
+      # @api private
+      def port
+        if @port == DEFAULT_HTTP_PORT
+          DEFAULT_SSL_PORT
+        else
+          @port
+        end
+      end
+
+      # @since 0.4.1
+      # @api private
+      def _redefine_call
+        return unless @active
+
+        define_singleton_method :call do |env|
+          [redirect_code(env), { LOCATION_HEADER => full_url(env) }, EMPTY_BODY] if force?(env)
+        end
+      end
+
+      # Adapted from Rack::Request#scheme
+      #
+      # @since 0.4.1
+      # @api private
+      def scheme(env)
+        if env[HTTPS] == ON
+          SSL_SCHEME
+        elsif env[HTTP_X_FORWARDED_SSL] == ON
+          SSL_SCHEME
+        elsif env[HTTP_X_FORWARDED_SCHEME]
+          env[HTTP_X_FORWARDED_SCHEME]
+        elsif env[HTTP_X_FORWARDED_PROTO]
+          env[HTTP_X_FORWARDED_PROTO].split(HTTP_X_FORWARDED_PROTO_SEPARATOR)[0]
+        else
+          env[RACK_URL_SCHEME]
+        end
+      end
+
+      # @since 0.4.1
+      # @api private
+      def ssl?(env)
+        scheme(env) == SSL_SCHEME
+      end
+    end
+  end
+end