grape 1.3.1 → 1.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1711dd2fb0f0c86757c7e73d780907efa87e3da54e0a999a4b45c276b5eec92c
-  data.tar.gz: f5ba49001d1816d92130f70fb1b63ae061d7d9250142605f706d75c207880ad9
+  metadata.gz: d63fb79e412ead32064ad4994e171e65962131a04afb20d12957942c744f4df8
+  data.tar.gz: 9a9f4fb654e346eabb8a0b902d5e49ae54dc567797789c98c76f2a2fe2e2daa9
 SHA512:
-  metadata.gz: 8b2dcf4d4903e3923dd10086a3371258404756cf294cd42c6fb64f3d2520fe7243c0accfe1b68f2e02fbaa85f29396c161d830cde4c5fdedd660b31e8d223a7f
-  data.tar.gz: 88a4d5e9740495430cd28ed1e213d6aafd92895c1b7966bd6358dd6aeb5b2e1f16eac2e14834d63e7791a6d66e16475ef30cdef5e37d10bca0f38f1d1a22c1e4
+  metadata.gz: b75afa355e6a2b8200d72a2c4407bc78646648832a94d576bff06bdebde90d54b1897df09a560665bd9f58e735f9832a110b63bbcaabe14a4e2ee3c97e743b57
+  data.tar.gz: 18a4ea057230ae0e6cfe16f92e5043339b66026a94d29bd8c897d2482577cb279ec4e202f41a643605a3ea09c748fa159fddc36977a3c4828b5b64daef080272

data/CHANGELOG.md

@@ -1,3 +1,37 @@
+### 1.3.3 (2020/05/23)
+
+#### Features
+
+* [#2048](https://github.com/ruby-grape/grape/issues/2034): Grape Enterprise support is now available [via TideLift](https://tidelift.com/subscription/request-a-demo?utm_source=rubygems-grape&utm_medium=referral&utm_campaign=enterprise) - [@dblock](https://github.com/dblock).
+* [#2039](https://github.com/ruby-grape/grape/pull/2039): Travis - update rails versions - [@ericproulx](https://github.com/ericproulx).
+* [#2038](https://github.com/ruby-grape/grape/pull/2038): Travis - update ruby versions - [@ericproulx](https://github.com/ericproulx).
+* [#2050](https://github.com/ruby-grape/grape/pull/2050): Refactor route public_send to AttributeTranslator - [@ericproulx](https://github.com/ericproulx).
+
+#### Fixes
+
+* [#2049](https://github.com/ruby-grape/grape/pull/2049): Coerce an empty string to nil in case of the bool type - [@dnesteryuk](https://github.com/dnesteryuk).
+* [#2043](https://github.com/ruby-grape/grape/pull/2043): Modify declared for nested array and hash - [@kadotami](https://github.com/kadotami).
+* [#2040](https://github.com/ruby-grape/grape/pull/2040): Fix a regression with Array of type nil - [@ericproulx](https://github.com/ericproulx).
+* [#2054](https://github.com/ruby-grape/grape/pull/2054): Coercing of nested arrays - [@dnesteryuk](https://github.com/dnesteryuk).
+* [#2050](https://github.com/ruby-grape/grape/pull/2053): Fix broken multiple mounts - [@Jack12816](https://github.com/Jack12816).
+
+### 1.3.2 (2020/04/12)
+
+#### Features
+
+* [#2020](https://github.com/ruby-grape/grape/pull/2020): Reduce array allocation - [@ericproulx](https://github.com/ericproulx).
+* [#2015](https://github.com/ruby-grape/grape/pull/2014): Reduce MatchData allocation - [@ericproulx](https://github.com/ericproulx).
+* [#2014](https://github.com/ruby-grape/grape/pull/2014): Reduce total allocated arrays - [@ericproulx](https://github.com/ericproulx).
+* [#2011](https://github.com/ruby-grape/grape/pull/2011): Reduce total retained regexes - [@ericproulx](https://github.com/ericproulx).
+
+#### Fixes
+
+* [#2033](https://github.com/ruby-grape/grape/pull/2033): Ensure `Float` params are correctly coerced to `BigDecimal` - [@tlconnor](https://github.com/tlconnor).
+* [#2031](https://github.com/ruby-grape/grape/pull/2031): Fix a regression with an array of a custom type - [@dnesteryuk](https://github.com/dnesteryuk).
+* [#2026](https://github.com/ruby-grape/grape/pull/2026): Fix a regression in `coerce_with` when coercion returns `nil` - [@misdoro](https://github.com/misdoro).
+* [#2025](https://github.com/ruby-grape/grape/pull/2025): Fix Decimal type category - [@kdoya](https://github.com/kdoya).
+* [#2019](https://github.com/ruby-grape/grape/pull/2019): Avoid coercing parameter with multiple types to an empty Array - [@stanhu](https://github.com/stanhu).
+
 ### 1.3.1 (2020/03/11)
 
 #### Features

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010-2019 Michael Bleigh, Intridea Inc. and Contributors.
+Copyright (c) 2010-2020 Michael Bleigh, Intridea Inc. and Contributors.
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -12,6 +12,7 @@
 - [What is Grape?](#what-is-grape)
 - [Stable Release](#stable-release)
 - [Project Resources](#project-resources)
+- [Grape for Enterprise](#grape-for-enterprise)
 - [Installation](#installation)
 - [Basic Usage](#basic-usage)
 - [Mounting](#mounting)
@@ -141,6 +142,7 @@
     - [format_response.grape](#format_responsegrape)
   - [Monitoring Products](#monitoring-products)
 - [Contributing to Grape](#contributing-to-grape)
+- [Security](#security)
 - [License](#license)
 - [Copyright](#copyright)
 
@@ -154,7 +156,7 @@ content negotiation, versioning and much more.
 
 ## Stable Release
 
-You're reading the documentation for the stable release of Grape, **1.3.1**.
+You're reading the documentation for the stable release of Grape, **1.3.3**.
 
 ## Project Resources
 
@@ -163,6 +165,14 @@ You're reading the documentation for the stable release of Grape, **1.3.1**.
 * Need help? Try [Grape Google Group](http://groups.google.com/group/ruby-grape) or [Gitter](https://gitter.im/ruby-grape/grape)
 * [Follow us on Twitter](https://twitter.com/grapeframework)
 
+## Grape for Enterprise
+
+Available as part of the Tidelift Subscription.
+
+The maintainers of Grape are working with Tidelift to deliver commercial support and maintenance. Save time, reduce risk, and improve code health, while paying the maintainers of Grape. Click [here](https://tidelift.com/subscription/request-a-demo?utm_source=rubygems-grape&utm_medium=referral&utm_campaign=enterprise) for more details.
+
+In 2020, we plan to use the money towards gathering Grape contributors for dinner in New York City.
+
 ## Installation
 
 Ruby 2.4 or newer is required.
@@ -3187,14 +3197,13 @@ applies to the current namespace and any children, but not parents.
 ```ruby
 http_basic do |username, password|
   # verify user's password here
-  { 'test' => 'password1' }[username] == password
+  # IMPORTANT: make sure you use a comparison method which isn't prone to a timing attack
 end
 ```
 
 ```ruby
 http_digest({ realm: 'Test Api', opaque: 'app secret' }) do |username|
   # lookup the user's password here
-  { 'user1' => 'password1' }[username]
 end
 ```
 
@@ -3851,7 +3860,7 @@ Grape integrates with following third-party tools:
 * **Librato Metrics** - [grape-librato](https://github.com/seanmoon/grape-librato) gem
 * **[Skylight](https://www.skylight.io/)** - [skylight](https://github.com/skylightio/skylight-ruby) gem, [documentation](https://docs.skylight.io/grape/)
 * **[AppSignal](https://www.appsignal.com)** - [appsignal-ruby](https://github.com/appsignal/appsignal-ruby) gem, [documentation](http://docs.appsignal.com/getting-started/supported-frameworks.html#grape)
-* **[ElasticAPM](https://www.elastic.co/products/apm) - [elastic-apm](https://github.com/elastic/apm-agent-ruby) gem, [documentation](https://www.elastic.co/guide/en/apm/agent/ruby/3.x/getting-started-rack.html#getting-started-grape)
+* **[ElasticAPM](https://www.elastic.co/products/apm)** - [elastic-apm](https://github.com/elastic/apm-agent-ruby) gem, [documentation](https://www.elastic.co/guide/en/apm/agent/ruby/3.x/getting-started-rack.html#getting-started-grape)
 
 ## Contributing to Grape
 
@@ -3860,10 +3869,14 @@ features and discuss issues.
 
 See [CONTRIBUTING](CONTRIBUTING.md).
 
+## Security
+
+See [SECURITY](SECURITY.md) for details.
+
 ## License
 
-MIT License. See LICENSE for details.
+MIT License. See [LICENSE](LICENSE) for details.
 
 ## Copyright
 
-Copyright (c) 2010-2019 Michael Bleigh, Intridea Inc. and Contributors.
+Copyright (c) 2010-2020 Michael Bleigh, Intridea Inc. and Contributors.

data/UPGRADING.md

@@ -1,6 +1,65 @@
 Upgrading Grape
 ===============
 
+### Upgrading to >= 1.4.0
+
+#### Nil values for structures
+
+Nil values always been a special case when dealing with types especially with the following structures:
+ - Array
+ - Hash
+ - Set
+ 
+The behaviour for these structures has change through out the latest releases. For instance:
+
+```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 +68,83 @@ 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?`
+
+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:
 
-  attribute :id, Integer
-  attribute :name, String
+```ruby
+# New dry-types parser
+class SecureUri
+  def self.parse(value)
+    URI.parse value
+  end
 
-  def self.parse(attrs)
-    new(attrs)
+  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.
+#### 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).
 

data/lib/grape/api/instance.rb

@@ -205,11 +205,12 @@ module Grape
             route_settings[:requirements] = route.requirements
             route_settings[:path] = route.origin
             route_settings[:methods] ||= []
-            route_settings[:methods] << route.request_method
+            if route.request_method == '*' || route_settings[:methods].include?('*')
+              route_settings[:methods] = Grape::Http::Headers::SUPPORTED_METHODS
+            else
+              route_settings[:methods] << route.request_method
+            end
             route_settings[:endpoint] = route.app
-
-            # using the :any shorthand produces [nil] for route methods, substitute all manually
-            route_settings[:methods] = Grape::Http::Headers::SUPPORTED_METHODS if route_settings[:methods].include?('*')
           end
         end
 
@@ -243,9 +244,13 @@ module Grape
       # 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)

data/lib/grape/dsl/inside_route.rb

@@ -28,36 +28,38 @@ module Grape
       # Methods which should not be available in filters until the before filter
       # has completed
       module PostBeforeFilter
-        def declared(passed_params, options = {}, declared_params = nil)
+        def declared(passed_params, options = {}, declared_params = nil, params_nested_path = [])
           options = options.reverse_merge(include_missing: true, include_parent_namespaces: true)
           declared_params ||= optioned_declared_params(**options)
 
           if passed_params.is_a?(Array)
-            declared_array(passed_params, options, declared_params)
+            declared_array(passed_params, options, declared_params, params_nested_path)
           else
-            declared_hash(passed_params, options, declared_params)
+            declared_hash(passed_params, options, declared_params, params_nested_path)
           end
         end
 
         private
 
-        def declared_array(passed_params, options, declared_params)
+        def declared_array(passed_params, options, declared_params, params_nested_path)
           passed_params.map do |passed_param|
-            declared(passed_param || {}, options, declared_params)
+            declared(passed_param || {}, options, declared_params, params_nested_path)
           end
         end
 
-        def declared_hash(passed_params, options, declared_params)
+        def declared_hash(passed_params, options, declared_params, params_nested_path)
           declared_params.each_with_object(passed_params.class.new) do |declared_param, memo|
             if declared_param.is_a?(Hash)
               declared_param.each_pair do |declared_parent_param, declared_children_params|
+                params_nested_path_dup = params_nested_path.dup
+                params_nested_path_dup << declared_parent_param.to_s
                 next unless options[:include_missing] || passed_params.key?(declared_parent_param)
 
                 passed_children_params = passed_params[declared_parent_param] || passed_params.class.new
                 memo_key = optioned_param_key(declared_parent_param, options)
 
-                memo[memo_key] = handle_passed_param(declared_parent_param, passed_children_params) do
-                  declared(passed_children_params, options, declared_children_params)
+                memo[memo_key] = handle_passed_param(passed_children_params, params_nested_path_dup) do
+                  declared(passed_children_params, options, declared_children_params, params_nested_path_dup)
                 end
               end
             else
@@ -77,19 +79,34 @@ module Grape
           end
         end
 
-        def handle_passed_param(declared_param, passed_children_params, &_block)
-          should_be_empty_array?(declared_param, passed_children_params) ? [] : yield
+        def handle_passed_param(passed_children_params, params_nested_path, &_block)
+          if should_be_empty_hash?(passed_children_params, params_nested_path)
+            {}
+          elsif should_be_empty_array?(passed_children_params, params_nested_path)
+            []
+          else
+            yield
+          end
         end
 
-        def should_be_empty_array?(declared_param, passed_children_params)
-          declared_param_is_array?(declared_param) && passed_children_params.empty?
+        def should_be_empty_array?(passed_children_params, params_nested_path)
+          passed_children_params.empty? && declared_param_is_array?(params_nested_path)
         end
 
-        def declared_param_is_array?(declared_param)
-          key = declared_param.to_s
+        def declared_param_is_array?(params_nested_path)
+          key = route_options_params_key(params_nested_path)
           route_options_params[key] && route_options_params[key][:type] == 'Array'
         end
 
+        def should_be_empty_hash?(passed_children_params, params_nested_path)
+          passed_children_params.empty? && declared_param_is_hash?(params_nested_path)
+        end
+
+        def declared_param_is_hash?(params_nested_path)
+          key = route_options_params_key(params_nested_path)
+          route_options_params[key] && route_options_params[key][:type] == 'Hash'
+        end
+
         def route_options_params
           options[:route_options][:params] || {}
         end
@@ -98,6 +115,12 @@ module Grape
           options[:stringify] ? declared_param.to_s : declared_param.to_sym
         end
 
+        def route_options_params_key(params_nested_path)
+          key = params_nested_path[0]
+          key += '[' + params_nested_path[1..-1].join('][') + ']' if params_nested_path.size > 1
+          key
+        end
+
         def optioned_declared_params(**options)
           declared_params = if options[:include_parent_namespaces]
                               # Declared params including parent namespaces

data/lib/grape/http/headers.rb

@@ -21,6 +21,7 @@ module Grape
       OPTIONS = 'OPTIONS'
 
       SUPPORTED_METHODS = [GET, POST, PUT, PATCH, DELETE, HEAD, OPTIONS].freeze
+      SUPPORTED_METHODS_WITHOUT_OPTIONS = Grape::Util::LazyObject.new { [GET, POST, PUT, PATCH, DELETE, HEAD].freeze }
 
       HTTP_ACCEPT_VERSION    = 'HTTP_ACCEPT_VERSION'
       X_CASCADE              = 'X-Cascade'

data/lib/grape/middleware/versioner/header.rb

@@ -63,7 +63,7 @@ module Grape
 
         def an_accept_header_with_version_and_vendor_is_present?
           header.qvalues.keys.any? do |h|
-            VENDOR_VERSION_HEADER_REGEX =~ h.sub('application/', '')
+            VENDOR_VERSION_HEADER_REGEX.match?(h.sub('application/', ''))
           end
         end
 

data/lib/grape/middleware/versioner/parse_media_type_patch.rb

@@ -3,11 +3,12 @@
 module Rack
   module Accept
     module Header
+      ALLOWED_CHARACTERS = %r{^([a-z*]+)\/([a-z0-9*\&\^\-_#\$!.+]+)(?:;([a-z0-9=;]+))?$}.freeze
       class << self
         # Corrected version of https://github.com/mjackson/rack-accept/blob/master/lib/rack/accept/header.rb#L40-L44
         def parse_media_type(media_type)
           # see http://tools.ietf.org/html/rfc6838#section-4.2 for allowed characters in media type names
-          m = media_type.to_s.match(%r{^([a-z*]+)\/([a-z0-9*\&\^\-_#\$!.+]+)(?:;([a-z0-9=;]+))?$})
+          m = media_type&.match(ALLOWED_CHARACTERS)
           m ? [m[1], m[2], m[3] || ''] : []
         end
       end

data/lib/grape/path.rb

@@ -42,11 +42,11 @@ module Grape
     end
 
     def namespace?
-      namespace && namespace.to_s =~ /^\S/ && namespace != '/'
+      namespace&.match?(/^\S/) && namespace != '/'
     end
 
     def path?
-      raw_path && raw_path.to_s =~ /^\S/ && raw_path != '/'
+      raw_path&.match?(/^\S/) && raw_path != '/'
     end
 
     def suffix

data/lib/grape/router/attribute_translator.rb

@@ -6,10 +6,31 @@ module Grape
     class AttributeTranslator
       attr_reader :attributes, :request_method, :requirements
 
+      ROUTE_ATTRIBUTES = %i[
+        prefix
+        version
+        settings
+        format
+        description
+        http_codes
+        headers
+        entity
+        details
+        requirements
+        request_method
+        namespace
+      ].freeze
+
+      ROUTER_ATTRIBUTES = %i[pattern index].freeze
+
       def initialize(attributes = {})
         @attributes = attributes
-        @request_method = attributes[:request_method]
-        @requirements = attributes[:requirements]
+      end
+
+      (ROUTER_ATTRIBUTES + ROUTE_ATTRIBUTES).each do |attr|
+        define_method attr do
+          attributes[attr]
+        end
       end
 
       def to_h

data/lib/grape/router/route.rb

@@ -12,12 +12,13 @@ module Grape
       SOURCE_LOCATION_REGEXP = /^(.*?):(\d+?)(?::in `.+?')?$/.freeze
       FIXED_NAMED_CAPTURES = %w[format version].freeze
 
-      attr_accessor :pattern, :translator, :app, :index, :regexp, :options
+      attr_accessor :pattern, :translator, :app, :index, :options
 
       alias attributes translator
 
       extend Forwardable
       def_delegators :pattern, :path, :origin
+      delegate Grape::Router::AttributeTranslator::ROUTE_ATTRIBUTES => :attributes
 
       def method_missing(method_id, *arguments)
         match = ROUTE_ATTRIBUTE_REGEXP.match(method_id.to_s)
@@ -31,26 +32,7 @@ module Grape
       end
 
       def respond_to_missing?(method_id, _)
-        ROUTE_ATTRIBUTE_REGEXP.match(method_id.to_s)
-      end
-
-      %i[
-        prefix
-        version
-        settings
-        format
-        description
-        http_codes
-        headers
-        entity
-        details
-        requirements
-        request_method
-        namespace
-      ].each do |method_name|
-        define_method method_name do
-          attributes.public_send method_name
-        end
+        ROUTE_ATTRIBUTE_REGEXP.match?(method_id.to_s)
       end
 
       def route_method
@@ -67,7 +49,6 @@ module Grape
         method_s = method.to_s
         method_upcase = Grape::Http::Headers.find_supported_method(method_s) || method_s.upcase
 
-        @suffix     = options[:suffix]
         @options    = options.merge(method: method_upcase)
         @pattern    = Pattern.new(pattern, **options)
         @translator = AttributeTranslator.new(**options, request_method: method_upcase)

data/lib/grape/router.rb

@@ -7,16 +7,6 @@ module Grape
   class Router
     attr_reader :map, :compiled
 
-    class Any < AttributeTranslator
-      attr_reader :pattern, :regexp, :index
-      def initialize(pattern, regexp, index, **attributes)
-        @pattern = pattern
-        @regexp = regexp
-        @index = index
-        super(attributes)
-      end
-    end
-
     class NormalizePathCache < Grape::Util::Cache
       def initialize
         @cache = Hash.new do |h, path|
@@ -39,18 +29,20 @@ module Grape
 
     def initialize
       @neutral_map = []
+      @neutral_regexes = []
       @map = Hash.new { |hash, key| hash[key] = [] }
       @optimized_map = Hash.new { |hash, key| hash[key] = // }
     end
 
     def compile!
       return if compiled
-      @union = Regexp.union(@neutral_map.map(&:regexp))
+      @union = Regexp.union(@neutral_regexes)
+      @neutral_regexes = nil
       self.class.supported_methods.each do |method|
         routes = map[method]
         @optimized_map[method] = routes.map.with_index do |route, index|
           route.index = index
-          route.regexp = Regexp.new("(?<_#{index}>#{route.pattern.to_regexp})")
+          Regexp.new("(?<_#{index}>#{route.pattern.to_regexp})")
         end
         @optimized_map[method] = Regexp.union(@optimized_map[method])
       end
@@ -62,8 +54,8 @@ module Grape
     end
 
     def associate_routes(pattern, **options)
-      regexp = Regexp.new("(?<_#{@neutral_map.length}>)#{pattern.to_regexp}")
-      @neutral_map << Any.new(pattern, regexp, @neutral_map.length, **options)
+      @neutral_regexes << Regexp.new("(?<_#{@neutral_map.length}>)#{pattern.to_regexp}")
+      @neutral_map << Grape::Router::AttributeTranslator.new(options.merge(pattern: pattern, index: @neutral_map.length))
     end
 
     def call(env)

data/lib/grape/util/base_inheritable.rb

@@ -5,8 +5,7 @@ module Grape
     # Base for classes which need to operate with own values kept
     # in the hash and inherited values kept in a Hash-like object.
     class BaseInheritable
-      attr_accessor :inherited_values
-      attr_accessor :new_values
+      attr_accessor :inherited_values, :new_values
 
       # @param inherited_values [Object] An object implementing an interface
       #   of the Hash class.
@@ -26,10 +25,14 @@ module Grape
       end
 
       def keys
-        combined = inherited_values.keys
-        combined.concat(new_values.keys)
-        combined.uniq!
-        combined
+        if new_values.any?
+          combined = inherited_values.keys
+          combined.concat(new_values.keys)
+          combined.uniq!
+          combined
+        else
+          inherited_values.keys
+        end
       end
 
       def key?(name)

data/lib/grape/util/reverse_stackable_values.rb

@@ -8,8 +8,10 @@ module Grape
       protected
 
       def concat_values(inherited_value, new_value)
+        return inherited_value unless new_value
+
         [].tap do |value|
-          value.concat(new_value) if new_value
+          value.concat(new_value)
           value.concat(inherited_value)
         end
       end