grape 1.0.0 → 1.6.0

data/lib/grape/util/base_inheritable.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    # Base for classes which need to operate with own values kept
+    # in the hash and inherited values kept in a Hash-like object.
+    class BaseInheritable
+      attr_accessor :inherited_values, :new_values
+
+      # @param inherited_values [Object] An object implementing an interface
+      #   of the Hash class.
+      def initialize(inherited_values = nil)
+        @inherited_values = inherited_values || {}
+        @new_values = {}
+      end
+
+      def delete(key)
+        new_values.delete key
+      end
+
+      def initialize_copy(other)
+        super
+        self.inherited_values = other.inherited_values
+        self.new_values = other.new_values.dup
+      end
+
+      def keys
+        if new_values.any?
+          combined = inherited_values.keys
+          combined.concat(new_values.keys)
+          combined.uniq!
+          combined
+        else
+          inherited_values.keys
+        end
+      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/endpoint_configuration.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    class EndpointConfiguration < LazyValueHash
+    end
+  end
+end

data/lib/grape/util/env.rb

@@ -1,23 +1,25 @@
+# frozen_string_literal: true
+
 module Grape
   module Env
-    API_VERSION = 'api.version'.freeze
-    API_ENDPOINT = 'api.endpoint'.freeze
-    API_REQUEST_INPUT = 'api.request.input'.freeze
-    API_REQUEST_BODY = 'api.request.body'.freeze
-    API_TYPE = 'api.type'.freeze
-    API_SUBTYPE = 'api.subtype'.freeze
-    API_VENDOR = 'api.vendor'.freeze
-    API_FORMAT = 'api.format'.freeze
+    API_VERSION = 'api.version'
+    API_ENDPOINT = 'api.endpoint'
+    API_REQUEST_INPUT = 'api.request.input'
+    API_REQUEST_BODY = 'api.request.body'
+    API_TYPE = 'api.type'
+    API_SUBTYPE = 'api.subtype'
+    API_VENDOR = 'api.vendor'
+    API_FORMAT = 'api.format'
 
-    RACK_INPUT = 'rack.input'.freeze
-    RACK_REQUEST_QUERY_HASH = 'rack.request.query_hash'.freeze
-    RACK_REQUEST_FORM_HASH = 'rack.request.form_hash'.freeze
-    RACK_REQUEST_FORM_INPUT = 'rack.request.form_input'.freeze
+    RACK_INPUT = 'rack.input'
+    RACK_REQUEST_QUERY_HASH = 'rack.request.query_hash'
+    RACK_REQUEST_FORM_HASH = 'rack.request.form_hash'
+    RACK_REQUEST_FORM_INPUT = 'rack.request.form_input'
 
-    GRAPE_REQUEST = 'grape.request'.freeze
-    GRAPE_REQUEST_HEADERS = 'grape.request.headers'.freeze
-    GRAPE_REQUEST_PARAMS = 'grape.request.params'.freeze
-    GRAPE_ROUTING_ARGS = 'grape.routing_args'.freeze
-    GRAPE_ALLOWED_METHODS = 'grape.allowed_methods'.freeze
+    GRAPE_REQUEST = 'grape.request'
+    GRAPE_REQUEST_HEADERS = 'grape.request.headers'
+    GRAPE_REQUEST_PARAMS = 'grape.request.params'
+    GRAPE_ROUTING_ARGS = 'grape.routing_args'
+    GRAPE_ALLOWED_METHODS = 'grape.allowed_methods'
   end
 end

data/lib/grape/util/inheritable_setting.rb

@@ -1,11 +1,11 @@
+# frozen_string_literal: true
+
 module Grape
   module Util
     # A branchable, inheritable settings object which can store both stackable
     # and inheritable values (see InheritableValues and StackableValues).
     class InheritableSetting
-      attr_accessor :route, :api_class, :namespace
-      attr_accessor :namespace_inheritable, :namespace_stackable, :namespace_reverse_stackable
-      attr_accessor :parent, :point_in_time_copies
+      attr_accessor :route, :api_class, :namespace, :namespace_inheritable, :namespace_stackable, :namespace_reverse_stackable, :parent, :point_in_time_copies
 
       # Retrieve global settings.
       def self.global

data/lib/grape/util/inheritable_values.rb

@@ -1,14 +1,10 @@
-module Grape
-  module Util
-    class InheritableValues
-      attr_accessor :inherited_values
-      attr_accessor :new_values
+# frozen_string_literal: true
 
-      def initialize(inherited_values = {})
-        self.inherited_values = inherited_values
-        self.new_values = {}
-      end
+require_relative 'base_inheritable'
 
+module Grape
+  module Util
+    class InheritableValues < BaseInheritable
       def [](name)
         values[name]
       end
@@ -17,26 +13,12 @@ module Grape
         new_values[name] = value
       end
 
-      def delete(key)
-        new_values.delete key
-      end
-
       def merge(new_hash)
-        values.merge(new_hash)
-      end
-
-      def keys
-        (new_values.keys + inherited_values.keys).sort.uniq
+        values.merge!(new_hash)
       end
 
       def to_hash
-        values.clone
-      end
-
-      def initialize_copy(other)
-        super
-        self.inherited_values = other.inherited_values
-        self.new_values = other.new_values.dup
+        values
       end
 
       protected

data/lib/grape/util/json.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   if Object.const_defined? :MultiJson
     Json = ::MultiJson

data/lib/grape/util/lazy_block.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    class LazyBlock
+      def initialize(&new_block)
+        @block = new_block
+      end
+
+      def evaluate_from(configuration)
+        @block.call(configuration)
+      end
+
+      def evaluate
+        @block.call({})
+      end
+
+      def lazy?
+        true
+      end
+
+      def to_s
+        evaluate.to_s
+      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/lazy_value.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Grape
+  module Util
+    class LazyValue
+      attr_reader :access_keys
+
+      def initialize(value, access_keys = [])
+        @value = value
+        @access_keys = access_keys
+      end
+
+      def evaluate_from(configuration)
+        matching_lazy_value = configuration.fetch(@access_keys)
+        matching_lazy_value.evaluate
+      end
+
+      def evaluate
+        @value
+      end
+
+      def lazy?
+        true
+      end
+
+      def reached_by(parent_access_keys, access_key)
+        @access_keys = parent_access_keys + [access_key]
+        self
+      end
+
+      def to_s
+        evaluate.to_s
+      end
+    end
+
+    class LazyValueEnumerable < LazyValue
+      def [](key)
+        if @value_hash[key].nil?
+          LazyValue.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
+                             LazyValueHash.new(value)
+                           when Array
+                             LazyValueArray.new(value)
+                           else
+                             LazyValue.new(value)
+                           end
+      end
+    end
+
+    class LazyValueArray < LazyValueEnumerable
+      def initialize(array)
+        super
+        @value_hash = []
+        array.each_with_index do |value, index|
+          self[index] = value
+        end
+      end
+
+      def evaluate
+        evaluated = []
+        @value_hash.each_with_index do |value, index|
+          evaluated[index] = value.evaluate
+        end
+        evaluated
+      end
+    end
+
+    class LazyValueHash < LazyValueEnumerable
+      def initialize(hash)
+        super
+        @value_hash = {}.with_indifferent_access
+        hash.each do |key, value|
+          self[key] = value
+        end
+      end
+
+      def evaluate
+        evaluated = {}.with_indifferent_access
+        @value_hash.each do |key, value|
+          evaluated[key] =  value.evaluate
+        end
+        evaluated
+      end
+    end
+  end
+end

data/lib/grape/util/registrable.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Util
     module Registrable

data/lib/grape/util/reverse_stackable_values.rb

@@ -1,45 +1,20 @@
+# frozen_string_literal: true
+
+require_relative 'stackable_values'
+
 module Grape
   module Util
-    class ReverseStackableValues
-      attr_accessor :inherited_values
-      attr_accessor :new_values
+    class ReverseStackableValues < StackableValues
+      protected
 
-      def initialize(inherited_values = {})
-        @inherited_values = inherited_values
-        @new_values = {}
-      end
+      def concat_values(inherited_value, new_value)
+        return inherited_value unless new_value
 
-      def [](name)
         [].tap do |value|
-          value.concat(@new_values[name] || [])
-          value.concat(@inherited_values[name] || [])
-        end
-      end
-
-      def []=(name, value)
-        @new_values[name] ||= []
-        @new_values[name].push value
-      end
-
-      def delete(key)
-        new_values.delete key
-      end
-
-      def keys
-        (@new_values.keys + @inherited_values.keys).sort.uniq
-      end
-
-      def to_hash
-        keys.each_with_object({}) do |key, result|
-          result[key] = self[key]
+          value.concat(new_value)
+          value.concat(inherited_value)
         end
       end
-
-      def initialize_copy(other)
-        super
-        self.inherited_values = other.inherited_values
-        self.new_values = other.new_values.dup
-      end
     end
   end
 end

data/lib/grape/util/stackable_values.rb

@@ -1,37 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'base_inheritable'
+
 module Grape
   module Util
-    class StackableValues
-      attr_accessor :inherited_values
-      attr_accessor :new_values
-      attr_reader :frozen_values
-
-      def initialize(inherited_values = {})
-        @inherited_values = inherited_values
-        @new_values = {}
-        @frozen_values = {}
-      end
-
+    class StackableValues < BaseInheritable
+      # Even if there is no value, an empty array will be returned.
       def [](name)
-        return @frozen_values[name] if @frozen_values.key? name
-
-        value = []
-        value.concat(@inherited_values[name] || [])
-        value.concat(@new_values[name] || [])
-        value
-      end
+        inherited_value = inherited_values[name]
+        new_value = new_values[name]
 
-      def []=(name, value)
-        raise if @frozen_values.key? name
-        @new_values[name] ||= []
-        @new_values[name].push value
-      end
+        return new_value || [] unless inherited_value
 
-      def delete(key)
-        new_values.delete key
+        concat_values(inherited_value, new_value)
       end
 
-      def keys
-        (@new_values.keys + @inherited_values.keys).sort.uniq
+      def []=(name, value)
+        new_values[name] ||= []
+        new_values[name].push value
       end
 
       def to_hash
@@ -40,14 +26,15 @@ module Grape
         end
       end
 
-      def freeze_value(key)
-        @frozen_values[key] = self[key].freeze
-      end
+      protected
+
+      def concat_values(inherited_value, new_value)
+        return inherited_value unless new_value
 
-      def initialize_copy(other)
-        super
-        self.inherited_values = other.inherited_values
-        self.new_values = other.new_values.dup
+        [].tap do |value|
+          value.concat(inherited_value)
+          value.concat(new_value)
+        end
       end
     end
   end

data/lib/grape/util/strict_hash_configuration.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Util
     module StrictHashConfiguration

data/lib/grape/util/xml.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   if Object.const_defined? :MultiXml
     Xml = ::MultiXml

data/lib/grape/validations/attributes_iterator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Grape
   module Validations
     class AttributesIterator
@@ -29,9 +31,7 @@ module Grape
 
           if @scope.type == Array
             next unless @original_params.is_a?(Array) # do not validate content of array if it isn't array
-            inside_array = true
-          end
-          if inside_array
+
             # fill current and parent scopes with correct array indicies
             parent_scope = @scope.parent
             parent_indicies.each do |parent_index|
@@ -41,11 +41,21 @@ module Grape
             @scope.index = index
           end
 
-          @attrs.each do |attr_name|
-            yield resource_params, attr_name, inside_array
-          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/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, skip?(resource_params)
+      end
+    end
+  end
+end