hanami-router 0.0.0 → 0.6.0

data/lib/hanami/routing/http_router.rb

@@ -0,0 +1,187 @@
+require 'http_router'
+require 'hanami/utils/io'
+require 'hanami/routing/endpoint_resolver'
+require 'hanami/routing/route'
+require 'hanami/routing/parsers'
+require 'hanami/routing/force_ssl'
+require 'hanami/routing/error'
+require 'hanami/utils/path_prefix'
+
+Hanami::Utils::IO.silence_warnings do
+  HttpRouter::Route::VALID_HTTP_VERBS = %w{GET POST PUT PATCH DELETE HEAD OPTIONS TRACE}
+end
+
+module Hanami
+  module Routing
+    # Invalid route
+    # This is raised when the router fails to recognize a route, because of the
+    # given arguments.
+    #
+    # @since 0.1.0
+    class InvalidRouteException < Hanami::Routing::Error
+    end
+
+    # HTTP router
+    #
+    # This implementation is based on ::HttpRouter (http_router gem).
+    #
+    # Hanami::Router wraps an instance of this class, in order to protect its
+    # public API from any future change of ::HttpRouter.
+    #
+    # @since 0.1.0
+    # @api private
+    class HttpRouter < ::HttpRouter
+      # Script name - rack enviroment variable
+      #
+      # @since 0.5.0
+      # @api private
+      SCRIPT_NAME = 'SCRIPT_NAME'.freeze
+
+      # @since 0.5.0
+      # @api private
+      attr_reader :namespace
+
+      # Initialize the router.
+      #
+      # @see Hanami::Router#initialize
+      #
+      # @since 0.1.0
+      # @api private
+      def initialize(options = {}, &blk)
+        super(options, &nil)
+
+        @namespace        = options[:namespace] if options[:namespace]
+        @default_scheme   = options[:scheme]    if options[:scheme]
+        @default_host     = options[:host]      if options[:host]
+        @default_port     = options[:port]      if options[:port]
+        @route_class      = options[:route]    || Routing::Route
+        @resolver         = options[:resolver] || Routing::EndpointResolver.new(options)
+        @parsers          = Routing::Parsers.new(options[:parsers])
+        @prefix           = Utils::PathPrefix.new(options[:prefix] || '')
+        @force_ssl        = Hanami::Routing::ForceSsl.new(!!options[:force_ssl], host: @default_host, port: @default_port)
+      end
+
+      # Separator between controller and action name.
+      #
+      # @see Hanami::Routing::EndpointResolver::ACTION_SEPARATOR
+      #
+      # @since 0.1.0
+      # @api private
+      def action_separator
+        @resolver.action_separator
+      end
+
+      # Finds a path from the given options.
+      #
+      # @see Hanami::Routing::EndpointResolver#find
+      #
+      # @since 0.1.0
+      # @api private
+      def find(options)
+        @resolver.find(options)
+      end
+
+      # Generate a relative URL for a specified named route.
+      #
+      # @see Hanami::Router#path
+      #
+      # @since 0.1.0
+      # @api private
+      def raw_path(route, *args)
+        _rescue_url_recognition do
+          _custom_path(super(route, *args))
+        end
+      end
+
+      # Generate an absolute URL for a specified named route.
+      #
+      # @see Hanami::Router#path
+      #
+      # @since 0.1.0
+      # @api private
+      def raw_url(route, *args)
+        _rescue_url_recognition do
+          _custom_path(super(route, *args))
+        end
+      end
+
+      # Support for OPTIONS HTTP verb
+      #
+      # @see Hanami::Router#options
+      #
+      # @since 0.1.0
+      # @api private
+      def options(path, options = {}, &blk)
+        add_with_request_method(path, :options, options, &blk)
+      end
+
+      # Allow to mount a Rack app
+      #
+      # @see Hanami::Router#mount
+      #
+      # @since 0.1.1
+      # @api private
+      def mount(app, options)
+        add("#{ options.fetch(:at) }*").to(
+          @resolver.resolve(to: app)
+        )
+      end
+
+      # @api private
+      def raw_call(env, &blk)
+        if response = @force_ssl.call(env)
+          response
+        else
+          super(@parsers.call(env))
+        end
+      end
+
+      # @api private
+      def reset!
+        uncompile
+        @routes, @named_routes, @root = [], Hash.new{|h,k| h[k] = []}, Node::Root.new(self)
+        @default_host, @default_port, @default_scheme = 'localhost', 80, 'http'
+      end
+
+      # @api private
+      def pass_on_response(response)
+        super response.to_a
+      end
+
+      # @api private
+      def no_response(request, env)
+        if request.acceptable_methods.any? && !request.acceptable_methods.include?(env['REQUEST_METHOD'])
+          [405, {'Allow' => request.acceptable_methods.sort.join(", ")}, []]
+        else
+          @default_app.call(env)
+        end
+      end
+
+      # @api private
+      # @since 0.5.0
+      def rewrite_path_info(env, request)
+        super
+        env[SCRIPT_NAME] = @prefix + env[SCRIPT_NAME]
+      end
+
+      private
+
+      def _rescue_url_recognition
+        yield
+      rescue ::HttpRouter::InvalidRouteException,
+             ::HttpRouter::TooManyParametersException => e
+        raise Routing::InvalidRouteException.new("#{ e.message } - please check given arguments")
+      end
+
+      def add_with_request_method(path, method, opts = {}, &app)
+        super.generate(@resolver, opts, &app)
+      end
+
+      def _custom_path(uri_string)
+        uri = URI.parse(uri_string)
+        uri.path = @prefix.join(uri.path)
+        uri.to_s
+      end
+    end
+  end
+end

data/lib/hanami/routing/namespace.rb

@@ -0,0 +1,92 @@
+require 'delegate'
+require 'hanami/utils/path_prefix'
+
+module Hanami
+  module Routing
+    # Namespace for routes.
+    # Implementation of Hanami::Router#namespace
+    #
+    # @since 0.1.0
+    #
+    # @api private
+    #
+    # @see Hanami::Router#namespace
+    class Namespace < SimpleDelegator
+      # @api private
+      # @since 0.1.0
+      def initialize(router, name, &blk)
+        @router = router
+        @name   = Utils::PathPrefix.new(name)
+        __setobj__(@router)
+        instance_eval(&blk)
+      end
+
+      # @api private
+      # @since 0.1.0
+      def get(path, options = {}, &endpoint)
+        super(@name.join(path), options, &endpoint)
+      end
+
+      # @api private
+      # @since 0.1.0
+      def post(path, options = {}, &endpoint)
+        super(@name.join(path), options, &endpoint)
+      end
+
+      # @api private
+      # @since 0.1.0
+      def put(path, options = {}, &endpoint)
+        super(@name.join(path), options, &endpoint)
+      end
+
+      # @api private
+      # @since 0.1.0
+      def patch(path, options = {}, &endpoint)
+        super(@name.join(path), options, &endpoint)
+      end
+
+      # @api private
+      # @since 0.1.0
+      def delete(path, options = {}, &endpoint)
+        super(@name.join(path), options, &endpoint)
+      end
+
+      # @api private
+      # @since 0.1.0
+      def trace(path, options = {}, &endpoint)
+        super(@name.join(path), options, &endpoint)
+      end
+
+      # @api private
+      # @since 0.1.0
+      def options(path, options = {}, &endpoint)
+        super(@name.join(path), options, &endpoint)
+      end
+
+      # @api private
+      # @since 0.1.0
+      def resource(name, options = {})
+        super name, options.merge(namespace: @name.relative_join(options[:namespace]))
+      end
+
+      # @api private
+      # @since 0.1.0
+      def resources(name, options = {})
+        super name, options.merge(namespace: @name.relative_join(options[:namespace]))
+      end
+
+      # @api private
+      # @since 0.1.0
+      def redirect(path, options = {}, &endpoint)
+        super(@name.join(path), options.merge(to: @name.join(options[:to])), &endpoint)
+      end
+
+      # Supports nested namespaces
+      # @api private
+      # @since 0.1.0
+      def namespace(name, &blk)
+        Routing::Namespace.new(self, name, &blk)
+      end
+    end
+  end
+end

data/lib/hanami/routing/parsers.rb

@@ -0,0 +1,71 @@
+require 'hanami/routing/parsing/parser'
+
+module Hanami
+  module Routing
+    class Parsers
+      CONTENT_TYPE       = 'CONTENT_TYPE'.freeze
+      MEDIA_TYPE_MATCHER = /\s*[;,]\s*/.freeze
+
+      RACK_INPUT    = 'rack.input'.freeze
+      ROUTER_PARAMS = 'router.params'.freeze
+
+      def initialize(parsers)
+        @parsers = prepare(parsers)
+        _redefine_call
+      end
+
+      def call(env)
+        env
+      end
+
+      private
+      def prepare(args)
+        result  = Hash.new
+        args    = Array(args)
+        return result if args.empty?
+
+        args.each do |arg|
+          parser = Parsing::Parser.for(arg)
+
+          parser.mime_types.each do |mime|
+            result[mime] = parser
+          end
+        end
+
+        result.default = Parsing::Parser.new
+        result
+      end
+
+      def _redefine_call
+        return if @parsers.empty?
+
+        define_singleton_method :call do |env|
+          body = env[RACK_INPUT].read
+          return env if body.empty?
+
+          env[RACK_INPUT].rewind    # somebody might try to read this stream
+          env[ROUTER_PARAMS] ||= {} # prepare params
+
+          env[ROUTER_PARAMS].merge!(
+            @parsers[
+              media_type(env)
+            ].parse(body)
+          )
+
+          env
+        end
+      end
+
+      def media_type(env)
+        if ct = content_type(env)
+          ct.split(MEDIA_TYPE_MATCHER, 2).first.downcase
+        end
+      end
+
+      def content_type(env)
+        content_type = env[CONTENT_TYPE]
+        content_type.nil? || content_type.empty? ? nil : content_type
+      end
+    end
+  end
+end

data/lib/hanami/routing/parsing/json_parser.rb

@@ -0,0 +1,28 @@
+require 'json'
+
+module Hanami
+  module Routing
+    module Parsing
+      class JsonParser < Parser
+        def mime_types
+          ['application/json', 'application/vnd.api+json']
+        end
+
+        # Parse a json string
+        #
+        # @param body [String] a json string
+        #
+        # @return [Hash] the parsed json
+        #
+        # @raise [Hanami::Routing::Parsing::BodyParsingError] when the body can't be parsed.
+        #
+        # @since 0.2.0
+        def parse(body)
+          JSON.parse(body)
+        rescue JSON::ParserError => e
+          raise BodyParsingError.new(e.message)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/routing/parsing/parser.rb

@@ -0,0 +1,58 @@
+require 'hanami/utils/class'
+require 'hanami/utils/string'
+require 'hanami/routing/error'
+
+module Hanami
+  module Routing
+    module Parsing
+      # Body parsing error
+      # This is raised when parser fails to parse the body
+      #
+      # @since 0.5.0
+      class BodyParsingError < Hanami::Routing::Error
+      end
+
+      # @since 0.2.0
+      class UnknownParserError < Hanami::Routing::Error
+        def initialize(parser)
+          super("Unknown Parser: `#{ parser }'")
+        end
+      end
+
+      # @since 0.2.0
+      class Parser
+        # @since 0.2.0
+        def self.for(parser)
+          case parser
+          when String, Symbol
+            require_parser(parser)
+          else
+            parser
+          end
+        end
+
+        # @since 0.2.0
+        def mime_types
+          raise NotImplementedError
+        end
+
+        # @since 0.2.0
+        def parse(body)
+          Hash.new
+        end
+
+        private
+        # @since 0.2.0
+        # @api private
+        def self.require_parser(parser)
+          require "hanami/routing/parsing/#{ parser }_parser"
+
+          parser = Utils::String.new(parser).classify
+          Utils::Class.load!("Hanami::Routing::Parsing::#{ parser }Parser").new
+        rescue LoadError, NameError
+          raise UnknownParserError.new(parser)
+        end
+      end
+    end
+  end
+end

data/lib/hanami/routing/recognized_route.rb

@@ -0,0 +1,153 @@
+require 'hanami/utils/string'
+
+module Hanami
+  module Routing
+    # Represents a result of router path recognition.
+    #
+    # @since 0.5.0
+    #
+    # @see Hanami::Router#recognize
+    class RecognizedRoute
+      # @since 0.5.0
+      # @api private
+      REQUEST_METHOD = 'REQUEST_METHOD'.freeze
+
+      # @since 0.5.0
+      # @api private
+      NAMESPACE             = '%s::'.freeze
+
+      # @since 0.5.0
+      # @api private
+      NAMESPACE_REPLACEMENT = ''.freeze
+
+      # @since 0.5.0
+      # @api private
+      ACTION_PATH_SEPARATOR = '/'.freeze
+
+      # @since 0.5.0
+      # @api public
+      attr_reader :params
+
+      # Creates a new instance
+      #
+      # @param response [HttpRouter::Response] raw response of recognition
+      # @param env [Hash] Rack env
+      # @param router [Hanami::Routing::HttpRouter] low level router
+      #
+      # @return [Hanami::Routing::RecognizedRoute]
+      #
+      # @since 0.5.0
+      # @api private
+      def initialize(response, env, router)
+        @env = env
+
+        unless response.nil?
+          @endpoint = response.route.dest
+          @params   = response.params
+        end
+
+        @namespace        = router.namespace
+        @action_separator = router.action_separator
+      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::Routing::RecognizedRoute#routable?
+      # @see Hanami::Router::NotRoutableEndpointError
+      def call(env)
+        if routable?
+          @endpoint.call(env)
+        else
+          raise Hanami::Router::NotRoutableEndpointError.new(@env)
+        end
+      end
+
+      # HTTP verb (aka method)
+      #
+      # @return [String]
+      #
+      # @since 0.5.0
+      # @api public
+      def verb
+        @env[REQUEST_METHOD]
+      end
+
+      # Action name
+      #
+      # @return [String]
+      #
+      # @since 0.5.0
+      # @api public
+      #
+      # @see Hanami::Router#recognize
+      #
+      # @example
+      #   require 'hanami/router'
+      #
+      #   router = Hanami::Router.new do
+      #     get '/books/:id', to: 'books#show'
+      #   end
+      #
+      #   puts router.recognize('/books/23').action # => "books#show"
+      def action
+        namespace = NAMESPACE % @namespace
+
+        if destination.match(namespace)
+          Hanami::Utils::String.new(
+            destination.sub(namespace, NAMESPACE_REPLACEMENT)
+          ).underscore.rsub(ACTION_PATH_SEPARATOR, @action_separator)
+        else
+          destination
+        end
+      end
+
+      # Check if routable
+      #
+      # @return [TrueClass,FalseClass]
+      #
+      # @since 0.5.0
+      # @api public
+      #
+      # @see Hanami::Router#recognize
+      #
+      # @example
+      #   require 'hanami/router'
+      #
+      #   router = Hanami::Router.new do
+      #     get '/', to: 'home#index'
+      #   end
+      #
+      #   puts router.recognize('/').routable?    # => true
+      #   puts router.recognize('/foo').routable? # => false
+      def routable?
+        !!@endpoint
+      end
+
+      private
+
+      # @since 0.5.0
+      # @api private
+      #
+      # @see Hanami::Routing::Endpoint
+      def destination
+        @destination ||= begin
+          case k = @endpoint.__getobj__
+          when Class
+            k
+          else
+            k.class
+          end.name
+        end
+      end
+    end
+  end
+end