grape 0.1.1 → 2.4.0

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/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 #{klass}" 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 ||= {}.with_indifferent_access
+      end
+    end
+  end
+end

data/lib/grape/util/reverse_stackable_values.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    class ReverseStackableValues < StackableValues
+      protected
+
+      def concat_values(inherited_value, new_value)
+        return inherited_value unless new_value
+
+        new_value + inherited_value
+      end
+    end
+  end
+end

data/lib/grape/util/stackable_values.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    class StackableValues < BaseInheritable
+      # Even if there is no value, an empty array will be returned.
+      def [](name)
+        inherited_value = inherited_values[name]
+        new_value = new_values[name]
+
+        return new_value || [] unless inherited_value
+
+        concat_values(inherited_value, new_value)
+      end
+
+      def []=(name, value)
+        new_values[name] ||= []
+        new_values[name].push value
+      end
+
+      def to_hash
+        keys.each_with_object({}) do |key, result|
+          result[key] = self[key]
+        end
+      end
+
+      protected
+
+      def concat_values(inherited_value, new_value)
+        return inherited_value unless new_value
+
+        inherited_value + new_value
+      end
+    end
+  end
+end

data/lib/grape/util/strict_hash_configuration.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    module StrictHashConfiguration
+      extend ActiveSupport::Concern
+
+      module DSL
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def settings
+            config_context.to_hash
+          end
+
+          def configure(&block)
+            config_context.instance_exec(&block)
+          end
+        end
+      end
+
+      class SettingsContainer
+        def initialize
+          @settings = {}
+          @contexts = {}
+        end
+
+        def to_hash
+          @settings.to_hash
+        end
+      end
+
+      def self.config_class(*args)
+        new_config_class = Class.new(SettingsContainer)
+
+        args.each do |setting_name|
+          if setting_name.respond_to? :values
+            nested_settings_methods(setting_name, new_config_class)
+          else
+            simple_settings_methods(setting_name, new_config_class)
+          end
+        end
+
+        new_config_class
+      end
+
+      def self.simple_settings_methods(setting_name, new_config_class)
+        setting_name_sym = setting_name.to_sym
+        new_config_class.class_eval do
+          define_method setting_name do |new_value|
+            @settings[setting_name_sym] = new_value
+          end
+        end
+      end
+
+      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
+              @contexts[key] ||= Grape::Util::StrictHashConfiguration.config_class(*value).new
+            end
+
+            define_method key do |&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
+              end
+            )
+          end
+        end
+      end
+
+      def self.module(*args)
+        new_module = Module.new do
+          extend ActiveSupport::Concern
+          include DSL
+        end
+
+        new_module.tap do |mod|
+          class_mod = create_class_mod(args)
+
+          mod.const_set(:ClassMethods, class_mod)
+        end
+      end
+
+      def self.create_class_mod(args)
+        new_module = Module.new do
+          def config_context
+            @config_context ||= config_class.new
+          end
+        end
+
+        new_module.tap do |class_mod|
+          new_config_class = config_class(*args)
+
+          class_mod.send(:define_method, :config_class) do
+            @config_class ||= new_config_class
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/validations/attributes_doc.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+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.
+
+    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)
+
+        desc = validations.delete(:desc) || validations.delete(:description)
+
+        details[:desc] = desc if desc
+
+        documentation = validations.delete(:documentation)
+
+        details[:documentation] = documentation if documentation
+
+        details[:default] = validations[:default] if validations.key?(:default)
+
+        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
+
+      def document(attrs)
+        return if @api.namespace_inheritable(:do_not_document)
+
+        details[:type] = type.to_s if type
+        details[:values] = values if values
+
+        documented_attrs = attrs.each_with_object({}) do |name, memo|
+          memo[@scope.full_name(name)] = details
+        end
+
+        @api.namespace_stackable(:params, documented_attrs)
+      end
+
+      def required
+        details[:required]
+      end
+
+      protected
+
+      def details
+        @details ||= {}
+      end
+    end
+  end
+end

data/lib/grape/validations/attributes_iterator.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    class AttributesIterator
+      include Enumerable
+
+      attr_reader :scope
+
+      def initialize(validator, scope, params)
+        @scope = scope
+        @attrs = validator.attrs
+        @original_params = scope.params(params)
+        @params = Array.wrap(@original_params)
+      end
+
+      def each(&block)
+        do_each(@params, &block) # because we need recursion for nested arrays
+      end
+
+      private
+
+      def do_each(params_to_process, parent_indicies = [], &block)
+        @scope.reset_index # gets updated depending on the size of params_to_process
+        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 indicies
+          if resource_params.is_a?(Array)
+            do_each(resource_params, [index] + parent_indicies, &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
+
+            # fill current and parent scopes with correct array indicies
+            parent_scope = @scope.parent
+            parent_indicies.each do |parent_index|
+              parent_scope.index = parent_index
+              parent_scope = parent_scope.parent
+            end
+            @scope.index = index
+          end
+
+          yield_attributes(resource_params, @attrs, &block)
+        end
+      end
+
+      def yield_attributes(_resource_params, _attrs)
+        raise NotImplementedError
+      end
+
+      # This is a special case so that we can ignore tree's where option
+      # values are missing lower down. Unfortunately we can remove this
+      # are the parameter parsing stage as they are required to ensure
+      # the correct indexing is maintained
+      def skip?(val)
+        val == Grape::DSL::Parameters::EmptyOptionalValue
+      end
+    end
+  end
+end

data/lib/grape/validations/contract_scope.rb

@@ -0,0 +1,34 @@
+# 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: Grape::Validations.require_validator(:contract_scope),
+          opts: { schema: contract, fail_fast: false }
+        }
+
+        api.namespace_stackable(:validations, validator_options)
+      end
+    end
+  end
+end

data/lib/grape/validations/multiple_attributes_iterator.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Grape
+  module Validations
+    class MultipleAttributesIterator < AttributesIterator
+      private
+
+      def yield_attributes(resource_params, _attrs)
+        yield resource_params unless skip?(resource_params)
+      end
+    end
+  end
+end