params-validator 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rvmrc

@@ -0,0 +1,2 @@
+rvm_gemset_create_on_use_flag=1
+rvm gemset use params-validator

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in params-validator.gemspec
+gemspec
+
+group :development, :test do
+  gem 'rspec'
+end
+

data/README.md

@@ -0,0 +1,99 @@
+# Introduction
+
+ The aim of params-validator is to allow an easy way to validate the
+parameters in a method call.
+
+# Install
+
+    gem install params-validator
+
+# Requirementes
+
+# Usage
+
+* There are three ways of use:
+
+  * Include validation rules inside the object:
+
+        require 'params-validator'
+        class MockObject
+          include ParamsValidator::ValidParams
+          # define two useless methods 
+          [:method1, :method2].each{|m|
+            define_method(m) do |*args, &block|
+              puts {:foo => "bar"}
+              true
+            end
+          }
+          # method1 arguments ruleset
+          validate_method(:method1) do
+            level(Fixnum, :optional)
+          end
+          # method2 arguments ruleset
+          validate_method(:method2) do
+            data(String) { |data| !data.nil? and data.length > 0}
+            level(Fixnum, :optional) {|level| level <= 3}
+          end
+        end
+
+
+  When calling a specific method, an ArgumentError exception will be raised if at least one parameter is invalid
+
+        obj = MockObject.new
+        obj.method1({:level => "1"})  # This will raise an ArgumentError exception because :level parameter type is invalid
+        obj.method1({:level => 1})  # This will execute successfully the method call
+        obj.method2({:level => 1})  # This will raise an ArgumentError exception because :data parameter is missing
+
+  * Include validation rules outside the object:
+
+        class MockObject
+          include ParamsValidator::ValidParams
+          # define two useless methods 
+          [:method1, :method2].each{|m|
+            define_method(m) do |*args, &block|
+              true
+            end
+          }
+          # method1 and method2 should be validated, but no ruleset is defined
+          validate_method [:method1, :method2]
+        end
+
+
+  Then in a separate file, rulesets must be loaded:
+
+        require 'params-validator'
+        include ParamsValidator::ValidParams
+        # define rulesets
+        rules = <<EOF
+          validation_rule("MockObject::method1") do
+            level(Fixnum, :optional)
+          end
+          validation_rule("MockObject::method2") do
+            data(String) { |data| !data.nil? and data.length > 0}
+            level(Fixnum, :optional) {|level| level <= 3}
+          end
+        EOF
+        # load rulesets in validation framework
+        load_rules(rules)
+        obj = MockObject.new
+        obj.method1({:level => "1"})  # This will raise an ArgumentError exception because :level parameter type is invalid 
+        obj.method1({:level => 1})  # This will execute successfully the method call
+        obj.method2({:level => 1})  # This will raise an ArgumentError exception because :data parameter is missing
+
+
+  * Client side validation (kudos to @drslump)
+
+        obj = ParamsValidator::Request.new
+        obj[:data] = "this is a log"
+        obj[:level] = 1
+        ruleset = MockObject.get_rule(:method2)
+        obj.valid?(ruleset) # false
+        begin
+          obj.validate(ruleset)
+        rescue ArgumentError => ae
+          p ae.message  # array with validation errors
+        end
+
+
+  More examples can be found in test folder.
+

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/params-validator.rb

@@ -0,0 +1,9 @@
+require 'params_validator/validator'
+require 'params_validator/request'
+
+#
+# Juan de Bravo <juandebravo@gmail.com>
+#
+module ParamsValidator
+  # this file just import the required files 
+end

data/lib/params_validator/method_validation.rb

@@ -0,0 +1,69 @@
+require 'params_validator/parameter'
+
+#
+# Juan de Bravo <juandebravo@gmail.com>
+#
+module ParamsValidator
+
+  #
+  # This class models the information required to validate
+  # a specific method call
+  #
+  class MethodValidation
+
+    # fully qualified method name
+    attr_accessor :method_name
+
+    # parameters expected by the method
+    attr_accessor :parameters
+
+    #
+    # MethodValidation constructor
+    # @param method_name fully qualified method name (Module::Class::method)
+    # @param block the block to be executed
+    #
+    def initialize(method_name, &block)
+      @method_name = method_name
+      @parameters = []
+      block_given? and self.instance_eval &block
+    end
+
+    # get mandatory parameters
+    def mandatories
+      values = []
+      @parameters.each{|param|
+        param.mandatory? and values << param
+      }
+      values
+    end
+
+    #
+    # Execute validation block in this object scope
+    #
+    def block(&block)
+      block_given? and self.instance_eval &block
+    end
+
+    #
+    # DSL that defines the validation rules.
+    # parameter (Object, :optional = false) { block }
+    #
+    def method_missing(meth, *args, &block)
+
+      if args.length < 2
+        optional = false
+      else
+        if args[1].eql?(:optional)
+          optional = true
+        else
+          optional = false
+        end
+      end
+
+      parameter = Parameter.new(meth, args.length < 1 ? Object : args[0], optional, block)
+      @parameters.push parameter
+    end
+
+  end
+end
+

data/lib/params_validator/parameter.rb

@@ -0,0 +1,39 @@
+#
+# Juan de Bravo <juandebravo@gmail.com>
+#
+
+module ParamsValidator
+
+  #
+  # Parameter definition
+  #
+  class Parameter
+
+    # parameter name
+    attr_accessor :name
+
+    # set if parameter is mandatory or optional
+    attr_accessor :optional
+
+    # parameter type (Object by default)
+    attr_accessor :klass
+
+    # specific ruleset (i.e. max or min length)
+    attr_accessor :rule
+
+    def initialize(name, klass = Object, optional = false, rule = nil)
+      @name = name.to_sym
+      @optional = optional
+      @klass = klass
+      @rule = rule
+    end
+
+    def optional?
+      @optional
+    end
+
+    def mandatory?
+      !@optional
+    end
+  end
+end

data/lib/params_validator/request.rb

@@ -0,0 +1,48 @@
+require 'params_validator/validator'
+
+#
+# Juan de Bravo <juandebravo@gmail.com>
+#
+
+module ParamsValidator
+  #
+  # Class used to enhance the way to pass parameters to a method
+  #
+  class Request < Hash
+
+    def initialize(params = nil)
+      super(params)
+    end
+
+    def add(key, value)
+      self[key.to_sym] = value
+      self
+    end
+
+    alias :delete_old :delete
+
+    def delete(key)
+      delete_old(key)
+      self
+    end
+
+    def params
+      keys
+    end
+
+    alias :size :length
+
+    def validate(ruleset)
+      ParamsValidator::Validator.validate_ruleset(ruleset, self)
+    end
+
+    def valid?(ruleset)
+      begin
+        validate(ruleset)
+        true
+      rescue
+        false
+      end
+    end
+  end
+end

data/lib/params_validator/valid_params.rb

@@ -0,0 +1,106 @@
+#
+# Juan de Bravo <juandebravo@gmail.com>
+#
+
+module ParamsValidator
+
+  #
+  # Module to be included in a class which methods should be validated
+  #
+  module ValidParams
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    #
+    # This method is called to validate the request parameters to a specific method before calling the method itself
+    # @param params Hash of parameters to validate
+    # @param interface_method String containing the fully qualified method name (Module1::Module2::Class::method)
+    #
+    def previous_validation(params = nil, interface_method = nil)
+      unless validator.nil?
+        if interface_method.nil?
+          interface = caller[0][/^(.*)(\.rb).*$/, 1].split('/').last
+          interface = caller[0][/^(.*)(\.rb).*$/, 1].split('/')
+          interface.shift
+          interface = interface.map!{|x| x.capitalize}.join("::")
+          method    = caller[0][/`([^']*)'/, 1]
+          interface_method = [interface, method].join("::")
+        else
+          # Got directly the method name in interface_method
+        end
+        params.instance_of?(Array) and params = params[0]
+        validator.validate_params(interface_method, params)
+      end
+    end
+
+    def validator
+      self.class.validator
+    end
+
+    def load_rules(rules)
+      self.class.load_rules(rules)
+    end
+
+    # inner module to define class methods
+    module ClassMethods
+
+      # This method is used in classes to define which methods
+      # should be validated when called.
+      # i.e. validate_method :method1
+      #      validate_method [:method1, :method2]
+      def validate_method(method, &block)
+        # get the fully qualified method name
+        interface = self.name
+
+        # cast to array if method is one symbol
+        method.instance_of?(Symbol) and method = [method]
+
+        # wrap each method
+        method.each{|m|
+          interface_method = [interface, m].join("::")
+
+          # add validation rule to the specific method if a block is defined
+          if block_given?
+            validator.validation_rule(interface_method, &block)
+          end
+
+          # wrap old method with the previous validation
+          old_method = "#{m}_old"
+          self.send :alias_method, *[old_method, m]
+
+          define_method(m) do |*args, &block|
+            # validate parameters
+            previous_validation(args, interface_method)
+            # call method
+            send(old_method, *args, &block)
+          end
+        }
+      end
+
+      # get the specified rule for a method
+      def get_rule(method)
+        object_name = self.name
+        key = "#{object_name}::#{method}"
+        method_validation = validator.methods_loaded[key.to_sym]
+        unless method_validation.nil?
+          return method_validation.parameters
+        end
+        nil
+      end
+
+      # validator object
+      def validator
+        @@validator ||= Validator.new
+      end
+
+      # shortcut to validator.load_rules
+      def load_rules(rules)
+        validator.load_rules(rules)
+      end
+
+    end
+
+  end
+end

data/lib/params_validator/validator.rb

@@ -0,0 +1,132 @@
+require 'params_validator/method_validation'
+require 'params_validator/valid_params'
+
+#
+# Juan de Bravo <juandebravo@gmail.com>
+#
+
+module ParamsValidator
+
+  #
+  # This class
+  #
+  class Validator
+
+    ERROR_MESSAGE_NULL  = "Parameter %s cannot be null"
+    ERROR_MESSAGE_TYPE  = "Parameter %s present but invalid type %s"
+    ERROR_MESSAGE_BLOCK = "Parameter %s present but does not match the ruleset"
+
+    attr_reader :methods_loaded
+
+    def initialize
+      @methods_loaded = {}
+    end
+
+    #
+    # This method loads new rules in memory
+    # validatation_rule method do
+    #   param1 (type) &block
+    #   param2 (type) &block
+    # end
+    #
+    def load_rules(rules)
+      self.instance_eval(rules)
+    end
+
+    #
+    # This method is part of the DSL and defines a new validator rule
+    # @param method_name fully qualified method name (Module::Class::method)
+    # @param block the block to be executed
+    #
+    def validation_rule(method_name, &block)
+      method = MethodValidation.new(method_name)
+      block_given? and method.block &block
+      @methods_loaded[:"#{method_name}"] = method
+    end
+
+    #
+    # This method validates if the specific call to method_name is valid
+    # @param method_name fully qualified method name (Module::Class::method)
+    # @param params
+    #
+    def validate_params(method_name, params)
+      errors = []
+
+      # fetch method rulesets
+      method = @methods_loaded[method_name.to_sym]
+
+      if method.nil?
+        # TODO enable devel or prod mode to raise or not an exception
+        errors.push "Unable to validate method #{method_name} with (#{@methods_loaded.keys.length}) keys #{@methods_loaded.keys}"
+        raise ArgumentError, errors
+      end
+
+      # fetch all params (optional and mandatory)
+      check_params = method.parameters
+
+      self.class.validate_ruleset(check_params, params)
+
+    end
+
+    #
+    # This method validates a params hash against a specific rulset
+    # @param valid_params ruleset
+    # @param params
+    #
+    def Validator.validate_ruleset(valid_params, params)
+      errors = []
+      if !valid_params.nil? and params.nil?
+        errors.push "Nil parameters when #{valid_params.length} expected"
+        raise ArgumentError, errors
+      end
+
+      # if just one param -> include as array with length 1
+      if valid_params.instance_of?(Array) && valid_params.length == 1 && params.instance_of?(String)
+        params = {valid_params[0].name.to_sym => params}
+      end
+
+      # Validate the params
+      valid_params.each{|key|
+        # get param
+        param = params[key.name.to_sym]
+        check_result = Validator.check_param(key, param)
+        unless check_result.nil?
+          errors.push check_result
+        end
+      }
+      unless errors.empty?
+        raise ArgumentError, errors
+      end
+      # no exception -> successfully validated
+      true
+
+    end
+
+    #
+    # This method validates if the specific method is valid
+    # @param valid_param object containing the param ruleset
+    # @param param param specified by the user in the method call
+    #
+    def Validator.check_param(valid_param, param)
+      if valid_param.optional? and param.nil? # argument optional and not present -> continue
+        return nil
+      end
+
+      if param.nil? # argument mandatory and not present
+        return ERROR_MESSAGE_NULL % valid_param.name
+      else
+        # check argument type is valid
+        unless param.is_a?(valid_param.klass)
+          return ERROR_MESSAGE_TYPE % [valid_param.name, param.class]
+        end
+
+        # check argument satisfies ruleset (if present)
+        unless valid_param.rule.nil?
+          !valid_param.rule.call(param) and return ERROR_MESSAGE_BLOCK % valid_param.name
+        end
+      end
+      nil
+    end
+
+  end
+end

data/lib/params_validator/version.rb

@@ -0,0 +1,8 @@
+
+#
+# Juan de Bravo <juandebravo@gmail.com>
+#
+
+module ParamsValidator
+    VERSION = "0.1.0"
+end

data/params-validator.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("lib", ".")
+
+require "params_validator/version"
+
+Gem::Specification.new do |s|
+  s.name        = "params-validator"
+  s.version     = ParamsValidator::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Juan de Bravo"]
+  s.email       = ["juandebravo@gmail.com"]
+  s.homepage    = ""
+  s.summary     = "params-validators allows to validate the required/optional parameters in a method"
+  s.description = "params-validators allows to validate the required/optional parameters in a method"
+
+  s.rubyforge_project = "params-validator"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+end

data/test/main.rb

@@ -0,0 +1,39 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'params-validator'
+require 'project/provisioning/user_object'
+require 'project/provisioning/application'
+
+if __FILE__ == $0
+  rules = <<EOF
+    validation_rule "Project::Provisioning::UserObject::create" do
+      name (String) {|value| value.length > 5 && value.length < 10}
+      password String
+      birthday (Fixnum) {|value| Time.now.year > value}
+      description(String, :optional) {|value| value.length > 50 && value.length < 100}
+    end
+
+    validation_rule "Project::Provisioning::UserObject::delete" do
+      user_id (String)
+    end
+EOF
+
+  include ParamsValidator::ValidParams
+
+  load_rules(rules)
+
+
+  user = Project::Provisioning::UserObject.new
+  begin
+    user.create({:name => "juan", :password1 => "project", :birthday => 1978})
+  rescue ArgumentError => ex
+    p ex.message
+  end
+  user.delete({:user_id => "juan"})
+
+  application = Project::Provisioning::Application.new
+  application.create({:user_id => "juan"})
+
+  application.delete({:app_id => "app1"})
+
+end

data/test/method_validation_spec.rb

@@ -0,0 +1,49 @@
+require 'params-validator'
+
+describe ParamsValidator::MethodValidation  do
+  describe "method_name" do
+    it "method_name returns the valid method name" do
+      method = ParamsValidator::MethodValidation.new("method_name")
+      method.method_name.should == "method_name"
+    end
+    it "method_name with module/class returns the valid method name" do
+      method = ParamsValidator::MethodValidation.new("Module1::Module2::Class::method")
+      method.method_name.should eq("Module1::Module2::Class::method")
+    end
+  end
+
+  describe "parameters" do
+    proc = lambda{
+      name(String) {|value| value.length > 5 && value.length < 10}
+      password
+      birthday(Fixnum) {|value| Time.now.year > value}
+      description(String, :optional) {|value| value.length > 50 && value.length < 100}
+    }
+
+    it "params length should be 4" do
+      method = ParamsValidator::MethodValidation.new("Module::Class:method", &proc)
+      method.parameters.length.should == 4
+    end
+
+    it "mandatory params length should be 3" do
+      method = ParamsValidator::MethodValidation.new("Module::Class:method", &proc)
+      method.parameters.length.should == 4
+    end
+
+    it "default object should be Object" do
+      method = ParamsValidator::MethodValidation.new("Module::Class:method", &proc)
+      method.parameters[1].klass.should == Object
+    end
+
+    it "parameter with ruleset should have rule attribute" do
+      method = ParamsValidator::MethodValidation.new("Module::Class:method", &proc)
+      method.parameters[0].rule.should_not == nil
+    end
+
+    it "parameter without ruleset should have nil rule attribute" do
+      method = ParamsValidator::MethodValidation.new("Module::Class:method", &proc)
+      method.parameters[1].rule.should == nil
+    end
+  end
+
+end

data/test/mock/mock_object.rb

@@ -0,0 +1,34 @@
+require 'params-validator'
+
+module Mock
+  class MockObject
+    include ParamsValidator::ValidParams
+
+    [:log, :log_level, :log_level_type, :log_level_type_optional, :log_data, :log_data_block].each{|m|
+      define_method(m) do |*args, &block|
+        #puts "call to method #{m.to_s}"
+        true
+      end
+    }
+
+    validate_method(:log) do
+    end
+    validate_method(:log_level) do
+      level
+    end
+    validate_method(:log_level_type) do
+      level Fixnum
+    end
+    validate_method(:log_level_type_optional) do
+      level(Fixnum, :optional)
+    end
+    validate_method(:log_data) do
+      data(String)
+      level(Fixnum, :optional)
+    end
+    validate_method(:log_data_block) do
+      data(String) { |data| !data.nil? and data.length > 0}
+      level(Fixnum, :optional) {|level| level <= 3}
+    end
+  end
+end  

data/test/parameter_spec.rb

@@ -0,0 +1,37 @@
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+require 'params-validator'
+
+describe ParamsValidator::Parameter  do
+  describe "optional" do
+    #optional
+    it "optional? returns true if parameter is optional" do
+      param = ParamsValidator::Parameter.new("parameter", Object, true, nil)
+      param.optional?.should == true
+    end
+    it "optional? returns false if parameter is mandatory" do
+      param = ParamsValidator::Parameter.new("parameter", Object, false, nil)
+      param.optional?.should == false
+    end
+  end
+
+  describe "ruleset" do
+    # ruleset
+    it "rule returns nil if parameter has no ruleset defined" do
+      param = ParamsValidator::Parameter.new("parameter", Object, false, nil)
+      param.rule.should == nil
+    end
+  end
+
+  describe "klass" do
+    # klass
+    it "klass returns parameter class if defined" do
+      param = ParamsValidator::Parameter.new("parameter", String)
+      param.klass.should == String
+    end
+    it "klass returns Object class if undefined" do
+      param = ParamsValidator::Parameter.new("parameter")
+      param.klass.should == Object
+    end
+  end
+end

data/test/project/provisioning/application.rb

@@ -0,0 +1,31 @@
+require 'params-validator'
+
+module Project::Provisioning
+  class Application
+    include ParamsValidator::ValidParams
+
+    def create(params)
+      puts "create a specific #{self.class.name}"
+    end
+
+    def delete(params)
+      puts "delete a specific #{self.class.name}"
+    end
+
+    rules = <<EOF
+      validation_rule "Project::Provisioning::Application::create" do
+        user_id (String)
+      end
+EOF
+
+    load_rules(rules)
+
+
+    validate_method :create
+
+    validate_method(:delete) {
+      app_id (String)
+    }
+    
+  end
+end

data/test/project/provisioning/user_object.rb

@@ -0,0 +1,20 @@
+require 'params-validator'
+
+module Project
+  module Provisioning
+    class UserObject
+      include ParamsValidator::ValidParams
+
+      def create(params)
+        puts "create a specific user"
+      end
+
+      def delete(params)
+        puts "delete a specific user"
+      end
+
+      validate_method [:delete, :create]
+
+    end
+  end
+end

data/test/request_spec.rb

@@ -0,0 +1,79 @@
+$:.unshift File.join(File.dirname(__FILE__),'.')
+
+require 'params-validator'
+require 'mock/mock_object'
+require 'yamock_object'
+
+
+describe ParamsValidator::Request do
+  describe "handle parameters" do
+
+    it "add any parameter" do
+      obj = ParamsValidator::Request.new
+      obj.add(:foo, "bar")
+      obj.add(:length, 3)
+      obj.size.should eq(2)
+    end
+
+    it "delete any parameter" do
+      obj = ParamsValidator::Request.new
+      obj.add(:foo, "bar")
+      obj.add(:length, 3)
+      obj.delete(:length)
+      obj.size.should eq(1)
+    end
+  end
+
+  describe "validate parameters" do
+
+    it "validation return true with valid parameters" do
+      obj = ParamsValidator::Request.new
+      obj[:data] = "this is a log"
+      obj[:level] = 1
+      ruleset = Mock::MockObject.get_rule(:log_data_block)
+      obj.validate(ruleset).should eq(true)
+    end
+
+    it "validation throw exception with invalid parameters" do
+      obj = ParamsValidator::Request.new
+      obj[:data] = "this is a log"
+      obj[:level] = "1"
+      ruleset = Mock::MockObject.get_rule(:log_data_block)
+      lambda{obj.validate(ruleset)}.should raise_error(ArgumentError)
+    end
+
+    it "validation throw exception with the correct number of errors" do
+      obj = ParamsValidator::Request.new
+      obj[:data] = ""
+      obj[:level] = "1"
+      ruleset = Mock::MockObject.get_rule(:log_data_block)
+      begin
+        obj.validate(ruleset)
+      rescue ArgumentError => ae
+        ae.message.length.should eq(2)
+      end
+    end
+
+  end
+
+  describe "valid? method" do
+
+    it "returns true if valid" do
+      obj = ParamsValidator::Request.new
+      obj[:data] = "this is a log"
+      obj[:level] = 1
+      ruleset = Mock::MockObject.get_rule(:log_data_block)
+      obj.valid?(ruleset).should eq(true)
+    end
+
+    it "returns false if invalid" do
+      obj = ParamsValidator::Request.new
+      obj[:data] = "this is a log"
+      obj[:level] = "1"
+      ruleset = Mock::MockObject.get_rule(:log_data_block)
+      obj.valid?(ruleset).should eq(false)
+    end
+
+  end
+
+end

data/test/valid_params_spec.rb

@@ -0,0 +1,99 @@
+$:.unshift File.join(File.dirname(__FILE__),'.')
+
+require 'params-validator'
+require 'mock/mock_object'
+require 'yamock_object'
+
+include Mock
+
+describe ParamsValidator::ValidParams do
+  describe "validate_method inside class" do
+    it "executes an empty block and validates true always" do
+      obj = MockObject.new
+      obj.log({}).should eq(true)
+    end
+
+    it "raises an exception if mandatory parameter missing" do
+      obj = MockObject.new
+      lambda{obj.log_level({})}.should raise_error(ArgumentError)
+    end
+
+    it "raises an exception if mandatory parameter included but invalid type" do
+      obj = MockObject.new
+      lambda{obj.log_level_type({:level => "INFO"})}.should raise_error(ArgumentError)
+    end
+
+    it "raises an exception if optional parameter included but invalid type" do
+      obj = MockObject.new
+      lambda{obj.log_level_type_optional({:level => "INFO"})}.should raise_error(ArgumentError)
+    end
+
+    it "executes a valid ruleset with mandatory parameters" do
+      obj = MockObject.new
+      obj.log_level_type({:level => 3}).should eq(true)
+    end
+
+    it "executes a valid ruleset with mandatory and optional parameters included" do
+      obj = MockObject.new
+      obj.log_data({:level => 3, :data => "This is a test"}).should eq(true)
+    end
+
+    it "executes a valid ruleset with mandatory parameters included and optional parameters missing" do
+      obj = MockObject.new
+      obj.log_data({:data => "This is a test"}).should eq(true)
+    end
+
+    it "executes a valid ruleset with validation block for parameters" do
+      obj = MockObject.new
+      obj.log_data_block({:data => "This is a test", :level => 1}).should eq(true)
+    end
+
+    it "executes a valid ruleset with invalid validation block for mandatory parameter" do
+      obj = MockObject.new
+      lambda{obj.log_data_block({:data => ""})}.should raise_error(ArgumentError)
+    end
+
+    it "executes a valid ruleset with invalid validation block for optional parameter" do
+      obj = MockObject.new
+      lambda{obj.log_data_block({:data => "", :level => 5})}.should raise_error(ArgumentError)
+    end
+  end
+
+  describe "validate_method inline" do
+    rules = <<EOF
+      validation_rule("YamockObject::log") do
+      end
+      validation_rule("YamockObject::log_level") do
+        level
+      end 
+      validation_rule("YamockObject::log_level_type") do
+        level Fixnum
+      end 
+      validation_rule("YamockObject::log_level_type_optional") do
+        level(Fixnum, :optional)
+      end 
+      validation_rule("YamockObject::log_data") do
+        data(String)
+        level(Fixnum, :optional)
+      end 
+      validation_rule("YamockObject::log_data_block") do
+        data(String) { |data| !data.nil? and data.length > 0}
+        level(Fixnum, :optional) {|level| level <= 3}
+      end 
+
+EOF
+
+    include ParamsValidator::ValidParams
+    load_rules(rules)
+
+    it "executes a valid ruleset with invalid validation block for optional parameter" do
+      obj = YamockObject.new
+      lambda{obj.log_data_block({:data => "", :level => 5})}.should raise_error(ArgumentError)
+    end
+    it "executes a valid ruleset with valid validation blocks" do
+      obj = YamockObject.new
+      obj.log_data_block({:data => "info", :level => 2}).should eq(true)
+    end
+  end
+
+end

data/test/yamock_object.rb

@@ -0,0 +1,16 @@
+require 'params-validator'
+
+class YamockObject
+  include ParamsValidator::ValidParams
+
+  METHODS = [:log, :log_level, :log_level_type, :log_level_type_optional, :log_data, :log_data_block]
+  
+  METHODS.each{|m|
+    define_method(m) do |*args, &block|
+      true
+    end
+  }
+
+  validate_method METHODS
+end
+

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification 
+name: params-validator
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: 
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Juan de Bravo
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-24 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: params-validators allows to validate the required/optional parameters in a method
+email: 
+- juandebravo@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rvmrc
+- Gemfile
+- README.md
+- Rakefile
+- lib/params-validator.rb
+- lib/params_validator/method_validation.rb
+- lib/params_validator/parameter.rb
+- lib/params_validator/request.rb
+- lib/params_validator/valid_params.rb
+- lib/params_validator/validator.rb
+- lib/params_validator/version.rb
+- params-validator.gemspec
+- test/main.rb
+- test/method_validation_spec.rb
+- test/mock/mock_object.rb
+- test/parameter_spec.rb
+- test/project/provisioning/application.rb
+- test/project/provisioning/user_object.rb
+- test/request_spec.rb
+- test/valid_params_spec.rb
+- test/yamock_object.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: params-validator
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: params-validators allows to validate the required/optional parameters in a method
+test_files: 
+- test/main.rb
+- test/method_validation_spec.rb
+- test/mock/mock_object.rb
+- test/parameter_spec.rb
+- test/project/provisioning/application.rb
+- test/project/provisioning/user_object.rb
+- test/request_spec.rb
+- test/valid_params_spec.rb
+- test/yamock_object.rb