deeply_valid 0.1.5 → 0.1.7

data/VERSION

@@ -1 +1 @@
-0.1.5
+0.1.7

data/deeply_valid.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{deeply_valid}
-  s.version = "0.1.5"
+  s.version = "0.1.7"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Starr Horne"]
-  s.date = %q{2010-06-11}
+  s.date = %q{2010-06-15}
   s.description = %q{This gem lets you declaratively specify validations for complex data structures, like those returned from an api.}
   s.email = %q{starr@chromahq.com}
   s.extra_rdoc_files = [

data/lib/deeply_valid/base.rb

@@ -51,8 +51,18 @@ module DeeplyValid
         (@definitions ||= {})[name.to_sym]
       end
 
-      def structure(name)
-        Validation.new { |d| self[name.to_sym].valid?(d) }
+      def structure(name = nil, &block)
+        if name
+          Validation.new { |d| self[name.to_sym].valid?(d) }
+        elsif block_given?
+          block
+        else
+          raise "structure requires name or block"
+        end
+      end
+
+      def value(&block)
+        block
       end
 
     end

data/lib/deeply_valid/validation.rb

@@ -6,6 +6,8 @@ module DeeplyValid
   #
   class Validation
 
+    attr_accessor :options
+
     #
     # The initializer defines the conditions that will
     # satasfy this validation.
@@ -15,12 +17,13 @@ module DeeplyValid
     # @param [Object] rule    When `rule` is any other non-nil object, use `==` to validate
     # @param [Proc]   &block  An optional block, which will take one param and return true or false
     #
-    def initialize(rule = nil, &block)
+    def initialize(rule = nil, options = {}, &block)
 
       if rule.nil? && !block_given?
         raise "No validation rule specified"
       end
 
+      @options = options
       @rule = rule
       @block = block
     end
@@ -58,8 +61,10 @@ module DeeplyValid
     def valid_structure?(data, fragment_rule = nil)
       (fragment_rule || @rule).all? do |k, v|
 
+        v = v.call(@data) if v.is_a?(Proc)
+
         if v.is_a?(Validation)
-          v.valid?(data[k])
+          (v.options[:optional] && !data.has_key?(k)) || v.valid?(data[k])
 
         elsif v.is_a?(Regexp)
           !!(data[k] =~ v)
@@ -67,6 +72,9 @@ module DeeplyValid
         elsif v.is_a?(Hash)
           valid_structure?(data[k], v)
 
+        elsif v.nil?
+          !data.has_key?(k)
+
         else
           data[k] == v
         end
@@ -81,10 +89,17 @@ module DeeplyValid
     #
     def valid?(data)
 
-      if @rule.kind_of?(Regexp)
+      @data = data
+
+      rule = @rule.is_a?(Proc) ? @rule.call(@data) : @rule
+
+      result = if rule.kind_of?(Regexp)
         valid_pattern?(data)
 
-      elsif @rule.kind_of?(Hash)
+      elsif rule.kind_of?(Validation)
+        rule.valid?(data)
+
+      elsif rule.kind_of?(Hash)
         valid_structure?(data)
 
       elsif @block
@@ -94,6 +109,10 @@ module DeeplyValid
         data == @rule
       end
 
+      @data = nil
+
+      result
+
     end
 
   end

data/lib/deeply_valid/validation_helpers.rb

@@ -1,4 +1,5 @@
 require 'json'
+require 'date'
 
 module DeeplyValid
 
@@ -66,23 +67,23 @@ module DeeplyValid
       end
 
       #
-      # Validates datetime with optional limit
+      # Validates time with optional limit
       #
       # @param [Integer, Range] limit 
       # @return [Validation] The validation
       #
-      def datetime(limit = nil)
-        Validation.new { |d| d.is_a?(DateTime) && in_range?(d, limit) }
+      def time(limit = nil)
+        Validation.new { |d| d.is_a?(Time) && in_range?(d, limit) }
       end
 
       #
-      # Validates time with optional limit
+      # Validates nil. Normally a nil means "don't validate". Use this
+      # if you're expecting an actual nil
       #
-      # @param [Integer, Range] limit 
       # @return [Validation] The validation
       #
-      def time(limit = nil)
-        Validation.new { |d| d.is_a?(Time) && in_range?(d, limit) }
+      def nil_value
+        Validation.new { |d| d.nil? }
       end
 
       #
@@ -228,8 +229,29 @@ module DeeplyValid
           range = [range] unless range.respond_to?(:include?)
           range.include?(val)
         end
+      end
+
+      #
+      # Set a validation as optional. This only has any effect
+      # if the validation is part of a structure.
+      #
+      # The following validation:
+      #   
+      #   {:key => optional(integer)}
+      #
+      # Will validate both:
+      #
+      #   {:key => 1}
+      #   {}
+      #
+      # @param [Validation] validation
+      # @return [Validation]
+      #
+      def optional(validation)
+        validation.options[:optional] = true
+        validation
+      end
 
-        end
     end
   end
 end

data/test/base_test.rb

@@ -12,6 +12,7 @@ class BaseTest < Test::Unit::TestCase
         define :manual, DeeplyValid::Validation.new { |d| d > 10 } 
         define :literal, "x"
         define :hash, { :key => "val" }
+        define :nested_self_reference, structure { |data| structure(:regexp) }
       end
     end
 
@@ -35,6 +36,12 @@ class BaseTest < Test::Unit::TestCase
       assert Sample[:self_reference].valid?("abc")
       assert !Sample[:self_reference].valid?("123")
     end
+
+    should "Handle nested self-reference" do
+      assert Sample[:nested_self_reference]
+      assert Sample[:nested_self_reference].valid?("abc")
+      assert !Sample[:nested_self_reference].valid?("123")
+    end
     
   end
 

data/test/helper.rb

@@ -1,6 +1,7 @@
 require 'rubygems'
 require 'test/unit'
 require 'shoulda'
+begin; require 'turn'; rescue LoadError; end
 
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))

data/test/system_test.rb

@@ -16,7 +16,10 @@ class SystemTest < Test::Unit::TestCase
             :name => any('sales', 'accounting', 'engineering'),
             :building => integer
           },
-          :performace_reviews => array( structure(:review) )
+          :performace_reviews => array( structure(:review) ),
+          :pension => value { |data| integer if data[:age] > 50 },
+          :hobby => optional(string)
+          
         }
 
         # This structure is referenced in the "person" structure
@@ -26,7 +29,7 @@ class SystemTest < Test::Unit::TestCase
         }
       end
 
-      @valid_person = {
+      @valid_person1 = {
         :id => "x"*32,
         :age => 22,
         :name => "Bob Jones",
@@ -40,10 +43,44 @@ class SystemTest < Test::Unit::TestCase
         ]
       }
 
-      @invalid_person = {
+      # this person is over 50, so there's a value for pension
+      @valid_person2 = {
+        :id => "x"*32,
+        :age => 61,
+        :name => "Bob Jones",
+        :pension => 666,
+        :hobby => "boating",
+        :department => {
+          :name => "sales",
+          :building => 33
+        },
+        :performace_reviews  => [
+          { :author => "joe", :body => "a review" }, 
+          { :author => "bill", :body => "another review" } 
+        ]
+      }
+
+      # this person is under 50, and has a value for pension,
+      # so the record is invalid.
+      @invalid_person1 = {
         :id => "x"*32,
         :age => 22,
         :name => "Bob Jones",
+        :pension => 666,
+        :department => {
+          :name => "sales",
+          :building => 33
+        },
+        :performace_reviews  => [
+          { :author => "joe", :body => "a review" }, 
+          { :author => "bill", :body => "another review" } 
+        ]
+      }
+
+      @invalid_person2 = {
+        :id => "x"*32,
+        :age => 32,
+        :name => "Bob Jones",
         :department => {
           :name => "sales",
           :building => 33
@@ -57,8 +94,10 @@ class SystemTest < Test::Unit::TestCase
     end
 
     should "validate correctly" do
-      assert MyValidations[:person].valid?(@valid_person)
-      assert !MyValidations[:person].valid?(@invalid_person)
+      assert MyValidations[:person].valid?(@valid_person1)
+      assert MyValidations[:person].valid?(@valid_person2)
+      assert !MyValidations[:person].valid?(@invalid_person1)
+      assert !MyValidations[:person].valid?(@invalid_person2)
     end
     
   end

data/test/validation_helpers_test.rb

@@ -92,17 +92,8 @@ class ValidationHelpersTest < Test::Unit::TestCase
     context "date helper" do
 
       should "validate correctly" do
-        assert Sample.date.valid?(Date.today)
-        assert !Sample.date(:before => Date.today).valid?(Date.today)
-      end
-
-    end
-
-    context "datetime helper" do
-
-      should "validate correctly" do
-        assert Sample.datetime.valid?(DateTime.now)
-        assert !Sample.datetime(:before => DateTime.now).valid?(DateTime.now)
+        assert Sample.date.valid?(Date.civil(2010, 3, 10))
+        assert !Sample.date(:before => Date.civil(2010, 3, 10)).valid?(Date.civil(2010, 4, 10))
       end
 
     end

data/test/validation_test.rb

@@ -101,4 +101,42 @@ class ValidationTest < Test::Unit::TestCase
 
   end
 
+  context "A structure validation for {:key => nil}" do
+    setup do
+      rule = { :key => nil, :bogus => 1 }
+      @validation = Validation.new(rule)
+    end
+
+    should_validate_all([
+      {:bogus => 1}
+    ])
+
+    should_not_validate_any([
+      {:key => false, :bogus => 1},
+      {:key => true, :bogus => 1},
+      {:key => nil, :bogus => 1},
+      {:key => "sesame", :bogus => 1},
+    ])
+
+  end
+
+  context "A structure with an optional validation" do
+    setup do
+      rule = { :key => Validation.new(1, :optional => true) }
+      @validation = Validation.new(rule)
+    end
+
+    should_validate_all([
+      {:key => 1},
+      {}
+    ])
+
+    should_not_validate_any([
+      {:key => 2},
+      {:key => nil},
+      {:key => false}
+    ])
+
+  end
+
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 5
-  version: 0.1.5
+  - 7
+  version: 0.1.7
 platform: ruby
 authors: 
 - Starr Horne
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-06-11 00:00:00 -05:00
+date: 2010-06-15 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency