grape 1.8.0 → 2.1.0

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    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
+        end
+
+        def fetch(access_keys)
+          fetched_keys = access_keys.dup
+          value = self[fetched_keys.shift]
+          fetched_keys.any? ? value.fetch(fetched_keys) : value
+        end
+
+        def []=(key, value)
+          @value_hash[key] = case value
+                             when Hash
+                               ValueHash.new(value)
+                             when Array
+                               ValueArray.new(value)
+                             else
+                               Value.new(value)
+                             end
+        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,70 @@
+# 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/.freeze
+
+      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)
+        eql?(other)
+      end
+
+      def eql?(other)
+        self.class == other.class &&
+          other.type == type &&
+          other.subtype == subtype &&
+          other.vendor == vendor &&
+          other.version == version &&
+          other.format == format
+      end
+
+      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: type, subtype: 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/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,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'base_inheritable'
-
 module Grape
   module Util
     class StackableValues < BaseInheritable
@@ -31,10 +29,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/strict_hash_configuration.rb

@@ -56,19 +56,19 @@ module Grape
       def self.nested_settings_methods(setting_name, new_config_class)
         new_config_class.class_eval do
           setting_name.each_pair do |key, value|
-            define_method "#{key}_context" do
+            define_method :"#{key}_context" do
               @contexts[key] ||= Grape::Util::StrictHashConfiguration.config_class(*value).new
             end
 
             define_method key do |&block|
-              send("#{key}_context").instance_exec(&block)
+              send(:"#{key}_context").instance_exec(&block)
             end
           end
 
           define_method :to_hash do
             @settings.to_hash.merge(
               setting_name.each_key.with_object({}) do |k, merge_hash|
-                merge_hash[k] = send("#{k}_context").to_hash
+                merge_hash[k] = send(:"#{k}_context").to_hash
               end
             )
           end

data/lib/grape/validations/attributes_doc.rb

@@ -2,56 +2,58 @@
 
 module Grape
   module Validations
-    class ParamsScope
-      # 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.
-      class AttributesDoc
-        attr_accessor :type, :values
-
-        # @param api [Grape::API::Instance]
-        # @param scope [Validations::ParamsScope]
-        def initialize(api, scope)
-          @api = api
-          @scope = scope
-          @type = type
-        end
+    # 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.
+
+    class AttributesDoc
+      attr_accessor :type, :values
+
+      # @param api [Grape::API::Instance]
+      # @param scope [Validations::ParamsScope]
+      def initialize(api, scope)
+        @api = api
+        @scope = scope
+        @type = type
+      end
 
-        def extract_details(validations)
-          details[:required] = validations.key?(:presence)
+      def extract_details(validations)
+        details[:required] = validations.key?(:presence)
 
-          desc = validations.delete(:desc) || validations.delete(:description)
+        desc = validations.delete(:desc) || validations.delete(:description)
 
-          details[:desc] = desc if desc
+        details[:desc] = desc if desc
 
-          documentation = validations.delete(:documentation)
+        documentation = validations.delete(:documentation)
 
-          details[:documentation] = documentation if documentation
+        details[:documentation] = documentation if documentation
 
-          details[:default] = validations[:default] if validations.key?(:default)
-        end
+        details[:default] = validations[:default] if validations.key?(:default)
 
-        def document(attrs)
-          return if @api.namespace_inheritable(:do_not_document)
+        details[:min_length] = validations[:length][:min] if validations.key?(:length) && validations[:length].key?(:min)
+        details[:max_length] = validations[:length][:max] if validations.key?(:length) && validations[:length].key?(:max)
+      end
 
-          details[:type] = type.to_s if type
-          details[:values] = values if values
+      def document(attrs)
+        return if @api.namespace_inheritable(:do_not_document)
 
-          documented_attrs = attrs.each_with_object({}) do |name, memo|
-            memo[@scope.full_name(name)] = details
-          end
+        details[:type] = type.to_s if type
+        details[:values] = values if values
 
-          @api.namespace_stackable(:params, documented_attrs)
+        documented_attrs = attrs.each_with_object({}) do |name, memo|
+          memo[@scope.full_name(name)] = details
         end
 
-        def required
-          details[:required]
-        end
+        @api.namespace_stackable(:params, documented_attrs)
+      end
+
+      def required
+        details[:required]
+      end
 
-        protected
+      protected
 
-        def details
-          @details ||= {}
-        end
+      def details
+        @details ||= {}
       end
     end
   end

data/lib/grape/validations/contract_scope.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    class ContractScope
+      # Declare the contract to be used for the endpoint's parameters.
+      # @param api [API] the API endpoint to modify.
+      # @param contract the contract or schema to be used for validation. Optional.
+      # @yield a block yielding a new schema class. Optional.
+      def initialize(api, contract = nil, &block)
+        # When block is passed, the first arg is either schema or nil.
+        contract = Dry::Schema.Params(parent: contract, &block) if block
+
+        if contract.respond_to?(:schema)
+          # It's a Dry::Validation::Contract, then.
+          contract = contract.new
+          key_map = contract.schema.key_map
+        else
+          # Dry::Schema::Processor, hopefully.
+          key_map = contract.key_map
+        end
+
+        api.namespace_stackable(:contract_key_map, key_map)
+
+        validator_options = {
+          validator_class: Validator,
+          opts: { schema: contract }
+        }
+
+        api.namespace_stackable(:validations, validator_options)
+      end
+
+      class Validator
+        attr_reader :schema
+
+        def initialize(*_args, schema:)
+          @schema = schema
+        end
+
+        # Validates a given request.
+        # @param request [Grape::Request] the request currently being handled
+        # @raise [Grape::Exceptions::ValidationArrayErrors] if validation failed
+        # @return [void]
+        def validate(request)
+          res = schema.call(request.params)
+
+          if res.success?
+            request.params.deep_merge!(res.to_h)
+            return
+          end
+
+          errors = []
+
+          res.errors.messages.each do |message|
+            full_name = message.path.first.to_s
+
+            full_name += "[#{message.path[1..].join('][')}]" if message.path.size > 1
+
+            errors << Grape::Exceptions::Validation.new(params: [full_name], message: message.text)
+          end
+
+          raise Grape::Exceptions::ValidationArrayErrors.new(errors)
+        end
+
+        def fail_fast?
+          false
+        end
+      end
+    end
+  end
+end

data/lib/grape/validations/params_scope.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'attributes_doc'
-
 module Grape
   module Validations
     class ParamsScope
@@ -211,11 +209,11 @@ module Grape
 
       def require_required_and_optional_fields(context, opts)
         if context == :all
-          optional_fields = Array(opts[:except])
-          required_fields = opts[:using].keys - optional_fields
+          optional_fields = Array.wrap(opts[:except])
+          required_fields = opts[:using].keys.delete_if { |f| optional_fields.include?(f) }
         else # context == :none
-          required_fields = Array(opts[:except])
-          optional_fields = opts[:using].keys - required_fields
+          required_fields = Array.wrap(opts[:except])
+          optional_fields = opts[:using].keys.delete_if { |f| required_fields.include?(f) }
         end
         required_fields.each do |field|
           field_opts = opts[:using][field]
@@ -231,7 +229,10 @@ module Grape
 
       def require_optional_fields(context, opts)
         optional_fields = opts[:using].keys
-        optional_fields -= Array(opts[:except]) unless context == :all
+        unless context == :all
+          except_fields = Array.wrap(opts[:except])
+          optional_fields.delete_if { |f| except_fields.include?(f) }
+        end
         optional_fields.each do |field|
           field_opts = opts[:using][field]
           optional(field, field_opts) if field_opts
@@ -266,6 +267,7 @@ module Grape
           parent: self,
           optional: optional,
           type: type || Array,
+          group: @group,
           &block
         )
       end
@@ -463,8 +465,7 @@ module Grape
         raise Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :values, values) if values && !values.is_a?(Proc) && !Array(default).all? { |def_val| values.include?(def_val) }
 
         if except_values && !except_values.is_a?(Proc) && Array(default).any? { |def_val| except_values.include?(def_val) }
-          raise Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :except, except_values) \
-
+          raise Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :except, except_values)
         end
 
         return unless excepts && !excepts.is_a?(Proc)

data/lib/grape/validations/types/array_coercer.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'dry_type_coercer'
-
 module Grape
   module Validations
     module Types

data/lib/grape/validations/types/build_coercer.rb

@@ -1,94 +1,92 @@
 # frozen_string_literal: true
 
-require_relative 'array_coercer'
-require_relative 'set_coercer'
-require_relative 'primitive_coercer'
-
 module Grape
   module Validations
     module Types
-      # Chooses the best coercer for the given type. For example, if the type
-      # is Integer, it will return a coercer which will be able to coerce a value
-      # to the integer.
-      #
-      # There are a few very special coercers which might be returned.
-      #
-      # +Grape::Types::MultipleTypeCoercer+ is a coercer which is returned when
-      # the given type implies values in an array with different types.
-      # For example, +[Integer, String]+ allows integer and string values in
-      # an array.
-      #
-      # +Grape::Types::CustomTypeCoercer+ is a coercer which is returned when
-      # a method is specified by a user with +coerce_with+ option or the user
-      # specifies a custom type which implements requirments of
-      # +Grape::Types::CustomTypeCoercer+.
-      #
-      # +Grape::Types::CustomTypeCollectionCoercer+ is a very similar to the
-      # previous one, but it expects an array or set of values having a custom
-      # type implemented by the user.
-      #
-      # There is also a group of custom types implemented by Grape, check
-      # +Grape::Validations::Types::SPECIAL+ to get the full list.
-      #
-      # @param type [Class] the type to which input strings
-      #   should be coerced
-      # @param method [Class,#call] the coercion method to use
-      # @return [Object] object to be used
-      #   for coercion and type validation
-      def self.build_coercer(type, method: nil, strict: false)
-        cache_instance(type, method, strict) do
-          create_coercer_instance(type, method, strict)
+      module BuildCoercer
+        # Chooses the best coercer for the given type. For example, if the type
+        # is Integer, it will return a coercer which will be able to coerce a value
+        # to the integer.
+        #
+        # There are a few very special coercers which might be returned.
+        #
+        # +Grape::Types::MultipleTypeCoercer+ is a coercer which is returned when
+        # the given type implies values in an array with different types.
+        # For example, +[Integer, String]+ allows integer and string values in
+        # an array.
+        #
+        # +Grape::Types::CustomTypeCoercer+ is a coercer which is returned when
+        # a method is specified by a user with +coerce_with+ option or the user
+        # specifies a custom type which implements requirments of
+        # +Grape::Types::CustomTypeCoercer+.
+        #
+        # +Grape::Types::CustomTypeCollectionCoercer+ is a very similar to the
+        # previous one, but it expects an array or set of values having a custom
+        # type implemented by the user.
+        #
+        # There is also a group of custom types implemented by Grape, check
+        # +Grape::Validations::Types::SPECIAL+ to get the full list.
+        #
+        # @param type [Class] the type to which input strings
+        #   should be coerced
+        # @param method [Class,#call] the coercion method to use
+        # @return [Object] object to be used
+        #   for coercion and type validation
+        def self.build_coercer(type, method: nil, strict: false)
+          cache_instance(type, method, strict) do
+            create_coercer_instance(type, method, strict)
+          end
         end
-      end
 
-      def self.create_coercer_instance(type, method, strict)
-        # Maps a custom type provided by Grape, it doesn't map types wrapped by collections!!!
-        type = Types.map_special(type)
+        def self.create_coercer_instance(type, method, strict)
+          # Maps a custom type provided by Grape, it doesn't map types wrapped by collections!!!
+          type = Types.map_special(type)
 
-        # Use a special coercer for multiply-typed parameters.
-        if Types.multiple?(type)
-          MultipleTypeCoercer.new(type, method)
+          # Use a special coercer for multiply-typed parameters.
+          if Types.multiple?(type)
+            MultipleTypeCoercer.new(type, method)
 
-        # Use a special coercer for custom types and coercion methods.
-        elsif method || Types.custom?(type)
-          CustomTypeCoercer.new(type, method)
+            # Use a special coercer for custom types and coercion methods.
+          elsif method || Types.custom?(type)
+            CustomTypeCoercer.new(type, method)
 
-        # Special coercer for collections of types that implement a parse method.
-        # CustomTypeCoercer (above) already handles such types when an explicit coercion
-        # method is supplied.
-        elsif Types.collection_of_custom?(type)
-          Types::CustomTypeCollectionCoercer.new(
-            Types.map_special(type.first), type.is_a?(Set)
-          )
-        else
-          DryTypeCoercer.coercer_instance_for(type, strict)
+            # Special coercer for collections of types that implement a parse method.
+            # CustomTypeCoercer (above) already handles such types when an explicit coercion
+            # method is supplied.
+          elsif Types.collection_of_custom?(type)
+            Types::CustomTypeCollectionCoercer.new(
+              Types.map_special(type.first), type.is_a?(Set)
+            )
+          else
+            DryTypeCoercer.coercer_instance_for(type, strict)
+          end
         end
-      end
 
-      def self.cache_instance(type, method, strict, &_block)
-        key = cache_key(type, method, strict)
+        def self.cache_instance(type, method, strict, &_block)
+          key = cache_key(type, method, strict)
 
-        return @__cache[key] if @__cache.key?(key)
+          return @__cache[key] if @__cache.key?(key)
 
-        instance = yield
+          instance = yield
 
-        @__cache_write_lock.synchronize do
-          @__cache[key] = instance
-        end
+          @__cache_write_lock.synchronize do
+            @__cache[key] = instance
+          end
 
-        instance
-      end
+          instance
+        end
 
-      def self.cache_key(type, method, strict)
-        [type, method, strict].each_with_object(+'_') do |val, memo|
-          next if val.nil?
+        def self.cache_key(type, method, strict)
+          [type, method, strict].each_with_object(+'_') do |val, memo|
+            next if val.nil?
 
-          memo << '_' << val.to_s
+            memo << '_' << val.to_s
+          end
         end
-      end
 
-      instance_variable_set(:@__cache,            {})
-      instance_variable_set(:@__cache_write_lock, Mutex.new)
+        instance_variable_set(:@__cache,            {})
+        instance_variable_set(:@__cache_write_lock, Mutex.new)
+      end
     end
   end
 end

data/lib/grape/validations/types/dry_type_coercer.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'dry-types'
-
 module DryTypes
   # Call +Dry.Types()+ to add all registered types to +DryTypes+ which is
   # a container in this case. Check documentation for more information
@@ -24,9 +22,7 @@ module Grape
           #    collection_coercer_for(Array)
           #    #=> Grape::Validations::Types::ArrayCoercer
           def collection_coercer_for(type)
-            collection_coercers.fetch(type) do
-              DryTypeCoercer.collection_coercers[type] = Grape::Validations::Types.const_get("#{type.name.camelize}Coercer")
-            end
+            Grape::Validations::Types.const_get(:"#{type.name.camelize}Coercer")
           end
 
           # Returns an instance of a coercer for a given type
@@ -37,12 +33,6 @@ module Grape
             # so we need to figure out the actual type
             collection_coercer_for(type.class).new(type, strict)
           end
-
-          protected
-
-          def collection_coercers
-            @collection_coercers ||= {}
-          end
         end
 
         def initialize(type, strict = false)

data/lib/grape/validations/types/json.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'json'
-
 module Grape
   module Validations
     module Types

data/lib/grape/validations/types/primitive_coercer.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require_relative 'dry_type_coercer'
-
 module Grape
   module Validations
     module Types

data/lib/grape/validations/types/set_coercer.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require 'set'
-require_relative 'array_coercer'
-
 module Grape
   module Validations
     module Types

data/lib/grape/validations/types.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require 'grape/validations/types/json'
-require 'grape/validations/types/file'
-
 module Grape
   module Validations
     # Module for code related to grape's system for