grape 1.3.0 → 1.3.1

data/lib/grape/namespace.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'grape/util/cache'
+
 module Grape
   # A container for endpoints or other namespaces, which allows for both
   # logical grouping of endpoints as well as sharing common configuration.
@@ -25,13 +27,21 @@ module Grape
 
     # (see ::joined_space_path)
     def self.joined_space(settings)
-      (settings || []).map(&:space).join('/')
+      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)
-      Grape::Router.normalize_path(joined_space(settings))
+      Grape::Router.normalize_path(JoinedSpaceCache[joined_space(settings)])
+    end
+
+    class JoinedSpaceCache < Grape::Util::Cache
+      def initialize
+        @cache = Hash.new do |h, joined_space|
+          h[joined_space] = -joined_space.join('/')
+        end
+      end
     end
   end
 end

data/lib/grape/path.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'grape/util/cache'
+
 module Grape
   # Represents a path to an endpoint.
   class Path
@@ -58,7 +60,7 @@ module Grape
     end
 
     def path
-      Grape::Router.normalize_path(parts.join('/'))
+      Grape::Router.normalize_path(PartsCache[parts])
     end
 
     def path_with_suffix
@@ -71,6 +73,14 @@ module Grape
 
     private
 
+    class PartsCache < Grape::Util::Cache
+      def initialize
+        @cache = Hash.new do |h, parts|
+          h[parts] = -parts.join('/')
+        end
+      end
+    end
+
     def parts
       parts = [mount_path, root_prefix].compact
       parts << ':version' if uses_path_versioning?

data/lib/grape/request.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'grape/util/lazy_object'
+
 module Grape
   class Request < Rack::Request
     HTTP_PREFIX = 'HTTP_'
@@ -30,14 +32,17 @@ module Grape
     end
 
     def build_headers
-      headers = {}
-      env.each_pair do |k, v|
-        next unless k.to_s.start_with? HTTP_PREFIX
-
-        k = k[5..-1].split('_').each(&:capitalize!).join('-')
-        headers[k] = v
+      Grape::Util::LazyObject.new do
+        env.each_pair.with_object({}) do |(k, v), headers|
+          next unless k.to_s.start_with? HTTP_PREFIX
+          transformed_header = Grape::Http::Headers::HTTP_HEADERS[k] || transform_header(k)
+          headers[transformed_header] = v
+        end
       end
-      headers
+    end
+
+    def transform_header(header)
+      -header[5..-1].split('_').each(&:capitalize!).join('-')
     end
   end
 end

data/lib/grape/router.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'grape/router/route'
+require 'grape/util/cache'
 
 module Grape
   class Router
@@ -16,12 +17,20 @@ module Grape
       end
     end
 
+    class NormalizePathCache < Grape::Util::Cache
+      def initialize
+        @cache = Hash.new do |h, path|
+          normalized_path = +"/#{path}"
+          normalized_path.squeeze!('/')
+          normalized_path.sub!(%r{/+\Z}, '')
+          normalized_path = '/' if normalized_path.empty?
+          h[path] = -normalized_path
+        end
+      end
+    end
+
     def self.normalize_path(path)
-      path = +"/#{path}"
-      path.squeeze!('/')
-      path.sub!(%r{/+\Z}, '')
-      path = '/' if path == ''
-      path
+      NormalizePathCache[path]
     end
 
     def self.supported_methods
@@ -106,7 +115,7 @@ module Grape
         env,
         neighbor.allow_header,
         neighbor.endpoint
-      ) if neighbor && method == 'OPTIONS' && !cascade
+      ) if neighbor && method == Grape::Http::Headers::OPTIONS && !cascade
 
       route = match?(input, '*')
       return neighbor.endpoint.call(env) if neighbor && cascade && route
@@ -160,7 +169,7 @@ module Grape
     end
 
     def call_with_allow_headers(env, methods, endpoint)
-      env[Grape::Env::GRAPE_ALLOWED_METHODS] = methods
+      env[Grape::Env::GRAPE_ALLOWED_METHODS] = methods.join(', ').freeze
       endpoint.call(env)
     end
 

data/lib/grape/router/pattern.rb

@@ -2,35 +2,32 @@
 
 require 'forwardable'
 require 'mustermann/grape'
+require 'grape/util/cache'
 
 module Grape
   class Router
     class Pattern
-      DEFAULT_PATTERN_OPTIONS   = { uri_decode: true, type: :grape }.freeze
+      DEFAULT_PATTERN_OPTIONS   = { uri_decode: true }.freeze
       DEFAULT_SUPPORTED_CAPTURE = %i[format version].freeze
 
-      attr_reader :origin, :path, :capture, :pattern
+      attr_reader :origin, :path, :pattern, :to_regexp
 
       extend Forwardable
       def_delegators :pattern, :named_captures, :params
-      def_delegators :@regexp, :===
+      def_delegators :to_regexp, :===
       alias match? ===
 
       def initialize(pattern, **options)
         @origin  = pattern
         @path    = build_path(pattern, **options)
-        @capture = extract_capture(**options)
-        @pattern = Mustermann.new(@path, **pattern_options)
-        @regexp  = to_regexp
-      end
-
-      def to_regexp
-        @to_regexp ||= @pattern.to_regexp
+        @pattern = Mustermann::Grape.new(@path, **pattern_options(options))
+        @to_regexp = @pattern.to_regexp
       end
 
       private
 
-      def pattern_options
+      def pattern_options(options)
+        capture = extract_capture(**options)
         options = DEFAULT_PATTERN_OPTIONS.dup
         options[:capture] = capture if capture.present?
         options
@@ -43,23 +40,27 @@ module Grape
           pattern << '*path'
         end
 
-        pattern = pattern.split('/').tap do |parts|
+        pattern = -pattern.split('/').tap do |parts|
           parts[parts.length - 1] = '?' + parts.last
         end.join('/') if pattern.end_with?('*path')
 
-        "#{pattern}#{suffix}"
+        PatternCache[[pattern, suffix]]
       end
 
       def extract_capture(requirements: {}, **options)
         requirements = {}.merge(requirements)
-        supported_capture.each_with_object(requirements) do |field, capture|
+        DEFAULT_SUPPORTED_CAPTURE.each_with_object(requirements) do |field, capture|
           option = Array(options[field])
           capture[field] = option.map(&:to_s) if option.present?
         end
       end
 
-      def supported_capture
-        DEFAULT_SUPPORTED_CAPTURE
+      class PatternCache < Grape::Util::Cache
+        def initialize
+          @cache = Hash.new do |h, (pattern, suffix)|
+            h[[pattern, suffix]] = -"#{pattern}#{suffix}"
+          end
+        end
       end
     end
   end

data/lib/grape/router/route.rb

@@ -8,8 +8,8 @@ require 'pathname'
 module Grape
   class Router
     class Route
-      ROUTE_ATTRIBUTE_REGEXP = /route_([_a-zA-Z]\w*)/
-      SOURCE_LOCATION_REGEXP = /^(.*?):(\d+?)(?::in `.+?')?$/
+      ROUTE_ATTRIBUTE_REGEXP = /route_([_a-zA-Z]\w*)/.freeze
+      SOURCE_LOCATION_REGEXP = /^(.*?):(\d+?)(?::in `.+?')?$/.freeze
       FIXED_NAMED_CAPTURES = %w[format version].freeze
 
       attr_accessor :pattern, :translator, :app, :index, :regexp, :options

data/lib/grape/util/base_inheritable.rb

@@ -31,6 +31,10 @@ module Grape
         combined.uniq!
         combined
       end
+
+      def key?(name)
+        inherited_values.key?(name) || new_values.key?(name)
+      end
     end
   end
 end

data/lib/grape/util/cache.rb

@@ -0,0 +1,20 @@
+# frozen_String_literal: true
+
+require 'singleton'
+require 'forwardable'
+
+module Grape
+  module Util
+    class Cache
+      include Singleton
+
+      attr_reader :cache
+
+      class << self
+        extend Forwardable
+        def_delegators :cache, :[]
+        def_delegators :instance, :cache
+      end
+    end
+  end
+end

data/lib/grape/util/lazy_object.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+# Based on https://github.com/HornsAndHooves/lazy_object
+
+module Grape
+  module Util
+    class LazyObject < 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

data/lib/grape/util/reverse_stackable_values.rb

@@ -9,7 +9,7 @@ module Grape
 
       def concat_values(inherited_value, new_value)
         [].tap do |value|
-          value.concat(new_value)
+          value.concat(new_value) if new_value
           value.concat(inherited_value)
         end
       end

data/lib/grape/util/stackable_values.rb

@@ -5,30 +5,19 @@ require_relative 'base_inheritable'
 module Grape
   module Util
     class StackableValues < BaseInheritable
-      attr_reader :frozen_values
-
-      def initialize(*_args)
-        super
-
-        @frozen_values = {}
-      end
-
       # Even if there is no value, an empty array will be returned.
       def [](name)
-        return @frozen_values[name] if @frozen_values.key? name
+        inherited_value = inherited_values[name]
+        new_value = new_values[name]
 
-        inherited_value = @inherited_values[name]
-        new_value = @new_values[name] || []
-
-        return new_value unless inherited_value
+        return new_value || [] unless inherited_value
 
         concat_values(inherited_value, new_value)
       end
 
       def []=(name, value)
-        raise if @frozen_values.key? name
-        @new_values[name] ||= []
-        @new_values[name].push value
+        new_values[name] ||= []
+        new_values[name].push value
       end
 
       def to_hash
@@ -37,16 +26,12 @@ module Grape
         end
       end
 
-      def freeze_value(key)
-        @frozen_values[key] = self[key].freeze
-      end
-
       protected
 
       def concat_values(inherited_value, new_value)
         [].tap do |value|
           value.concat(inherited_value)
-          value.concat(new_value)
+          value.concat(new_value) if new_value
         end
       end
     end

data/lib/grape/validations/params_scope.rb

@@ -244,7 +244,7 @@ module Grape
       end
 
       def validates(attrs, validations)
-        doc_attrs = { required: validations.keys.include?(:presence) }
+        doc_attrs = { required: validations.key?(:presence) }
 
         coerce_type = infer_coercion(validations)
 

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

@@ -8,6 +8,7 @@ module Grape
       # this class is here only to assert that rack's handling has succeeded.
       class File
         def call(input)
+          return if input.nil?
           return InvalidValue.new unless coerced?(input)
 
           # Processing of multipart file objects

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

@@ -6,17 +6,20 @@ module Grape
   module Validations
     module Types
       # Coerces the given value to a type defined via a +type+ argument during
-      # initialization.
+      # initialization. When +strict+ is true, it doesn't coerce a value but check
+      # that it has the proper type.
       class PrimitiveCoercer < DryTypeCoercer
         MAPPING = {
           Grape::API::Boolean => DryTypes::Params::Bool,
 
-          # unfortunatelly, a +Params+ scope doesn't contain String
-          String              => DryTypes::Coercible::String
+          # unfortunately, a +Params+ scope doesn't contain String
+          String              => DryTypes::Coercible::String,
+          BigDecimal          => DryTypes::Coercible::Decimal
         }.freeze
 
         STRICT_MAPPING = {
-          Grape::API::Boolean => DryTypes::Strict::Bool
+          Grape::API::Boolean => DryTypes::Strict::Bool,
+          BigDecimal          => DryTypes::Strict::Decimal
         }.freeze
 
         def initialize(type, strict = false)

data/lib/grape/validations/validators/coerce.rb

@@ -76,7 +76,7 @@ module Grape
         converter.call(val)
 
       # Some custom types might fail, so it should be treated as an invalid value
-      rescue
+      rescue StandardError
         Types::InvalidValue.new
       end
 

data/lib/grape/validations/validators/exactly_one_of.rb

@@ -6,8 +6,10 @@ module Grape
   module Validations
     class ExactlyOneOfValidator < MultipleParamsBase
       def validate_params!(params)
-        return if keys_in_common(params).length == 1
-        raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:exactly_one))
+        keys = keys_in_common(params)
+        return if keys.length == 1
+        raise Grape::Exceptions::Validation.new(params: all_keys, message: message(:exactly_one)) if keys.length.zero?
+        raise Grape::Exceptions::Validation.new(params: keys, message: message(:mutual_exclusion))
       end
     end
   end

data/lib/grape/version.rb

@@ -2,5 +2,5 @@
 
 module Grape
   # The current version of Grape.
-  VERSION = '1.3.0'
+  VERSION = '1.3.1'
 end