grape 1.8.0 → 3.3.5

data/lib/grape/util/base_inheritable.rb

@@ -4,6 +4,9 @@ module Grape
   module Util
     # Base for classes which need to operate with own values kept
     # in the hash and inherited values kept in a Hash-like object.
+    #
+    # +@new_values+ is lazily allocated on first write so settings layers
+    # that only inherit (never override) don't carry an empty Hash each.
     class BaseInheritable
       attr_accessor :inherited_values, :new_values
 
@@ -11,32 +14,29 @@ module Grape
       #   of the Hash class.
       def initialize(inherited_values = nil)
         @inherited_values = inherited_values || {}
-        @new_values = {}
+        # @new_values stays nil until the first write.
       end
 
-      def delete(key)
-        new_values.delete key
+      def delete(*keys)
+        return [] unless @new_values
+
+        keys.map { |key| @new_values.delete(key) }
       end
 
       def initialize_copy(other)
         super
-        self.inherited_values = other.inherited_values
-        self.new_values = other.new_values.dup
+        @inherited_values = other.inherited_values
+        @new_values = other.new_values&.dup
       end
 
       def keys
-        if new_values.any?
-          combined = inherited_values.keys
-          combined.concat(new_values.keys)
-          combined.uniq!
-          combined
-        else
-          inherited_values.keys
-        end
+        return @inherited_values.keys if @new_values.nil? || @new_values.empty?
+
+        (@inherited_values.keys + @new_values.keys).uniq
       end
 
       def key?(name)
-        inherited_values.key?(name) || new_values.key?(name)
+        @inherited_values.key?(name) || @new_values&.key?(name) || false
       end
     end
   end

data/lib/grape/util/cache.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require 'singleton'
-require 'forwardable'
-
 module Grape
   module Util
     class Cache
@@ -12,6 +9,7 @@ module Grape
 
       class << self
         extend Forwardable
+
         def_delegators :cache, :[]
         def_delegators :instance, :cache
       end

data/lib/grape/util/deep_freeze.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    module DeepFreeze
+      module_function
+
+      # Recursively freezes Hash (keys and values), Array (elements), and String
+      # objects. All other types are returned as-is.
+      #
+      # Intentionally left unfrozen:
+      #   - Procs / lambdas — may be deferred DB-backed callables
+      #   - Coercers (e.g. ArrayCoercer) — use lazy ivar memoization at request time
+      #   - Classes / Modules — shared constants that must remain open
+      #   - ParamsScope — self-freezes at the end of its own initialize
+      def deep_freeze(obj)
+        case obj
+        when Hash
+          obj.each do |k, v|
+            deep_freeze(k)
+            deep_freeze(v)
+          end
+          obj.freeze
+        when Array
+          obj.each { |v| deep_freeze(v) }
+          obj.freeze
+        when String
+          obj.freeze
+        else
+          obj
+        end
+      end
+    end
+  end
+end

data/lib/grape/util/endpoint_configuration.rb

@@ -2,7 +2,7 @@
 
 module Grape
   module Util
-    class EndpointConfiguration < LazyValueHash
+    class EndpointConfiguration < Lazy::ValueHash
     end
   end
 end

data/lib/grape/util/header.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    if Gem::Version.new(Rack.release) >= Gem::Version.new('3')
+      require 'rack/headers'
+      Header = Rack::Headers
+    else
+      require 'rack/utils'
+      Header = Rack::Utils::HeaderHash
+    end
+  end
+end

data/lib/grape/util/inheritable_setting.rb

@@ -5,7 +5,17 @@ module Grape
     # A branchable, inheritable settings object which can store both stackable
     # and inheritable values (see InheritableValues and StackableValues).
     class InheritableSetting
-      attr_accessor :route, :api_class, :namespace, :namespace_inheritable, :namespace_stackable, :namespace_reverse_stackable, :parent, :point_in_time_copies
+      attr_reader :route, :namespace, :namespace_inheritable, :namespace_stackable, :namespace_reverse_stackable, :parent
+
+      # Lazy-allocated; +api_class+ and +point_in_time_copies+ are rarely
+      # written on most settings layers, so don't pay for a Hash/Array each.
+      def api_class
+        @api_class ||= {}
+      end
+
+      def point_in_time_copies
+        @point_in_time_copies ||= []
+      end
 
       # Retrieve global settings.
       def self.global
@@ -23,17 +33,14 @@ module Grape
       # instance can then be set to inherit from an existing instance (see
       # #inherit_from).
       def initialize
-        self.route = {}
-        self.api_class = {}
-        self.namespace = InheritableValues.new # only inheritable from a parent when
+        @route = {}
+        @namespace = InheritableValues.new # only inheritable from a parent when
         # used with a mount, or should every API::Class be a separate namespace by default?
-        self.namespace_inheritable = InheritableValues.new
-        self.namespace_stackable = StackableValues.new
-        self.namespace_reverse_stackable = ReverseStackableValues.new
-
-        self.point_in_time_copies = []
-
-        self.parent = nil
+        @namespace_inheritable = InheritableValues.new
+        @namespace_stackable = StackableValues.new
+        @namespace_reverse_stackable = ReverseStackableValues.new
+        @parent = nil
+        # @api_class and @point_in_time_copies stay nil until first access.
       end
 
       # Return the class-level global properties.
@@ -48,14 +55,14 @@ module Grape
       def inherit_from(parent)
         return if parent.nil?
 
-        self.parent = parent
+        @parent = parent
 
         namespace_inheritable.inherited_values = parent.namespace_inheritable
         namespace_stackable.inherited_values = parent.namespace_stackable
         namespace_reverse_stackable.inherited_values = parent.namespace_reverse_stackable
-        self.route = parent.route.merge(route)
+        @route = parent.route.merge(route)
 
-        point_in_time_copies.map { |cloned_one| cloned_one.inherit_from parent }
+        @point_in_time_copies&.each { |cloned_one| cloned_one.inherit_from parent }
       end
 
       # Create a point-in-time copy of this settings instance, with clones of
@@ -63,19 +70,11 @@ module Grape
       # changed via #inherit_from, it will copy that inheritence to any copies
       # which were made.
       def point_in_time_copy
-        self.class.new.tap do |new_setting|
-          point_in_time_copies << new_setting
-          new_setting.point_in_time_copies = []
-
-          new_setting.namespace = namespace.clone
-          new_setting.namespace_inheritable = namespace_inheritable.clone
-          new_setting.namespace_stackable = namespace_stackable.clone
-          new_setting.namespace_reverse_stackable = namespace_reverse_stackable.clone
-          new_setting.route = route.clone
-          new_setting.api_class = api_class
-
-          new_setting.inherit_from(parent)
-        end
+        new_setting = self.class.new
+        point_in_time_copies << new_setting
+        new_setting.copy_state_from(self)
+        new_setting.inherit_from(parent)
+        new_setting
       end
 
       # Resets the instance store of per-route settings.
@@ -95,6 +94,31 @@ module Grape
           namespace_reverse_stackable: namespace_reverse_stackable.to_hash
         }
       end
+
+      def ==(other)
+        other.is_a?(self.class) && to_hash == other.to_hash
+      end
+      alias eql? ==
+
+      def namespace_stackable_with_hash(key)
+        data = namespace_stackable[key]
+        return if data.blank?
+
+        data.each_with_object({}) { |value, result| result.deep_merge!(value) }
+      end
+
+      protected
+
+      # Used by +point_in_time_copy+ to populate a freshly-built instance
+      # with cloned state from another instance of the same class.
+      def copy_state_from(source)
+        @namespace = source.namespace.clone
+        @namespace_inheritable = source.namespace_inheritable.clone
+        @namespace_stackable = source.namespace_stackable.clone
+        @namespace_reverse_stackable = source.namespace_reverse_stackable.clone
+        @route = source.route.clone
+        @api_class = source.api_class
+      end
     end
   end
 end

data/lib/grape/util/inheritable_values.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
-require_relative 'base_inheritable'
-
 module Grape
   module Util
     class InheritableValues < BaseInheritable
       def [](name)
-        values[name]
+        return @inherited_values[name] unless @new_values
+
+        @new_values.fetch(name) { @inherited_values[name] }
       end
 
       def []=(name, value)
-        new_values[name] = value
+        (@new_values ||= {})[name] = value
       end
 
       def merge(new_hash)
@@ -24,7 +24,9 @@ module Grape
       protected
 
       def values
-        @inherited_values.merge(@new_values)
+        return @inherited_values.merge(@new_values) if @new_values && !@new_values.empty?
+
+        @inherited_values.is_a?(Hash) ? @inherited_values.dup : @inherited_values.to_hash
       end
     end
   end

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    module Lazy
+      # Abstract parent for lazy wrappers used by the remount/configuration
+      # machinery. Call sites can type-check with +is_a?(Grape::Util::Lazy::Base)+
+      # instead of enumerating the concrete subclasses.
+      class Base
+        def to_s
+          evaluate.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    module Lazy
+      class Block < Base
+        def initialize(&new_block)
+          super()
+          @block = new_block
+        end
+
+        def evaluate_from(configuration)
+          @block.call(configuration)
+        end
+
+        def evaluate
+          @block.call({})
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    module Lazy
+      class Value < Base
+        attr_reader :access_keys
+
+        def initialize(value, access_keys = [])
+          super()
+          @value = value
+          @access_keys = access_keys
+        end
+
+        def evaluate_from(configuration)
+          matching_lazy_value = configuration.fetch(@access_keys)
+          matching_lazy_value.evaluate
+        end
+
+        def evaluate
+          @value
+        end
+
+        def reached_by(parent_access_keys, access_key)
+          @access_keys = parent_access_keys + [access_key]
+          self
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    module Lazy
+      class ValueArray < ValueEnumerable
+        def initialize(array)
+          super
+          @value_hash = []
+          array.each_with_index do |value, index|
+            self[index] = value
+          end
+        end
+
+        def evaluate
+          @value_hash.map(&:evaluate)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    module Lazy
+      class ValueEnumerable < Value
+        def [](key)
+          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)
+          access_keys.reduce(self) { |node, key| node[key] }
+        end
+
+        def []=(key, value)
+          value_class = case value
+                        when Hash
+                          ValueHash
+                        when Array
+                          ValueArray
+                        else
+                          Value
+                        end
+          @value_hash[key] = value_class.new(value)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    module Lazy
+      class ValueHash < ValueEnumerable
+        def initialize(hash)
+          super
+          @value_hash = ActiveSupport::HashWithIndifferentAccess.new
+          hash.each do |key, value|
+            self[key] = value
+          end
+        end
+
+        def evaluate
+          @value_hash.transform_values(&:evaluate)
+        end
+      end
+    end
+  end
+end

data/lib/grape/util/media_type.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    class MediaType
+      attr_reader :type, :subtype, :vendor, :version, :format
+
+      # based on the HTTP Accept header with the pattern:
+      # application/vnd.:vendor-:version+:format
+      VENDOR_VERSION_HEADER_REGEX = /\Avnd\.(?<vendor>[a-z0-9.\-_!^]+?)(?:-(?<version>[a-z0-9*.]+))?(?:\+(?<format>[a-z0-9*\-.]+))?\z/
+
+      def initialize(type:, subtype:)
+        @type = type
+        @subtype = subtype
+        VENDOR_VERSION_HEADER_REGEX.match(subtype) do |m|
+          @vendor = m[:vendor]
+          @version = m[:version]
+          @format = m[:format]
+        end
+      end
+
+      def ==(other)
+        self.class == other.class &&
+          other.type == type &&
+          other.subtype == subtype &&
+          other.vendor == vendor &&
+          other.version == version &&
+          other.format == format
+      end
+      alias eql? ==
+
+      def hash
+        [self.class, type, subtype, vendor, version, format].hash
+      end
+
+      class << self
+        def best_quality(header, available_media_types)
+          parse(best_quality_media_type(header, available_media_types))
+        end
+
+        def parse(media_type)
+          return if media_type.blank?
+
+          type, subtype = media_type.split('/', 2)
+          return if type.blank? || subtype.blank?
+
+          new(type:, subtype:)
+        end
+
+        def match?(media_type)
+          return false if media_type.blank?
+
+          subtype = media_type.split('/', 2).last
+          return false if subtype.blank?
+
+          VENDOR_VERSION_HEADER_REGEX.match?(subtype)
+        end
+
+        def best_quality_media_type(header, available_media_types)
+          header.blank? ? available_media_types.first : Rack::Utils.best_q_match(header, available_media_types)
+        end
+      end
+
+      private_class_method :best_quality_media_type
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    module Registry
+      def register(klass)
+        short_name = build_short_name(klass)
+        return if short_name.nil?
+
+        warn "#{short_name} is already registered with class #{registry[short_name]}. It will be overridden globally with the following: #{klass.name}" if registry.key?(short_name)
+        registry[short_name] = klass
+      end
+
+      private
+
+      def build_short_name(klass)
+        return if klass.name.blank?
+
+        klass.name.demodulize.underscore
+      end
+
+      def registry
+        @registry ||= ActiveSupport::HashWithIndifferentAccess.new
+      end
+    end
+  end
+end

data/lib/grape/util/reverse_stackable_values.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'stackable_values'
-
 module Grape
   module Util
     class ReverseStackableValues < StackableValues
@@ -10,10 +8,7 @@ module Grape
       def concat_values(inherited_value, new_value)
         return inherited_value unless new_value
 
-        [].tap do |value|
-          value.concat(new_value)
-          value.concat(inherited_value)
-        end
+        new_value + inherited_value
       end
     end
   end

data/lib/grape/util/stackable_values.rb

@@ -1,28 +1,29 @@
 # frozen_string_literal: true
 
-require_relative 'base_inheritable'
-
 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
 
@@ -31,10 +32,7 @@ module Grape
       def concat_values(inherited_value, new_value)
         return inherited_value unless new_value
 
-        [].tap do |value|
-          value.concat(inherited_value)
-          value.concat(new_value)
-        end
+        inherited_value + new_value
       end
     end
   end

data/lib/grape/util/translation.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    module Translation
+      FALLBACK_LOCALE = :en
+      private_constant :FALLBACK_LOCALE
+      # Sentinel returned by I18n when a key is missing (passed as the default:
+      # value). Using a named class rather than plain Object.new makes it
+      # identifiable in debug output and immune to backends that call .to_s on
+      # the default before returning it.
+      MISSING = Class.new { def inspect = 'Grape::Util::Translation::MISSING' }.new.freeze
+      private_constant :MISSING
+
+      private
+
+      # Extra keyword args (**) are forwarded verbatim to I18n as interpolation
+      # variables (e.g. +min:+, +max:+ from LengthValidator's Hash message).
+      # Callers must not pass unintended keyword arguments — any extra keyword
+      # will silently become an I18n interpolation variable.
+      def translate(key, default: MISSING, scope: 'grape.errors.messages', locale: nil, **)
+        i18n_opts = { default:, scope:, ** }
+        i18n_opts[:locale] = locale if locale
+        message = ::I18n.translate(key, **i18n_opts)
+        return message unless message.equal?(MISSING)
+
+        effective_default = default.equal?(MISSING) ? [*Array(scope), key].join('.') : default
+        return effective_default if fallback_locale?(locale) || fallback_locale_unavailable?
+
+        ::I18n.translate(key, default: effective_default, scope:, locale: FALLBACK_LOCALE, **)
+      end
+
+      def fallback_locale?(locale)
+        (locale || ::I18n.locale) == FALLBACK_LOCALE
+      end
+
+      def fallback_locale_unavailable?
+        ::I18n.enforce_available_locales && !::I18n.available_locales.include?(FALLBACK_LOCALE)
+      end
+    end
+  end
+end