valid 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 08af3476e39855609076f5f0258bebe71805abc2
-  data.tar.gz: 3a068b16cc74896589d36a182dfae61a53783c14
+  metadata.gz: b1334f9de1e7da57f86aec24980f4b69f32ad95b
+  data.tar.gz: c941a5983d49df7fefa43035c00fd16f5756208c
 SHA512:
-  metadata.gz: 74388c59fc69f8c1c0aed7901e9aec6e993bc8024eeb7a7fc6fd5e59c6a36dbbb6b1e62169a73b0325533c8c8a66cca52a55626518e7a9cafc7582e705484c52
-  data.tar.gz: 188f7b55a14dc7eb68aa062c3419105ffecff87690f39835f0c74261b9cc2687732b4e0cc6d5b83c68ba8f0369ac611419ce20c1c7a71b90b94811b0a714e161
+  metadata.gz: 350ca99bcea57a6b3e9c5ddd4329e6d3509fd59d9624738717d16f982603b2ce6403765bafd18b39991abc90f0de94612034070abaf93b242189269587175445
+  data.tar.gz: 33fff341d03a984e5726ccc1e6105057e47e8c1a0cfaa9b355b1c54d1c80ecbb059870efc47d979d1827f2c4304fbc4441b7808770aba7f29ece973ec0ba74ff

data/README.md

@@ -13,9 +13,9 @@ Validator is useful for validating the state of any existing ruby object.
 ```ruby
   object = OpenStruct.new(:email => 'foo@bar.com', :password => 'foobar')
   validator = Validation::Validator.new(object)
-  validator.rule(:email, [:email, :not_empty]) # multiple rules in one line
-  validator.rule(:password, :not_empty) # a single rule on a line
-  validator.rule(:password, :length => {:minimum => 3}) # a rule that takes parameters
+  validator.rule(:email, [:email, :not_empty])             # multiple rules in one line
+  validator.rule(:password, :not_empty)                    # a single rule on a line
+  validator.rule(:password, :length => { :minimum => 3 })  # a rule that takes parameters
 
   if validator.valid?
     # save the data somewhere
@@ -28,24 +28,20 @@ The first paramater can be any message that the object responds to.
 
 ### Writing your own rules
 
-If you have a custom rule you need to write, just put it inside the `Validation::Rule` namespace:
+If you have a custom rule you need to write, you can create a custom rule class for it:
 
 ```ruby
-  module Validation
-    module Rule
-      class MyCustomRule
-        def error_key
-          :my_custom_rule
-        end
-
-        def valid_value?(value)
-          # Logic for determining the validity of the value
-        end
-
-        def params
-          {}
-        end
-      end
+  class MyCustomRule
+    def error_key
+      :my_custom_rule
+    end
+
+    def valid_value?(value)
+      # Logic for determining the validity of the value
+    end
+
+    def params
+      {}
     end
   end
 ```
@@ -56,6 +52,20 @@ A rule class should have the following methods on it:
   - `valid_value?(value)` the beef of the rule. This is where you determine if the value is valid or not
   - `params` the params hash that was passed into the constructor
 
+If you add your custom rule class to the `Validation::Rule` namespace, you can reference it using a symbol:
+
+```ruby
+  validator.rule(:field, :my_custom_rule)  # resolves to Validation::Rule::MyCustomRule
+  validator.rule(:field, :my_custom_rule => { :param => :value })
+```
+
+Otherwise, just pass in the rule class itself:
+
+```ruby
+  validator.rule(:field, MyProject::CustomRule)
+  validator.rule(:field, MyProject::CustomRule => { :param => :value })
+```
+
 ### Writing self-contained validators
 
 You can also create self-contained validation classes if you don't like the dynamic creation approach:

data/lib/validation/validator.rb

@@ -17,31 +17,25 @@ module Validation
     # * a symbol that matches to a class in the Validation::Rule namespace
     #  * e.g. rule(:field, :not_empty)
     # * a hash containing the rule as the key and it's parameters as the values
-    #  * e.g. rule(:field, :length => {:minimum => 3, :maximum => 5})
+    #  * e.g. rule(:field, :length => { :minimum => 3, :maximum => 5 })
     # * an array combining the two previous types
-    def rule(field, rule)
+    def rule(field, definition)
       field = field.to_sym
-      if rules[field].nil?
-        rules[field] = []
-      end
+      rules[field] = [] if rules[field].nil?
 
       begin
-        if rule.respond_to?(:each_pair)
-          add_parameterized_rule(field, rule)
-        elsif rule.respond_to?(:each)
-          rule.each do |r|
-            if r.respond_to?(:each_pair)
-              add_parameterized_rule(field, r)
+        if definition.respond_to?(:each_pair)
+          add_parameterized_rules(field, definition)
+        elsif definition.respond_to?(:each)
+          definition.each do |item|
+            if item.respond_to?(:each_pair)
+              add_parameterized_rules(field, item)
             else
-              r = Validation::Rule.const_get(camelize(r)).new
-              add_object_to_rule(r)
-              rules[field] << r
+              add_single_rule(field, item)
             end
           end
         else
-          rule = Validation::Rule.const_get(camelize(rule)).new
-          add_object_to_rule(rule)
-          rules[field] << rule
+          add_single_rule(field, definition)
         end
       rescue NameError => e
         raise InvalidRule.new(e)
@@ -57,7 +51,7 @@ module Validation
 
       rules.each_pair do |field, rules|
         if ! @obj.respond_to?(field)
-          raise InvalidKey
+          raise InvalidKey, "cannot validate non-existent field '#{field}'"
         end
 
         rules.each do |r|
@@ -74,22 +68,35 @@ module Validation
 
     protected
 
-    # Adds a parameterized rule to this object
-    def add_parameterized_rule(field, rule)
-      rule.each_pair do |key, value|
-        r = Validation::Rule.const_get(camelize(key)).new(value)
-        add_object_to_rule(r)
-        rules[field] << r
+    # Adds a single rule to this object
+    def add_single_rule(field, key_or_klass, params = nil)
+      klass = if key_or_klass.respond_to?(:new)
+        key_or_klass
+      else
+        get_rule_class_by_name(key_or_klass)
       end
+
+      args = [params].compact
+      rule = klass.new(*args)
+      rule.obj = @obj if rule.respond_to?(:obj=)
+      rules[field] << rule
     end
 
-    # Adds this validation object to a rule if it can accept it
-    def add_object_to_rule(rule)
-      if rule.respond_to?(:obj=)
-        rule.obj = @obj
+    # Adds a set of parameterized rules to this object
+    def add_parameterized_rules(field, rules)
+      rules.each_pair do |key, params|
+        add_single_rule(field, key, params)
       end
     end
 
+    # Resolves the specified rule name to a rule class
+    def get_rule_class_by_name(klass)
+      klass = camelize(klass)
+      Validation::Rule.const_get(klass)
+    rescue NameError => e
+      raise InvalidRule.new(e)
+    end
+
     # Converts a symbol to a class name, taken from rails
     def camelize(term)
       string = term.to_s

data/lib/validation/version.rb

@@ -1,3 +1,3 @@
 module Validation
-  VERSION = '1.1.0'
+  VERSION = '1.2.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: valid
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Jeremy Bush
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-01 00:00:00.000000000 Z
+date: 2016-06-27 00:00:00.000000000 Z
 dependencies: []
 description: 
 email:
@@ -50,7 +50,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: A standalone, generic object validator for ruby