grape 1.1.0 → 1.2.5

data/lib/grape/util/base_inheritable.rb

@@ -0,0 +1,34 @@
+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
+      attr_accessor :new_values
+
+      # @param inherited_values [Object] An object implementing an interface
+      #   of the Hash class.
+      def initialize(inherited_values = {})
+        @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
+        combined = inherited_values.keys
+        combined.concat(new_values.keys)
+        combined.uniq!
+        combined
+      end
+    end
+  end
+end

data/lib/grape/util/endpoint_configuration.rb

@@ -0,0 +1,6 @@
+module Grape
+  module Util
+    class EndpointConfiguration < LazyValueHash
+    end
+  end
+end

data/lib/grape/util/inheritable_values.rb

@@ -1,14 +1,8 @@
+require_relative 'base_inheritable'
+
 module Grape
   module Util
-    class InheritableValues
-      attr_accessor :inherited_values
-      attr_accessor :new_values
-
-      def initialize(inherited_values = {})
-        self.inherited_values = inherited_values
-        self.new_values = {}
-      end
-
+    class InheritableValues < BaseInheritable
       def [](name)
         values[name]
       end
@@ -17,26 +11,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/lazy_block.rb

@@ -0,0 +1,25 @@
+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_value.rb

@@ -0,0 +1,95 @@
+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] = if value.is_a?(Hash)
+                             LazyValueHash.new(value)
+                           elsif value.is_a?(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/reverse_stackable_values.rb

@@ -1,45 +1,16 @@
+require_relative 'stackable_values'
+
 module Grape
   module Util
-    class ReverseStackableValues
-      attr_accessor :inherited_values
-      attr_accessor :new_values
-
-      def initialize(inherited_values = {})
-        @inherited_values = inherited_values
-        @new_values = {}
-      end
+    class ReverseStackableValues < StackableValues
+      protected
 
-      def [](name)
+      def concat_values(inherited_value, new_value)
         [].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,23 +1,25 @@
+require_relative 'base_inheritable'
+
 module Grape
   module Util
-    class StackableValues
-      attr_accessor :inherited_values
-      attr_accessor :new_values
+    class StackableValues < BaseInheritable
       attr_reader :frozen_values
 
-      def initialize(inherited_values = {})
-        @inherited_values = inherited_values
-        @new_values = {}
+      def initialize(*_args)
+        super
+
         @frozen_values = {}
       end
 
       def [](name)
         return @frozen_values[name] if @frozen_values.key? name
 
-        value = []
-        value.concat(@inherited_values[name] || [])
-        value.concat(@new_values[name] || [])
-        value
+        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)
@@ -26,14 +28,6 @@ module Grape
         @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]
@@ -44,10 +38,13 @@ module Grape
         @frozen_values[key] = self[key].freeze
       end
 
-      def initialize_copy(other)
-        super
-        self.inherited_values = other.inherited_values
-        self.new_values = other.new_values.dup
+      protected
+
+      def concat_values(inherited_value, new_value)
+        [].tap do |value|
+          value.concat(inherited_value)
+          value.concat(new_value)
+        end
       end
     end
   end

data/lib/grape/validations/attributes_iterator.rb

@@ -41,11 +41,13 @@ 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
     end
   end
 end

data/lib/grape/validations/multiple_attributes_iterator.rb

@@ -0,0 +1,11 @@
+module Grape
+  module Validations
+    class MultipleAttributesIterator < AttributesIterator
+      private
+
+      def yield_attributes(resource_params, _attrs)
+        yield resource_params
+      end
+    end
+  end
+end

data/lib/grape/validations/params_scope.rb

@@ -36,6 +36,10 @@ module Grape
         configure_declared_params
       end
 
+      def configuration
+        @api.configuration.evaluate
+      end
+
       # @return [Boolean] whether or not this entire scope needs to be
       #   validated
       def should_validate?(parameters)
@@ -52,6 +56,7 @@ module Grape
 
         return true unless @dependent_on
         return params.any? { |param| meets_dependency?(param, request_params) } if params.is_a?(Array)
+        return false unless params.respond_to?(:with_indifferent_access)
         params = params.with_indifferent_access
 
         @dependent_on.each do |dependency|
@@ -71,7 +76,7 @@ module Grape
       def full_name(name, index: nil)
         if nested?
           # Find our containing element's name, and append ours.
-          [@parent.full_name(@element), [@index || index, name].map(&method(:brackets))].compact.join
+          "#{@parent.full_name(@element)}#{brackets(@index || index)}#{brackets(name)}"
         elsif lateral?
           # Find the name of the element as if it was at the same nesting level
           # as our parent. We need to forward our index upward to achieve this.
@@ -119,8 +124,9 @@ module Grape
           @parent.push_declared_params(attrs, opts)
         else
           if opts && opts[:as]
-            @api.route_setting(:aliased_params, @api.route_setting(:aliased_params) || [])
-            @api.route_setting(:aliased_params) << { attrs.first => opts[:as] }
+            @api.route_setting(:renamed_params, @api.route_setting(:renamed_params) || [])
+            @api.route_setting(:renamed_params) << { attrs.first => opts[:as] }
+            attrs = [opts[:as]]
           end
 
           @declared_params.concat attrs
@@ -178,14 +184,12 @@ module Grape
           raise Grape::Exceptions::UnsupportedGroupTypeError.new unless Grape::Validations::Types.group?(type)
         end
 
-        opts = attrs[1] || { type: Array }
-
         self.class.new(
           api:      @api,
-          element:  attrs.first,
+          element:  attrs[1][:as] || attrs.first,
           parent:   self,
           optional: optional,
-          type:     opts[:type],
+          type:     type || Array,
           &block
         )
       end
@@ -406,13 +410,15 @@ module Grape
 
         raise Grape::Exceptions::UnknownValidator.new(type) unless validator_class
 
-        factory = Grape::Validations::ValidatorFactory.new(attributes:      attrs,
-                                                           options:         options,
-                                                           required:        doc_attrs[:required],
-                                                           params_scope:    self,
-                                                           opts:            opts,
-                                                           validator_class: validator_class)
-        @api.namespace_stackable(:validations, factory)
+        validator_options = {
+          attributes:      attrs,
+          options:         options,
+          required:        doc_attrs[:required],
+          params_scope:    self,
+          opts:            opts,
+          validator_class: validator_class
+        }
+        @api.namespace_stackable(:validations, validator_options)
       end
 
       def validate_value_coercion(coerce_type, *values_list)

data/lib/grape/validations/single_attribute_iterator.rb

@@ -0,0 +1,13 @@
+module Grape
+  module Validations
+    class SingleAttributeIterator < AttributesIterator
+      private
+
+      def yield_attributes(resource_params, attrs)
+        attrs.each do |attr_name|
+          yield resource_params, attr_name
+        end
+      end
+    end
+  end
+end