grape 3.2.1 → 3.3.0

data/lib/grape/util/lazy/value.rb

@@ -3,10 +3,11 @@
 module Grape
   module Util
     module Lazy
-      class Value
+      class Value < Base
         attr_reader :access_keys
 
         def initialize(value, access_keys = [])
+          super()
           @value = value
           @access_keys = access_keys
         end
@@ -20,18 +21,10 @@ module Grape
           @value
         end
 
-        def lazy?
-          true
-        end
-
         def reached_by(parent_access_keys, access_key)
           @access_keys = parent_access_keys + [access_key]
           self
         end
-
-        def to_s
-          evaluate.to_s
-        end
       end
     end
   end

data/lib/grape/util/lazy/value_enumerable.rb

@@ -5,28 +5,25 @@ module Grape
     module Lazy
       class ValueEnumerable < Value
         def [](key)
-          if @value_hash[key].nil?
-            Value.new(nil).reached_by(access_keys, key)
-          else
-            @value_hash[key].reached_by(access_keys, key)
-          end
+          return Value.new(nil).reached_by(access_keys, key) if @value_hash[key].nil?
+
+          @value_hash[key].reached_by(access_keys, key)
         end
 
         def fetch(access_keys)
-          fetched_keys = access_keys.dup
-          value = self[fetched_keys.shift]
-          fetched_keys.any? ? value.fetch(fetched_keys) : value
+          access_keys.reduce(self) { |node, key| node[key] }
         end
 
         def []=(key, value)
-          @value_hash[key] = case value
-                             when Hash
-                               ValueHash.new(value)
-                             when Array
-                               ValueArray.new(value)
-                             else
-                               Value.new(value)
-                             end
+          value_class = case value
+                        when Hash
+                          ValueHash
+                        when Array
+                          ValueArray
+                        else
+                          Value
+                        end
+          @value_hash[key] = value_class.new(value)
         end
       end
     end

data/lib/grape/util/media_type.rb

@@ -20,10 +20,6 @@ module Grape
       end
 
       def ==(other)
-        eql?(other)
-      end
-
-      def eql?(other)
         self.class == other.class &&
           other.type == type &&
           other.subtype == subtype &&
@@ -31,6 +27,7 @@ module Grape
           other.version == version &&
           other.format == format
       end
+      alias eql? ==
 
       def hash
         [self.class, type, subtype, vendor, version, format].hash

data/lib/grape/util/path_normalizer.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    module PathNormalizer
+      # Taken from Rails
+      #     call("/foo")  # => "/foo"
+      #     call("/foo/") # => "/foo"
+      #     call("foo")   # => "/foo"
+      #     call("")      # => "/"
+      #     call("/%ab")  # => "/%AB"
+      # https://github.com/rails/rails/blob/00cc4ff0259c0185fe08baadaa40e63ea2534f6e/actionpack/lib/action_dispatch/journey/router/utils.rb#L19
+      def self.call(path)
+        return '/' unless path
+        return path if path == '/'
+
+        # Fast path for the overwhelming majority of paths that don't need to be normalized
+        return path if path.start_with?('/') && !(path.end_with?('/') || path.match?(%r{%|//}))
+
+        # Slow path
+        encoding = path.encoding
+        path = "/#{path}"
+        path.squeeze!('/')
+
+        unless path == '/'
+          path.delete_suffix!('/')
+          path.gsub!(/(%[a-f0-9]{2})/) { ::Regexp.last_match(1).upcase }
+        end
+
+        path.force_encoding(encoding)
+      end
+    end
+  end
+end

data/lib/grape/util/registry.rb

@@ -20,7 +20,7 @@ module Grape
       end
 
       def registry
-        @registry ||= {}.with_indifferent_access
+        @registry ||= ActiveSupport::HashWithIndifferentAccess.new
       end
     end
   end

data/lib/grape/util/stackable_values.rb

@@ -3,24 +3,27 @@
 module Grape
   module Util
     class StackableValues < BaseInheritable
-      # Even if there is no value, an empty array will be returned.
+      EMPTY = [].freeze
+
+      # Even if there is no value, an empty (frozen) array will be returned.
       def [](name)
-        inherited_value = inherited_values[name]
-        new_value = new_values[name]
+        inherited_value = @inherited_values[name]
+        new_value = @new_values && @new_values[name]
 
-        return new_value || [] unless inherited_value
+        return new_value || EMPTY unless inherited_value
 
         concat_values(inherited_value, new_value)
       end
 
       def []=(name, value)
-        new_values[name] ||= []
-        new_values[name].push value
+        @new_values ||= {}
+        @new_values[name] ||= []
+        @new_values[name].push value
       end
 
       def to_hash
-        keys.each_with_object({}) do |key, result|
-          result[key] = self[key]
+        keys.to_h do |key|
+          [key, self[key]]
         end
       end
 

data/lib/grape/validations/attributes_iterator.rb

@@ -3,37 +3,37 @@
 module Grape
   module Validations
     class AttributesIterator
-      include Enumerable
-
-      attr_reader :scope
-
-      def initialize(attrs, scope, params)
+      # +attrs+ and +scope+ are static per validator; only +params+ varies
+      # per request, so an instance can be built once and reused (it keeps
+      # no request-derived state). Reused instances are shared across
+      # threads, so +each+ must stay free of mutable instance state.
+      def initialize(attrs, scope)
         @attrs = attrs
         @scope = scope
-        @original_params = scope.params(params)
-        @params = Array.wrap(@original_params)
       end
 
-      def each(&)
-        do_each(@params, &) # because we need recursion for nested arrays
+      def each(params, &)
+        original_params = @scope.params(params)
+        # because we need recursion for nested arrays
+        do_each(Array.wrap(original_params), original_params, &)
       end
 
       private
 
-      def do_each(params_to_process, parent_indices = [], &block)
+      def do_each(params_to_process, original_params, parent_indices = [], &block)
         params_to_process.each_with_index do |resource_params, index|
           # when we get arrays of arrays it means that target element located inside array
           # we need this because we want to know parent arrays indices
           if resource_params.is_a?(Array)
-            do_each(resource_params, [index] + parent_indices, &block)
+            do_each(resource_params, original_params, [index] + parent_indices, &block)
             next
           end
 
           if @scope.type == Array
-            next unless @original_params.is_a?(Array) # do not validate content of array if it isn't array
+            next unless original_params.is_a?(Array) # do not validate content of array if it isn't array
 
             store_indices(@scope, index, parent_indices)
-          elsif @original_params.is_a?(Array)
+          elsif original_params.is_a?(Array)
             # Lateral scope (no @element) whose params resolved to an array —
             # delegate index tracking to the nearest array-typed ancestor so
             # that full_name produces the correct bracketed index.

data/lib/grape/validations/coerce_options.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    # Immutable value object describing how a parameter is coerced. Assembled
+    # by {ValidationsSpec#coerce_options} from the parsed +type+/+coerce_with+/
+    # +coerce_message+ declaration — never written by the user — and consumed
+    # by {ParamsScope#check_coerce_with} / {ParamsScope#validate_coerce} and by
+    # {Validators::Validators::CoerceValidator} (which receives it as its
+    # +options+ argument).
+    #
+    # All three fields may be +nil+ (e.g. a remountable API evaluated on its
+    # base instance has no resolved +type+ yet).
+    # +coerce_method+ (not +method+) avoids shadowing +Object#method+.
+    CoerceOptions = Data.define(:type, :coerce_method, :message) do
+      def initialize(type: nil, coerce_method: nil, message: nil)
+        super
+      end
+    end
+  end
+end

data/lib/grape/validations/oneof_collector.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    # Stand-in for the +@api+ object that {ParamsScope} normally writes to.
+    # Used when evaluating a single variant block of a +oneof:+ schema so that
+    # the variant's validators are captured locally rather than registered on
+    # the real API. Exposes only the slice of the API surface that
+    # ParamsScope and its helpers touch during definition.
+    class OneofCollector
+      attr_reader :inheritable_setting
+
+      def initialize
+        @inheritable_setting = Grape::Util::InheritableSetting.new
+        @inheritable_setting.namespace_inheritable[:do_not_document] = true
+      end
+
+      def configuration
+        nil
+      end
+
+      def validators
+        inheritable_setting.namespace_stackable[:validations]
+      end
+
+      def declared_params
+        inheritable_setting.namespace_stackable[:declared_params]
+      end
+
+      # Evaluate +variant_block+ in a fresh +ParamsScope+ backed by a new
+      # collector and return the validators that the block registered.
+      def self.collect(variant_block)
+        collector = new
+        ParamsScope.new(api: collector, type: Hash, &variant_block)
+        collector.validators
+      end
+    end
+  end
+end

data/lib/grape/validations/param_scope_tracker.rb

@@ -29,28 +29,33 @@ module Grape
         Fiber[FIBER_KEY]
       end
 
-      def initialize
-        @index_tracker = {}.compare_by_identity
-        @qualifying_params_tracker = {}.compare_by_identity
-      end
-
       def store_index(scope, index)
-        @index_tracker.store(scope, index)
+        index_tracker.store(scope, index)
       end
 
       def index_for(scope)
-        @index_tracker[scope]
+        index_tracker[scope]
       end
 
       # Returns qualifying params for +scope+, or EMPTY_PARAMS if none were stored.
       # Note: an explicitly stored empty array and "never stored" are treated identically
       # by callers (both yield a blank result that falls through to the parent params).
       def qualifying_params(scope)
-        @qualifying_params_tracker.fetch(scope, EMPTY_PARAMS)
+        qualifying_params_tracker.fetch(scope, EMPTY_PARAMS)
       end
 
       def store_qualifying_params(scope, params)
-        @qualifying_params_tracker.store(scope, params)
+        qualifying_params_tracker.store(scope, params)
+      end
+
+      private
+
+      def index_tracker
+        @index_tracker ||= {}.compare_by_identity
+      end
+
+      def qualifying_params_tracker
+        @qualifying_params_tracker ||= {}.compare_by_identity
       end
     end
   end

data/lib/grape/validations/params_documentation.rb

@@ -2,39 +2,41 @@
 
 module Grape
   module Validations
-    # Documents parameters of an endpoint. If documentation isn't needed (for instance, it is an
-    # internal API), the class only cleans up attributes to avoid junk in RAM.
-
+    # Documents parameters of an endpoint. Reads from a frozen
+    # +ValidationsSpec+; never mutates the user's validations hash.
     module ParamsDocumentation
-      def document_params(attrs, validations, type = nil, values = nil, except_values = nil)
-        return validations.except!(:desc, :description, :documentation) if @api.inheritable_setting.namespace_inheritable[:do_not_document]
+      def document_params(attrs, spec)
+        return if @api.inheritable_setting.namespace_inheritable[:do_not_document]
 
-        documented_attrs = attrs.each_with_object({}) do |name, memo|
-          memo[full_name(name)] = extract_details(validations, type, values, except_values)
+        documented_attrs = attrs.to_h do |name|
+          [full_name(name), extract_details(spec)]
         end
         @api.inheritable_setting.namespace_stackable[:params] = documented_attrs
       end
 
       private
 
-      def extract_details(validations, type, values, except_values)
-        {}.tap do |details|
-          details[:required] = validations.key?(:presence)
-          details[:type] = TypeCache[type] if type
-          details[:values] = values if values
-          details[:except_values] = except_values if except_values
-          details[:default] = validations[:default] if validations.key?(:default)
-          if validations.key?(:length)
-            details[:min_length] = validations[:length][:min] if validations[:length].key?(:min)
-            details[:max_length] = validations[:length][:max] if validations[:length].key?(:max)
-          end
+      def extract_details(spec)
+        details = {}
+        details[:required] = spec.required?
+        details[:type] = TypeCache[spec.coerce_type] if spec.coerce_type
+        details[:values] = spec.values if spec.values
+        details[:except_values] = spec.except_values if spec.except_values
+        details[:default] = spec.default unless spec.default.nil?
+
+        length = spec.raw[:length]
+        if length.is_a?(Hash)
+          details[:min_length] = length[:min] if length.key?(:min)
+          details[:max_length] = length[:max] if length.key?(:max)
+        end
 
-          desc = validations.delete(:desc) || validations.delete(:description)
-          details[:desc] = desc if desc
+        desc = spec.raw[:desc] || spec.raw[:description]
+        details[:desc] = desc if desc
 
-          documentation = validations.delete(:documentation)
-          details[:documentation] = documentation if documentation
-        end
+        documentation = spec.raw[:documentation]
+        details[:documentation] = documentation if documentation
+
+        details
       end
 
       class TypeCache < Grape::Util::Cache