params-validator 0.1.0 → 0.2.0

data/.gitignore

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

data/Gemfile.lock

@@ -0,0 +1,24 @@
+PATH
+  remote: .
+  specs:
+    params-validator (0.2.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  params-validator!
+  rspec

data/README.md

@@ -7,11 +7,24 @@ parameters in a method call.
 
     gem install params-validator
 
-# Requirementes
+# Requirements
+
+# v0.2.0 changes
+
+- FEATURE: definition of validation rulesets inside the method, so it improves the code style including the validation as the first step in a method execution (suggested by [osuka](https://github.com/osuka))
+
+- FIXED: If a method has a ruleset that defines all the parameters as optional, a nil argument
+	is allowed. On previous versions an ArgumentError exception was thrown
+	
+- FIXED: inheritance allowed. A method can define a more restrictive ruleset in a inherited method.
+
+- FIXED: a method validation can be redefined, the first definition will not be used.
+	
+- MOVED: specs to folder ./spec
 
 # Usage
 
-* There are three ways of use:
+* There are four ways of use:
 
   * Include validation rules inside the object:
 
@@ -80,8 +93,20 @@ parameters in a method call.
         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
 
+  * Implicit validation: ruleset defined inside the method, kudos to [osuka](https://github.com/osuka)
+
+		require 'params-validator'
+		class MockObject
+		  include ParamsValidator::ValidParams
+		
+		  def method1(args)
+		  	validate_method(args) do
+		    	level(Fixnum, :optional)
+		  	end
+		  end
+		end
 
-  * Client side validation (kudos to @drslump)
+  * Client side validation, kudos to [drslump](https://github.com/drslump)
 
         obj = ParamsValidator::Request.new
         obj[:data] = "this is a log"

data/Rakefile

@@ -1,2 +1,14 @@
 require 'bundler'
+require 'rake'
+require 'rspec/core/rake_task'
+
 Bundler::GemHelper.install_tasks
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc "Run all specs"
+
+RSpec::Core::RakeTask.new do |t|
+    t.pattern = './spec/**/*_spec.rb'
+end

data/lib/params_validator/method_validation.rb

@@ -25,7 +25,7 @@ module ParamsValidator
     def initialize(method_name, &block)
       @method_name = method_name
       @parameters = []
-      block_given? and self.instance_eval &block
+      block_given? and self.instance_exec &block
     end
 
     # get mandatory parameters
@@ -41,7 +41,7 @@ module ParamsValidator
     # Execute validation block in this object scope
     #
     def block(&block)
-      block_given? and self.instance_eval &block
+      block_given? and self.instance_exec &block
     end
 
     #
@@ -63,6 +63,10 @@ module ParamsValidator
       parameter = Parameter.new(meth, args.length < 1 ? Object : args[0], optional, block)
       @parameters.push parameter
     end
+    
+    def to_s
+      "method <#{self.method_name}> => #{parameters.to_s}"
+    end
 
   end
 end

data/lib/params_validator/valid_params.rb

@@ -41,6 +41,21 @@ module ParamsValidator
 
     def load_rules(rules)
       self.class.load_rules(rules)
+    end    
+    
+    # This method is used for implicit validations (ruleset specification inside a method)
+    #
+    # @param params method call parameters
+    # @param &block DSL that defines the validation ruleset
+    # return true if params fit the ruleset defined in &block
+    # raise ArgumentError if an error occurred
+    #
+    def validate_method(params = nil, &block)
+      method = MethodValidation.new("foo_bar")
+      
+      block_given? and method.block &block
+      
+      Validator.validate_ruleset(method.parameters, params)
     end
 
     # inner module to define class methods
@@ -50,16 +65,23 @@ module ParamsValidator
       # should be validated when called.
       # i.e. validate_method :method1
       #      validate_method [:method1, :method2]
-      def validate_method(method, &block)
+      def validate_method(method=nil, &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("::")
+          
+          if validator.has_method_rule?(interface_method)
+            # already has a validation => delete it
+            old_method = "#{m}_old"
+            self.send :alias_method, *[m, old_method]
+            remove_method("#{m}_old".to_sym)
+          end
 
           # add validation rule to the specific method if a block is defined
           if block_given?

data/lib/params_validator/validator.rb

@@ -8,7 +8,8 @@ require 'params_validator/valid_params'
 module ParamsValidator
 
   #
-  # This class
+  # This class keeps the rulesets defined in the program and performs the validation between
+  # a specific ruleset and a set of parameters
   #
   class Validator
 
@@ -43,6 +44,11 @@ module ParamsValidator
       block_given? and method.block &block
       @methods_loaded[:"#{method_name}"] = method
     end
+    
+    def has_method_rule?(method_name)
+      !method_name.is_a?(Symbol) and method_name = method_name.to_sym
+      @methods_loaded.has_key?(method_name)
+    end
 
     #
     # This method validates if the specific call to method_name is valid
@@ -54,7 +60,7 @@ module ParamsValidator
 
       # 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}"
@@ -68,64 +74,74 @@ module ParamsValidator
 
     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
+    class << self
+      #
+      # This method validates a params hash against a specific ruleset
+      # @param valid_params ruleset
+      # @param params
+      #
+      def validate_ruleset(valid_params, params)
+        errors = []
+      
+        # if params.nil? but the ruleset defines all the parameters as optional
+        # this method should return true
+        if !valid_params.nil? and params.nil?
+          valid_params.each{|param|
+            !param.optional? and (
+              errors.push "Nil parameters when #{valid_params.length} expected"
+              raise ArgumentError, errors
+            )
+          }
+          return true
+        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
+        # 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
-      }
-      unless errors.empty?
-        raise ArgumentError, errors
-      end
-      # no exception -> successfully validated
-      true
 
-    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
 
-    #
-    # 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]
+      #
+      # 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 check_param(valid_param, param)
+        if valid_param.optional? and param.nil? # argument optional and not present -> continue
+          return nil
         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
+        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
-      nil
     end
 
   end

data/lib/params_validator/version.rb

@@ -4,5 +4,5 @@
 #
 
 module ParamsValidator
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
 end

data/spec/implicit_valid_params_spec.rb

@@ -0,0 +1,65 @@
+$:.unshift File.join(File.dirname(__FILE__),'../test')
+
+require 'params-validator'
+require 'mock/implicit_validation_mock_object'
+require 'yamock_object'
+
+include Mock
+
+describe ParamsValidator::ValidParams do
+
+  let(:obj) do
+    ImplicitValidationMockObject.new
+  end
+
+  describe "validate_method inside method (implicit definition)" do
+    
+    it "executes an empty block and validates true always" do
+      obj.log_implicit_validation().should eq(nil)
+    end
+    
+    it "executes an empty block and validates true if arguments defined" do
+      obj.log_implicit_validation({:level => 1}).should eq(nil)
+    end
+    
+    it "raises an exception if mandatory parameter missing" do
+      lambda{obj.log_implicit_validation_one_arg()}.should raise_error(ArgumentError)
+    end
+    
+    it "raises an exception if invalid type" do
+      lambda{obj.log_implicit_validation_one_arg({:level => "1"})}.should raise_error(ArgumentError)
+    end
+
+    it "raises an exception if invalid type (II)" do
+      lambda{obj.log_implicit_validation_one_arg({:level => 1.2})}.should raise_error(ArgumentError)
+    end
+    
+    it "works if optional attr missing" do
+      obj.log_implicit_validation_one_optional_arg({}).should eq(nil)
+    end
+    
+    it "works if optional attr missing (nil arguments object)" do
+      obj.log_implicit_validation_one_optional_arg(nil).should eq(nil)
+    end        
+  end
+  
+  describe "arguments that validates against a block" do
+
+    it "works when the argument fits the block" do
+      obj.log_implicit_validation_two_args(:level => 1, :data => "foo").should eq(nil)
+    end
+    
+    it "works when the argument fits the block and one optional argument is not provided" do
+      obj.log_implicit_validation_two_args(:data => "foo").should eq(nil)
+    end
+    
+    it "works when the argument fits the block and both optional arguments is not provided" do
+      obj.log_implicit_validation_two_args().should eq(nil)
+    end
+
+    it "raises an exception when argument not fit the block" do
+      lambda{obj.log_implicit_validation_two_args({:data => ""})}.should raise_error(ArgumentError)
+    end
+  end
+
+end

data/spec/inheritance_spec.rb

@@ -0,0 +1,52 @@
+$:.unshift File.join(File.dirname(__FILE__),'../test')
+
+require 'params-validator'
+require 'mock/mock_submodule/mock_object'
+
+include Mock::MockSubmodule
+
+describe ParamsValidator::Validator do
+  describe "new defined method" do
+    it "works with a new defined method with no arguments" do
+      obj = MockObject.new
+      obj.log_new_method().should eq(nil)
+    end
+
+    it "works with a new defined method with one argument" do
+      obj = MockObject.new
+      obj.log_new_method({:level => "2"}).should eq(nil)
+    end
+
+    it "raises an exception with a new defined method one invalid argument" do
+      obj = MockObject.new
+      lambda{obj.log_new_method({:level => 2})}.should raise_exception(ArgumentError)
+    end    
+  end
+
+  describe "ruleset inheritance" do
+    it "works with a inherited ruleset with valid arguments" do
+      obj = MockObject.new
+      obj.log_data_block({:level => 1, :data => "foo"}).should eq(true)
+    end
+
+    it "raises an exception with an inherited ruleset with invalid data" do
+      obj = MockObject.new
+      lambda{obj.log_new_method({:level => 2})}.should raise_exception(ArgumentError)
+    end    
+  end
+  
+  describe "ruleset overwritten" do
+    it "works when child ruleset changed and valid params" do
+      obj = Mock::MockObject.new
+      obj.inherit_method({:level => 1}).should eq(true)
+    end
+
+    it "works when child ruleset changed and invalid params" do
+      obj = Mock::MockObject.new
+      lambda{obj.inherit_method({:level => "6"})}.should raise_exception(ArgumentError)
+    end
+
+  end
+  
+
+end

data/{test → spec}/method_validation_spec.rb

@@ -21,7 +21,8 @@ describe ParamsValidator::MethodValidation  do
     }
 
     it "params length should be 4" do
-      method = ParamsValidator::MethodValidation.new("Module::Class:method", &proc)
+      method = ParamsValidator::MethodValidation.new("Module::Class:method")
+      method.block &proc
       method.parameters.length.should == 4
     end
 

data/{test → spec}/parameter_spec.rb

@@ -4,6 +4,8 @@ require 'params-validator'
 
 describe ParamsValidator::Parameter  do
   describe "optional" do
+    
+    let("value"){puts "1"}
     #optional
     it "optional? returns true if parameter is optional" do
       param = ParamsValidator::Parameter.new("parameter", Object, true, nil)

data/{test → spec}/request_spec.rb

@@ -1,4 +1,4 @@
-$:.unshift File.join(File.dirname(__FILE__),'.')
+$:.unshift File.join(File.dirname(__FILE__),'../test')
 
 require 'params-validator'
 require 'mock/mock_object'

data/{test → spec}/valid_params_spec.rb

@@ -1,4 +1,4 @@
-$:.unshift File.join(File.dirname(__FILE__),'.')
+$:.unshift File.join(File.dirname(__FILE__),'../test')
 
 require 'params-validator'
 require 'mock/mock_object'

data/test/mock/implicit_validation_mock_object.rb

@@ -0,0 +1,31 @@
+require 'params-validator'
+
+module Mock
+  class ImplicitValidationMockObject
+    include ParamsValidator::ValidParams
+
+    def log_implicit_validation(args=nil)
+    end
+
+    def log_implicit_validation_one_arg(args)
+      validate_method(args) do
+        level Fixnum  
+      end
+    end
+
+    def log_implicit_validation_one_optional_arg(args={})
+      validate_method(args) do
+        level(Fixnum, :optional)
+      end
+      nil
+    end
+
+    def log_implicit_validation_two_args(args=nil)
+      validate_method(args) do
+        data(String, :optional) { |data| !data.nil? and data.length > 0}
+        level(Fixnum, :optional)
+      end
+      nil
+    end
+  end
+end  

data/test/mock/mock_object.rb

@@ -4,13 +4,13 @@ module Mock
   class MockObject
     include ParamsValidator::ValidParams
 
-    [:log, :log_level, :log_level_type, :log_level_type_optional, :log_data, :log_data_block].each{|m|
+    [:log, :log_level, :log_level_type, :log_level_type_optional, :log_data, :log_data_block, :inherit_method].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
@@ -30,5 +30,9 @@ module Mock
       data(String) { |data| !data.nil? and data.length > 0}
       level(Fixnum, :optional) {|level| level <= 3}
     end
+    
+    validate_method(:inherit_method) do
+      level(Fixnum, :optional)
+    end
   end
 end  

data/test/mock/mock_submodule/mock_object.rb

@@ -0,0 +1,25 @@
+require 'params-validator'
+require 'mock/mock_object'
+
+module Mock
+  module MockSubmodule
+    class MockObject < Mock::MockObject
+      
+      def log_new_method(params=nil)
+        nil
+      end
+
+      validate_method(:log_new_method) do
+        level(String, :optional)
+      end
+      
+      def log_data(params)
+        true
+      end
+      
+      validate_method(:inherit_method) do
+        level(Fixnum, :optional) {|level| level <= 3}
+      end
+    end
+  end
+end  

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: params-validator
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 23
   prerelease: 
   segments: 
   - 0
-  - 1
+  - 2
   - 0
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Juan de Bravo
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-24 00:00:00 +01:00
+date: 2011-04-19 00:00:00 +01:00
 default_executable: 
 dependencies: []
 
@@ -30,8 +30,8 @@ extra_rdoc_files: []
 
 files: 
 - .gitignore
-- .rvmrc
 - Gemfile
+- Gemfile.lock
 - README.md
 - Rakefile
 - lib/params-validator.rb
@@ -42,14 +42,18 @@ files:
 - lib/params_validator/validator.rb
 - lib/params_validator/version.rb
 - params-validator.gemspec
+- spec/implicit_valid_params_spec.rb
+- spec/inheritance_spec.rb
+- spec/method_validation_spec.rb
+- spec/parameter_spec.rb
+- spec/request_spec.rb
+- spec/valid_params_spec.rb
 - test/main.rb
-- test/method_validation_spec.rb
+- test/mock/implicit_validation_mock_object.rb
 - test/mock/mock_object.rb
-- test/parameter_spec.rb
+- test/mock/mock_submodule/mock_object.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: ""
@@ -81,17 +85,21 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: params-validator
-rubygems_version: 1.4.2
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: params-validators allows to validate the required/optional parameters in a method
 test_files: 
+- spec/implicit_valid_params_spec.rb
+- spec/inheritance_spec.rb
+- spec/method_validation_spec.rb
+- spec/parameter_spec.rb
+- spec/request_spec.rb
+- spec/valid_params_spec.rb
 - test/main.rb
-- test/method_validation_spec.rb
+- test/mock/implicit_validation_mock_object.rb
 - test/mock/mock_object.rb
-- test/parameter_spec.rb
+- test/mock/mock_submodule/mock_object.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

data/.rvmrc

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