grape 0.1.1 → 2.4.0

data/lib/grape/middleware/versioner.rb

@@ -1,27 +1,27 @@
-require 'grape/middleware/base'
+# frozen_string_literal: true
 
+# Versioners set env['api.version'] when a version is defined on an API and
+# on the requests. The current methods for determining version are:
+#
+#   :header - version from HTTP Accept header.
+#   :accept_version_header - version from HTTP Accept-Version header
+#   :path   - version from uri. e.g. /v1/resource
+#   :param  - version from uri query string, e.g. /v1/resource?apiver=v1
+# See individual classes for details.
 module Grape
   module Middleware
-    class Versioner < Base
-      def default_options
-        {
-          :pattern => /.*/i
-        }
-      end
-      
-      def before
-        pieces = env['PATH_INFO'].split('/')
-        potential_version = pieces[1]
-        if potential_version =~ options[:pattern]
-          if options[:versions] && !options[:versions].include?(potential_version)
-            throw :error, :status => 404, :message => "404 API Version Not Found"
-          end
-          
-          truncated_path = "/#{pieces[2..-1].join('/')}"
-          env['api.version'] = potential_version
-          env['PATH_INFO'] = truncated_path
-        end
+    module Versioner
+      extend Grape::Util::Registry
+
+      module_function
+
+      # @param strategy [Symbol] :path, :header, :accept_version_header or :param
+      # @return a middleware class based on strategy
+      def using(strategy)
+        raise Grape::Exceptions::InvalidVersionerOption, strategy unless registry.key?(strategy)
+
+        registry[strategy]
       end
     end
   end
-end
+end

data/lib/grape/namespace.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Grape
+  # A container for endpoints or other namespaces, which allows for both
+  # logical grouping of endpoints as well as sharing common configuration.
+  # May also be referred to as group, segment, or resource.
+  class Namespace
+    attr_reader :space, :options
+
+    # @param space [String] the name of this namespace
+    # @param options [Hash] options hash
+    # @option options :requirements [Hash] param-regex pairs, all of which must
+    #   be met by a request's params for all endpoints in this namespace, or
+    #   validation will fail and return a 422.
+    def initialize(space, options)
+      @space = space.to_s
+      @options = options
+    end
+
+    # Retrieves the requirements from the options hash, if given.
+    # @return [Hash]
+    def requirements
+      options[:requirements] || {}
+    end
+
+    # (see ::joined_space_path)
+    def self.joined_space(settings)
+      settings&.map(&:space)
+    end
+
+    # Join the namespaces from a list of settings to create a path prefix.
+    # @param settings [Array] list of Grape::Util::InheritableSettings.
+    def self.joined_space_path(settings)
+      JoinedSpaceCache[joined_space(settings)]
+    end
+
+    class JoinedSpaceCache < Grape::Util::Cache
+      def initialize
+        super
+        @cache = Hash.new do |h, joined_space|
+          h[joined_space] = Grape::Router.normalize_path(joined_space.join('/'))
+        end
+      end
+    end
+  end
+end

data/lib/grape/params_builder/base.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Grape
+  module ParamsBuilder
+    class Base
+      class << self
+        def call(_params)
+          raise NotImplementedError
+        end
+
+        def inherited(klass)
+          super
+          ParamsBuilder.register(klass)
+        end
+      end
+    end
+  end
+end

data/lib/grape/params_builder/hash.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Grape
+  module ParamsBuilder
+    class Hash < Base
+      def self.call(params)
+        params.deep_symbolize_keys
+      end
+    end
+  end
+end

data/lib/grape/params_builder/hash_with_indifferent_access.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Grape
+  module ParamsBuilder
+    class HashWithIndifferentAccess < Base
+      def self.call(params)
+        params.with_indifferent_access
+      end
+    end
+  end
+end

data/lib/grape/params_builder/hashie_mash.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Grape
+  module ParamsBuilder
+    class HashieMash < Base
+      def self.call(params)
+        ::Hashie::Mash.new(params)
+      end
+    end
+  end
+end

data/lib/grape/params_builder.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Grape
+  module ParamsBuilder
+    extend Grape::Util::Registry
+
+    SHORT_NAME_LOOKUP = {
+      'Grape::Extensions::Hash::ParamBuilder' => :hash,
+      'Grape::Extensions::ActiveSupport::HashWithIndifferentAccess::ParamBuilder' => :hash_with_indifferent_access,
+      'Grape::Extensions::Hashie::Mash::ParamBuilder' => :hashie_mash
+    }.freeze
+
+    module_function
+
+    def params_builder_for(short_name)
+      verified_short_name = verify_short_name!(short_name)
+
+      raise Grape::Exceptions::UnknownParamsBuilder, verified_short_name unless registry.key?(verified_short_name)
+
+      registry[verified_short_name]
+    end
+
+    def verify_short_name!(short_name)
+      return short_name if short_name.is_a?(Symbol)
+
+      class_name = short_name.name
+      SHORT_NAME_LOOKUP[class_name].tap do |real_short_name|
+        Grape.deprecator.warn "#{class_name} has been deprecated. Use short name :#{real_short_name} instead."
+      end
+    end
+  end
+end

data/lib/grape/parser/base.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Grape
+  module Parser
+    class Base
+      def self.call(_object, _env)
+        raise NotImplementedError
+      end
+
+      def self.inherited(klass)
+        super
+        Parser.register(klass)
+      end
+    end
+  end
+end

data/lib/grape/parser/json.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Grape
+  module Parser
+    class Json < Base
+      def self.call(object, _env)
+        ::Grape::Json.load(object)
+      rescue ::Grape::Json::ParseError
+        # handle JSON parsing errors via the rescue handlers or provide error message
+        raise Grape::Exceptions::InvalidMessageBody.new('application/json')
+      end
+    end
+  end
+end

data/lib/grape/parser/xml.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Grape
+  module Parser
+    class Xml < Base
+      def self.call(object, _env)
+        ::Grape::Xml.parse(object)
+      rescue ::Grape::Xml::ParseError
+        # handle XML parsing errors via the rescue handlers or provide error message
+        raise Grape::Exceptions::InvalidMessageBody.new('application/xml')
+      end
+    end
+  end
+end

data/lib/grape/parser.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Grape
+  module Parser
+    extend Grape::Util::Registry
+
+    module_function
+
+    def parser_for(format, parsers = nil)
+      return parsers[format] if parsers&.key?(format)
+
+      registry[format]
+    end
+  end
+end

data/lib/grape/path.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Grape
+  # Represents a path to an endpoint.
+  class Path
+    DEFAULT_FORMAT_SEGMENT = '(/.:format)'
+    NO_VERSIONING_WITH_VALID_PATH_FORMAT_SEGMENT = '(.:format)'
+    VERSION_SEGMENT = ':version'
+
+    attr_reader :origin, :suffix
+
+    def initialize(raw_path, raw_namespace, settings)
+      @origin = PartsCache[build_parts(raw_path, raw_namespace, settings)]
+      @suffix = build_suffix(raw_path, raw_namespace, settings)
+    end
+
+    def to_s
+      "#{origin}#{suffix}"
+    end
+
+    private
+
+    def build_suffix(raw_path, raw_namespace, settings)
+      if uses_specific_format?(settings)
+        "(.#{settings[:format]})"
+      elsif !uses_path_versioning?(settings) || (valid_part?(raw_namespace) || valid_part?(raw_path))
+        NO_VERSIONING_WITH_VALID_PATH_FORMAT_SEGMENT
+      else
+        DEFAULT_FORMAT_SEGMENT
+      end
+    end
+
+    def build_parts(raw_path, raw_namespace, settings)
+      [].tap do |parts|
+        add_part(parts, settings[:mount_path])
+        add_part(parts, settings[:root_prefix])
+        parts << VERSION_SEGMENT if uses_path_versioning?(settings)
+        add_part(parts, raw_namespace)
+        add_part(parts, raw_path)
+      end
+    end
+
+    def add_part(parts, value)
+      parts << value if value && not_slash?(value)
+    end
+
+    def not_slash?(value)
+      value != '/'
+    end
+
+    def uses_specific_format?(settings)
+      return false unless settings.key?(:format) && settings.key?(:content_types)
+
+      settings[:format] && Array(settings[:content_types]).size == 1
+    end
+
+    def uses_path_versioning?(settings)
+      return false unless settings.key?(:version) && settings[:version_options]&.key?(:using)
+
+      settings[:version] && settings[:version_options][:using] == :path
+    end
+
+    def valid_part?(part)
+      part&.match?(/^\S/) && not_slash?(part)
+    end
+
+    class PartsCache < Grape::Util::Cache
+      def initialize
+        super
+        @cache = Hash.new do |h, parts|
+          h[parts] = Grape::Router.normalize_path(parts.join('/'))
+        end
+      end
+    end
+  end
+end

data/lib/grape/presenters/presenter.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Grape
+  module Presenters
+    class Presenter
+      def self.represent(object, **_options)
+        object
+      end
+    end
+  end
+end

data/lib/grape/railtie.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Grape
+  class Railtie < ::Rails::Railtie
+    initializer 'grape.deprecator' do |app|
+      app.deprecators[:grape] = Grape.deprecator
+    end
+  end
+end

data/lib/grape/request.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module Grape
+  class Request < Rack::Request
+    # Based on rack 3 KNOWN_HEADERS
+    # https://github.com/rack/rack/blob/4f15e7b814922af79605be4b02c5b7c3044ba206/lib/rack/headers.rb#L10
+
+    KNOWN_HEADERS = %w[
+      Accept
+      Accept-CH
+      Accept-Encoding
+      Accept-Language
+      Accept-Patch
+      Accept-Ranges
+      Accept-Version
+      Access-Control-Allow-Credentials
+      Access-Control-Allow-Headers
+      Access-Control-Allow-Methods
+      Access-Control-Allow-Origin
+      Access-Control-Expose-Headers
+      Access-Control-Max-Age
+      Age
+      Allow
+      Alt-Svc
+      Authorization
+      Cache-Control
+      Client-Ip
+      Connection
+      Content-Disposition
+      Content-Encoding
+      Content-Language
+      Content-Length
+      Content-Location
+      Content-MD5
+      Content-Range
+      Content-Security-Policy
+      Content-Security-Policy-Report-Only
+      Content-Type
+      Cookie
+      Date
+      Delta-Base
+      Dnt
+      ETag
+      Expect-CT
+      Expires
+      Feature-Policy
+      Forwarded
+      Host
+      If-Modified-Since
+      If-None-Match
+      IM
+      Last-Modified
+      Link
+      Location
+      NEL
+      P3P
+      Permissions-Policy
+      Pragma
+      Preference-Applied
+      Proxy-Authenticate
+      Public-Key-Pins
+      Range
+      Referer
+      Referrer-Policy
+      Refresh
+      Report-To
+      Retry-After
+      Sec-Fetch-Dest
+      Sec-Fetch-Mode
+      Sec-Fetch-Site
+      Sec-Fetch-User
+      Server
+      Set-Cookie
+      Status
+      Strict-Transport-Security
+      Timing-Allow-Origin
+      Tk
+      Trailer
+      Transfer-Encoding
+      Upgrade
+      Upgrade-Insecure-Requests
+      User-Agent
+      Vary
+      Version
+      Via
+      Warning
+      WWW-Authenticate
+      X-Accel-Buffering
+      X-Accel-Charset
+      X-Accel-Expires
+      X-Accel-Limit-Rate
+      X-Accel-Mapping
+      X-Accel-Redirect
+      X-Access-Token
+      X-Auth-Request-Access-Token
+      X-Auth-Request-Email
+      X-Auth-Request-Groups
+      X-Auth-Request-Preferred-Username
+      X-Auth-Request-Redirect
+      X-Auth-Request-Token
+      X-Auth-Request-User
+      X-Cascade
+      X-Client-Ip
+      X-Content-Duration
+      X-Content-Security-Policy
+      X-Content-Type-Options
+      X-Correlation-Id
+      X-Download-Options
+      X-Forwarded-Access-Token
+      X-Forwarded-Email
+      X-Forwarded-For
+      X-Forwarded-Groups
+      X-Forwarded-Host
+      X-Forwarded-Port
+      X-Forwarded-Preferred-Username
+      X-Forwarded-Proto
+      X-Forwarded-Scheme
+      X-Forwarded-Ssl
+      X-Forwarded-Uri
+      X-Forwarded-User
+      X-Frame-Options
+      X-HTTP-Method-Override
+      X-Permitted-Cross-Domain-Policies
+      X-Powered-By
+      X-Real-IP
+      X-Redirect-By
+      X-Request-Id
+      X-Requested-With
+      X-Runtime
+      X-Sendfile
+      X-Sendfile-Type
+      X-UA-Compatible
+      X-WebKit-CS
+      X-XSS-Protection
+    ].each_with_object({}) do |header, response|
+      response["HTTP_#{header.upcase.tr('-', '_')}"] = header
+    end.freeze
+
+    alias rack_params params
+    alias rack_cookies cookies
+
+    def initialize(env, build_params_with: nil)
+      super(env)
+      @params_builder = Grape::ParamsBuilder.params_builder_for(build_params_with || Grape.config.param_builder)
+    end
+
+    def params
+      @params ||= make_params
+    end
+
+    def headers
+      @headers ||= build_headers
+    end
+
+    def cookies
+      @cookies ||= Grape::Cookies.new(-> { rack_cookies })
+    end
+
+    # needs to be public until extensions param_builder are removed
+    def grape_routing_args
+      # preserve version from query string parameters
+      env[Grape::Env::GRAPE_ROUTING_ARGS]&.except(:version, :route_info) || {}
+    end
+
+    private
+
+    def make_params
+      @params_builder.call(rack_params).deep_merge!(grape_routing_args)
+    rescue EOFError
+      raise Grape::Exceptions::EmptyMessageBody.new(content_type)
+    rescue Rack::Multipart::MultipartPartLimitError, Rack::Multipart::MultipartTotalPartLimitError
+      raise Grape::Exceptions::TooManyMultipartFiles.new(Rack::Utils.multipart_part_limit)
+    rescue Rack::QueryParser::ParamsTooDeepError
+      raise Grape::Exceptions::TooDeepParameters.new(Rack::Utils.param_depth_limit)
+    rescue Rack::Utils::ParameterTypeError
+      raise Grape::Exceptions::ConflictingTypes
+    rescue Rack::Utils::InvalidParameterError
+      raise Grape::Exceptions::InvalidParameters
+    end
+
+    def build_headers
+      each_header.with_object(Grape::Util::Header.new) do |(k, v), headers|
+        next unless k.start_with? 'HTTP_'
+
+        transformed_header = KNOWN_HEADERS.fetch(k) { -k[5..].tr('_', '-').downcase }
+        headers[transformed_header] = v
+      end
+    end
+  end
+end

data/lib/grape/router/base_route.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Grape
+  class Router
+    class BaseRoute
+      delegate_missing_to :@options
+
+      attr_reader :index, :pattern, :options
+
+      def initialize(options)
+        @options = options.is_a?(ActiveSupport::OrderedOptions) ? options : ActiveSupport::OrderedOptions.new.update(options)
+      end
+
+      alias attributes options
+
+      def regexp_capture_index
+        CaptureIndexCache[index]
+      end
+
+      def pattern_regexp
+        pattern.to_regexp
+      end
+
+      def to_regexp(index)
+        @index = index
+        Regexp.new("(?<#{regexp_capture_index}>#{pattern_regexp})")
+      end
+
+      class CaptureIndexCache < Grape::Util::Cache
+        def initialize
+          super
+          @cache = Hash.new do |h, index|
+            h[index] = "_#{index}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/router/greedy_route.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# Act like a Grape::Router::Route but for greedy_match
+# see @neutral_map
+
+module Grape
+  class Router
+    class GreedyRoute < BaseRoute
+      def initialize(pattern, options)
+        @pattern = pattern
+        super(options)
+      end
+
+      # Grape::Router:Route defines params as a function
+      def params(_input = nil)
+        options[:params] || {}
+      end
+    end
+  end
+end

data/lib/grape/router/pattern.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Grape
+  class Router
+    class Pattern
+      extend Forwardable
+
+      DEFAULT_CAPTURES = %w[format version].freeze
+
+      attr_reader :origin, :path, :pattern, :to_regexp
+
+      def_delegators :pattern, :params
+      def_delegators :to_regexp, :===
+      alias match? ===
+
+      def initialize(origin, suffix, options)
+        @origin = origin
+        @path = build_path(origin, options[:anchor], suffix)
+        @pattern = build_pattern(@path, options[:params], options[:format], options[:version], options[:requirements])
+        @to_regexp = @pattern.to_regexp
+      end
+
+      def captures_default
+        to_regexp.names
+                 .delete_if { |n| DEFAULT_CAPTURES.include?(n) }
+                 .to_h { |k| [k, ''] }
+      end
+
+      private
+
+      def build_pattern(path, params, format, version, requirements)
+        Mustermann::Grape.new(
+          path,
+          uri_decode: true,
+          params: params,
+          capture: extract_capture(format, version, requirements)
+        )
+      end
+
+      def build_path(pattern, anchor, suffix)
+        PatternCache[[build_path_from_pattern(pattern, anchor), suffix]]
+      end
+
+      def extract_capture(format, version, requirements)
+        capture = {}.tap do |h|
+          h[:format] = map_str(format) if format.present?
+          h[:version] = map_str(version) if version.present?
+        end
+
+        return capture if requirements.blank?
+
+        requirements.merge(capture)
+      end
+
+      def build_path_from_pattern(pattern, anchor)
+        if pattern.end_with?('*path')
+          pattern.dup.insert(pattern.rindex('/') + 1, '?')
+        elsif anchor
+          pattern
+        elsif pattern.end_with?('/')
+          "#{pattern}?*path"
+        else
+          "#{pattern}/?*path"
+        end
+      end
+
+      def map_str(value)
+        Array.wrap(value).map(&:to_s)
+      end
+
+      class PatternCache < Grape::Util::Cache
+        def initialize
+          super
+          @cache = Hash.new do |h, (pattern, suffix)|
+            h[[pattern, suffix]] = -"#{pattern}#{suffix}"
+          end
+        end
+      end
+    end
+  end
+end