grape 0.9.0 → 0.10.0

data/lib/grape/dsl/validations.rb

@@ -5,10 +5,13 @@ module Grape
     module Validations
       extend ActiveSupport::Concern
 
+      include Grape::DSL::Configuration
+
       module ClassMethods
         def reset_validations!
-          settings.peek[:declared_params] = []
-          settings.peek[:validations] = []
+          unset_namespace_stackable :declared_params
+          unset_namespace_stackable :validations
+          unset_namespace_stackable :params
         end
 
         def params(&block)
@@ -16,11 +19,16 @@ module Grape
         end
 
         def document_attribute(names, opts)
-          @last_description ||= {}
-          @last_description[:params] ||= {}
+          route_setting(:description, {}) unless route_setting(:description)
+
+          route_setting(:description)[:params] ||= {}
+
+          setting = route_setting(:description)[:params]
           Array(names).each do |name|
-            @last_description[:params][name[:full_name].to_s] ||= {}
-            @last_description[:params][name[:full_name].to_s].merge!(opts)
+            setting[name[:full_name].to_s] ||= {}
+            setting[name[:full_name].to_s].merge!(opts)
+
+            namespace_stackable(:params, name[:full_name].to_s => opts)
           end
         end
       end

data/lib/grape/endpoint.rb

@@ -4,7 +4,9 @@ module Grape
   # on the instance level of this class may be called
   # from inside a `get`, `post`, etc.
   class Endpoint
-    attr_accessor :block, :source, :options, :settings
+    include Grape::DSL::Settings
+
+    attr_accessor :block, :source, :options
     attr_reader :env, :request, :headers, :params
 
     include Grape::DSL::InsideRoute
@@ -37,7 +39,7 @@ module Grape
       # @raise [NameError] an instance method with the same name already exists
       def generate_api_method(method_name, &block)
         if instance_methods.include?(method_name.to_sym) || instance_methods.include?(method_name.to_s)
-          raise NameError.new("method #{method_name.inspect} already exists and cannot be used as an unbound method name")
+          fail NameError.new("method #{method_name.inspect} already exists and cannot be used as an unbound method name")
         end
         define_method(method_name, &block)
         method = instance_method(method_name)
@@ -46,12 +48,17 @@ module Grape
       end
     end
 
-    def initialize(settings, options = {}, &block)
+    def initialize(new_settings, options = {}, &block)
       require_option(options, :path)
       require_option(options, :method)
 
-      @settings = settings
-      @settings[:default_error_status] ||= 500
+      self.inheritable_setting = new_settings.point_in_time_copy
+
+      route_setting(:saved_declared_params, namespace_stackable(:declared_params))
+      route_setting(:saved_validations, namespace_stackable(:validations))
+
+      namespace_stackable(:representations, []) unless namespace_stackable(:representations)
+      namespace_inheritable(:default_error_status, 500) unless namespace_inheritable(:default_error_status)
 
       @options = options
 
@@ -68,29 +75,40 @@ module Grape
     end
 
     def require_option(options, key)
-      raise Grape::Exceptions::MissingOption.new(key) unless options.key?(key)
+      fail Grape::Exceptions::MissingOption.new(key) unless options.key?(key)
     end
 
     def method_name
       [options[:method],
-       Namespace.joined_space(settings),
-       settings.gather(:mount_path).join('/'),
+       Namespace.joined_space(namespace_stackable(:namespace)),
+       (namespace_stackable(:mount_path) || []).join('/'),
        options[:path].join('/')
-     ].join(" ")
+     ].join(' ')
     end
 
     def routes
       @routes ||= endpoints ? endpoints.collect(&:routes).flatten : prepare_routes
     end
 
+    def reset_routes!
+      endpoints.map(&:reset_routes!) if endpoints
+      @namespace = nil
+      @routes = nil
+    end
+
     def mount_in(route_set)
       if endpoints
-        endpoints.each { |e| e.mount_in(route_set) }
+        endpoints.each do |e|
+          e.inheritable_setting.inherit_from inheritable_setting
+          e.mount_in(route_set)
+        end
       else
+        @routes = nil
+
         routes.each do |route|
           methods = [route.route_method]
-          if !settings[:do_not_route_head] && route.route_method == "GET"
-            methods << "HEAD"
+          if !namespace_inheritable(:do_not_route_head) && route.route_method == 'GET'
+            methods << 'HEAD'
           end
           methods.each do |method|
             route_set.add_route(self, {
@@ -102,56 +120,63 @@ module Grape
       end
     end
 
-    def prepare_routes
-      routes = []
-      options[:method].each do |method|
-        options[:path].each do |path|
-          prepared_path = prepare_path(path)
+    def prepare_routes_requirements
+      endpoint_requirements = options[:route_options][:requirements] || {}
+      all_requirements = (namespace_stackable(:namespace).map(&:requirements) << endpoint_requirements)
+      all_requirements.reduce({}) do |base_requirements, single_requirements|
+        base_requirements.merge!(single_requirements)
+      end
+    end
 
-          anchor = options[:route_options][:anchor]
-          anchor = anchor.nil? ? true : anchor
+    def prepare_routes_path_params(path)
+      path_params = {}
 
-          endpoint_requirements = options[:route_options][:requirements] || {}
-          all_requirements = (settings.gather(:namespace).map(&:requirements) << endpoint_requirements)
-          requirements = all_requirements.reduce({}) do |base_requirements, single_requirements|
-            base_requirements.merge!(single_requirements)
-          end
+      # 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] = '' }
+
+      # 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
 
-          path = compile_path(prepared_path, anchor && !options[:app], requirements)
-          regex = Rack::Mount::RegexpWithNamedGroups.new(path)
-          path_params = {}
-          # named parameters in the api path
-          named_params = regex.named_captures.map { |nc| nc[0] } - %w(version format)
-          named_params.each { |named_param| path_params[named_param] = "" }
-          # route parameters declared via desc or appended to the api declaration
-          route_params = (options[:route_options][:params] || {})
-          path_params.merge!(route_params)
+      path_params
+    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)
-          routes << Route.new(options[:route_options].clone.merge(
-            prefix: settings[:root_prefix],
-            version: settings[:version] ? settings[:version].join('|') : nil,
+
+          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: path_params,
-            compiled: path
+            params: prepare_routes_path_params(path),
+            compiled: path,
+            settings: inheritable_setting.route.except(:saved_declared_params, :saved_validations)
           ))
         end
-      end
-      routes
+      end.flatten
     end
 
     def prepare_path(path)
-      Path.prepare(path, namespace, settings)
+      path_settings = inheritable_setting.to_hash[:namespace_stackable].merge(inheritable_setting.to_hash[:namespace_inheritable])
+      Path.prepare(path, namespace, path_settings)
     end
 
     def namespace
-      @namespace ||= Namespace.joined_space_path(settings)
+      @namespace ||= Namespace.joined_space_path(namespace_stackable(:namespace))
     end
 
     def compile_path(prepared_path, anchor = true, requirements = {})
       endpoint_options = {}
-      endpoint_options[:version] = /#{settings[:version].join('|')}/ if settings[:version]
+      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
@@ -168,7 +193,7 @@ module Grape
         options[:app].call(env)
       else
         builder = build_middleware
-        builder.run options[:app] || lambda { |arg| run(arg) }
+        builder.run lambda { |arg| run(arg) }
         builder.call(env)
       end
     end
@@ -203,7 +228,10 @@ module Grape
 
       # Retrieve validations from this namespace and all parent namespaces.
       validation_errors = []
-      settings.gather(:validations).each do |validator|
+
+      # require 'pry-byebug'; binding.pry
+
+      route_setting(:saved_validations).each do |validator|
         begin
           validator.validate!(params)
         rescue Grape::Exceptions::Validation => e
@@ -212,7 +240,7 @@ module Grape
       end
 
       if validation_errors.any?
-        raise Grape::Exceptions::ValidationErrors, errors: validation_errors
+        fail Grape::Exceptions::ValidationErrors, errors: validation_errors
       end
 
       run_filters after_validations
@@ -229,18 +257,18 @@ module Grape
 
       b.use Rack::Head
       b.use Grape::Middleware::Error,
-            format: settings[:format],
-            content_types: settings[:content_types],
-            default_status: settings[:default_error_status],
-            rescue_all: settings[:rescue_all],
-            default_error_formatter: settings[:default_error_formatter],
-            error_formatters: settings[:error_formatters],
-            rescue_options: settings[:rescue_options],
-            rescue_handlers: merged_setting(:rescue_handlers),
-            base_only_rescue_handlers: merged_setting(:base_only_rescue_handlers),
-            all_rescue_handler: settings[:all_rescue_handler]
-
-      aggregate_setting(:middleware).each do |m|
+            format: namespace_inheritable(:format),
+            content_types: Grape::DSL::Configuration.stacked_hash_to_hash(namespace_stackable(:content_types)),
+            default_status: namespace_inheritable(:default_error_status),
+            rescue_all: namespace_inheritable(:rescue_all),
+            default_error_formatter: namespace_inheritable(:default_error_formatter),
+            error_formatters: Grape::DSL::Configuration.stacked_hash_to_hash(namespace_stackable(:error_formatters)),
+            rescue_options: Grape::DSL::Configuration.stacked_hash_to_hash(namespace_stackable(:rescue_options)) || {},
+            rescue_handlers: Grape::DSL::Configuration.stacked_hash_to_hash(namespace_stackable(:rescue_handlers)) || {},
+            base_only_rescue_handlers: Grape::DSL::Configuration.stacked_hash_to_hash(namespace_stackable(:base_only_rescue_handlers)) || {},
+            all_rescue_handler: namespace_inheritable(:all_rescue_handler)
+
+      (namespace_stackable(:middleware) || []).each do |m|
         m = m.dup
         block = m.pop if m.last.is_a?(Proc)
         if block
@@ -250,42 +278,30 @@ module Grape
         end
       end
 
-      if settings[:version]
-        b.use Grape::Middleware::Versioner.using(settings[:version_options][:using]),
-              versions: settings[:version] ? settings[:version].flatten : nil,
-              version_options: settings[:version_options],
-              prefix: settings[:root_prefix]
+      if namespace_inheritable(:version)
+        b.use Grape::Middleware::Versioner.using(namespace_inheritable(:version_options)[:using]),
+              versions: namespace_inheritable(:version) ? namespace_inheritable(:version).flatten : nil,
+              version_options: namespace_inheritable(:version_options),
+              prefix: namespace_inheritable(:root_prefix)
 
       end
 
       b.use Grape::Middleware::Formatter,
-            format: settings[:format],
-            default_format: settings[:default_format] || :txt,
-            content_types: settings[:content_types],
-            formatters: settings[:formatters],
-            parsers: settings[:parsers]
+            format: namespace_inheritable(:format),
+            default_format: namespace_inheritable(:default_format) || :txt,
+            content_types: Grape::DSL::Configuration.stacked_hash_to_hash(namespace_stackable(:content_types)),
+            formatters: Grape::DSL::Configuration.stacked_hash_to_hash(namespace_stackable(:formatters)),
+            parsers: Grape::DSL::Configuration.stacked_hash_to_hash(namespace_stackable(:parsers))
 
       b
     end
 
     def helpers
-      m = Module.new
-      settings.stack.each do |frame|
-        m.send :include, frame[:helpers] if frame[:helpers]
-      end
-      m
-    end
-
-    def aggregate_setting(key)
-      settings.stack.inject([]) do |aggregate, frame|
-        aggregate + (frame[key] || [])
-      end
-    end
-
-    def merged_setting(key)
-      settings.stack.inject({}) do |merged, frame|
-        merged.merge(frame[key] || {})
+      mod = Module.new
+      (namespace_stackable(:helpers) || []).each do |mod_to_include|
+        mod.send :include, mod_to_include
       end
+      mod
     end
 
     def run_filters(filters)
@@ -295,19 +311,19 @@ module Grape
     end
 
     def befores
-      aggregate_setting(:befores)
+      namespace_stackable(:befores) || []
     end
 
     def before_validations
-      aggregate_setting(:before_validations)
+      namespace_stackable(:before_validations) || []
     end
 
     def after_validations
-      aggregate_setting(:after_validations)
+      namespace_stackable(:after_validations) || []
     end
 
     def afters
-      aggregate_setting(:afters)
+      namespace_stackable(:afters) || []
     end
   end
 end

data/lib/grape/exceptions/base.rb

@@ -28,7 +28,7 @@ module Grape
           @problem = problem(key, attributes)
           @summary = summary(key, attributes)
           @resolution = resolution(key, attributes)
-          [["Problem", @problem], ["Summary", @summary], ["Resolution", @resolution]].reduce("") do |message, detail_array|
+          [['Problem', @problem], ['Summary', @summary], ['Resolution', @resolution]].reduce('') do |message, detail_array|
             message <<  "\n#{detail_array[0]}:\n  #{detail_array[1]}" unless detail_array[1].blank?
             message
           end
@@ -52,7 +52,7 @@ module Grape
       def translate_attributes(keys, options = {})
         keys.map do |key|
           translate("#{BASE_ATTRIBUTES_KEY}.#{key}", { default: key }.merge(options))
-        end.join(", ")
+        end.join(', ')
       end
 
       def translate_attribute(key, options = {})

data/lib/grape/exceptions/incompatible_option_values.rb

@@ -3,7 +3,7 @@ module Grape
   module Exceptions
     class IncompatibleOptionValues < Base
       def initialize(option1, value1, option2, value2)
-        super(message: compose_message("incompatible_option_values", option1: option1, value1: value1, option2: option2, value2: value2))
+        super(message: compose_message('incompatible_option_values', option1: option1, value1: value1, option2: option2, value2: value2))
       end
     end
   end

data/lib/grape/exceptions/invalid_formatter.rb

@@ -3,7 +3,7 @@ module Grape
   module Exceptions
     class InvalidFormatter < Base
       def initialize(klass, to_format)
-        super(message: compose_message("invalid_formatter", klass: klass, to_format: to_format))
+        super(message: compose_message('invalid_formatter', klass: klass, to_format: to_format))
       end
     end
   end

data/lib/grape/exceptions/invalid_versioner_option.rb

@@ -3,7 +3,7 @@ module Grape
   module Exceptions
     class InvalidVersionerOption < Base
       def initialize(strategy)
-        super(message: compose_message("invalid_versioner_option", strategy: strategy))
+        super(message: compose_message('invalid_versioner_option', strategy: strategy))
       end
     end
   end

data/lib/grape/exceptions/invalid_with_option_for_represent.rb

@@ -3,7 +3,7 @@ module Grape
   module Exceptions
     class InvalidWithOptionForRepresent < Base
       def initialize
-        super(message: compose_message("invalid_with_option_for_represent"))
+        super(message: compose_message('invalid_with_option_for_represent'))
       end
     end
   end

data/lib/grape/exceptions/missing_mime_type.rb

@@ -3,7 +3,7 @@ module Grape
   module Exceptions
     class MissingMimeType < Base
       def initialize(new_format)
-        super(message: compose_message("missing_mime_type", new_format: new_format))
+        super(message: compose_message('missing_mime_type', new_format: new_format))
       end
     end
   end

data/lib/grape/exceptions/missing_option.rb

@@ -3,7 +3,7 @@ module Grape
   module Exceptions
     class MissingOption < Base
       def initialize(option)
-        super(message: compose_message("missing_option", option: option))
+        super(message: compose_message('missing_option', option: option))
       end
     end
   end

data/lib/grape/exceptions/missing_vendor_option.rb

@@ -3,7 +3,7 @@ module Grape
   module Exceptions
     class MissingVendorOption < Base
       def initialize
-        super(message: compose_message("missing_vendor_option"))
+        super(message: compose_message('missing_vendor_option'))
       end
     end
   end

data/lib/grape/exceptions/unknown_options.rb

@@ -3,7 +3,7 @@ module Grape
   module Exceptions
     class UnknownOptions < Base
       def initialize(options)
-        super(message: compose_message("unknown_options", options: options))
+        super(message: compose_message('unknown_options', options: options))
       end
     end
   end