grape 0.15.0 → 0.16.1

data/grape.gemspec

@@ -13,7 +13,7 @@ Gem::Specification.new do |s|
   s.license     = 'MIT'
 
   s.add_runtime_dependency 'rack', '>= 1.3.0'
-  s.add_runtime_dependency 'rack-mount'
+  s.add_runtime_dependency 'mustermann19', '~> 0.4.3'
   s.add_runtime_dependency 'rack-accept'
   s.add_runtime_dependency 'activesupport'
   s.add_runtime_dependency 'multi_json', '>= 1.3.2'
@@ -23,7 +23,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency 'builder'
 
   s.add_development_dependency 'grape-entity', '>= 0.4.4'
-  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rake', '~> 10'
   s.add_development_dependency 'maruku'
   s.add_development_dependency 'yard'
   s.add_development_dependency 'rack-test'

data/lib/grape.rb

@@ -1,6 +1,5 @@
 require 'logger'
 require 'rack'
-require 'rack/mount'
 require 'rack/builder'
 require 'rack/accept'
 require 'rack/auth/basic'
@@ -33,8 +32,8 @@ module Grape
   eager_autoload do
     autoload :API
     autoload :Endpoint
+    autoload :Router
 
-    autoload :Route
     autoload :Namespace
 
     autoload :Path
@@ -78,28 +77,6 @@ module Grape
     autoload :MethodNotAllowed
   end
 
-  module ErrorFormatter
-    extend ActiveSupport::Autoload
-    autoload :Base
-    autoload :Json
-    autoload :Txt
-    autoload :Xml
-  end
-
-  module Formatter
-    extend ActiveSupport::Autoload
-    autoload :Json
-    autoload :SerializableHash
-    autoload :Txt
-    autoload :Xml
-  end
-
-  module Parser
-    extend ActiveSupport::Autoload
-    autoload :Json
-    autoload :Xml
-  end
-
   module Middleware
     extend ActiveSupport::Autoload
     autoload :Base
@@ -131,8 +108,29 @@ module Grape
     autoload :StackableValues
     autoload :InheritableSetting
     autoload :StrictHashConfiguration
-    autoload :FileResponse
-    autoload :SendfileResponse
+    autoload :Registrable
+  end
+
+  module ErrorFormatter
+    extend ActiveSupport::Autoload
+    autoload :Base
+    autoload :Json
+    autoload :Txt
+    autoload :Xml
+  end
+
+  module Formatter
+    extend ActiveSupport::Autoload
+    autoload :Json
+    autoload :SerializableHash
+    autoload :Txt
+    autoload :Xml
+  end
+
+  module Parser
+    extend ActiveSupport::Autoload
+    autoload :Json
+    autoload :Xml
   end
 
   module DSL
@@ -163,6 +161,13 @@ module Grape
     extend ActiveSupport::Autoload
     autoload :Presenter
   end
+
+  module ServeFile
+    extend ActiveSupport::Autoload
+    autoload :FileResponse
+    autoload :FileBody
+    autoload :SendfileResponse
+  end
 end
 
 require 'grape/util/content_types'

data/lib/grape/api.rb

@@ -1,3 +1,5 @@
+require 'grape/router'
+
 module Grape
   # The API class is the primary entry point for creating Grape APIs. Users
   # should subclass this class in order to build an API.
@@ -52,6 +54,12 @@ module Grape
         end
       end
 
+      # see Grape::Router#recognize_path
+      def recognize_path(path)
+        LOCK.synchronize { compile } unless instance
+        instance.router.recognize_path(path)
+      end
+
       protected
 
       def prepare_routes
@@ -84,27 +92,30 @@ module Grape
       end
     end
 
+    attr_reader :router
+
     # Builds the routes from the defined endpoints, effectively compiling
     # this API into a usable form.
     def initialize
-      @route_set = Rack::Mount::RouteSet.new
+      @router = Router.new
       add_head_not_allowed_methods_and_options_methods
       self.class.endpoints.each do |endpoint|
-        endpoint.mount_in(@route_set)
+        endpoint.mount_in(@router)
       end
 
-      @route_set.freeze
+      @router.compile!
+      @router.freeze
     end
 
     # Handle a request. See Rack documentation for what `env` is.
     def call(env)
-      result = @route_set.call(env)
+      result = @router.call(env)
       result[1].delete(Grape::Http::Headers::X_CASCADE) unless cascade?
       result
     end
 
     # Some requests may return a HTTP 404 error if grape cannot find a matching
-    # route. In this case, Rack::Mount adds a X-Cascade header to the response
+    # route. In this case, Grape::Router adds a X-Cascade header to the response
     # and sets it to 'pass', indicating to grape's parents they should keep
     # looking for a matching route on other resources.
     #
@@ -126,20 +137,24 @@ module Grape
     # will return an HTTP 405 response for any HTTP method that the resource
     # cannot handle.
     def add_head_not_allowed_methods_and_options_methods
-      methods_per_path = {}
+      routes_map = {}
 
       self.class.endpoints.each do |endpoint|
         routes = endpoint.routes
         routes.each do |route|
-          route_path = route.route_path
-                       .gsub(/\(.*\)/, '') # ignore any optional portions
-                       .gsub(%r{\:[^\/.?]+}, ':x') # substitute variable names to avoid conflicts
-
-          methods_per_path[route_path] ||= []
-          methods_per_path[route_path] << route.route_method
+          # using the :any shorthand produces [nil] for route methods, substitute all manually
+          route_key = route.pattern.to_regexp
+          routes_map[route_key] ||= {}
+          route_settings = routes_map[route_key]
+          route_settings[:pattern] = route.pattern
+          route_settings[:requirements] = route.requirements
+          route_settings[:path] = route.origin
+          route_settings[:methods] ||= []
+          route_settings[:methods] << route.request_method
+          route_settings[:endpoint] = route.app
 
           # using the :any shorthand produces [nil] for route methods, substitute all manually
-          methods_per_path[route_path] = %w(GET PUT POST DELETE PATCH HEAD OPTIONS) if methods_per_path[route_path].compact.empty?
+          route_settings[:methods] = %w(GET PUT POST DELETE PATCH HEAD OPTIONS) if route_settings[:methods].include?('ANY')
         end
       end
 
@@ -149,7 +164,9 @@ module Grape
       # informations again.
       without_root_prefix do
         without_versioning do
-          methods_per_path.each do |path, methods|
+          routes_map.each do |_, config|
+            methods = config[:methods]
+            path = config[:path]
             allowed_methods = methods.dup
 
             unless self.class.namespace_inheritable(:do_not_route_head)
@@ -159,18 +176,19 @@ module Grape
             allow_header = (self.class.namespace_inheritable(:do_not_route_options) ? allowed_methods : [Grape::Http::Headers::OPTIONS] | allowed_methods).join(', ')
 
             unless self.class.namespace_inheritable(:do_not_route_options)
-              generate_options_method(path, allow_header) unless allowed_methods.include?(Grape::Http::Headers::OPTIONS)
+              generate_options_method(path, allow_header, config) unless allowed_methods.include?(Grape::Http::Headers::OPTIONS)
             end
 
-            generate_not_allowed_method(path, allowed_methods, allow_header)
+            attributes = config.merge(allowed_methods: allowed_methods, allow_header: allow_header)
+            generate_not_allowed_method(config[:pattern], attributes)
           end
         end
       end
     end
 
     # Generate an 'OPTIONS' route for a pre-exisiting user defined route
-    def generate_options_method(path, allow_header)
-      self.class.options(path, {}) do
+    def generate_options_method(path, allow_header, options = {})
+      self.class.options(path, options) do
         header 'Allow', allow_header
         status 204
         ''
@@ -179,15 +197,13 @@ module Grape
 
     # Generate a route that returns an HTTP 405 response for a user defined
     # path on methods not specified
-    def generate_not_allowed_method(path, allowed_methods, allow_header)
-      not_allowed_methods = %w(GET PUT POST DELETE PATCH HEAD) - allowed_methods
+    def generate_not_allowed_method(pattern, attributes = {})
+      not_allowed_methods = %w(GET PUT POST DELETE PATCH HEAD) - attributes[:allowed_methods]
       not_allowed_methods << Grape::Http::Headers::OPTIONS if self.class.namespace_inheritable(:do_not_route_options)
 
       return if not_allowed_methods.empty?
 
-      self.class.route(not_allowed_methods, path) do
-        fail Grape::Exceptions::MethodNotAllowed, header.merge('Allow' => allow_header)
-      end
+      @router.associate_routes(pattern, attributes.merge(not_allowed_methods: not_allowed_methods))
     end
 
     # Allows definition of endpoints that ignore the versioning configuration

data/lib/grape/dsl/inside_route.rb

@@ -191,8 +191,12 @@ module Grape
       #
       #   GET /file # => "contents of file"
       def file(value = nil)
-        if value
-          @file = Grape::Util::FileResponse.new(value)
+        if value.is_a?(String)
+          file_body = Grape::ServeFile::FileBody.new(value)
+          @file = Grape::ServeFile::FileResponse.new(file_body)
+        elsif !value.is_a?(NilClass)
+          warn '[DEPRECATION] Argument as FileStreamer-like object is deprecated. Use path to file instead.'
+          @file = Grape::ServeFile::FileResponse.new(value)
         else
           @file
         end
@@ -269,10 +273,10 @@ module Grape
       #
       #   desc "Returns the route description."
       #   get '/' do
-      #     route.route_description
+      #     route.description
       #   end
       def route
-        env[Grape::Env::RACK_ROUTING_ARGS][:route_info]
+        env[Grape::Env::GRAPE_ROUTING_ARGS][:route_info]
       end
 
       # Attempt to locate the Entity class for a given object, if not given

data/lib/grape/dsl/routing.rb

@@ -82,7 +82,7 @@ module Grape
             in_setting = inheritable_setting
 
             if app.respond_to?(:inheritable_setting, true)
-              mount_path = Rack::Mount::Utils.normalize_path(path)
+              mount_path = Grape::Router.normalize_path(path)
               app.top_level_setting.namespace_stackable[:mount_path] = mount_path
 
               app.inherit_settings(inheritable_setting)
@@ -98,6 +98,7 @@ module Grape
               method: :any,
               path: path,
               app: app,
+              forward_match: !app.respond_to?(:inheritable_setting),
               for: self
             )
           end

data/lib/grape/endpoint.rb

@@ -110,7 +110,7 @@ module Grape
     end
 
     def routes
-      @routes ||= endpoints ? endpoints.collect(&:routes).flatten : prepare_routes
+      @routes ||= endpoints ? endpoints.collect(&:routes).flatten : to_routes
     end
 
     def reset_routes!
@@ -119,29 +119,36 @@ module Grape
       @routes = nil
     end
 
-    def mount_in(route_set)
+    def mount_in(router)
       if endpoints
-        endpoints.each do |e|
-          e.mount_in(route_set)
-        end
+        endpoints.each { |e| e.mount_in(router) }
       else
         reset_routes!
-
         routes.each do |route|
-          methods = [route.route_method]
-          if !namespace_inheritable(:do_not_route_head) && route.route_method == Grape::Http::Headers::GET
+          methods = [route.request_method]
+          if !namespace_inheritable(:do_not_route_head) && route.request_method == Grape::Http::Headers::GET
             methods << Grape::Http::Headers::HEAD
           end
           methods.each do |method|
-            route_set.add_route(self, {
-                                  path_info: route.route_compiled,
-                                  request_method: method
-                                }, route_info: route)
+            unless route.request_method.to_s.upcase == method
+              route = Grape::Router::Route.new(method, route.origin, route.attributes.to_h)
+            end
+            router.append(route.apply(self))
           end
         end
       end
     end
 
+    def to_routes
+      route_options = prepare_default_route_attributes
+      map_routes do |method, path|
+        path = prepare_path(path)
+        params = merge_route_options(route_options.merge(suffix: path.suffix))
+        route = Router::Route.new(method, path.path, params)
+        route.apply(self)
+      end.flatten
+    end
+
     def prepare_routes_requirements
       endpoint_requirements = options[:route_options][:requirements] || {}
       all_requirements = (namespace_stackable(:namespace).map(&:requirements) << endpoint_requirements)
@@ -150,41 +157,30 @@ module Grape
       end
     end
 
-    def prepare_routes_path_params(path)
-      path_params = {}
-
-      # named parameters in the api path
-      regex = Rack::Mount::RegexpWithNamedGroups.new(path)
-      named_params = regex.named_captures.map { |nc| nc[0] } - %w(version format)
-      named_params.each { |named_param| path_params[named_param] = '' }
+    def prepare_default_route_attributes
+      {
+        namespace: namespace,
+        version: prepare_version,
+        requirements: prepare_routes_requirements,
+        prefix: namespace_inheritable(:root_prefix),
+        anchor: options[:route_options].fetch(:anchor, true),
+        settings: inheritable_setting.route.except(:saved_declared_params, :saved_validations),
+        forward_match: options[:forward_match]
+      }
+    end
 
-      # route parameters declared via desc or appended to the api declaration
-      route_params = options[:route_options][:params]
-      path_params.merge! route_params if route_params
+    def prepare_version
+      version = namespace_inheritable(:version) || []
+      return if version.length == 0
+      version.length == 1 ? version.first.to_s : version
+    end
 
-      path_params
+    def merge_route_options(default = {})
+      options[:route_options].clone.reverse_merge(default)
     end
 
-    def prepare_routes
-      options[:method].map do |method|
-        options[:path].map do |path|
-          prepared_path = prepare_path(path)
-          anchor = options[:route_options].fetch(:anchor, true)
-          path = compile_path(prepared_path, anchor && !options[:app], prepare_routes_requirements)
-          request_method = (method.to_s.upcase unless method == :any)
-
-          Route.new(options[:route_options].clone.merge(
-                      prefix: namespace_inheritable(:root_prefix),
-                      version: namespace_inheritable(:version) ? namespace_inheritable(:version).join('|') : nil,
-                      namespace: namespace,
-                      method: request_method,
-                      path: prepared_path,
-                      params: prepare_routes_path_params(path),
-                      compiled: path,
-                      settings: inheritable_setting.route.except(:saved_declared_params, :saved_validations)
-          ))
-        end
-      end.flatten
+    def map_routes
+      options[:method].map { |method| options[:path].map { |path| yield method, path } }
     end
 
     def prepare_path(path)
@@ -196,13 +192,6 @@ module Grape
       @namespace ||= Namespace.joined_space_path(namespace_stackable(:namespace))
     end
 
-    def compile_path(prepared_path, anchor = true, requirements = {})
-      endpoint_options = {}
-      endpoint_options[:version] = /#{namespace_inheritable(:version).join('|')}/ if namespace_inheritable(:version)
-      endpoint_options.merge!(requirements)
-      Rack::Mount::Strexp.compile(prepared_path, endpoint_options, %w( / . ? ), anchor)
-    end
-
     def call(env)
       lazy_initialize!
       dup.call!(env)
@@ -242,7 +231,7 @@ module Grape
 
         run_filters before_validations, :before_validation
 
-        run_validators validations, request
+        run_validators validations, request unless @method_not_allowed
 
         run_filters after_validations, :after_validation
 
@@ -275,11 +264,7 @@ module Grape
       (namespace_stackable(:middleware) || []).each do |m|
         m = m.dup
         block = m.pop if m.last.is_a?(Proc)
-        if block
-          b.use(*m, &block)
-        else
-          b.use(*m)
-        end
+        block ? b.use(*m, &block) : b.use(*m)
       end
 
       if namespace_inheritable(:version)
@@ -305,9 +290,7 @@ module Grape
     def build_helpers
       helpers = namespace_stackable(:helpers) || []
       Module.new do
-        helpers.each do |mod_to_include|
-          include mod_to_include
-        end
+        helpers.each { |mod_to_include| include mod_to_include }
       end
     end
 
@@ -348,9 +331,7 @@ module Grape
 
     def run_filters(filters, type = :other)
       ActiveSupport::Notifications.instrument('endpoint_run_filters.grape', endpoint: self, filters: filters, type: type) do
-        (filters || []).each do |filter|
-          instance_eval(&filter)
-        end
+        (filters || []).each { |filter| instance_eval(&filter) }
       end
       post_extension = DSL::InsideRoute.post_filter_methods(type)
       extend post_extension if post_extension