grape 0.15.0 → 0.16.1

data/lib/grape/error_formatter.rb

@@ -1,8 +1,10 @@
 module Grape
   module ErrorFormatter
+    extend Util::Registrable
+
     class << self
       def builtin_formatters
-        {
+        @builtin_formatters ||= {
           serializable_hash: Grape::ErrorFormatter::Json,
           json: Grape::ErrorFormatter::Json,
           jsonapi: Grape::ErrorFormatter::Json,
@@ -12,7 +14,7 @@ module Grape
       end
 
       def formatters(options)
-        builtin_formatters.merge(options[:error_formatters] || {})
+        builtin_formatters.merge(default_elements).merge(options[:error_formatters] || {})
       end
 
       def formatter_for(api_format, options = {})

data/lib/grape/error_formatter/base.rb

@@ -3,14 +3,18 @@ module Grape
     module Base
       def present(message, env)
         present_options = {}
-        present_options[:with] = message.delete(:with) if message.is_a?(Hash)
+        presented_message = message
+        if presented_message.is_a?(Hash)
+          presented_message = presented_message.dup
+          present_options[:with] = presented_message.delete(:with)
+        end
 
-        presenter = env[Grape::Env::API_ENDPOINT].entity_class_for_obj(message, present_options)
+        presenter = env[Grape::Env::API_ENDPOINT].entity_class_for_obj(presented_message, present_options)
 
-        unless presenter || env[Grape::Env::RACK_ROUTING_ARGS].nil?
+        unless presenter || env[Grape::Env::GRAPE_ROUTING_ARGS].nil?
           # env['api.endpoint'].route does not work when the error occurs within a middleware
           # the Endpoint does not have a valid env at this moment
-          http_codes = env[Grape::Env::RACK_ROUTING_ARGS][:route_info].route_http_codes || []
+          http_codes = env[Grape::Env::GRAPE_ROUTING_ARGS][:route_info].http_codes || []
           found_code = http_codes.find do |http_code|
             (http_code[0].to_i == env[Grape::Env::API_ENDPOINT].status) && http_code[2].respond_to?(:represent)
           end if env[Grape::Env::API_ENDPOINT].request
@@ -21,10 +25,10 @@ module Grape
         if presenter
           embeds = { env: env }
           embeds[:version] = env[Grape::Env::API_VERSION] if env[Grape::Env::API_VERSION]
-          message = presenter.represent(message, embeds).serializable_hash
+          presented_message = presenter.represent(presented_message, embeds).serializable_hash
         end
 
-        message
+        presented_message
       end
     end
   end

data/lib/grape/formatter.rb

@@ -1,8 +1,10 @@
 module Grape
   module Formatter
+    extend Util::Registrable
+
     class << self
       def builtin_formmaters
-        {
+        @builtin_formatters ||= {
           json: Grape::Formatter::Json,
           jsonapi: Grape::Formatter::Json,
           serializable_hash: Grape::Formatter::SerializableHash,
@@ -12,7 +14,7 @@ module Grape
       end
 
       def formatters(options)
-        builtin_formmaters.merge(options[:formatters] || {})
+        builtin_formmaters.merge(default_elements).merge(options[:formatters] || {})
       end
 
       def formatter_for(api_format, options = {})

data/lib/grape/http/headers.rb

@@ -4,6 +4,7 @@ module Grape
       # https://github.com/rack/rack/blob/master/lib/rack.rb
       HTTP_VERSION    = 'HTTP_VERSION'.freeze
       PATH_INFO       = 'PATH_INFO'.freeze
+      REQUEST_METHOD  = 'REQUEST_METHOD'.freeze
       QUERY_STRING    = 'QUERY_STRING'.freeze
       CONTENT_TYPE    = 'Content-Type'.freeze
 

data/lib/grape/middleware/formatter.rb

@@ -34,8 +34,8 @@ module Grape
       def build_formatted_response(status, headers, bodies)
         headers = ensure_content_type(headers)
 
-        if bodies.is_a?(Grape::Util::FileResponse)
-          Grape::Util::SendfileResponse.new([], status, headers) do |resp|
+        if bodies.is_a?(Grape::ServeFile::FileResponse)
+          Grape::ServeFile::SendfileResponse.new([], status, headers) do |resp|
             resp.body = bodies.file
           end
         else

data/lib/grape/middleware/versioner/accept_version_header.rb

@@ -14,7 +14,7 @@ module Grape
       #    env['api.version']  => 'v1'
       #
       # If version does not match this route, then a 406 is raised with
-      # X-Cascade header to alert Rack::Mount to attempt the next matched
+      # X-Cascade header to alert Grape::Router to attempt the next matched
       # route.
       class AcceptVersionHeader < Base
         def before
@@ -46,7 +46,7 @@ module Grape
         end
 
         # By default those errors contain an `X-Cascade` header set to `pass`, which allows nesting and stacking
-        # of routes (see [Rack::Mount](https://github.com/josh/rack-mount) for more information). To prevent
+        # of routes (see Grape::Router) for more information). To prevent
         # this behavior, and not add the `X-Cascade` header, one can set the `:cascade` option to `false`.
         def cascade?
           if options[:version_options] && options[:version_options].key?(:cascade)

data/lib/grape/middleware/versioner/header.rb

@@ -20,7 +20,7 @@ module Grape
       #    env['api.format]   => 'json'
       #
       # If version does not match this route, then a 406 is raised with
-      # X-Cascade header to alert Rack::Mount to attempt the next matched
+      # X-Cascade header to alert Grape::Router to attempt the next matched
       # route.
       class Header < Base
         VENDOR_VERSION_HEADER_REGEX =
@@ -154,7 +154,7 @@ module Grape
 
         # By default those errors contain an `X-Cascade` header set to `pass`,
         # which allows nesting and stacking of routes
-        # (see [Rack::Mount](https://github.com/josh/rack-mount) for more
+        # (see Grape::Router for more
         # information). To prevent # this behavior, and not add the `X-Cascade`
         # header, one can set the `:cascade` option to `false`.
         def cascade?

data/lib/grape/middleware/versioner/path.rb

@@ -28,7 +28,7 @@ module Grape
 
           if prefix && path.index(prefix) == 0
             path.sub!(prefix, '')
-            path = Rack::Mount::Utils.normalize_path(path)
+            path = Grape::Router.normalize_path(path)
           end
 
           pieces = path.split('/')
@@ -41,7 +41,7 @@ module Grape
         private
 
         def prefix
-          Rack::Mount::Utils.normalize_path(options[:prefix].to_s) if options[:prefix]
+          Grape::Router.normalize_path(options[:prefix].to_s) if options[:prefix]
         end
       end
     end

data/lib/grape/namespace.rb

@@ -29,7 +29,7 @@ module Grape
     # Join the namespaces from a list of settings to create a path prefix.
     # @param settings [Array] list of Grape::Util::InheritableSettings.
     def self.joined_space_path(settings)
-      Rack::Mount::Utils.normalize_path(joined_space(settings))
+      Grape::Router.normalize_path(joined_space(settings))
     end
   end
 end

data/lib/grape/parser.rb

@@ -1,8 +1,10 @@
 module Grape
   module Parser
+    extend Util::Registrable
+
     class << self
       def builtin_parsers
-        {
+        @builtin_parsers ||= {
           json: Grape::Parser::Json,
           jsonapi: Grape::Parser::Json,
           xml: Grape::Parser::Xml
@@ -10,7 +12,7 @@ module Grape
       end
 
       def parsers(options)
-        builtin_parsers.merge(options[:parsers] || {})
+        builtin_parsers.merge(default_elements).merge(options[:parsers] || {})
       end
 
       def parser_for(api_format, options = {})

data/lib/grape/path.rb

@@ -2,7 +2,7 @@ module Grape
   # Represents a path to an endpoint.
   class Path
     def self.prepare(raw_path, namespace, settings)
-      Path.new(raw_path, namespace, settings).path_with_suffix
+      Path.new(raw_path, namespace, settings)
     end
 
     attr_reader :raw_path, :namespace, :settings
@@ -22,7 +22,7 @@ module Grape
     end
 
     def uses_specific_format?
-      !!(settings[:format] && settings[:content_types].size == 1)
+      !!(settings[:format] && Array(settings[:content_types]).size == 1)
     end
 
     def uses_path_versioning?
@@ -48,7 +48,7 @@ module Grape
     end
 
     def path
-      Rack::Mount::Utils.normalize_path(parts.join('/'))
+      Grape::Router.normalize_path(parts.join('/'))
     end
 
     def path_with_suffix

data/lib/grape/request.rb

@@ -16,8 +16,8 @@ module Grape
 
     def build_params
       params = Hashie::Mash.new(rack_params)
-      if env[Grape::Env::RACK_ROUTING_ARGS]
-        args = env[Grape::Env::RACK_ROUTING_ARGS].dup
+      if env[Grape::Env::GRAPE_ROUTING_ARGS]
+        args = env[Grape::Env::GRAPE_ROUTING_ARGS].dup
         # preserve version from query string parameters
         args.delete(:version)
         args.delete(:route_info)

data/lib/grape/router.rb

@@ -0,0 +1,156 @@
+require 'grape/router/route'
+
+module Grape
+  class Router
+    attr_reader :map, :compiled
+
+    class Any < AttributeTranslator
+      def initialize(pattern, attributes = {})
+        @pattern = pattern
+        super(attributes)
+      end
+    end
+
+    def initialize
+      @neutral_map = []
+      @map = Hash.new { |hash, key| hash[key] = [] }
+      @optimized_map = Hash.new { |hash, key| hash[key] = // }
+    end
+
+    def compile!
+      return if compiled
+      @union = Regexp.union(@neutral_map.map(&:regexp))
+      map.each do |method, routes|
+        @optimized_map[method] = routes.map.with_index do |route, index|
+          route.index = index
+          route.regexp = /(?<_#{index}>#{route.pattern.to_regexp})/
+        end
+        @optimized_map[method] = Regexp.union(@optimized_map[method])
+      end
+      @compiled = true
+    end
+
+    def append(route)
+      map[route.request_method.to_s.upcase] << route
+    end
+
+    def associate_routes(pattern, options = {})
+      regexp = /(?<_#{@neutral_map.length}>)#{pattern.to_regexp}/
+      @neutral_map << Any.new(pattern, options.merge(regexp: regexp, index: @neutral_map.length))
+    end
+
+    def call(env)
+      with_optimization do
+        identity(env) || rotation(env) { |route| route.exec(env) }
+      end
+    end
+
+    def recognize_path(input)
+      any = with_optimization { greedy_match?(input) }
+      return if any == default_response
+      any.endpoint
+    end
+
+    private
+
+    def identity(env)
+      transaction(env) do |input, method, routing_args|
+        route = match?(input, method)
+        if route
+          env[Grape::Env::GRAPE_ROUTING_ARGS] = make_routing_args(routing_args, route, input)
+          route.exec(env)
+        end
+      end
+    end
+
+    def rotation(env)
+      transaction(env) do |input, method, routing_args|
+        response = nil
+        routes_for(method).each do |route|
+          next unless route.match?(input)
+          env[Grape::Env::GRAPE_ROUTING_ARGS] = make_routing_args(routing_args, route, input)
+          response = yield(route)
+          break unless cascade?(response)
+        end
+        response
+      end
+    end
+
+    def transaction(env)
+      input, method, routing_args = *extract_required_args(env)
+      response = yield(input, method, routing_args)
+
+      return response if response && !(cascade = cascade?(response))
+      neighbor = greedy_match?(input)
+      return unless neighbor
+
+      (!cascade && neighbor) ? method_not_allowed(env, neighbor.allow_header, neighbor.endpoint) : nil
+    end
+
+    def make_routing_args(default_args, route, input)
+      args = default_args || { route_info: route }
+      args.merge(route.params(input))
+    end
+
+    def extract_required_args(env)
+      input = string_for(env[Grape::Http::Headers::PATH_INFO])
+      method = env[Grape::Http::Headers::REQUEST_METHOD]
+      routing_args = env[Grape::Env::GRAPE_ROUTING_ARGS]
+      [input, method, routing_args]
+    end
+
+    def with_optimization
+      compile! unless compiled
+      yield || default_response
+    end
+
+    def default_response
+      [404, { Grape::Http::Headers::X_CASCADE => 'pass' }, ['404 Not Found']]
+    end
+
+    def match?(input, method)
+      current_regexp = @optimized_map[method]
+      return unless current_regexp.match(input)
+      last_match = Regexp.last_match
+      @map[method].detect { |route| last_match["_#{route.index}"] }
+    end
+
+    def greedy_match?(input)
+      return unless @union.match(input)
+      last_match = Regexp.last_match
+      @neutral_map.detect { |route| last_match["_#{route.index}"] }
+    end
+
+    def method_not_allowed(env, methods, endpoint)
+      current = endpoint.dup
+      current.instance_eval do
+        run_filters befores, :before
+        @method_not_allowed = true
+        @block = proc do
+          fail Grape::Exceptions::MethodNotAllowed, header.merge('Allow' => methods)
+        end
+      end
+      current.call(env)
+    end
+
+    def cascade?(response)
+      response && response[1][Grape::Http::Headers::X_CASCADE] == 'pass'
+    end
+
+    def routes_for(method)
+      map[method] + map['ANY']
+    end
+
+    def string_for(input)
+      self.class.normalize_path(input)
+    end
+
+    def self.normalize_path(path)
+      path = "/#{path}"
+      path.squeeze!('/')
+      path.sub!(%r{/+\Z}, '')
+      path = '/' if path == ''
+      path
+    end
+  end
+end

data/lib/grape/router/attribute_translator.rb

@@ -0,0 +1,40 @@
+require 'delegate'
+require 'ostruct'
+
+module Grape
+  class Router
+    class AttributeTranslator < DelegateClass(OpenStruct)
+      def self.register(*attributes)
+        AttributeTranslator.supported_attributes.concat(attributes)
+      end
+
+      def self.supported_attributes
+        @supported_attributes ||= []
+      end
+
+      def initialize(attributes = {})
+        ostruct = OpenStruct.new(attributes)
+        super ostruct
+        @attributes = attributes
+        self.class.supported_attributes.each do |name|
+          ostruct.send(:"#{name}=", nil) unless ostruct.respond_to?(name)
+          self.class.instance_eval do
+            define_method(name) { instance_variable_get(:"@#{name}") }
+          end if name == :format
+        end
+      end
+
+      def to_h
+        @attributes.each_with_object({}) do |(key, _), attributes|
+          attributes[key.to_sym] = send(:"#{key}")
+        end
+      end
+
+      private
+
+      def accessor_available?(name)
+        respond_to?(name) && respond_to?(:"#{name}=")
+      end
+    end
+  end
+end

data/lib/grape/router/pattern.rb

@@ -0,0 +1,55 @@
+require 'forwardable'
+require 'mustermann/grape'
+
+module Grape
+  class Router
+    class Pattern
+      DEFAULT_PATTERN_OPTIONS   = { uri_decode: true, type: :grape }.freeze
+      DEFAULT_SUPPORTED_CAPTURE = [:format, :version].freeze
+
+      attr_reader :origin, :path, :capture, :pattern
+
+      extend Forwardable
+      def_delegators :pattern, :named_captures, :params
+      def_delegators :@regexp, :===
+      alias_method :match?, :===
+
+      def initialize(pattern, options = {})
+        @origin  = pattern
+        @path    = build_path(pattern, options)
+        @capture = extract_capture(options)
+        @pattern = Mustermann.new(@path, pattern_options)
+        @regexp  = to_regexp
+      end
+
+      def to_regexp
+        @to_regexp ||= @pattern.to_regexp
+      end
+
+      private
+
+      def pattern_options
+        options = DEFAULT_PATTERN_OPTIONS.dup
+        options.merge!(capture: capture) if capture.present?
+        options
+      end
+
+      def build_path(pattern, options = {})
+        pattern << '*path' unless options[:anchor] || pattern.end_with?('*path')
+        pattern + options[:suffix].to_s
+      end
+
+      def extract_capture(options = {})
+        requirements = {}.merge(options[:requirements])
+        supported_capture.each_with_object(requirements) do |field, capture|
+          option = Array(options[field])
+          capture[field] = option.map(&:to_s) if option.present?
+        end
+      end
+
+      def supported_capture
+        DEFAULT_SUPPORTED_CAPTURE
+      end
+    end
+  end
+end