grape 1.3.0 → 1.5.2

data/UPGRADING.md

@@ -1,6 +1,192 @@
 Upgrading Grape
 ===============
 
+### Upgrading to >= 1.5.1
+
+#### Dependent params
+
+If you use [dependent params](https://github.com/ruby-grape/grape#dependent-parameters) with
+`Grape::Extensions::Hash::ParamBuilder`, make sure a parameter to be dependent on is set as a Symbol.
+If a String is given, a parameter that other parameters depend on won't be found even if it is present.
+
+_Correct_:
+```ruby
+given :matrix do
+  # dependent params
+end
+```
+
+_Wrong_:
+```ruby
+given 'matrix' do
+  # dependent params
+end
+```
+
+### Upgrading to >= 1.5.0
+
+Prior to 1.3.3, the `declared` helper would always return the complete params structure if `include_missing=true` was set. In 1.3.3 a regression was introduced such that a missing Hash with or without nested parameters would always resolve to `{}`.
+
+In 1.5.0 this behavior is reverted, so the whole params structure will always be available via `declared`, regardless of whether any params are passed.
+
+The following rules now apply to the `declared` helper when params are missing and `include_missing=true`:
+
+* Hash params with children will resolve to a Hash with keys for each declared child.
+* Hash params with no children will resolve to `{}`.
+* Set params will resolve to `Set.new`.
+* Array params will resolve to `[]`.
+* All other params will resolve to `nil`.
+
+#### Example
+
+```ruby
+class Api < Grape::API
+  params do
+    optional :outer, type: Hash do
+      optional :inner, type: Hash do
+        optional :value, type: String
+      end
+    end
+  end
+  get 'example' do
+    declared(params, include_missing: true)
+  end
+end
+```
+
+```
+get '/example'
+# 1.3.3 = {}
+# 1.5.0 = {outer: {inner: {value:null}}}
+```
+
+For more information see [#2103](https://github.com/ruby-grape/grape/pull/2103).
+
+### Upgrading to >= 1.4.0
+
+#### Reworking stream and file and un-deprecating stream like-objects
+
+Previously in 0.16 stream-like objects were deprecated. This release restores their functionality for use-cases other than file streaming.
+
+This release deprecated `file` in favor of `sendfile` to better document its purpose.
+
+To deliver a file via the Sendfile support in your web server and have the Rack::Sendfile middleware enabled. See [`Rack::Sendfile`](https://www.rubydoc.info/gems/rack/Rack/Sendfile).
+```ruby
+class API < Grape::API
+  get '/' do
+    sendfile '/path/to/file'
+  end
+end
+```
+
+Use `stream` to stream file content in chunks.
+
+```ruby
+class API < Grape::API
+  get '/' do
+    stream '/path/to/file'
+  end
+end
+```
+
+Or use `stream` to stream other kinds of content. In the following example a streamer class
+streams paginated data from a database.
+
+```ruby
+class MyObject
+  attr_accessor :result
+
+  def initialize(query)
+    @result = query
+  end
+
+  def each
+    yield '['
+    # Do paginated DB fetches and return each page formatted
+    first = false
+    result.find_in_batches do |records|
+      yield process_records(records, first)
+      first = false
+    end
+    yield ']'
+  end
+
+  def process_records(records, first)
+    buffer = +''
+    buffer << ',' unless first
+    buffer << records.map(&:to_json).join(',')
+    buffer
+  end
+end
+
+class API < Grape::API
+  get '/' do
+    stream MyObject.new(Sprocket.all)
+  end
+end
+```
+
+### Upgrading to >= 1.3.3
+
+#### Nil values for structures
+
+Nil values always been a special case when dealing with types especially with the following structures:
+
+- Array
+- Hash
+- Set
+
+The behavior for these structures has change through out the latest releases. For example:
+
+```ruby
+class Api < Grape::API
+  params do
+    require :my_param, type: Array[Integer]
+  end
+
+  get 'example' do
+     params[:my_param]
+  end
+  get '/example', params: { my_param: nil }
+  # 1.3.1 = []
+  # 1.3.2 = nil
+end
+```
+
+For now on, `nil` values stay `nil` values for all types, including arrays, sets and hashes.
+
+If you want to have the same behavior as 1.3.1, apply a `default` validator:
+
+```ruby
+class Api < Grape::API
+  params do
+    require :my_param, type: Array[Integer], default: []
+  end
+
+  get 'example' do
+     params[:my_param]
+  end
+  get '/example', params: { my_param: nil } # => []
+end
+```
+
+#### Default validator
+
+Default validator is now applied for `nil` values.
+
+```ruby
+class Api < Grape::API
+  params do
+    requires :my_param, type: Integer, default: 0
+  end
+
+  get 'example' do
+     params[:my_param]
+  end
+  get '/example', params: { my_param: nil } #=> before: nil, after: 0
+end
+```
+
 ### Upgrading to >= 1.3.0
 
 #### Ruby
@@ -9,38 +195,87 @@ After adding dry-types, Ruby 2.4 or newer is required.
 
 #### Coercion
 
-[Virtus](https://github.com/solnic/virtus) has been replaced by [dry-types](https://dry-rb.org/gems/dry-types/1.2/) for parameter coercion. If your project depends on Virtus, explicitly add it to your `Gemfile`. Also, if Virtus is used for defining custom types
+[Virtus](https://github.com/solnic/virtus) has been replaced by [dry-types](https://dry-rb.org/gems/dry-types/1.2/) for parameter coercion. If your project depends on Virtus outside of Grape, explicitly add it to your `Gemfile`.
+
+Here's an example of how to migrate a custom type from Virtus to dry-types:
 
 ```ruby
-class User
-  include Virtus.model
+# Legacy Grape parser
+class SecureUriType < Virtus::Attribute
+  def coerce(input)
+    URI.parse value
+  end
 
-  attribute :id, Integer
-  attribute :name, String
+  def value_coerced?(input)
+    value.is_a? String
+  end
 end
 
-# somewhere in your API
 params do
-  requires :user, type: User
+  requires :secure_uri, type: SecureUri
 end
 ```
 
-Add a class-level `parse` method to the model:
+To use dry-types, we need to:
 
-```ruby
-class User
-  include Virtus.model
+1. Remove the inheritance of `Virtus::Attribute`
+1. Rename `coerce` to `self.parse`
+1. Rename `value_coerced?` to `self.parsed?`
 
-  attribute :id, Integer
-  attribute :name, String
+The custom type must have a class-level `parse` method to the model. A class-level `parsed?` is needed if the parsed type differs from the defined type. In the example below, since `SecureUri` is not the same as `URI::HTTPS`, `self.parsed?` is needed:
 
-  def self.parse(attrs)
-    new(attrs)
+```ruby
+# New dry-types parser
+class SecureUri
+  def self.parse(value)
+    URI.parse value
+  end
+
+  def self.parsed?(value)
+    value.is_a? URI::HTTPS
   end
 end
+
+params do
+  requires :secure_uri, type: SecureUri
+end
 ```
 
-Custom types which don't depend on Virtus don't require any changes.
+#### Coercing to `FalseClass` or `TrueClass` no longer works
+
+Previous Grape versions allowed this, though it wasn't documented:
+
+```ruby
+requires :true_value, type: TrueClass
+requires :bool_value, types: [FalseClass, TrueClass]
+```
+
+This is no longer supported, if you do this, your values will never be valid. Instead you should do this:
+
+```ruby
+requires :true_value, type: Boolean # in your endpoint you should validate if this is actually `true`
+requires :bool_value, type: Boolean
+```
+
+#### Ensure that Array types have explicit coercions
+
+Unlike Virtus, dry-types does not perform any implict coercions. If you have any uses of `Array[String]`, `Array[Integer]`, etc. be sure they use a `coerce_with` block. For example:
+
+```ruby
+requires :values, type: Array[String]
+```
+
+It's quite common to pass a comma-separated list, such as `tag1,tag2` as `values`. Previously Virtus would implicitly coerce this to `Array(values)` so that `["tag1,tag2"]` would pass the type checks, but with `dry-types` the values are no longer coerced for you. To fix this, you might do:
+
+```ruby
+requires :values, type: Array[String], coerce_with: ->(val) { val.split(',').map(&:strip) }
+```
+
+Likewise, for `Array[Integer]`, you might do:
+
+```ruby
+requires :values, type: Array[Integer], coerce_with: ->(val) { val.split(',').map(&:strip).map(&:to_i) }
+```
 
 For more information see [#1920](https://github.com/ruby-grape/grape/pull/1920).
 
@@ -97,12 +332,9 @@ In order to make obtaining the name of a mounted class simpler, we've delegated
 
 ##### Patching the class
 
-In an effort to make APIs re-mountable, The class `Grape::API` no longer refers to an API instance,
-rather, what used to be `Grape::API` is now `Grape::API::Instance` and `Grape::API` was replaced
-with a class that can contain several instances of `Grape::API`.
+In an effort to make APIs re-mountable, The class `Grape::API` no longer refers to an API instance, rather, what used to be `Grape::API` is now `Grape::API::Instance` and `Grape::API` was replaced with a class that can contain several instances of `Grape::API`.
 
-This changes were done in such a way that no code-changes should be required.
-However, if experiencing problems, or relying on private methods and internal behaviour too deeply, it is possible to restore the prior behaviour by replacing the references from `Grape::API` to `Grape::API::Instance`.
+This changes were done in such a way that no code-changes should be required. However, if experiencing problems, or relying on private methods and internal behaviour too deeply, it is possible to restore the prior behaviour by replacing the references from `Grape::API` to `Grape::API::Instance`.
 
 Note, this is particularly relevant if you are opening the class `Grape::API` for modification.
 
@@ -125,15 +357,20 @@ end
 
 After the patch, the mounted API is no longer a Named class inheriting from `Grape::API`, it is an anonymous class
 which inherit from `Grape::API::Instance`.
+
 What this means in practice, is:
+
 - Generally: you can access the named class from the instance calling the getter `base`.
-- In particular: If you need the `name`, you can use `base`.`name`
+- In particular: If you need the `name`, you can use `base`.`name`.
 
 **Deprecated**
+
 ```ruby
   payload[:endpoint].options[:for].name
 ```
+
 **New**
+
 ```ruby
   payload[:endpoint].options[:for].base.name
 ```
@@ -224,8 +461,7 @@ See [#1610](https://github.com/ruby-grape/grape/pull/1610) for more information.
 
 #### The `except`, `except_message`, and `proc` options of the `values` validator are deprecated.
 
-The new `except_values` validator should be used in place of the `except` and `except_message` options of
-the `values` validator.
+The new `except_values` validator should be used in place of the `except` and `except_message` options of the `values` validator.
 
 Arity one Procs may now be used directly as the `values` option to explicitly test param values.
 
@@ -301,9 +537,7 @@ get '/example' #=> before: 405, after: 404
 
 #### Removed param processing from built-in OPTIONS handler
 
-When a request is made to the built-in `OPTIONS` handler, only the `before` and `after`
-callbacks associated with the resource will be run.  The `before_validation` and
-`after_validation` callbacks and parameter validations will be skipped.
+When a request is made to the built-in `OPTIONS` handler, only the `before` and `after` callbacks associated with the resource will be run.  The `before_validation` and `after_validation` callbacks and parameter validations will be skipped.
 
 See [#1505](https://github.com/ruby-grape/grape/pull/1505) for more information.
 
@@ -324,8 +558,7 @@ See [#1510](https://github.com/ruby-grape/grape/pull/1510) for more information.
 
 #### The default status code for DELETE is now 204 instead of 200.
 
-Breaking change: Sets the default response status code for a delete request to 204.
-A status of 204 makes the response more distinguishable and therefore easier to handle on the client side, particularly because a DELETE request typically returns an empty body as the resource was deleted or voided.
+Breaking change: Sets the default response status code for a delete request to 204. A status of 204 makes the response more distinguishable and therefore easier to handle on the client side, particularly because a DELETE request typically returns an empty body as the resource was deleted or voided.
 
 To achieve the old behavior, one has to set it explicitly:
 ```ruby
@@ -503,18 +736,14 @@ See [#1114](https://github.com/ruby-grape/grape/pull/1114) for more information.
 
 #### Bypasses formatters when status code indicates no content
 
-To be consistent with rack and it's handling of standard responses
-associated with no content, both default and custom formatters will now
+To be consistent with rack and it's handling of standard responses associated with no content, both default and custom formatters will now
 be bypassed when processing responses for status codes defined [by rack](https://github.com/rack/rack/blob/master/lib/rack/utils.rb#L567)
 
 See [#1190](https://github.com/ruby-grape/grape/pull/1190) for more information.
 
 #### Redirects respond as plain text with message
 
-`#redirect` now uses `text/plain` regardless of whether that format has
-been enabled. This prevents formatters from attempting to serialize the
-message body and allows for a descriptive message body to be provided - and
-optionally overridden - that better fulfills the theme of the HTTP spec.
+`#redirect` now uses `text/plain` regardless of whether that format has been enabled. This prevents formatters from attempting to serialize the message body and allows for a descriptive message body to be provided - and optionally overridden - that better fulfills the theme of the HTTP spec.
 
 See [#1194](https://github.com/ruby-grape/grape/pull/1194) for more information.
 
@@ -548,10 +777,7 @@ end
 
 See [#1029](https://github.com/ruby-grape/grape/pull/1029) for more information.
 
-There is a known issue because of this change. When Grape is used with an older
-than 1.2.4 version of [warden](https://github.com/hassox/warden) there may be raised
-the following exception having the [rack-mount](https://github.com/jm/rack-mount) gem's
-lines as last ones in the backtrace:
+There is a known issue because of this change. When Grape is used with an older than 1.2.4 version of [warden](https://github.com/hassox/warden) there may be raised the following exception having the [rack-mount](https://github.com/jm/rack-mount) gem's lines as last ones in the backtrace:
 
 ```
 NoMethodError: undefined method `[]' for nil:NilClass

data/lib/grape/api/instance.rb

@@ -74,7 +74,7 @@ module Grape
         # (see #cascade?)
         def cascade(value = nil)
           if value.nil?
-            inheritable_setting.namespace_inheritable.keys.include?(:cascade) ? !namespace_inheritable(:cascade).nil? : true
+            inheritable_setting.namespace_inheritable.key?(:cascade) ? !namespace_inheritable(:cascade).nil? : true
           else
             namespace_inheritable(:cascade, value)
           end
@@ -178,7 +178,7 @@ module Grape
       # errors from reaching upstream. This is effectivelly done by unsetting
       # X-Cascade. Default :cascade is true.
       def cascade?
-        return self.class.namespace_inheritable(:cascade) if self.class.inheritable_setting.namespace_inheritable.keys.include?(:cascade)
+        return self.class.namespace_inheritable(:cascade) if self.class.inheritable_setting.namespace_inheritable.key?(:cascade)
         return self.class.namespace_inheritable(:version_options)[:cascade] if self.class.namespace_inheritable(:version_options) && self.class.namespace_inheritable(:version_options).key?(:cascade)
         true
       end
@@ -192,42 +192,21 @@ 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
-        routes_map = {}
-
-        self.class.endpoints.each do |endpoint|
-          routes = endpoint.routes
-          routes.each do |route|
-            # 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
-            route_settings[:methods] = %w[GET PUT POST DELETE PATCH HEAD OPTIONS] if route_settings[:methods].include?('*')
-          end
-        end
-
+        versioned_route_configs = collect_route_config_per_pattern
         # The paths we collected are prepared (cf. Path#prepare), so they
         # contain already versioning information when using path versioning.
         # Disable versioning so adding a route won't prepend versioning
         # informations again.
         without_root_prefix do
           without_versioning do
-            routes_map.each_value do |config|
-              methods = config[:methods]
-              allowed_methods = methods.dup
+            versioned_route_configs.each do |config|
+              allowed_methods = config[:methods].dup
 
               unless self.class.namespace_inheritable(:do_not_route_head)
                 allowed_methods |= [Grape::Http::Headers::HEAD] if allowed_methods.include?(Grape::Http::Headers::GET)
               end
 
-              allow_header = (self.class.namespace_inheritable(:do_not_route_options) ? allowed_methods : [Grape::Http::Headers::OPTIONS] | allowed_methods).join(', ')
+              allow_header = (self.class.namespace_inheritable(:do_not_route_options) ? allowed_methods : [Grape::Http::Headers::OPTIONS] | allowed_methods)
 
               unless self.class.namespace_inheritable(:do_not_route_options) || allowed_methods.include?(Grape::Http::Headers::OPTIONS)
                 config[:endpoint].options[:options_route_enabled] = true
@@ -240,14 +219,36 @@ module Grape
         end
       end
 
+      def collect_route_config_per_pattern
+        all_routes       = self.class.endpoints.map(&:routes).flatten
+        routes_by_regexp = all_routes.group_by { |route| route.pattern.to_regexp }
+
+        # Build the configuration based on the first endpoint and the collection of methods supported.
+        routes_by_regexp.values.map do |routes|
+          last_route        = routes.last # Most of the configuration is taken from the last endpoint
+          matching_wildchar = routes.any? { |route| route.request_method == '*' }
+          {
+            options: {},
+            pattern: last_route.pattern,
+            requirements: last_route.requirements,
+            path: last_route.origin,
+            endpoint: last_route.app,
+            methods: matching_wildchar ? Grape::Http::Headers::SUPPORTED_METHODS : routes.map(&:request_method)
+          }
+        end
+      end
+
       # Generate a route that returns an HTTP 405 response for a user defined
       # path on methods not specified
       def generate_not_allowed_method(pattern, allowed_methods: [], **attributes)
-        not_allowed_methods = %w[GET PUT POST DELETE PATCH HEAD] - allowed_methods
-        not_allowed_methods << Grape::Http::Headers::OPTIONS if self.class.namespace_inheritable(:do_not_route_options)
-
+        supported_methods =
+          if self.class.namespace_inheritable(:do_not_route_options)
+            Grape::Http::Headers::SUPPORTED_METHODS
+          else
+            Grape::Http::Headers::SUPPORTED_METHODS_WITHOUT_OPTIONS
+          end
+        not_allowed_methods = supported_methods - allowed_methods
         return if not_allowed_methods.empty?
-
         @router.associate_routes(pattern, not_allowed_methods: not_allowed_methods, **attributes)
       end
 

data/lib/grape/api.rb

@@ -8,7 +8,7 @@ module Grape
   # should subclass this class in order to build an API.
   class API
     # Class methods that we want to call on the API rather than on the API object
-    NON_OVERRIDABLE = (Class.new.methods + %i[call call! configuration compile!]).freeze
+    NON_OVERRIDABLE = (Class.new.methods + %i[call call! configuration compile! inherited]).freeze
 
     class << self
       attr_accessor :base_instance, :instances
@@ -30,7 +30,7 @@ module Grape
       # an instance that will be used to create the set up but will not be mounted
       def initial_setup(base_instance_parent)
         @instances = []
-        @setup = []
+        @setup = Set.new
         @base_parent = base_instance_parent
         @base_instance = mount_instance
       end
@@ -87,10 +87,10 @@ module Grape
       end
 
       # The remountable class can have a configuration hash to provide some dynamic class-level variables.
-      # For instance, a descripcion could be done using: `desc configuration[:description]` if it may vary
+      # For instance, a description could be done using: `desc configuration[:description]` if it may vary
       # depending on where the endpoint is mounted. Use with care, if you find yourself using configuration
       # too much, you may actually want to provide a new API rather than remount it.
-      def mount_instance(opts = {})
+      def mount_instance(**opts)
         instance = Class.new(@base_parent)
         instance.configuration = Grape::Util::EndpointConfiguration.new(opts[:configuration] || {})
         instance.base = self
@@ -175,7 +175,7 @@ module Grape
           if argument.respond_to?(:lazy?) && argument.lazy?
             argument.evaluate_from(configuration)
           elsif argument.is_a?(Hash)
-            argument.map { |key, value| [key, evaluate_arguments(configuration, value).first] }.to_h
+            argument.transform_values { |value| evaluate_arguments(configuration, value).first }
           elsif argument.is_a?(Array)
             evaluate_arguments(configuration, *argument)
           else

data/lib/grape/content_types.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require 'grape/util/registrable'
+
+module Grape
+  module ContentTypes
+    extend Util::Registrable
+
+    # Content types are listed in order of preference.
+    CONTENT_TYPES = {
+      xml: 'application/xml',
+      serializable_hash: 'application/json',
+      json: 'application/json',
+      binary: 'application/octet-stream',
+      txt: 'text/plain'
+    }.freeze
+
+    class << self
+      def content_types_for_settings(settings)
+        return if settings.blank?
+
+        settings.each_with_object({}) { |value, result| result.merge!(value) }
+      end
+
+      def content_types_for(from_settings)
+        if from_settings.present?
+          from_settings
+        else
+          Grape::ContentTypes::CONTENT_TYPES.merge(default_elements)
+        end
+      end
+    end
+  end
+end

data/lib/grape/dsl/callbacks.rb

@@ -59,7 +59,7 @@ module Grape
         #     end
         #   end
         #
-        # This will make sure that the ApiLogger is opened and close around every
+        # This will make sure that the ApiLogger is opened and closed around every
         # request
         # @param  ensured_block [Proc] The block to be executed after every api_call
         def finally(&block)

data/lib/grape/dsl/helpers.rb

@@ -81,6 +81,7 @@ module Grape
       # to provide some API-specific functionality.
       module BaseHelper
         attr_accessor :api
+
         def params(name, &block)
           @named_params ||= {}
           @named_params[name] = block
@@ -94,7 +95,7 @@ module Grape
         protected
 
         def process_named_params
-          return unless @named_params && @named_params.any?
+          return unless instance_variable_defined?(:@named_params) && @named_params && @named_params.any?
           api.namespace_stackable(:named_params, @named_params)
         end
       end