grape 0.9.0 → 0.10.0

data/lib/grape/util/stackable_values.rb

@@ -0,0 +1,52 @@
+module Grape
+  module Util
+    class StackableValues
+      attr_accessor :inherited_values
+      attr_reader :new_values
+      attr_reader :froozen_values
+
+      def initialize(inherited_values = {})
+        @inherited_values = inherited_values
+        @new_values = {}
+        @froozen_values = {}
+      end
+
+      def [](name)
+        return @froozen_values[name] if @froozen_values.key? name
+        [@inherited_values[name], @new_values[name]].compact.flatten(1)
+      end
+
+      def []=(name, value)
+        fail if @froozen_values.key? name
+        @new_values[name] ||= []
+        @new_values[name].push value
+      end
+
+      def delete(key)
+        new_values.delete key
+      end
+
+      attr_writer :new_values
+
+      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]
+        end
+      end
+
+      def freeze_value(key)
+        @froozen_values[key] = self[key].freeze
+      end
+
+      def initialize_copy(other)
+        super
+        self.inherited_values = other.inherited_values
+        self.new_values = other.new_values.deep_dup
+      end
+    end
+  end
+end

data/lib/grape/util/strict_hash_configuration.rb

@@ -0,0 +1,106 @@
+module Grape
+  module Util
+    module StrictHashConfiguration
+      extend ActiveSupport::Concern
+
+      module DSL
+        extend ActiveSupport::Concern
+
+        module ClassMethods
+          def settings
+            config_context.to_hash
+          end
+
+          def configure(&block)
+            config_context.instance_exec(&block)
+          end
+        end
+      end
+
+      class SettingsContainer
+        def initialize
+          @settings = {}
+          @contexts = {}
+        end
+
+        def to_hash
+          @settings.to_hash
+        end
+      end
+
+      def self.config_class(*args)
+        new_config_class = Class.new(SettingsContainer)
+
+        args.each do |setting_name|
+          if setting_name.respond_to? :values
+            nested_settings_methods(setting_name, new_config_class)
+          else
+            simple_settings_methods(setting_name, new_config_class)
+          end
+        end
+
+        new_config_class
+      end
+
+      def self.simple_settings_methods(setting_name, new_config_class)
+        setting_name_sym = setting_name.to_sym
+        new_config_class.class_eval do
+          define_method setting_name do |new_value|
+            @settings[setting_name_sym] = new_value
+          end
+        end
+      end
+
+      def self.nested_settings_methods(setting_name, new_config_class)
+        new_config_class.class_eval do
+          setting_name.each_pair do |key, value|
+            define_method "#{key}_context" do
+              @contexts[key] ||= Grape::Util::StrictHashConfiguration.config_class(*value).new
+            end
+
+            define_method key do |&block|
+              send("#{key}_context").instance_exec(&block)
+            end
+          end
+
+          define_method 'to_hash' do
+            merge_hash = setting_name.keys.each_with_object({}) { |k, hash| hash[k] = send("#{k}_context").to_hash }
+
+            @settings.to_hash.merge(
+              merge_hash
+            )
+          end
+        end
+      end
+
+      def self.module(*args)
+        new_module = Module.new do
+          extend ActiveSupport::Concern
+          include DSL
+        end
+
+        new_module.tap do |mod|
+          class_mod = create_class_mod(args)
+
+          mod.const_set(:ClassMethods, class_mod)
+        end
+      end
+
+      def self.create_class_mod(args)
+        new_module = Module.new do
+          def config_context
+            @config_context ||= config_class.new
+          end
+        end
+
+        new_module.tap do |class_mod|
+          new_config_class = config_class(*args)
+
+          class_mod.send(:define_method, :config_class) do
+            @config_context ||= new_config_class
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/validations.rb

@@ -1,72 +1,5 @@
 module Grape
   module Validations
-    ##
-    # All validators must inherit from this class.
-    #
-    class Validator
-      attr_reader :attrs
-
-      def initialize(attrs, options, required, scope)
-        @attrs = Array(attrs)
-        @required = required
-        @scope = scope
-      end
-
-      def validate!(params)
-        attributes = AttributesIterator.new(self, @scope, params)
-        attributes.each do |resource_params, attr_name|
-          if @required || resource_params.key?(attr_name)
-            validate_param!(attr_name, resource_params)
-          end
-        end
-      end
-
-      class AttributesIterator
-        include Enumerable
-
-        def initialize(validator, scope, params)
-          @attrs = validator.attrs
-          @params = scope.params(params)
-          @params = (@params.is_a?(Array) ? @params : [@params])
-        end
-
-        def each
-          @params.each do |resource_params|
-            @attrs.each do |attr_name|
-              yield resource_params, attr_name
-            end
-          end
-        end
-      end
-
-      def self.convert_to_short_name(klass)
-        ret = klass.name.gsub(/::/, '/')
-          .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
-          .gsub(/([a-z\d])([A-Z])/, '\1_\2')
-          .tr("-", "_")
-          .downcase
-        File.basename(ret, '_validator')
-      end
-    end
-
-    ##
-    # Base class for all validators taking only one param.
-    class SingleOptionValidator < Validator
-      def initialize(attrs, options, required, scope)
-        @option = options
-        super
-      end
-    end
-
-    # We define Validator::inherited here so SingleOptionValidator
-    # will not be considered a validator.
-    class Validator
-      def self.inherited(klass)
-        short_name = convert_to_short_name(klass)
-        Validations.register_validator(short_name, klass)
-      end
-    end
-
     class << self
       attr_accessor :validators
     end
@@ -76,158 +9,5 @@ module Grape
     def self.register_validator(short_name, klass)
       validators[short_name] = klass
     end
-
-    class ParamsScope
-      attr_accessor :element, :parent
-
-      include Grape::DSL::Parameters
-
-      def initialize(opts, &block)
-        @element  = opts[:element]
-        @parent   = opts[:parent]
-        @api      = opts[:api]
-        @optional = opts[:optional] || false
-        @type     = opts[:type]
-        @declared_params = []
-
-        instance_eval(&block) if block_given?
-
-        configure_declared_params
-      end
-
-      def should_validate?(parameters)
-        return false if @optional && params(parameters).respond_to?(:all?) && params(parameters).all?(&:blank?)
-        return true if parent.nil?
-        parent.should_validate?(parameters)
-      end
-
-      def full_name(name)
-        return "#{@parent.full_name(@element)}[#{name}]" if @parent
-        name.to_s
-      end
-
-      def root?
-        !@parent
-      end
-
-      protected
-
-      def push_declared_params(attrs)
-        @declared_params.concat attrs
-      end
-
-      private
-
-      def require_required_and_optional_fields(context, opts)
-        if context == :all
-          optional_fields = Array(opts[:except])
-          required_fields = opts[:using].keys - optional_fields
-        else # context == :none
-          required_fields = Array(opts[:except])
-          optional_fields = opts[:using].keys - required_fields
-        end
-        required_fields.each do |field|
-          field_opts = opts[:using][field]
-          raise ArgumentError, "required field not exist: #{field}" unless field_opts
-          requires(field, field_opts)
-        end
-        optional_fields.each do |field|
-          field_opts = opts[:using][field]
-          optional(field, field_opts) if field_opts
-        end
-      end
-
-      def validate_attributes(attrs, opts, &block)
-        validations = { presence: true }
-        validations.merge!(opts) if opts
-        validations[:type] ||= Array if block
-        validates(attrs, validations)
-      end
-
-      def new_scope(attrs, optional = false, &block)
-        opts = attrs[1] || { type: Array }
-        raise ArgumentError unless opts.keys.to_set.subset? [:type].to_set
-        ParamsScope.new(api: @api, element: attrs.first, parent: self, optional: optional, type: opts[:type], &block)
-      end
-
-      # Pushes declared params to parent or settings
-      def configure_declared_params
-        if @parent
-          @parent.push_declared_params [element => @declared_params]
-        else
-          @api.settings.peek[:declared_params] ||= []
-          @api.settings[:declared_params].concat @declared_params
-        end
-      end
-
-      def validates(attrs, validations)
-        doc_attrs = { required: validations.keys.include?(:presence) }
-
-        # special case (type = coerce)
-        validations[:coerce] = validations.delete(:type) if validations.key?(:type)
-
-        coerce_type = validations[:coerce]
-        doc_attrs[:type] = coerce_type.to_s if coerce_type
-
-        desc = validations.delete(:desc)
-        doc_attrs[:desc] = desc if desc
-
-        default = validations[:default]
-        doc_attrs[:default] = default if default
-
-        values = validations[:values]
-        doc_attrs[:values] = values if values
-
-        values = (values.is_a?(Proc) ? values.call : values)
-
-        # default value should be present in values array, if both exist
-        if default && values && !values.include?(default)
-          raise Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :values, values)
-        end
-
-        # type should be compatible with values array, if both exist
-        if coerce_type && values && values.any? { |v| !v.kind_of?(coerce_type) }
-          raise Grape::Exceptions::IncompatibleOptionValues.new(:type, coerce_type, :values, values)
-        end
-
-        doc_attrs[:documentation] = validations.delete(:documentation) if validations.key?(:documentation)
-
-        full_attrs = attrs.collect { |name| { name: name, full_name: full_name(name) } }
-        @api.document_attribute(full_attrs, doc_attrs)
-
-        # Validate for presence before any other validators
-        if validations.key?(:presence) && validations[:presence]
-          validate('presence', validations[:presence], attrs, doc_attrs)
-          validations.delete(:presence)
-        end
-
-        # Before we run the rest of the validators, lets handle
-        # whatever coercion so that we are working with correctly
-        # type casted values
-        if validations.key? :coerce
-          validate('coerce', validations[:coerce], attrs, doc_attrs)
-          validations.delete(:coerce)
-        end
-
-        validations.each do |type, options|
-          validate(type, options, attrs, doc_attrs)
-        end
-      end
-
-      def validate(type, options, attrs, doc_attrs)
-        validator_class = Validations.validators[type.to_s]
-
-        if validator_class
-          (@api.settings.peek[:validations] ||= []) << validator_class.new(attrs, options, doc_attrs[:required], self)
-        else
-          raise Grape::Exceptions::UnknownValidator.new(type)
-        end
-      end
-    end
   end
 end
-
-# Load all defined validations.
-Dir[File.expand_path('../validations/*.rb', __FILE__)].each do |path|
-  require(path)
-end

data/lib/grape/validations/attributes_iterator.rb

@@ -0,0 +1,21 @@
+module Grape
+  module Validations
+    class AttributesIterator
+      include Enumerable
+
+      def initialize(validator, scope, params)
+        @attrs = validator.attrs
+        @params = scope.params(params)
+        @params = (@params.is_a?(Array) ? @params : [@params])
+      end
+
+      def each
+        @params.each do |resource_params|
+          @attrs.each do |attr_name|
+            yield resource_params, attr_name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/grape/validations/params_scope.rb

@@ -0,0 +1,176 @@
+module Grape
+  module Validations
+    class ParamsScope
+      attr_accessor :element, :parent
+
+      include Grape::DSL::Parameters
+
+      def initialize(opts, &block)
+        @element  = opts[:element]
+        @parent   = opts[:parent]
+        @api      = opts[:api]
+        @optional = opts[:optional] || false
+        @type     = opts[:type]
+        @declared_params = []
+
+        instance_eval(&block) if block_given?
+
+        configure_declared_params
+      end
+
+      def should_validate?(parameters)
+        return false if @optional && params(parameters).respond_to?(:all?) && params(parameters).all?(&:blank?)
+        return true if parent.nil?
+        parent.should_validate?(parameters)
+      end
+
+      def full_name(name)
+        return "#{@parent.full_name(@element)}[#{name}]" if @parent
+        name.to_s
+      end
+
+      def root?
+        !@parent
+      end
+
+      def required?
+        !@optional
+      end
+
+      protected
+
+      def push_declared_params(attrs)
+        @declared_params.concat attrs
+      end
+
+      private
+
+      def require_required_and_optional_fields(context, opts)
+        if context == :all
+          optional_fields = Array(opts[:except])
+          required_fields = opts[:using].keys - optional_fields
+        else # context == :none
+          required_fields = Array(opts[:except])
+          optional_fields = opts[:using].keys - required_fields
+        end
+        required_fields.each do |field|
+          field_opts = opts[:using][field]
+          fail ArgumentError, "required field not exist: #{field}" unless field_opts
+          requires(field, field_opts)
+        end
+        optional_fields.each do |field|
+          field_opts = opts[:using][field]
+          optional(field, field_opts) if field_opts
+        end
+      end
+
+      def validate_attributes(attrs, opts, &block)
+        validations = { presence: true }
+        validations.merge!(opts) if opts
+        validations[:type] ||= Array if block
+        validates(attrs, validations)
+      end
+
+      def new_scope(attrs, optional = false, &block)
+        opts = attrs[1] || { type: Array }
+        ParamsScope.new(api: @api, element: attrs.first, parent: self, optional: optional, type: opts[:type], &block)
+      end
+
+      # Pushes declared params to parent or settings
+      def configure_declared_params
+        if @parent
+          @parent.push_declared_params [element => @declared_params]
+        else
+          @api.namespace_stackable(:declared_params, @declared_params)
+
+          @api.route_setting(:declared_params, []) unless @api.route_setting(:declared_params)
+          @api.route_setting(:declared_params).concat @declared_params
+        end
+      end
+
+      def validates(attrs, validations)
+        doc_attrs = { required: validations.keys.include?(:presence) }
+
+        # special case (type = coerce)
+        validations[:coerce] = validations.delete(:type) if validations.key?(:type)
+
+        coerce_type = validations[:coerce]
+
+        doc_attrs[:type] = coerce_type.to_s if coerce_type
+
+        desc = validations.delete(:desc) || validations.delete(:description)
+        doc_attrs[:desc] = desc if desc
+
+        default = validations[:default]
+        doc_attrs[:default] = default if default
+
+        values = validations[:values]
+        doc_attrs[:values] = values if values
+
+        coerce_type = guess_coerce_type(coerce_type, values)
+
+        # default value should be present in values array, if both exist and are not procs
+        check_incompatible_option_values(values, default)
+
+        # type should be compatible with values array, if both exist
+        validate_value_coercion(coerce_type, values)
+
+        doc_attrs[:documentation] = validations.delete(:documentation) if validations.key?(:documentation)
+
+        full_attrs = attrs.collect { |name| { name: name, full_name: full_name(name) } }
+        @api.document_attribute(full_attrs, doc_attrs)
+
+        # Validate for presence before any other validators
+        if validations.key?(:presence) && validations[:presence]
+          validate('presence', validations[:presence], attrs, doc_attrs)
+          validations.delete(:presence)
+        end
+
+        # Before we run the rest of the validators, lets handle
+        # whatever coercion so that we are working with correctly
+        # type casted values
+        if validations.key? :coerce
+          validate('coerce', validations[:coerce], attrs, doc_attrs)
+          validations.delete(:coerce)
+        end
+
+        validations.each do |type, options|
+          validate(type, options, attrs, doc_attrs)
+        end
+      end
+
+      def guess_coerce_type(coerce_type, values)
+        return coerce_type if !values || values.is_a?(Proc)
+        return values.first.class if coerce_type == Array && !values.empty?
+        coerce_type
+      end
+
+      def check_incompatible_option_values(values, default)
+        return unless values && default
+        return if values.is_a?(Proc) || default.is_a?(Proc)
+        return if values.include?(default)
+        fail Grape::Exceptions::IncompatibleOptionValues.new(:default, default, :values, values)
+      end
+
+      def validate(type, options, attrs, doc_attrs)
+        validator_class = Validations.validators[type.to_s]
+
+        if validator_class
+          value = validator_class.new(attrs, options, doc_attrs[:required], self)
+          @api.namespace_stackable(:validations, value)
+        else
+          fail Grape::Exceptions::UnknownValidator.new(type)
+        end
+      end
+
+      def validate_value_coercion(coerce_type, values)
+        return unless coerce_type && values
+        return if values.is_a?(Proc)
+        coerce_type = coerce_type.first if coerce_type.kind_of?(Array)
+        if values.any? { |v| !v.kind_of?(coerce_type) }
+          fail Grape::Exceptions::IncompatibleOptionValues.new(:type, coerce_type, :values, values)
+        end
+      end
+    end
+  end
+end