grape 0.9.0 → 0.10.0

data/lib/grape/dsl/middleware.rb

@@ -5,6 +5,8 @@ module Grape
     module Middleware
       extend ActiveSupport::Concern
 
+      include Grape::DSL::Configuration
+
       module ClassMethods
         # Apply a custom middleware to the API. Applies
         # to the current namespace and any children, but
@@ -15,17 +17,15 @@ module Grape
         def use(middleware_class, *args, &block)
           arr = [middleware_class, *args]
           arr << block if block_given?
-          imbue(:middleware, [arr])
+
+          namespace_stackable(:middleware, arr)
         end
 
         # Retrieve an array of the middleware classes
         # and arguments that are currently applied to the
         # application.
         def middleware
-          settings.stack.inject([]) do |a, s|
-            a += s[:middleware] if s[:middleware]
-            a
-          end
+          namespace_stackable(:middleware) || []
         end
       end
     end

data/lib/grape/dsl/parameters.rb

@@ -6,11 +6,11 @@ module Grape
       extend ActiveSupport::Concern
 
       def use(*names)
-        named_params = @api.settings[:named_params] || {}
+        named_params = Grape::DSL::Configuration.stacked_hash_to_hash(@api.namespace_stackable(:named_params)) || {}
         options = names.last.is_a?(Hash) ? names.pop : {}
         names.each do |name|
           params_block = named_params.fetch(name) do
-            raise "Params :#{name} not found!"
+            fail "Params :#{name} not found!"
           end
           instance_exec(options, &params_block)
         end
@@ -57,6 +57,10 @@ module Grape
         validates(attrs, at_least_one_of: true)
       end
 
+      def all_or_none_of(*attrs)
+        validates(attrs, all_or_none_of: true)
+      end
+
       def group(*attrs, &block)
         requires(*attrs, &block)
       end

data/lib/grape/dsl/request_response.rb

@@ -5,46 +5,48 @@ module Grape
     module RequestResponse
       extend ActiveSupport::Concern
 
+      include Grape::DSL::Configuration
+
       module ClassMethods
         # Specify the default format for the API's serializers.
         # May be `:json` or `:txt` (default).
         def default_format(new_format = nil)
-          new_format ? set(:default_format, new_format.to_sym) : settings[:default_format]
+          namespace_inheritable(:default_format, new_format.nil? ? nil : new_format.to_sym)
         end
 
         # Specify the format for the API's serializers.
         # May be `:json`, `:xml`, `:txt`, etc.
         def format(new_format = nil)
           if new_format
-            set(:format, new_format.to_sym)
+            namespace_inheritable(:format, new_format.to_sym)
             # define the default error formatters
-            set(:default_error_formatter, Grape::ErrorFormatter::Base.formatter_for(new_format, {}))
+            namespace_inheritable(:default_error_formatter, Grape::ErrorFormatter::Base.formatter_for(new_format, {}))
             # define a single mime type
             mime_type = content_types[new_format.to_sym]
-            raise Grape::Exceptions::MissingMimeType.new(new_format) unless mime_type
-            settings.imbue(:content_types, new_format.to_sym => mime_type)
+            fail Grape::Exceptions::MissingMimeType.new(new_format) unless mime_type
+            namespace_stackable(:content_types, new_format.to_sym => mime_type)
           else
-            settings[:format]
+            namespace_inheritable(:format)
           end
         end
 
         # Specify a custom formatter for a content-type.
         def formatter(content_type, new_formatter)
-          settings.imbue(:formatters, content_type.to_sym => new_formatter)
+          namespace_stackable(:formatters, content_type.to_sym => new_formatter)
         end
 
         # Specify a custom parser for a content-type.
         def parser(content_type, new_parser)
-          settings.imbue(:parsers, content_type.to_sym => new_parser)
+          namespace_stackable(:parsers, content_type.to_sym => new_parser)
         end
 
         # Specify a default error formatter.
         def default_error_formatter(new_formatter_name = nil)
           if new_formatter_name
             new_formatter = Grape::ErrorFormatter::Base.formatter_for(new_formatter_name, {})
-            set(:default_error_formatter, new_formatter)
+            namespace_inheritable(:default_error_formatter, new_formatter)
           else
-            settings[:default_error_formatter]
+            namespace_inheritable(:default_error_formatter)
           end
         end
 
@@ -55,23 +57,24 @@ module Grape
             formatter = options
           end
 
-          settings.imbue(:error_formatters, format.to_sym => formatter)
+          namespace_stackable(:error_formatters, format.to_sym => formatter)
         end
 
         # Specify additional content-types, e.g.:
         #   content_type :xls, 'application/vnd.ms-excel'
         def content_type(key, val)
-          settings.imbue(:content_types, key.to_sym => val)
+          namespace_stackable(:content_types, key.to_sym => val)
         end
 
         # All available content types.
         def content_types
-          Grape::ContentTypes.content_types_for(settings[:content_types])
+          c_types = Grape::DSL::Configuration.stacked_hash_to_hash(namespace_stackable(:content_types))
+          Grape::ContentTypes.content_types_for c_types
         end
 
         # Specify the default status code for errors.
         def default_error_status(new_status = nil)
-          new_status ? set(:default_error_status, new_status) : settings[:default_error_status]
+          namespace_inheritable(:default_error_status, new_status)
         end
 
         # Allows you to rescue certain exceptions that occur to return
@@ -105,8 +108,8 @@ module Grape
           handler ||= proc { options[:with] } if options.key?(:with)
 
           if args.include?(:all)
-            set(:rescue_all, true)
-            imbue :all_rescue_handler, handler
+            namespace_inheritable(:rescue_all, true)
+            namespace_inheritable :all_rescue_handler, handler
           else
             handler_type =
                 case options[:rescue_subclasses]
@@ -116,10 +119,10 @@ module Grape
                   :base_only_rescue_handlers
                 end
 
-            imbue handler_type, Hash[args.map { |arg| [arg, handler] }]
+            namespace_stackable handler_type, Hash[args.map { |arg| [arg, handler] }]
           end
 
-          imbue(:rescue_options, options)
+          namespace_stackable(:rescue_options, options)
         end
 
         # Allows you to specify a default representation entity for a
@@ -143,8 +146,8 @@ module Grape
         # @param model_class [Class] The model class that will be represented.
         # @option options [Class] :with The entity class that will represent the model.
         def represent(model_class, options)
-          raise Grape::Exceptions::InvalidWithOptionForRepresent.new unless options[:with] && options[:with].is_a?(Class)
-          imbue(:representations, model_class => options[:with])
+          fail Grape::Exceptions::InvalidWithOptionForRepresent.new unless options[:with] && options[:with].is_a?(Class)
+          namespace_stackable(:representations, model_class => options[:with])
         end
       end
     end

data/lib/grape/dsl/routing.rb

@@ -4,6 +4,7 @@ module Grape
   module DSL
     module Routing
       extend ActiveSupport::Concern
+      include Grape::DSL::Configuration
 
       module ClassMethods
         attr_reader :endpoints, :routes, :route_set
@@ -31,12 +32,12 @@ module Grape
             options ||= {}
             options = { using: :path }.merge(options)
 
-            raise Grape::Exceptions::MissingVendorOption.new if options[:using] == :header && !options.key?(:vendor)
+            fail Grape::Exceptions::MissingVendorOption.new if options[:using] == :header && !options.key?(:vendor)
 
             @versions = versions | args
             nest(block) do
-              set(:version, args)
-              set(:version_options, options)
+              namespace_inheritable(:version, args)
+              namespace_inheritable(:version_options, options)
             end
           end
 
@@ -45,33 +46,44 @@ module Grape
 
         # Define a root URL prefix for your entire API.
         def prefix(prefix = nil)
-          prefix ? set(:root_prefix, prefix) : settings[:root_prefix]
+          namespace_inheritable(:root_prefix, prefix)
         end
 
         # Do not route HEAD requests to GET requests automatically
         def do_not_route_head!
-          set(:do_not_route_head, true)
+          namespace_inheritable(:do_not_route_head, true)
         end
 
         # Do not automatically route OPTIONS
         def do_not_route_options!
-          set(:do_not_route_options, true)
+          namespace_inheritable(:do_not_route_options, true)
         end
 
         def mount(mounts)
           mounts = { mounts => '/' } unless mounts.respond_to?(:each_pair)
           mounts.each_pair do |app, path|
-            if app.respond_to?(:inherit_settings, true)
-              app_settings = settings.clone
-              mount_path = Rack::Mount::Utils.normalize_path([settings[:mount_path], path].compact.join("/"))
-              app_settings.set :mount_path, mount_path
-              app.inherit_settings(app_settings)
+            in_setting = inheritable_setting
+
+            if app.respond_to?(:inheritable_setting, true)
+              mount_path = Rack::Mount::Utils.normalize_path(path)
+              app.top_level_setting.namespace_stackable[:mount_path] =  mount_path
+
+              app.inherit_settings(inheritable_setting)
+
+              in_setting = app.top_level_setting
+
+              # app.regenerate_endpoints(in_setting)
+
+              app.change!
+              change!
             end
+
             endpoints << Grape::Endpoint.new(
-                settings.clone,
+                in_setting,
                 method: :any,
                 path: path,
-                app: app
+                app: app,
+                for: self
             )
           end
         end
@@ -92,53 +104,40 @@ module Grape
           endpoint_options = {
             method: methods,
             path: paths,
-            route_options: (@namespace_description || {}).deep_merge(@last_description || {}).deep_merge(route_options || {})
+            for: self,
+            route_options: ({
+              params: Grape::DSL::Configuration.stacked_hash_to_hash(namespace_stackable(:params)) || {}
+            }).deep_merge(route_setting(:description) || {}).deep_merge(route_options || {})
           }
-          endpoints << Grape::Endpoint.new(settings.clone, endpoint_options, &block)
 
-          @last_description = nil
-          reset_validations!
-        end
-
-        def get(paths = ['/'], options = {}, &block)
-          route('GET', paths, options, &block)
-        end
-
-        def post(paths = ['/'], options = {}, &block)
-          route('POST', paths, options, &block)
-        end
+          endpoints << Grape::Endpoint.new(inheritable_setting, endpoint_options, &block)
 
-        def put(paths = ['/'], options = {}, &block)
-          route('PUT', paths, options, &block)
-        end
-
-        def head(paths = ['/'], options = {}, &block)
-          route('HEAD', paths, options, &block)
-        end
-
-        def delete(paths = ['/'], options = {}, &block)
-          route('DELETE', paths, options, &block)
-        end
-
-        def options(paths = ['/'], options = {}, &block)
-          route('OPTIONS', paths, options, &block)
+          route_end
+          reset_validations!
         end
 
-        def patch(paths = ['/'], options = {}, &block)
-          route('PATCH', paths, options, &block)
+        %w"get post put head delete options patch".each do |meth|
+          define_method meth do |*args, &block|
+            options = args.extract_options!
+            paths = args.first || ['/']
+            route(meth.upcase, paths, options, &block)
+          end
         end
 
         def namespace(space = nil, options = {},  &block)
           if space || block_given?
-            previous_namespace_description = @namespace_description
-            @namespace_description = (@namespace_description || {}).deep_merge(@last_description || {})
-            @last_description = nil
-            nest(block) do
-              set(:namespace, Namespace.new(space, options)) if space
+            within_namespace do
+              previous_namespace_description = @namespace_description
+              @namespace_description = (@namespace_description || {}).deep_merge(namespace_setting(:description) || {})
+              nest(block) do
+                if space
+                  namespace_stackable(:namespace, Namespace.new(space, options))
+                end
+              end
+              @namespace_description = previous_namespace_description
             end
-            @namespace_description = previous_namespace_description
           else
-            Namespace.joined_space_path(settings)
+            Namespace.joined_space_path(namespace_stackable(:namespace))
           end
         end
 
@@ -152,6 +151,10 @@ module Grape
           @routes ||= prepare_routes
         end
 
+        def reset_routes!
+          @routes = nil
+        end
+
         # Thie method allows you to quickly define a parameter route segment
         # in your API.
         #

data/lib/grape/dsl/settings.rb

@@ -0,0 +1,110 @@
+require 'active_support/concern'
+
+module Grape
+  module DSL
+    module Settings
+      extend ActiveSupport::Concern
+
+      attr_accessor :inheritable_setting, :top_level_setting
+
+      def top_level_setting
+        @top_level_setting ||= Grape::Util::InheritableSetting.new
+      end
+
+      def inheritable_setting
+        @inheritable_setting ||= Grape::Util::InheritableSetting.new.tap { |new_settings| new_settings.inherit_from top_level_setting }
+      end
+
+      def unset(type, key)
+        setting = inheritable_setting.send(type)
+        setting.delete key
+      end
+
+      def get_or_set(type, key, value)
+        setting = inheritable_setting.send(type)
+        if value.nil?
+          setting[key]
+        else
+          setting[key] = value
+        end
+      end
+
+      def global_setting(key, value = nil)
+        get_or_set :global, key, value
+      end
+
+      def unset_global_setting(key)
+        unset :global, key
+      end
+
+      def route_setting(key, value = nil)
+        get_or_set :route, key, value
+      end
+
+      def unset_route_setting(key)
+        unset :route, key
+      end
+
+      def namespace_setting(key, value = nil)
+        get_or_set :namespace, key, value
+      end
+
+      def unset_namespace_setting(key)
+        unset :namespace_setting, key
+      end
+
+      def namespace_inheritable(key, value = nil)
+        get_or_set :namespace_inheritable, key, value
+      end
+
+      def unset_namespace_inheritable(key)
+        unset :namespace_inheritable, key
+      end
+
+      def namespace_inheritable_to_nil(key)
+        inheritable_setting.namespace_inheritable[key] = nil
+      end
+
+      def namespace_stackable(key, value = nil)
+        get_or_set :namespace_stackable, key, value
+      end
+
+      def unset_namespace_stackable(key)
+        unset :namespace_stackable, key
+      end
+
+      def api_class_setting(key, value = nil)
+        get_or_set :api_class, key, value
+      end
+
+      def unset_api_class_setting(key)
+        unset :api_class_setting, key
+      end
+
+      def namespace_start
+        @inheritable_setting = Grape::Util::InheritableSetting.new.tap { |new_settings| new_settings.inherit_from inheritable_setting }
+      end
+
+      def namespace_end
+        route_end
+        @inheritable_setting = inheritable_setting.parent
+      end
+
+      def route_end
+        inheritable_setting.route_end
+        reset_validations!
+      end
+
+      def within_namespace(&block)
+        namespace_start
+
+        result = yield if block_given?
+
+        namespace_end
+        reset_validations!
+
+        result
+      end
+    end
+  end
+end