reworked validations

- extracted validators
- auto-register validators
- added params scope

Author: schmurfy

lib/grape/api.rb

@@ -8,7 +8,7 @@ module Grape
   # creating Grape APIs.Users should subclass this
   # class in order to build an API.
   class API
-    include Validations
+    extend Validations::ClassMethods
 
     class << self
       attr_reader :route_set

lib/grape/validations.rb

@@ -1,95 +1,76 @@
 require 'virtus'
 Boolean = Virtus::Attribute::Boolean
+
 module Grape
-  
-  class Validator
-    def initialize(attrs, options)
-      @attrs = Array(attrs)
-      
-      if options.is_a?(Hash) && !options.empty?
-        raise "unknown options: #{options.keys}"
-      end
-    end
 
-    def validate!(params)
-      @attrs.each do |attr_name|
-        validate_param!(attr_name, params)
-      end
-    end
-  end
-  
-  
-  class SingleOptionValidator < Validator
-    def initialize(attrs, options)
-      @option = options
-      super
-    end
+  module Validations
 
-  end
-  
-  
-  class PresenceValidator < Validator
-    def validate_param!(attr_name, params)
-      unless params.has_key?(attr_name)
-        throw :error, :status => 400, :message => "missing parameter: #{attr_name}"
+    ##
+    # All validators must inherit from this class.
+    # 
+    class Validator
+      def initialize(attrs, options)
+        @attrs = Array(attrs)
+
+        if options.is_a?(Hash) && !options.empty?
+          raise "unknown options: #{options.keys}"
+        end
+      end
+
+      def validate!(params)
+        @attrs.each do |attr_name|
+          validate_param!(attr_name, params)
+        end
+      end
+
+    private
+
+      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
-    
-  end
-  
-  class CoerceValidator < SingleOptionValidator
-    def validate_param!(attr_name, params)
-      params[attr_name] = coerce_value(@option, params[attr_name])
-    end
-  
-  private
-    def coerce_value(type, val)
-      converter = Virtus::Attribute.build(:a, type)
-      converter.coerce(val)
+
+    ##
+    # Base class for all validators taking only one param.
+    class SingleOptionValidator < Validator
+      def initialize(attrs, options)
+        @option = options
+        super
+      end
+
     end
-  end
-  
-  class RegExpValidator < SingleOptionValidator
-    def validate_param!(attr_name, params)
-      if params[attr_name] && !( params[attr_name].to_s =~ @option )
-        throw :error, :status => 400, :message => "invalid parameter: #{attr_name}"
+
+    # 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
-  end
 
-  
-  
-  module Validations
+    
 
     class <<self
       attr_accessor :validators
     end
 
     self.validators = {}
-    self.validators[:presence] = PresenceValidator
-    self.validators[:regexp] = RegExpValidator
-    self.validators[:coerce] = CoerceValidator
 
-    def self.included(klass)
-      klass.instance_eval do
-        extend ClassMethods
-      end
+    def self.register_validator(short_name, klass)
+      validators[short_name] = klass
     end
 
-    module ClassMethods
-      def reset_validations!
-        settings[:validations] = []
-      end
-      
-      def document_attribute(names, opts)
-        if @last_description
-          @last_description[:params] ||= {}
-        
-          Array(names).each do |name|
-            @last_description[:params][name.to_sym] ||= {}
-            @last_description[:params][name.to_sym].merge!(opts)
-          end
-        end
+    
+    class ParamsScope
+      def initialize(api, &block)
+        @api = api
+        instance_eval(&block)
       end
 
       def requires(*attrs)
@@ -110,6 +91,7 @@ def optional(*attrs)
         validates(attrs, validations)
       end
 
+    private
       def validates(attrs, validations)
         doc_attrs = { :required => validations.keys.include?(:presence) }
 
@@ -121,21 +103,48 @@ def validates(attrs, validations)
           doc_attrs[:desc] = desc
         end
 
-        document_attribute(attrs, doc_attrs)
+        @api.document_attribute(attrs, doc_attrs)
 
         validations.each do |type, options|
-          validator_class = Validations::validators[type]
+          validator_class = Validations::validators[type.to_s]
           if validator_class
-            settings[:validations] << validator_class.new(attrs, options)
+            @api.settings[:validations] << validator_class.new(attrs, options)
           else
             raise "unknown validator: #{type}"
           end
         end
+      
+      end
+      
+    end
+    
+    # This module is mixed into the API Class.
+    module ClassMethods
+      def reset_validations!
+        settings[:validations] = []
+      end
+      
+      def params(&block)
+        ParamsScope.new(self, &block)
+      end
+      
+      def document_attribute(names, opts)
+        if @last_description
+          @last_description[:params] ||= {}
 
+          Array(names).each do |name|
+            @last_description[:params][name.to_sym] ||= {}
+            @last_description[:params][name.to_sym].merge!(opts)
+          end
+        end
       end
-
 
     end
 
   end
 end
+
+# load all defined validations
+Dir[File.expand_path('../validations/*.rb', __FILE__)].each do |path|
+  require(path)
+end

lib/grape/validations/coerce.rb

@@ -0,0 +1,17 @@
+module Grape
+  module Validations
+    
+    class CoerceValidator < SingleOptionValidator
+      def validate_param!(attr_name, params)
+        params[attr_name] = coerce_value(@option, params[attr_name])
+      end
+  
+    private
+      def coerce_value(type, val)
+        converter = Virtus::Attribute.build(:a, type)
+        converter.coerce(val)
+      end
+    end
+    
+  end
+end

lib/grape/validations/presence.rb

@@ -0,0 +1,14 @@
+module Grape
+  module Validations
+    
+    class PresenceValidator < Validator
+      def validate_param!(attr_name, params)
+        unless params.has_key?(attr_name)
+          throw :error, :status => 400, :message => "missing parameter: #{attr_name}"
+        end
+      end
+    
+    end
+    
+  end
+end

lib/grape/validations/regexp.rb

@@ -0,0 +1,13 @@
+module Grape
+  module Validations
+    
+    class RegexpValidator < SingleOptionValidator
+      def validate_param!(attr_name, params)
+        if params[attr_name] && !( params[attr_name].to_s =~ @option )
+          throw :error, :status => 400, :message => "invalid parameter: #{attr_name}"
+        end
+      end
+    end
+
+  end
+end

spec/grape/validations_spec.rb

@@ -7,20 +7,29 @@ def app; @app; end
     @app = Class.new(Grape::API) do
       default_format :json
 
-      requires :id, :regexp => /^[0-9]+$/
+      
+      params do
+        requires :id, :regexp => /^[0-9]+$/
+      end
+      
       post do
         {:ret => params[:id]}
       end
 
-      requires :name, :company
-      optional :a_number, :regexp => /^[0-9]+$/
+      params do
+        requires :name, :company
+        optional :a_number, :regexp => /^[0-9]+$/
+      end
+      
       get do
         "Hello"
       end
 
-      requires :int, :coerce => Integer
-      optional :arr, :coerce => Array[Integer]
-      optional :bool, :coerce => Array[Boolean]
+      params do
+        requires :int, :coerce => Integer
+        optional :arr, :coerce => Array[Integer]
+        optional :bool, :coerce => Array[Boolean]
+      end
       get '/coerce' do
         {
           :int    => params[:int].class,