dm-validations 1.1.0.rc2 → 1.1.0.rc3

data/Gemfile

@@ -5,7 +5,7 @@ source 'http://rubygems.org'
 SOURCE         = ENV.fetch('SOURCE', :git).to_sym
 REPO_POSTFIX   = SOURCE == :path ? ''                                : '.git'
 DATAMAPPER     = SOURCE == :path ? Pathname(__FILE__).dirname.parent : 'http://github.com/datamapper'
-DM_VERSION     = '~> 1.1.0.rc2'
+DM_VERSION     = '~> 1.1.0.rc3'
 DO_VERSION     = '~> 0.10.2'
 DM_DO_ADAPTERS = %w[ sqlite postgres mysql oracle sqlserver ]
 

data/VERSION

@@ -1 +1 @@
-1.1.0.rc2
+1.1.0.rc3

data/dm-validations.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dm-validations}
-  s.version = "1.1.0.rc2"
+  s.version = "1.1.0.rc3"
 
   s.required_rubygems_version = Gem::Requirement.new("> 1.3.1") if s.respond_to? :required_rubygems_version=
   s.authors = ["Guy van den Berg"]
-  s.date = %q{2011-03-01}
+  s.date = %q{2011-03-10}
   s.description = %q{Library for performing validations on DM models and pure Ruby object}
   s.email = %q{vandenberg.guy [a] gmail [d] com}
   s.extra_rdoc_files = [
@@ -31,6 +31,7 @@ Gem::Specification.new do |s|
     "lib/dm-validations/formats/url.rb",
     "lib/dm-validations/support/context.rb",
     "lib/dm-validations/support/object.rb",
+    "lib/dm-validations/support/ordered_hash.rb",
     "lib/dm-validations/validation_errors.rb",
     "lib/dm-validations/validators/absent_field_validator.rb",
     "lib/dm-validations/validators/acceptance_validator.rb",
@@ -165,7 +166,7 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/datamapper/dm-validations}
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{datamapper}
-  s.rubygems_version = %q{1.5.2}
+  s.rubygems_version = %q{1.6.2}
   s.summary = %q{Library for performing validations on DM models and pure Ruby object}
   s.test_files = [
     "spec/fixtures/barcode.rb",
@@ -285,21 +286,21 @@ Gem::Specification.new do |s|
     s.specification_version = 3
 
     if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<dm-core>, ["~> 1.1.0.rc2"])
-      s.add_development_dependency(%q<dm-types>, ["~> 1.1.0.rc2"])
+      s.add_runtime_dependency(%q<dm-core>, ["~> 1.1.0.rc3"])
+      s.add_development_dependency(%q<dm-types>, ["~> 1.1.0.rc3"])
       s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
       s.add_development_dependency(%q<rake>, ["~> 0.8.7"])
       s.add_development_dependency(%q<rspec>, ["~> 1.3.1"])
     else
-      s.add_dependency(%q<dm-core>, ["~> 1.1.0.rc2"])
-      s.add_dependency(%q<dm-types>, ["~> 1.1.0.rc2"])
+      s.add_dependency(%q<dm-core>, ["~> 1.1.0.rc3"])
+      s.add_dependency(%q<dm-types>, ["~> 1.1.0.rc3"])
       s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
       s.add_dependency(%q<rake>, ["~> 0.8.7"])
       s.add_dependency(%q<rspec>, ["~> 1.3.1"])
     end
   else
-    s.add_dependency(%q<dm-core>, ["~> 1.1.0.rc2"])
-    s.add_dependency(%q<dm-types>, ["~> 1.1.0.rc2"])
+    s.add_dependency(%q<dm-core>, ["~> 1.1.0.rc3"])
+    s.add_dependency(%q<dm-types>, ["~> 1.1.0.rc3"])
     s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
     s.add_dependency(%q<rake>, ["~> 0.8.7"])
     s.add_dependency(%q<rspec>, ["~> 1.3.1"])

data/lib/dm-validations.rb

@@ -1,29 +1,5 @@
 require 'dm-core'
-
-begin
-  # We need array for extract_options! which attr_accessors uses, at least in AS
-  # 2.3.3.
-  require 'active_support/core_ext/array'
-  require 'active_support/core_ext/class/attribute_accessors'
-rescue LoadError
-  require 'extlib/class'
-end
-
-begin
-  require 'active_support/core_ext/object/blank'
-rescue LoadError
-  require 'extlib/blank'
-end
-
-begin
-  require 'active_support/ordered_hash'
-rescue LoadError
-  require 'extlib/dictionary'
-
-  module ::ActiveSupport
-    OrderedHash = ::Dictionary
-  end
-end
+require 'dm-validations/support/ordered_hash'
 
 class Object
   # If receiver is callable, calls it and

data/lib/dm-validations/contextual_validators.rb

@@ -74,14 +74,22 @@ module DataMapper
         #      - those applied to dirty attributes only,
         #      - those that should always run (presence/absence)
         #      - those that don't reference any real properties (field-less
-        #        block validators)
-
-        if target.kind_of?(DataMapper::Resource) and !target.new?
+        #        block validators, validations in virtual attributes)
+        if target.kind_of?(DataMapper::Resource) && !target.new?
+          attrs       = target.attributes.keys
           dirty_attrs = target.dirty_attributes.keys.map{ |p| p.name }
-          validators  = runnable_validators.select{ |v| dirty_attrs.include?(v.field_name) }
+          validators  = runnable_validators.select{|v|
+            !attrs.include?(v.field_name) || dirty_attrs.include?(v.field_name)
+          }
+
+          # Load all lazy, not-yet-loaded properties that need validation,
+          # all at once.
+          fields_to_load = validators.map{|v|
+            target.class.properties[v.field_name]
+          }.compact.select {|p|
+            p.lazy? && !p.loaded?(target)
+          }
 
-          # Load all lazy, not-yet-loaded properties that need validation, all at once.
-          fields_to_load = validators.map{ |v| target.class.properties[v.field_name] }.select{ |p| p.lazy? && !p.loaded?(target) }
           target.__send__(:eager_load, fields_to_load)
 
           # Finally include any validators that should always run or don't

data/lib/dm-validations/support/ordered_hash.rb

@@ -0,0 +1,434 @@
+module DataMapper; module Validations
+  # TITLE:
+  #
+  #   OrderedHash (originally Dictionary)
+  #
+  # AUTHORS:
+  #
+  #   - Jan Molic
+  #   - Thomas Sawyer
+  #
+  # CREDIT:
+  #
+  #   - Andrew Johnson (merge, to_a, inspect, shift and Hash[])
+  #   - Jeff Sharpe    (reverse and reverse!)
+  #   - Thomas Leitner (has_key? and key?)
+  #
+  # LICENSE:
+  #
+  #   Copyright (c) 2005 Jan Molic, Thomas Sawyer
+  #
+  #   Ruby License
+  #
+  #   This module is free software. You may use, modify, and/or redistribute this
+  #   software under the same terms as Ruby.
+  #
+  #   This program is distributed in the hope that it will be useful, but WITHOUT
+  #   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+  #   FOR A PARTICULAR PURPOSE.
+  #
+  #   Originally ported from OrderHash 2.0, Copyright (c) 2005 jan molic
+  #
+  # LOG:
+  #
+  #   - 2007.10.31 trans
+  #     Fixed initialize so the constructor blocks correctly effected dictionary
+  #     rather then just the internal hash.
+
+  # = Dictionary
+  #
+  # The Dictionary class is a Hash that preserves order.
+  # So it has some array-like extensions also. By defualt
+  # a Dictionary object preserves insertion order, but any
+  # order can be specified including alphabetical key order.
+  #
+  # == Usage
+  #
+  # Just require this file and use Dictionary instead of Hash.
+  #
+  #   # You can do simply
+  #   hsh = Dictionary.new
+  #   hsh['z'] = 1
+  #   hsh['a'] = 2
+  #   hsh['c'] = 3
+  #   p hsh.keys     #=> ['z','a','c']
+  #
+  #   # or using Dictionary[] method
+  #   hsh = Dictionary['z', 1, 'a', 2, 'c', 3]
+  #   p hsh.keys     #=> ['z','a','c']
+  #
+  #   # but this doesn't preserve order
+  #   hsh = Dictionary['z'=>1, 'a'=>2, 'c'=>3]
+  #   p hsh.keys     #=> ['a','c','z']
+  #
+  #   # Dictionary has useful extensions: push, pop and unshift
+  #   p hsh.push('to_end', 15)       #=> true, key added
+  #   p hsh.push('to_end', 30)       #=> false, already - nothing happen
+  #   p hsh.unshift('to_begin', 50)  #=> true, key added
+  #   p hsh.unshift('to_begin', 60)  #=> false, already - nothing happen
+  #   p hsh.keys                     #=> ["to_begin", "a", "c", "z", "to_end"]
+  #   p hsh.pop                      #=> ["to_end", 15], if nothing remains, return nil
+  #   p hsh.keys                     #=> ["to_begin", "a", "c", "z"]
+  #   p hsh.shift                    #=> ["to_begin", 30], if nothing remains, return nil
+  #
+  # == Usage Notes
+  #
+  # * You can use #order_by to set internal sort order.
+  # * #<< takes a two element [k,v] array and inserts.
+  # * Use ::auto which creates Dictionay sub-entries as needed.
+  # * And ::alpha which creates a new Dictionary sorted by key.
+  class OrderedHash
+
+    include Enumerable
+
+    class << self
+      #--
+      # TODO is this needed? Doesn't the super class do this?
+      #++
+      def [](*args)
+        hsh = new
+        if Hash === args[0]
+          hsh.replace(args[0])
+        elsif (args.size % 2) != 0
+          raise ArgumentError, "odd number of elements for Hash"
+        else
+          while !args.empty?
+            hsh[args.shift] = args.shift
+          end
+        end
+        hsh
+      end
+
+      # Like #new but the block sets the order.
+      #
+      def new_by(*args, &blk)
+        new(*args).order_by(&blk)
+      end
+
+      # Alternate to #new which creates a dictionary sorted by key.
+      #
+      #   d = Dictionary.alpha
+      #   d["z"] = 1
+      #   d["y"] = 2
+      #   d["x"] = 3
+      #   d  #=> {"x"=>3,"y"=>2,"z"=>2}
+      #
+      # This is equivalent to:
+      #
+      #   Dictionary.new.order_by { |key,value| key }
+      def alpha(*args, &block)
+        new(*args, &block).order_by_key
+      end
+
+      # Alternate to #new which auto-creates sub-dictionaries as needed.
+      #
+      #   d = Dictionary.auto
+      #   d["a"]["b"]["c"] = "abc"  #=> { "a"=>{"b"=>{"c"=>"abc"}}}
+      #
+      def auto(*args)
+        #AutoDictionary.new(*args)
+        leet = lambda { |hsh, key| hsh[key] = new(&leet) }
+        new(*args, &leet)
+      end
+    end
+
+     # New Dictiionary.
+    def initialize(*args, &blk)
+      @order = []
+      @order_by = nil
+      if blk
+        dict = self                                  # This ensure autmatic key entry effect the
+        oblk = lambda{ |hsh, key| blk[dict,key] }    # dictionary rather then just the interal hash.
+        @hash = Hash.new(*args, &oblk)
+      else
+        @hash = Hash.new(*args)
+      end
+    end
+
+    def order
+      reorder if @order_by
+      @order
+    end
+
+    # Keep dictionary sorted by a specific sort order.
+    def order_by( &block )
+      @order_by = block
+      order
+      self
+    end
+
+    # Keep dictionary sorted by key.
+    #
+    #   d = Dictionary.new.order_by_key
+    #   d["z"] = 1
+    #   d["y"] = 2
+    #   d["x"] = 3
+    #   d  #=> {"x"=>3,"y"=>2,"z"=>2}
+    #
+    # This is equivalent to:
+    #
+    #   Dictionary.new.order_by { |key,value| key }
+    #
+    # The initializer Dictionary#alpha also provides this.
+    def order_by_key
+      @order_by = lambda { |k,v| k }
+      order
+      self
+    end
+
+    # Keep dictionary sorted by value.
+    #
+    #   d = Dictionary.new.order_by_value
+    #   d["z"] = 1
+    #   d["y"] = 2
+    #   d["x"] = 3
+    #   d  #=> {"x"=>3,"y"=>2,"z"=>2}
+    #
+    # This is equivalent to:
+    #
+    #   Dictionary.new.order_by { |key,value| value }
+    def order_by_value
+      @order_by = lambda { |k,v| v }
+      order
+      self
+    end
+
+    #
+    def reorder
+      if @order_by
+        assoc = @order.collect{ |k| [k,@hash[k]] }.sort_by(&@order_by)
+        @order = assoc.collect{ |k,v| k }
+      end
+      @order
+    end
+
+    def ==(hsh2)
+      if hsh2.is_a?( Dictionary )
+        @order == hsh2.order &&
+        @hash  == hsh2.instance_variable_get("@hash")
+      else
+        false
+      end
+    end
+
+    def [] k
+      @hash[ k ]
+    end
+
+    def fetch(k, *a, &b)
+      @hash.fetch(k, *a, &b)
+    end
+
+    # Store operator.
+    #
+    #   h[key] = value
+    #
+    # Or with additional index.
+    #
+    #  h[key,index] = value
+    def []=(k, i=nil, v=nil)
+      if v
+        insert(i,k,v)
+      else
+        store(k,i)
+      end
+    end
+
+    def insert( i,k,v )
+      @order.insert( i,k )
+      @hash.store( k,v )
+    end
+
+    def store( a,b )
+      @order.push( a ) unless @hash.has_key?( a )
+      @hash.store( a,b )
+    end
+
+    def clear
+      @order = []
+      @hash.clear
+    end
+
+    def delete( key )
+      @order.delete( key )
+      @hash.delete( key )
+    end
+
+    def each_key
+      order.each { |k| yield( k ) }
+      self
+    end
+
+    def each_value
+      order.each { |k| yield( @hash[k] ) }
+      self
+    end
+
+    def each
+      order.each { |k| yield( k,@hash[k] ) }
+      self
+    end
+    alias each_pair each
+
+    def delete_if
+      order.clone.each { |k| delete k if yield(k,@hash[k]) }
+      self
+    end
+
+    def values
+      ary = []
+      order.each { |k| ary.push @hash[k] }
+      ary
+    end
+
+    def keys
+      order
+    end
+
+    def invert
+      hsh2 = self.class.new
+      order.each { |k| hsh2[@hash[k]] = k }
+      hsh2
+    end
+
+    def reject( &block )
+      self.dup.delete_if(&block)
+    end
+
+    def reject!( &block )
+      hsh2 = reject(&block)
+      self == hsh2 ? nil : hsh2
+    end
+
+    def replace( hsh2 )
+      @order = hsh2.order
+      @hash = hsh2.hash
+    end
+
+    def shift
+      key = order.first
+      key ? [key,delete(key)] : super
+    end
+
+    def unshift( k,v )
+      unless @hash.include?( k )
+        @order.unshift( k )
+        @hash.store( k,v )
+        true
+      else
+        false
+      end
+    end
+
+    def <<(kv)
+      push( *kv )
+    end
+
+    def push( k,v )
+      unless @hash.include?( k )
+        @order.push( k )
+        @hash.store( k,v )
+        true
+      else
+        false
+      end
+    end
+
+    def pop
+      key = order.last
+      key ? [key,delete(key)] : nil
+    end
+
+    def inspect
+      ary = []
+      each {|k,v| ary << k.inspect + "=>" + v.inspect}
+      '{' + ary.join(", ") + '}'
+    end
+
+    def dup
+      a = []
+      each{ |k,v| a << k; a << v }
+      self.class[*a]
+    end
+
+    def update( hsh2 )
+      hsh2.each { |k,v| self[k] = v }
+      reorder
+      self
+    end
+    alias :merge! update
+
+    def merge( hsh2 )
+      self.dup.update(hsh2)
+    end
+
+    def select
+      ary = []
+      each { |k,v| ary << [k,v] if yield k,v }
+      ary
+    end
+
+    def reverse!
+      @order.reverse!
+      self
+    end
+
+    def reverse
+      dup.reverse!
+    end
+
+    def first
+      @hash[order.first]
+    end
+
+    def last
+      @hash[order.last]
+    end
+
+    def length
+      @order.length
+    end
+    alias :size :length
+
+    def empty?
+      @hash.empty?
+    end
+
+    def has_key?(key)
+      @hash.has_key?(key)
+    end
+
+    def key?(key)
+      @hash.key?(key)
+    end
+
+    def to_a
+      ary = []
+      each { |k,v| ary << [k,v] }
+      ary
+    end
+
+    def to_json
+      buf = "["
+      map do |k,v|
+        buf << k.to_json
+        buf << ", "
+        buf << v.to_json
+      end.join(", ")
+      buf << "]"
+      buf
+    end
+
+    def to_s
+      self.to_a.to_s
+    end
+
+    def to_hash
+      @hash.dup
+    end
+
+    def to_h
+      @hash.dup
+    end
+  end
+end; end

data/lib/dm-validations/validation_errors.rb

@@ -48,7 +48,7 @@ module DataMapper
 
       def initialize(resource)
         @resource = resource
-        @errors   = ActiveSupport::OrderedHash.new { |h,k| h[k] = [] }
+        @errors   = DataMapper::Validations::OrderedHash.new { |h,k| h[k] = [] }
       end
 
       # Clear existing validation errors.
@@ -91,12 +91,12 @@ module DataMapper
       #   array of validation errors or empty array, if there are no errors on given field
       def on(field_name)
         errors_for_field = errors[field_name]
-        errors_for_field.blank? ? nil : errors_for_field.uniq
+        DataMapper::Ext.blank?(errors_for_field) ? nil : errors_for_field.uniq
       end
 
       def each
         errors.map.each do |k, v|
-          next if v.blank?
+          next if DataMapper::Ext.blank?(v)
           yield(v)
         end
       end

data/lib/dm-validations/validators/absent_field_validator.rb

@@ -7,7 +7,8 @@ module DataMapper
     # @since  0.9
     class AbsenceValidator < GenericValidator
       def call(target)
-        return true if target.validation_property_value(field_name).blank?
+        value = target.validation_property_value(field_name)
+        return true if DataMapper::Ext.blank?(value)
 
         error_message = self.options[:message] || ValidationErrors.default_error_message(:absent, field_name)
         add_error(target, error_message, field_name)

data/lib/dm-validations/validators/generic_validator.rb

@@ -30,7 +30,7 @@ module DataMapper
       #
       def initialize(field_name, options = {})
         @field_name           = field_name
-        @options              = options.except(:if, :unless)
+        @options              = DataMapper::Ext::Hash.except(options, :if, :unless)
         @if_clause            = options[:if]
         @unless_clause        = options[:unless]
         @humanized_field_name = DataMapper::Inflector.humanize(@field_name)
@@ -99,7 +99,7 @@ module DataMapper
       def optional?(value)
         if value.nil?
           @options[:allow_nil] || (@options[:allow_blank] && !@options.has_key?(:allow_nil))
-        elsif value.blank?
+        elsif DataMapper::Ext.blank?(value)
           @options[:allow_blank]
         end
       end

data/lib/dm-validations/validators/required_field_validator.rb

@@ -23,7 +23,7 @@ module DataMapper
       # Other property types are considered present if non-blank.
       # Non-properties are considered present if non-blank.
       def present?(value, property)
-        boolean_type?(property) ? !value.nil? : !value.blank?
+        boolean_type?(property) ? !value.nil? : !DataMapper::Ext.blank?(value)
       end
 
       def default_error(property)

data/spec/fixtures/mittelschnauzer.rb

@@ -19,16 +19,19 @@ module DataMapper
           property :height, Float
         end
 
+        attr_accessor :owner
+
         #
         # Validations
         #
 
-        validates_length_of :name, :min => 2, :allow_nil => false
+        validates_length_of :name,  :min => 2, :allow_nil => false
+        validates_length_of :owner, :min => 2
 
         validates_numericality_of :height, :lt => 55.2
 
         def self.valid_instance
-          new(:name => "Roudolf Wilde", :height => 50.4)
+          new(:name => "Roudolf Wilde", :height => 50.4, :owner => 'don')
         end
       end # Mittelschnauzer
     end

data/spec/integration/absent_field_validator/absent_field_validator_spec.rb

@@ -34,7 +34,7 @@ describe 'DataMapper::Validations::Fixtures::Kayak' do
     end
 
     it "has no error messages" do
-      @kayak.errors.on(:salesman).should be_blank
+      @kayak.errors.on(:salesman).should be_nil
     end
   end
 
@@ -49,7 +49,7 @@ describe 'DataMapper::Validations::Fixtures::Kayak' do
     end
 
     it "has no error messages" do
-      @kayak.errors.on(:salesman).should be_blank
+      @kayak.errors.on(:salesman).should be_nil
     end
   end
 
@@ -64,7 +64,7 @@ describe 'DataMapper::Validations::Fixtures::Kayak' do
     end
 
     it "has no error messages" do
-      @kayak.errors.on(:salesman).should be_blank
+      @kayak.errors.on(:salesman).should be_nil
     end
   end
 end

data/spec/integration/length_validator/minimum_spec.rb

@@ -41,4 +41,14 @@ describe 'DataMapper::Validations::Fixtures::Mittelschnauzer' do
 
     it_should_behave_like "entity with a name shorter than 2 characters"
   end
+
+  describe "persisted, with a single character owner" do
+    before :all do
+      @model.save
+      @model.owner = 'a'
+      @model.valid?
+    end
+
+    it_should_behave_like "invalid model"
+  end
 end

data/spec/integration/length_validator/range_spec.rb

@@ -81,7 +81,7 @@ describe 'DataMapper::Validations::Fixtures::EthernetFrame' do
     it_should_behave_like "valid model"
 
     it "has blank error message" do
-      @model.errors.on(:payload).should be_blank
+      @model.errors.on(:payload).should be_nil
     end
   end
 end

data/spec/integration/method_validator/method_validator_spec.rb

@@ -118,7 +118,7 @@ describe "C++" do
 
   it "is not approved by Linus" do
     @model.valid?(:hacking_on_the_kernel)
-    @model.errors.on(:ensure_approved_by_linus_himself).should_not be_blank
+    @model.errors.on(:ensure_approved_by_linus_himself).should_not be_empty
   end
 end
 

data/spec/integration/pure_ruby_objects/plain_old_ruby_object_validation_spec.rb

@@ -107,7 +107,7 @@ describe 'PureRubyObjects::Country' do
     it_should_behave_like "object invalid in default context"
 
     it "has errors on name" do
-      @model.errors.on(:name).should_not be_blank
+      @model.errors.on(:name).should_not be_empty
     end
 
     it "is valid in encyclopedia context" do

data/spec/integration/required_field_validator/boolean_type_value_spec.rb

@@ -35,7 +35,7 @@ describe 'required_field_validator/boolean_type_value_spec' do
 
       it "is valid for committing" do
         @operation.should be_valid_for_committing
-        @operation.errors.on(:network_connection).should be_blank
+        @operation.errors.on(:network_connection).should be_nil
       end
 
       it "is not valid for pushing" do

data/spec/integration/shared/valid_and_invalid_model.rb

@@ -26,10 +26,10 @@ describe "invalid model", :shared => true do
   end
 
   it "has error messages" do
-    @model.errors.should_not be_blank
+    @model.errors.should_not be_empty
   end
 
   it "has list of full error messages" do
-    @model.errors.full_messages.should_not be_blank
+    @model.errors.full_messages.should_not be_empty
   end
 end

data/spec/spec_helper.rb

@@ -5,6 +5,14 @@ require 'dm-validations'
 require 'dm-types'
 require 'dm-migrations'
 
+class Hash
+  def except(*keys)
+    hash = dup
+    keys.each { |key| hash.delete(key) }
+    hash
+  end
+end
+
 SPEC_ROOT = Pathname(__FILE__).dirname
 Pathname.glob((SPEC_ROOT + 'fixtures/**/*.rb').to_s).each { |file| require file }
 Pathname.glob((SPEC_ROOT + 'integration/shared/**/*.rb').to_s).each { |file| require file }

metadata

@@ -2,7 +2,7 @@
 name: dm-validations
 version: !ruby/object:Gem::Version 
   prerelease: 6
-  version: 1.1.0.rc2
+  version: 1.1.0.rc3
 platform: ruby
 authors: 
 - Guy van den Berg
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-03-01 00:00:00 -08:00
+date: 2011-03-10 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -20,7 +20,7 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        version: 1.1.0.rc2
+        version: 1.1.0.rc3
   type: :runtime
   prerelease: false
   version_requirements: *id001
@@ -31,7 +31,7 @@ dependencies:
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        version: 1.1.0.rc2
+        version: 1.1.0.rc3
   type: :development
   prerelease: false
   version_requirements: *id002
@@ -92,6 +92,7 @@ files:
 - lib/dm-validations/formats/url.rb
 - lib/dm-validations/support/context.rb
 - lib/dm-validations/support/object.rb
+- lib/dm-validations/support/ordered_hash.rb
 - lib/dm-validations/validation_errors.rb
 - lib/dm-validations/validators/absent_field_validator.rb
 - lib/dm-validations/validators/acceptance_validator.rb
@@ -246,7 +247,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: datamapper
-rubygems_version: 1.5.2
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: Library for performing validations on DM models and pure Ruby object