grape 0.14.0 → 0.15.0

data/lib/grape/dsl/headers.rb

@@ -0,0 +1,16 @@
+module Grape
+  module DSL
+    module Headers
+      # Set an individual header or retrieve
+      # all headers that have been set.
+      def header(key = nil, val = nil)
+        if key
+          val ? header[key.to_s] = val : header.delete(key.to_s)
+        else
+          @header ||= {}
+        end
+      end
+      alias_method :headers, :header
+    end
+  end
+end

data/lib/grape/dsl/helpers.rb

@@ -30,14 +30,10 @@ module Grape
           if block_given? || new_mod
             mod = new_mod || Module.new
             define_boolean_in_mod(mod)
-            if new_mod
-              inject_api_helpers_to_mod(new_mod) if new_mod.is_a?(BaseHelper)
-            end
-            if block_given?
-              inject_api_helpers_to_mod(mod) do
-                mod.class_eval(&block)
-              end
-            end
+            inject_api_helpers_to_mod(mod) if new_mod
+            inject_api_helpers_to_mod(mod) do
+              mod.class_eval(&block)
+            end if block_given?
 
             namespace_stackable(:helpers, mod)
           else
@@ -58,7 +54,7 @@ module Grape
         end
 
         def inject_api_helpers_to_mod(mod, &_block)
-          mod.extend(BaseHelper)
+          mod.extend(BaseHelper) unless mod.is_a?(BaseHelper)
           yield if block_given?
           mod.api_changed(self)
         end

data/lib/grape/dsl/inside_route.rb

@@ -1,10 +1,12 @@
 require 'active_support/concern'
+require 'grape/dsl/headers'
 
 module Grape
   module DSL
     module InsideRoute
       extend ActiveSupport::Concern
       include Grape::DSL::Settings
+      include Grape::DSL::Headers
 
       # Denotes a situation where a DSL method has been invoked in a
       # filter which it should not yet be available in
@@ -138,16 +140,6 @@ module Grape
         end
       end
 
-      # Set an individual header or retrieve
-      # all headers that have been set.
-      def header(key = nil, val = nil)
-        if key
-          val ? @header[key.to_s] = val : @header.delete(key.to_s)
-        else
-          @header
-        end
-      end
-
       # Set response content-type
       def content_type(val = nil)
         if val
@@ -303,7 +295,7 @@ module Grape
                          end
 
           object_class.ancestors.each do |potential|
-            entity_class ||= (Grape::DSL::Configuration.stacked_hash_to_hash(namespace_stackable(:representations)) || {})[potential]
+            entity_class ||= (namespace_stackable_with_hash(:representations) || {})[potential]
           end
 
           entity_class ||= object_class.const_get(:Entity) if object_class.const_defined?(:Entity) && object_class.const_get(:Entity).respond_to?(:represent)

data/lib/grape/dsl/logger.rb

@@ -0,0 +1,20 @@
+module Grape
+  module DSL
+    module Logger
+      include Grape::DSL::Settings
+
+      attr_writer :logger
+
+      # Set or retrive the configured logger. If none was configured, this
+      # method will create a new one, logging to stdout.
+      # @param logger [Object] the new logger to use
+      def logger(logger = nil)
+        if logger
+          global_setting(:logger, logger)
+        else
+          global_setting(:logger) || global_setting(:logger, ::Logger.new($stdout))
+        end
+      end
+    end
+  end
+end

data/lib/grape/dsl/parameters.rb

@@ -30,7 +30,7 @@ module Grape
       #       end
       #     end
       def use(*names)
-        named_params = Grape::DSL::Configuration.stacked_hash_to_hash(@api.namespace_stackable(:named_params)) || {}
+        named_params = @api.namespace_stackable_with_hash(:named_params) || {}
         options = names.extract_options!
         names.each do |name|
           params_block = named_params.fetch(name) do
@@ -98,7 +98,7 @@ module Grape
         orig_attrs = attrs.clone
 
         opts = attrs.extract_options!.clone
-        opts[:presence] = true
+        opts[:presence] = { value: true, message: opts[:message] }
 
         if opts[:using]
           require_required_and_optional_fields(attrs.first, opts)
@@ -122,7 +122,7 @@ module Grape
         # check type for optional parameter group
         if attrs && block_given?
           fail Grape::Exceptions::MissingGroupTypeError.new if type.nil?
-          fail Grape::Exceptions::UnsupportedGroupTypeError.new unless [Array, Hash].include?(type)
+          fail Grape::Exceptions::UnsupportedGroupTypeError.new unless Grape::Validations::Types.group?(type)
         end
 
         if opts[:using]
@@ -137,25 +137,25 @@ module Grape
       # Disallow the given parameters to be present in the same request.
       # @param attrs [*Symbol] parameters to validate
       def mutually_exclusive(*attrs)
-        validates(attrs, mutual_exclusion: true)
+        validates(attrs, mutual_exclusion: { value: true, message: extract_message_option(attrs) })
       end
 
       # Require exactly one of the given parameters to be present.
       # @param (see #mutually_exclusive)
       def exactly_one_of(*attrs)
-        validates(attrs, exactly_one_of: true)
+        validates(attrs, exactly_one_of: { value: true, message: extract_message_option(attrs) })
       end
 
       # Require at least one of the given parameters to be present.
       # @param (see #mutually_exclusive)
       def at_least_one_of(*attrs)
-        validates(attrs, at_least_one_of: true)
+        validates(attrs, at_least_one_of: { value: true, message: extract_message_option(attrs) })
       end
 
       # Require that either all given params are present, or none are.
       # @param (see #mutually_exclusive)
       def all_or_none_of(*attrs)
-        validates(attrs, all_or_none_of: true)
+        validates(attrs, all_or_none_of: { value: true, message: extract_message_option(attrs) })
       end
 
       # Define a block of validations which should be applied if and only if
@@ -165,9 +165,11 @@ module Grape
       # @raise Grape::Exceptions::UnknownParameter if `attr` has not been
       #   defined in this scope yet
       # @yield a parameter definition DSL
-      def given(attr, &block)
-        fail Grape::Exceptions::UnknownParameter.new(attr) unless declared_param?(attr)
-        new_lateral_scope(dependent_on: attr, &block)
+      def given(*attrs, &block)
+        attrs.each do |attr|
+          fail Grape::Exceptions::UnknownParameter.new(attr) unless declared_param?(attr)
+        end
+        new_lateral_scope(dependent_on: attrs, &block)
       end
 
       # Test for whether a certain parameter has been defined in this params

data/lib/grape/dsl/request_response.rb

@@ -20,7 +20,7 @@ module Grape
           if new_format
             namespace_inheritable(:format, new_format.to_sym)
             # define the default error formatters
-            namespace_inheritable(:default_error_formatter, Grape::ErrorFormatter::Base.formatter_for(new_format, {}))
+            namespace_inheritable(:default_error_formatter, Grape::ErrorFormatter.formatter_for(new_format, {}))
             # define a single mime type
             mime_type = content_types[new_format.to_sym]
             fail Grape::Exceptions::MissingMimeType.new(new_format) unless mime_type
@@ -43,7 +43,7 @@ module Grape
         # 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, {})
+            new_formatter = Grape::ErrorFormatter.formatter_for(new_formatter_name, {})
             namespace_inheritable(:default_error_formatter, new_formatter)
           else
             namespace_inheritable(:default_error_formatter)
@@ -68,7 +68,7 @@ module Grape
 
         # All available content types.
         def content_types
-          c_types = Grape::DSL::Configuration.stacked_hash_to_hash(namespace_stackable(:content_types))
+          c_types = namespace_stackable_with_hash(:content_types)
           Grape::ContentTypes.content_types_for c_types
         end
 
@@ -105,7 +105,10 @@ module Grape
           end
 
           options = args.extract_options!
-          handler ||= proc { options[:with] } if options.key?(:with)
+          if block_given? && options.key?(:with)
+            fail ArgumentError, 'both :with option and block cannot be passed'
+          end
+          handler ||= extract_with(options)
 
           if args.include?(:all)
             namespace_inheritable(:rescue_all, true)
@@ -149,6 +152,16 @@ module Grape
           fail Grape::Exceptions::InvalidWithOptionForRepresent.new unless options[:with] && options[:with].is_a?(Class)
           namespace_stackable(:representations, model_class => options[:with])
         end
+
+        private
+
+        def extract_with(options)
+          return unless options.key?(:with)
+          with_option = options[:with]
+          return with_option if with_option.instance_of?(Proc)
+          return if with_option.instance_of?(Symbol) || with_option.instance_of?(String)
+          fail ArgumentError, "with: #{with_option.class}, expected Symbol, String or Proc"
+        end
       end
     end
   end

data/lib/grape/dsl/routing.rb

@@ -7,7 +7,7 @@ module Grape
       include Grape::DSL::Configuration
 
       module ClassMethods
-        attr_reader :endpoints, :routes, :route_set
+        attr_reader :endpoints, :routes
 
         # Specify an API version.
         #
@@ -46,8 +46,6 @@ module Grape
               namespace_inheritable(:version, args)
               namespace_inheritable(:version_options, options)
             end
-
-            # reset_validations!
           end
 
           @versions.last unless @versions.nil?
@@ -58,6 +56,16 @@ module Grape
           namespace_inheritable(:root_prefix, prefix)
         end
 
+        # Create a scope without affecting the URL.
+        #
+        # @param _name [Symbol] Purely placebo, just allows to name the scope to
+        # make the code more readable.
+        def scope(_name = nil, &block)
+          within_namespace do
+            nest(block)
+          end
+        end
+
         # Do not route HEAD requests to GET requests automatically.
         def do_not_route_head!
           namespace_inheritable(:do_not_route_head, true)
@@ -81,8 +89,6 @@ module Grape
 
               in_setting = app.top_level_setting
 
-              # app.regenerate_endpoints(in_setting)
-
               app.change!
               change!
             end
@@ -115,7 +121,7 @@ module Grape
             path: paths,
             for: self,
             route_options: ({
-              params: Grape::DSL::Configuration.stacked_hash_to_hash(namespace_stackable(:params)) || {}
+              params: namespace_stackable_with_hash(:params) || {}
             }).deep_merge(route_setting(:description) || {}).deep_merge(route_options || {})
           }
 
@@ -175,9 +181,14 @@ module Grape
 
         # Remove all defined routes.
         def reset_routes!
+          endpoints.each(&:reset_routes!)
           @routes = nil
         end
 
+        def reset_endpoints!
+          @endpoints = []
+        end
+
         # Thie method allows you to quickly define a parameter route segment
         # in your API.
         #
@@ -185,7 +196,13 @@ module Grape
         # @option options [Regexp] You may supply a regular expression that the declared parameter must meet.
         def route_param(param, options = {}, &block)
           options = options.dup
-          options[:requirements] = { param.to_sym => options[:requirements] } if options[:requirements].is_a?(Regexp)
+          options[:requirements] = {
+            param.to_sym => options[:requirements]
+          } if options[:requirements].is_a?(Regexp)
+
+          Grape::Validations::ParamsScope.new(api: self) do
+            requires param, type: options[:type]
+          end if options.key?(:type)
           namespace(":#{param}", options, &block)
         end
 

data/lib/grape/dsl/settings.rb

@@ -71,7 +71,7 @@ module Grape
 
       # (see #unset_global_setting)
       def unset_namespace_setting(key)
-        unset :namespace_setting, key
+        unset :namespace, key
       end
 
       # (see #global_setting)
@@ -94,6 +94,12 @@ module Grape
         get_or_set :namespace_stackable, key, value
       end
 
+      def namespace_stackable_with_hash(key)
+        settings = get_or_set :namespace_stackable, key, nil
+        return if settings.blank?
+        settings.each_with_object({}) { |value, result| result.deep_merge!(value) }
+      end
+
       # (see #unset_global_setting)
       def unset_namespace_stackable(key)
         unset :namespace_stackable, key
@@ -106,7 +112,7 @@ module Grape
 
       # (see #unset_global_setting)
       def unset_api_class_setting(key)
-        unset :api_class_setting, key
+        unset :api_class, key
       end
 
       # Fork our inheritable settings to a new instance, copied from our

data/lib/grape/endpoint.rb

@@ -5,12 +5,11 @@ module Grape
   # from inside a `get`, `post`, etc.
   class Endpoint
     include Grape::DSL::Settings
+    include Grape::DSL::InsideRoute
 
     attr_accessor :block, :source, :options
     attr_reader :env, :request, :headers, :params
 
-    include Grape::DSL::InsideRoute
-
     class << self
       def new(*args, &block)
         if self == Endpoint
@@ -115,7 +114,7 @@ module Grape
     end
 
     def reset_routes!
-      endpoints.map(&:reset_routes!) if endpoints
+      endpoints.each(&:reset_routes!) if endpoints
       @namespace = nil
       @routes = nil
     end
@@ -126,7 +125,7 @@ module Grape
           e.mount_in(route_set)
         end
       else
-        @routes = nil
+        reset_routes!
 
         routes.each do |route|
           methods = [route.route_method]
@@ -243,20 +242,7 @@ module Grape
 
         run_filters before_validations, :before_validation
 
-        # Retrieve validations from this namespace and all parent namespaces.
-        validation_errors = []
-
-        route_setting(:saved_validations).each do |validator|
-          begin
-            validator.validate!(params)
-          rescue Grape::Exceptions::Validation => e
-            validation_errors << e
-          end
-        end
-
-        if validation_errors.any?
-          fail Grape::Exceptions::ValidationErrors, errors: validation_errors, headers: header
-        end
+        run_validators validations, request
 
         run_filters after_validations, :after_validation
 
@@ -276,14 +262,14 @@ module Grape
       b.use Rack::Head
       b.use Grape::Middleware::Error,
             format: namespace_inheritable(:format),
-            content_types: Grape::DSL::Configuration.stacked_hash_to_hash(namespace_stackable(:content_types)),
+            content_types: namespace_stackable_with_hash(: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)) || {},
+            error_formatters: namespace_stackable_with_hash(:error_formatters),
+            rescue_options: namespace_stackable_with_hash(:rescue_options) || {},
+            rescue_handlers: namespace_stackable_with_hash(:rescue_handlers) || {},
+            base_only_rescue_handlers: namespace_stackable_with_hash(:base_only_rescue_handlers) || {},
             all_rescue_handler: namespace_inheritable(:all_rescue_handler)
 
       (namespace_stackable(:middleware) || []).each do |m|
@@ -307,9 +293,9 @@ module Grape
       b.use Grape::Middleware::Formatter,
             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))
+            content_types: namespace_stackable_with_hash(:content_types),
+            formatters: namespace_stackable_with_hash(:formatters),
+            parsers: namespace_stackable_with_hash(:parsers)
 
       b.run ->(env) { env[Grape::Env::API_ENDPOINT].run }
 
@@ -346,6 +332,20 @@ module Grape
       end
     end
 
+    def run_validators(validators, request)
+      validation_errors = []
+
+      validators.each do |validator|
+        begin
+          validator.validate(request)
+        rescue Grape::Exceptions::Validation => e
+          validation_errors << e
+        end
+      end
+
+      validation_errors.any? && fail(Grape::Exceptions::ValidationErrors, errors: validation_errors, headers: header)
+    end
+
     def run_filters(filters, type = :other)
       ActiveSupport::Notifications.instrument('endpoint_run_filters.grape', endpoint: self, filters: filters, type: type) do
         (filters || []).each do |filter|
@@ -371,5 +371,9 @@ module Grape
     def afters
       namespace_stackable(:afters) || []
     end
+
+    def validations
+      route_setting(:saved_validations) || []
+    end
   end
 end