grape 2.2.0 → 2.4.0

data/lib/grape/http/headers.rb

@@ -1,55 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  module Http
-    module Headers
-      HTTP_ACCEPT_VERSION = 'HTTP_ACCEPT_VERSION'
-      HTTP_ACCEPT = 'HTTP_ACCEPT'
-      HTTP_TRANSFER_ENCODING = 'HTTP_TRANSFER_ENCODING'
-
-      ALLOW = 'Allow'
-      LOCATION = 'Location'
-      X_CASCADE = 'X-Cascade'
-      TRANSFER_ENCODING = 'Transfer-Encoding'
-
-      SUPPORTED_METHODS = [
-        Rack::GET,
-        Rack::POST,
-        Rack::PUT,
-        Rack::PATCH,
-        Rack::DELETE,
-        Rack::HEAD,
-        Rack::OPTIONS
-      ].freeze
-
-      SUPPORTED_METHODS_WITHOUT_OPTIONS = (SUPPORTED_METHODS - [Rack::OPTIONS]).freeze
-
-      HTTP_HEADERS = Grape::Util::Lazy::Object.new do
-        common_http_headers = %w[
-          Version
-          Host
-          Connection
-          Cache-Control
-          Dnt
-          Upgrade-Insecure-Requests
-          User-Agent
-          Sec-Fetch-Dest
-          Accept
-          Sec-Fetch-Site
-          Sec-Fetch-Mode
-          Sec-Fetch-User
-          Accept-Encoding
-          Accept-Language
-          Cookie
-        ].freeze
-        common_http_headers.each_with_object({}) do |header, response|
-          response["HTTP_#{header.upcase.tr('-', '_')}"] = header
-        end.freeze
-      end
-
-      def self.find_supported_method(route_method)
-        Grape::Http::Headers::SUPPORTED_METHODS.detect { |supported_method| supported_method.casecmp(route_method).zero? }
-      end
-    end
-  end
-end

data/lib/grape/middleware/helpers.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  module Middleware
-    # Common methods for all types of Grape middleware
-    module Helpers
-      def context
-        env[Grape::Env::API_ENDPOINT]
-      end
-    end
-  end
-end

data/lib/grape/middleware/versioner_helpers.rb

@@ -1,75 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  module Middleware
-    module VersionerHelpers
-      DEFAULT_PATTERN = /.*/i.freeze
-      DEFAULT_PARAMETER = 'apiver'
-
-      def default_options
-        {
-          versions: nil,
-          prefix: nil,
-          mount_path: nil,
-          pattern: DEFAULT_PATTERN,
-          version_options: {
-            strict: false,
-            cascade: true,
-            parameter: DEFAULT_PARAMETER
-          }
-        }
-      end
-
-      def versions
-        options[:versions]
-      end
-
-      def prefix
-        options[:prefix]
-      end
-
-      def mount_path
-        options[:mount_path]
-      end
-
-      def pattern
-        options[:pattern]
-      end
-
-      def version_options
-        options[:version_options]
-      end
-
-      def strict?
-        version_options[:strict]
-      end
-
-      # By default those errors contain an `X-Cascade` header set to `pass`, which allows nesting and stacking
-      # of routes (see Grape::Router) for more information). To prevent
-      # this behavior, and not add the `X-Cascade` header, one can set the `:cascade` option to `false`.
-      def cascade?
-        version_options[:cascade]
-      end
-
-      def parameter_key
-        version_options[:parameter]
-      end
-
-      def vendor
-        version_options[:vendor]
-      end
-
-      def error_headers
-        cascade? ? { Grape::Http::Headers::X_CASCADE => 'pass' } : {}
-      end
-
-      def potential_version_match?(potential_version)
-        versions.blank? || versions.any? { |v| v.to_s == potential_version }
-      end
-
-      def version_not_found!
-        throw :error, status: 404, message: '404 API Version Not Found', headers: { Grape::Http::Headers::X_CASCADE => 'pass' }
-      end
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-# Based on https://github.com/HornsAndHooves/lazy_object
-
-module Grape
-  module Util
-    module Lazy
-      class Object < BasicObject
-        attr_reader :callable
-
-        def initialize(&callable)
-          @callable = callable
-        end
-
-        def __target_object__
-          @__target_object__ ||= callable.call
-        end
-
-        def ==(other)
-          __target_object__ == other
-        end
-
-        def !=(other)
-          __target_object__ != other
-        end
-
-        def !
-          !__target_object__
-        end
-
-        def method_missing(method_name, *args, &block)
-          if __target_object__.respond_to?(method_name)
-            __target_object__.send(method_name, *args, &block)
-          else
-            super
-          end
-        end
-
-        def respond_to_missing?(method_name, include_priv = false)
-          __target_object__.respond_to?(method_name, include_priv)
-        end
-      end
-    end
-  end
-end

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

@@ -1,92 +0,0 @@
-# frozen_string_literal: true
-
-module Grape
-  module Validations
-    module Types
-      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
-
-        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 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)
-          end
-        end
-
-        def self.cache_instance(type, method, strict, &_block)
-          key = cache_key(type, method, strict)
-
-          return @__cache[key] if @__cache.key?(key)
-
-          instance = yield
-
-          @__cache_write_lock.synchronize do
-            @__cache[key] = instance
-          end
-
-          instance
-        end
-
-        def self.cache_key(type, method, strict)
-          [type, method, strict].each_with_object(+'_') do |val, memo|
-            next if val.nil?
-
-            memo << '_' << val.to_s
-          end
-        end
-
-        instance_variable_set(:@__cache,            {})
-        instance_variable_set(:@__cache_write_lock, Mutex.new)
-      end
-    end
-  end
-end