grape 2.2.0 → 2.4.0

data/lib/grape/exceptions/unknown_auth_strategy.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Grape
+  module Exceptions
+    class UnknownAuthStrategy < Base
+      def initialize(strategy:)
+        super(message: compose_message(:unknown_auth_strategy, strategy: strategy))
+      end
+    end
+  end
+end

data/lib/grape/exceptions/unknown_params_builder.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Grape
+  module Exceptions
+    class UnknownParamsBuilder < Base
+      def initialize(params_builder_type)
+        super(message: compose_message(:unknown_params_builder, params_builder_type: params_builder_type))
+      end
+    end
+  end
+end

data/lib/grape/exceptions/validation.rb

@@ -2,16 +2,17 @@
 
 module Grape
   module Exceptions
-    class Validation < Grape::Exceptions::Base
+    class Validation < Base
       attr_accessor :params, :message_key
 
-      def initialize(params:, message: nil, **args)
+      def initialize(params:, message: nil, status: nil, headers: nil)
         @params = params
         if message
           @message_key = message if message.is_a?(Symbol)
-          args[:message] = translate_message(message)
+          message = translate_message(message)
         end
-        super(**args)
+
+        super(status: status, message: message, headers: headers)
       end
 
       # Remove all the unnecessary stuff from Grape::Exceptions::Base like status

data/lib/grape/exceptions/validation_errors.rb

@@ -2,7 +2,7 @@
 
 module Grape
   module Exceptions
-    class ValidationErrors < Grape::Exceptions::Base
+    class ValidationErrors < Base
       ERRORS_FORMAT_KEY = 'grape.errors.format'
       DEFAULT_ERRORS_FORMAT = '%<attributes>s %<message>s'
 
@@ -10,7 +10,7 @@ module Grape
 
       attr_reader :errors
 
-      def initialize(errors: [], headers: {}, **_options)
+      def initialize(errors: [], headers: {})
         @errors = errors.group_by(&:params)
         super(message: full_messages.join(', '), status: 400, headers: headers)
       end

data/lib/grape/extensions/active_support/hash_with_indifferent_access.rb

@@ -8,11 +8,8 @@ module Grape
           extend ::ActiveSupport::Concern
 
           included do
-            namespace_inheritable(:build_params_with, Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder)
-          end
-
-          def params_builder
-            Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder
+            Grape.deprecator.warn 'This concern has been deprecated. Use `build_with` with one of the following short_name (:hash, :hash_with_indifferent_access, :hashie_mash) instead.'
+            namespace_inheritable(:build_params_with, :hash_with_indifferent_access)
           end
 
           def build_params

data/lib/grape/extensions/hash.rb

@@ -7,7 +7,8 @@ module Grape
         extend ::ActiveSupport::Concern
 
         included do
-          namespace_inheritable(:build_params_with, Grape::Extensions::Hash::ParamBuilder)
+          Grape.deprecator.warn 'This concern has been deprecated. Use `build_with` with one of the following short_name (:hash, :hash_with_indifferent_access, :hashie_mash) instead.'
+          namespace_inheritable(:build_params_with, :hash)
         end
 
         def build_params

data/lib/grape/extensions/hashie/mash.rb

@@ -6,12 +6,10 @@ module Grape
       module Mash
         module ParamBuilder
           extend ::ActiveSupport::Concern
-          included do
-            namespace_inheritable(:build_params_with, Grape::Extensions::Hashie::Mash::ParamBuilder)
-          end
 
-          def params_builder
-            Grape::Extensions::Hashie::Mash::ParamBuilder
+          included do
+            Grape.deprecator.warn 'This concern has been deprecated. Use `build_with` with one of the following short_name (:hash, :hash_with_indifferent_access, :hashie_mash) instead.'
+            namespace_inheritable(:build_params_with, :hashie_mash)
           end
 
           def build_params

data/lib/grape/formatter/base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Grape
+  module Formatter
+    class Base
+      def self.call(_object, _env)
+        raise NotImplementedError
+      end
+
+      def self.inherited(klass)
+        super
+        Formatter.register(klass)
+      end
+    end
+  end
+end

data/lib/grape/formatter/json.rb

@@ -2,13 +2,11 @@
 
 module Grape
   module Formatter
-    module Json
-      class << self
-        def call(object, _env)
-          return object.to_json if object.respond_to?(:to_json)
+    class Json < Base
+      def self.call(object, _env)
+        return object.to_json if object.respond_to?(:to_json)
 
-          ::Grape::Json.dump(object)
-        end
+        ::Grape::Json.dump(object)
       end
     end
   end

data/lib/grape/formatter/serializable_hash.rb

@@ -2,7 +2,7 @@
 
 module Grape
   module Formatter
-    module SerializableHash
+    class SerializableHash < Base
       class << self
         def call(object, _env)
           return object if object.is_a?(String)

data/lib/grape/formatter/txt.rb

@@ -2,11 +2,9 @@
 
 module Grape
   module Formatter
-    module Txt
-      class << self
-        def call(object, _env)
-          object.respond_to?(:to_txt) ? object.to_txt : object.to_s
-        end
+    class Txt < Base
+      def self.call(object, _env)
+        object.respond_to?(:to_txt) ? object.to_txt : object.to_s
       end
     end
   end

data/lib/grape/formatter/xml.rb

@@ -2,13 +2,11 @@
 
 module Grape
   module Formatter
-    module Xml
-      class << self
-        def call(object, _env)
-          return object.to_xml if object.respond_to?(:to_xml)
+    class Xml < Base
+      def self.call(object, _env)
+        return object.to_xml if object.respond_to?(:to_xml)
 
-          raise Grape::Exceptions::InvalidFormatter.new(object.class, 'xml')
-        end
+        raise Grape::Exceptions::InvalidFormatter.new(object.class, 'xml')
       end
     end
   end

data/lib/grape/formatter.rb

@@ -2,24 +2,16 @@
 
 module Grape
   module Formatter
-    module_function
+    extend Grape::Util::Registry
 
-    DEFAULTS = {
-      json: Grape::Formatter::Json,
-      jsonapi: Grape::Formatter::Json,
-      serializable_hash: Grape::Formatter::SerializableHash,
-      txt: Grape::Formatter::Txt,
-      xml: Grape::Formatter::Xml
-    }.freeze
+    module_function
 
     DEFAULT_LAMBDA_FORMATTER = ->(obj, _env) { obj }
 
     def formatter_for(api_format, formatters)
-      select_formatter(formatters, api_format) || DEFAULT_LAMBDA_FORMATTER
-    end
+      return formatters[api_format] if formatters&.key?(api_format)
 
-    def select_formatter(formatters, api_format)
-      formatters&.key?(api_format) ? formatters[api_format] : DEFAULTS[api_format]
+      registry[api_format] || DEFAULT_LAMBDA_FORMATTER
     end
   end
 end

data/lib/grape/locale/en.yml

@@ -1,59 +1,59 @@
+---
 en:
   grape:
     errors:
-      format: ! '%{attributes} %{message}'
+      format: '%{attributes} %{message}'
       messages:
-        coerce: 'is invalid'
-        presence: 'is missing'
-        regexp: 'is invalid'
+        all_or_none: 'provide all or none of parameters'
+        at_least_one: 'are missing, at least one parameter must be provided'
         blank: 'is empty'
-        values: 'does not have a valid value'
+        coerce: 'is invalid'
+        conflicting_types: 'query params contains conflicting types'
+        empty_message_body: 'empty message body supplied with %{body_format} content-type'
+        exactly_one: 'are missing, exactly one parameter must be provided'
         except_values: 'has a value not allowed'
-        same_as: 'is not the same as %{parameter}'
+        incompatible_option_values: '%{option1}: %{value1} is incompatible with %{option2}: %{value2}'
+        invalid_accept_header:
+          problem: 'invalid accept header'
+          resolution: '%{message}'
+        invalid_formatter: 'cannot convert %{klass} to %{to_format}'
+        invalid_message_body:
+          problem: 'message body does not match declared format'
+          resolution: 'when specifying %{body_format} as content-type, you must pass valid %{body_format} in the request''s ''body'' '
+        invalid_parameters: 'query params contains invalid format or byte sequence'
+        invalid_response: 'Invalid response'
+        invalid_version_header:
+          problem: 'invalid version header'
+          resolution: '%{message}'
+        invalid_versioner_option:
+          problem: 'unknown :using for versioner: %{strategy}'
+          resolution: 'available strategy for :using is :path, :header, :accept_version_header, :param'
+        invalid_with_option_for_represent:
+          problem: 'you must specify an entity class in the :with option'
+          resolution: 'eg: represent User, :with => Entity::User'
         length: 'is expected to have length within %{min} and %{max}'
         length_is: 'is expected to have length exactly equal to %{is}'
-        length_min: 'is expected to have length greater than or equal to %{min}'
         length_max: 'is expected to have length less than or equal to %{max}'
-        missing_vendor_option:
-          problem: 'missing :vendor option'
-          summary: 'when version using header, you must specify :vendor option'
-          resolution: "eg: version 'v1', using: :header, vendor: 'twitter'"
+        length_min: 'is expected to have length greater than or equal to %{min}'
+        missing_group_type: 'group type is required'
         missing_mime_type:
           problem: 'missing mime type for %{new_format}'
-          resolution:
-            "you can choose existing mime type from Grape::ContentTypes::CONTENT_TYPES
-            or add your own with content_type :%{new_format}, 'application/%{new_format}'
-            "
-        invalid_with_option_for_represent:
-          problem: 'you must specify an entity class in the :with option'
-          resolution: 'eg: represent User, :with => Entity::User'
+          resolution: 'you can choose existing mime type from Grape::ContentTypes::CONTENT_TYPES or add your own with content_type :%{new_format}, ''application/%{new_format}'' '
         missing_option: 'you must specify :%{option} options'
-        invalid_formatter: 'cannot convert %{klass} to %{to_format}'
-        invalid_versioner_option:
-          problem: 'unknown :using for versioner: %{strategy}'
-          resolution: 'available strategy for :using is :path, :header, :accept_version_header, :param'
-        unknown_validator: 'unknown validator: %{validator_type}'
+        missing_vendor_option:
+          problem: 'missing :vendor option'
+          resolution: 'eg: version ''v1'', using: :header, vendor: ''twitter'''
+          summary: 'when version using header, you must specify :vendor option'
+        mutual_exclusion: 'are mutually exclusive'
+        presence: 'is missing'
+        regexp: 'is invalid'
+        same_as: 'is not the same as %{parameter}'
+        too_deep_parameters: 'query params are recursively nested over the specified limit (%{limit})'
+        too_many_multipart_files: 'the number of uploaded files exceeded the system''s configured limit (%{limit})'
+        unknown_auth_strategy: 'unknown auth strategy: %{strategy}'
         unknown_options: 'unknown options: %{options}'
         unknown_parameter: 'unknown parameter: %{param}'
-        incompatible_option_values: '%{option1}: %{value1} is incompatible with %{option2}: %{value2}'
-        mutual_exclusion: 'are mutually exclusive'
-        at_least_one: 'are missing, at least one parameter must be provided'
-        exactly_one: 'are missing, exactly one parameter must be provided'
-        all_or_none: 'provide all or none of parameters'
-        missing_group_type: 'group type is required'
+        unknown_params_builder: 'unknown params_builder: %{params_builder_type}'
+        unknown_validator: 'unknown validator: %{validator_type}'
         unsupported_group_type: 'group type must be Array, Hash, JSON or Array[JSON]'
-        invalid_message_body:
-          problem: "message body does not match declared format"
-          resolution:
-            "when specifying %{body_format} as content-type, you must pass valid
-            %{body_format} in the request's 'body'
-            "
-        empty_message_body: 'empty message body supplied with %{body_format} content-type'
-        too_many_multipart_files: "the number of uploaded files exceeded the system's configured limit (%{limit})"
-        invalid_accept_header:
-          problem: 'invalid accept header'
-          resolution: '%{message}'
-        invalid_version_header:
-          problem: 'invalid version header'
-          resolution: '%{message}'
-        invalid_response: 'Invalid response'
+        values: 'does not have a valid value'

data/lib/grape/middleware/auth/base.rb

@@ -3,40 +3,19 @@
 module Grape
   module Middleware
     module Auth
-      class Base
-        include Helpers
-
-        attr_accessor :options, :app, :env
-
-        def initialize(app, *options)
-          @app = app
-          @options = options.shift
-        end
-
-        def call(env)
-          dup._call(env)
+      class Base < Grape::Middleware::Base
+        def initialize(app, **options)
+          super
+          @auth_strategy = Grape::Middleware::Auth::Strategies[options[:type]].tap do |auth_strategy|
+            raise Grape::Exceptions::UnknownAuthStrategy.new(strategy: options[:type]) unless auth_strategy
+          end
         end
 
-        def _call(env)
-          self.env = env
-
-          if options.key?(:type)
-            auth_proc = options[:proc]
-            auth_proc_context = context
-
-            strategy_info = Grape::Middleware::Auth::Strategies[options[:type]]
-
-            throw(:error, status: 401, message: 'API Authorization Failed.') if strategy_info.blank?
-
-            strategy = strategy_info.create(@app, options) do |*args|
-              auth_proc_context.instance_exec(*args, &auth_proc)
-            end
-
-            strategy.call(env)
-
-          else
-            app.call(env)
-          end
+        def call!(env)
+          @env = env
+          @auth_strategy.create(app, options) do |*args|
+            context.instance_exec(*args, &options[:proc])
+          end.call(env)
         end
       end
     end

data/lib/grape/middleware/auth/dsl.rb

@@ -4,40 +4,34 @@ module Grape
   module Middleware
     module Auth
       module DSL
-        extend ActiveSupport::Concern
-
-        module ClassMethods
-          # Add an authentication type to the API. Currently
-          # only `:http_basic`, `:http_digest` are supported.
-          def auth(type = nil, options = {}, &block)
-            if type
-              namespace_inheritable(:auth, options.reverse_merge(type: type.to_sym, proc: block))
-              use Grape::Middleware::Auth::Base, namespace_inheritable(:auth)
-            else
-              namespace_inheritable(:auth)
-            end
-          end
-
-          # Add HTTP Basic authorization to the API.
-          #
-          # @param [Hash] options A hash of options.
-          # @option options [String] :realm "API Authorization" The HTTP Basic realm.
-          def http_basic(options = {}, &block)
-            options[:realm] ||= 'API Authorization'
-            auth :http_basic, options, &block
+        def auth(type = nil, options = {}, &block)
+          if type
+            namespace_inheritable(:auth, options.reverse_merge(type: type.to_sym, proc: block))
+            use Grape::Middleware::Auth::Base, namespace_inheritable(:auth)
+          else
+            namespace_inheritable(:auth)
           end
+        end
 
-          def http_digest(options = {}, &block)
-            options[:realm] ||= 'API Authorization'
+        # Add HTTP Basic authorization to the API.
+        #
+        # @param [Hash] options A hash of options.
+        # @option options [String] :realm "API Authorization" The HTTP Basic realm.
+        def http_basic(options = {}, &block)
+          options[:realm] ||= 'API Authorization'
+          auth :http_basic, options, &block
+        end
 
-            if options[:realm].respond_to?(:values_at)
-              options[:realm][:opaque] ||= 'secret'
-            else
-              options[:opaque] ||= 'secret'
-            end
+        def http_digest(options = {}, &block)
+          options[:realm] ||= 'API Authorization'
 
-            auth :http_digest, options, &block
+          if options[:realm].respond_to?(:values_at)
+            options[:realm][:opaque] ||= 'secret'
+          else
+            options[:opaque] ||= 'secret'
           end
+
+          auth :http_digest, options, &block
         end
       end
     end

data/lib/grape/middleware/base.rb

@@ -3,25 +3,18 @@
 module Grape
   module Middleware
     class Base
-      include Helpers
       include Grape::DSL::Headers
 
       attr_reader :app, :env, :options
 
-      TEXT_HTML = 'text/html'
-
       # @param [Rack Application] app The standard argument for a Rack middleware.
       # @param [Hash] options A hash of options, simply stored for use by subclasses.
-      def initialize(app, *options)
+      def initialize(app, **options)
         @app = app
-        @options = options.any? ? default_options.deep_merge(options.shift) : default_options
+        @options = merge_default_options(options)
         @app_response = nil
       end
 
-      def default_options
-        {}
-      end
-
       def call(env)
         dup.call!(env).to_a
       end
@@ -54,10 +47,18 @@ module Grape
       # @return [Response, nil] a Rack SPEC response or nil to call the application afterwards.
       def after; end
 
+      def rack_request
+        @rack_request ||= Rack::Request.new(env)
+      end
+
+      def context
+        env[Grape::Env::API_ENDPOINT]
+      end
+
       def response
         return @app_response if @app_response.is_a?(Rack::Response)
 
-        @app_response = Rack::Response.new(@app_response[2], @app_response[0], @app_response[1])
+        @app_response = Rack::Response[*@app_response]
       end
 
       def content_types
@@ -73,7 +74,15 @@ module Grape
       end
 
       def content_type
-        content_type_for(env[Grape::Env::API_FORMAT] || options[:format]) || TEXT_HTML
+        content_type_for(env[Grape::Env::API_FORMAT] || options[:format]) || 'text/html'
+      end
+
+      def query_params
+        rack_request.GET
+      rescue Rack::QueryParser::ParamsTooDeepError
+        raise Grape::Exceptions::TooDeepParameters.new(Rack::Utils.param_depth_limit)
+      rescue Rack::Utils::ParameterTypeError
+        raise Grape::Exceptions::ConflictingTypes
       end
 
       private
@@ -90,6 +99,16 @@ module Grape
       def content_types_indifferent_access
         @content_types_indifferent_access ||= content_types.with_indifferent_access
       end
+
+      def merge_default_options(options)
+        if respond_to?(:default_options)
+          default_options.deep_merge(options)
+        elsif self.class.const_defined?(:DEFAULT_OPTIONS)
+          self.class::DEFAULT_OPTIONS.deep_merge(options)
+        else
+          options
+        end
+      end
     end
   end
 end

data/lib/grape/middleware/error.rb

@@ -3,30 +3,22 @@
 module Grape
   module Middleware
     class Error < Base
-      def default_options
-        {
-          default_status: 500, # default status returned on error
-          default_message: '',
-          format: :txt,
-          helpers: nil,
-          formatters: {},
-          error_formatters: {},
-          rescue_all: false, # true to rescue all exceptions
-          rescue_grape_exceptions: false,
-          rescue_subclasses: true, # rescue subclasses of exceptions listed
-          rescue_options: {
-            backtrace: false, # true to display backtrace, true to let Grape handle Grape::Exceptions
-            original_exception: false # true to display exception
-          },
-          rescue_handlers: {}, # rescue handler blocks
-          base_only_rescue_handlers: {}, # rescue handler blocks rescuing only the base class
-          all_rescue_handler: nil # rescue handler block to rescue from all exceptions
-        }
-      end
-
-      def initialize(app, *options)
+      DEFAULT_OPTIONS = {
+        default_status: 500,
+        default_message: '',
+        format: :txt,
+        rescue_all: false,
+        rescue_grape_exceptions: false,
+        rescue_subclasses: true,
+        rescue_options: {
+          backtrace: false,
+          original_exception: false
+        }.freeze
+      }.freeze
+
+      def initialize(app, **options)
         super
-        self.class.include(@options[:helpers]) if @options[:helpers]
+        self.class.include(options[:helpers]) if options[:helpers]
       end
 
       def call!(env)
@@ -39,7 +31,7 @@ module Grape
       private
 
       def rack_response(status, headers, message)
-        message = Rack::Utils.escape_html(message) if headers[Rack::CONTENT_TYPE] == TEXT_HTML
+        message = Rack::Utils.escape_html(message) if headers[Rack::CONTENT_TYPE] == 'text/html'
         Rack::Response.new(Array.wrap(message), Rack::Utils.status_code(status), Grape::Util::Header.new.merge(headers))
       end
 
@@ -65,6 +57,7 @@ module Grape
 
       def error_response(error = {})
         status = error[:status] || options[:default_status]
+        env[Grape::Env::API_ENDPOINT].status(status) # error! may not have been called
         message = error[:message] || options[:default_message]
         headers = { Rack::CONTENT_TYPE => content_type }.tap do |h|
           h.merge!(error[:headers]) if error[:headers].is_a?(Hash)
@@ -130,6 +123,7 @@ module Grape
       end
 
       def error!(message, status = options[:default_status], headers = {}, backtrace = [], original_exception = nil)
+        env[Grape::Env::API_ENDPOINT].status(status) # not error! inside route
         rack_response(
           status, headers.reverse_merge(Rack::CONTENT_TYPE => content_type),
           format_message(message, backtrace, original_exception)