hanami-router 1.3.1 → 2.0.0.alpha4

data/lib/hanami/routing/http_router.rb

@@ -1,220 +0,0 @@
-require 'uri'
-require 'http_router'
-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'
-require 'hanami/routing/http_router_monkey_patch'
-
-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 environment variable
-      #
-      # @since 0.5.0
-      # @api private
-      SCRIPT_NAME = 'SCRIPT_NAME'.freeze
-
-      # Path info - rack environment variable
-      #
-      # @since 0.7.0
-      # @api private
-      PATH_INFO = 'PATH_INFO'.freeze
-
-      # Default PATH_INFO for Rack requests
-      #
-      # @since 0.7.0
-      # @api private
-      DEFAULT_PATH_INFO = '/'.freeze
-
-      # URL separator
-      #
-      # @since 0.7.0
-      # @api private
-      URL_SEPARATOR = '/'.freeze
-
-      # @since 0.5.0
-      # @api private
-      attr_reader :namespace
-
-      # @since 0.8.0
-      # @api private
-      attr_reader :prefix
-
-      # Initialize the router.
-      #
-      # @see Hanami::Router#initialize
-      #
-      # @since 0.1.0
-      # @api private
-      def initialize(options = {}, &blk)
-        if options[:parsers]
-          depecration_message = 'Hanami::Router options[:parsers] is deprecated and it will be removed in future versions'
-          Hanami::Utils::Deprecation.new(depecration_message)
-        end
-        @compiled         = false
-        @uri_parser       = URI::Parser.new
-        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) }*", host: options[:host]).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
-      def rewrite_partial_path_info(env, request)
-        if request.path.empty?
-          env[SCRIPT_NAME] += env[PATH_INFO]
-          env[PATH_INFO]    = DEFAULT_PATH_INFO
-        else
-          path_info_before  = env[PATH_INFO].dup
-          env[PATH_INFO]    = "/#{@uri_parser.escape(request.path.join(URL_SEPARATOR))}"
-          env[SCRIPT_NAME] += path_info_before[0, path_info_before.bytesize - env[PATH_INFO].bytesize]
-        end
-      end
-
-      private
-
-      # @api private
-      def _rescue_url_recognition
-        yield
-      rescue ::HttpRouter::InvalidRouteException,
-             ::HttpRouter::TooManyParametersException => e
-        raise Routing::InvalidRouteException.new("#{ e.message } - please check given arguments")
-      end
-
-      # @api private
-      def add_with_request_method(path, method, opts = {}, &app)
-        super.generate(@resolver, opts, &app)
-      end
-
-      # @api private
-      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/http_router_monkey_patch.rb

@@ -1,38 +0,0 @@
-# coding: utf-8
-#
-# This monkey patches http_router to make it Rack 2.0 compatible.
-# Details see: https://github.com/hanami/router/issues/136
-#
-# @api private
-class HttpRouter
-  # @api private
-  class Node
-    # @api private
-    class Path < Node
-      def to_code
-        path_ivar = inject_root_ivar(self)
-        "#{"if !callback && request.path.size == 1 && request.path.first == '' && (request.rack_request.head? || request.rack_request.get?) && request.rack_request.path_info[-1] == ?/
-          response = ::Rack::Response.new
-          response.redirect(request.rack_request.path_info[0, request.rack_request.path_info.size - 1], 302)
-          return response.finish
-        end" if router.redirect_trailing_slash?}
-
-        #{"if request.#{router.ignore_trailing_slash? ? 'path_finished?' : 'path.empty?'}" unless route.match_partially}
-          if callback
-            request.called = true
-            callback.call(Response.new(request, #{path_ivar}))
-          else
-            env = request.rack_request.env
-            env['router.request'] = request
-            env['router.params'] ||= {}
-            #{"env['router.params'].merge!(Hash[#{param_names.inspect}.zip(request.params)])" if dynamic?}
-            @router.rewrite#{"_partial" if route.match_partially}_path_info(env, request)
-            response = @router.process_destination_path(#{path_ivar}, env)
-            return response unless router.pass_on_response(response)
-          end
-        #{"end" unless route.match_partially}"
-      end
-
-    end
-  end
-end

data/lib/hanami/routing/namespace.rb

@@ -1,98 +0,0 @@
-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
-
-      # @api private
-      # @since 1.1.0
-      def mount(app, options)
-        super(app, options.merge(at: @name.join(options[:at])))
-      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

@@ -1,113 +0,0 @@
-require 'hanami/routing/parsing/parser'
-require 'hanami/utils/hash'
-
-module Hanami
-  module Routing
-    # @since 0.2.0
-    # @api private
-    class Parsers
-      # @since 0.2.0
-      # @api private
-      CONTENT_TYPE       = 'CONTENT_TYPE'.freeze
-
-      # @since 0.2.0
-      # @api private
-      MEDIA_TYPE_MATCHER = /\s*[;,]\s*/.freeze
-
-      # @since 0.2.0
-      # @api private
-      RACK_INPUT    = 'rack.input'.freeze
-
-      # @since 0.2.0
-      # @api private
-      ROUTER_PARAMS = 'router.params'.freeze
-
-      # @api private
-      ROUTER_PARSED_BODY = 'router.parsed_body'.freeze
-
-      # @api private
-      FALLBACK_KEY  = '_'.freeze
-
-      # @since 0.2.0
-      # @api private
-      def initialize(parsers)
-        @parsers = prepare(parsers)
-        _redefine_call
-      end
-
-      # @since 0.2.0
-      # @api private
-      def call(env)
-        env
-      end
-
-      private
-      # @since 0.2.0
-      # @api 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
-
-      # @since 0.2.0
-      # @api private
-      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_PARSED_BODY] = _parse(env, body)
-          env[ROUTER_PARAMS]      = _symbolize(env[ROUTER_PARSED_BODY]).merge(env[ROUTER_PARAMS])
-
-          env
-        end
-      end
-
-      # @api private
-      def _symbolize(body)
-        if body.is_a?(Hash)
-          Utils::Hash.deep_symbolize(body)
-        else
-          { FALLBACK_KEY => body }
-        end
-      end
-
-      # @api private
-      def _parse(env, body)
-        @parsers[
-          media_type(env)
-        ].parse(body)
-      end
-
-      # @api private
-      def media_type(env)
-        if ct = content_type(env)
-          ct.split(MEDIA_TYPE_MATCHER, 2).first.downcase
-        end
-      end
-
-      # @api private
-      def content_type(env)
-        content_type = env[CONTENT_TYPE]
-        content_type.nil? || content_type.empty? ? nil : content_type
-      end
-    end
-  end
-end