sequel_model 0.2 → 0.3

data/CHANGELOG

@@ -1,3 +1,15 @@
+=== 0.3 (2008-01-18)
+
+* Implemented Validatable::Errors class.
+
+* Added Model#reload as alias to Model#refresh.
+
+* Changed Model.create to accept a block (#126).
+
+* Rewrote validations.
+
+* Fixed Model#initialize to accept nil values (#115).
+
 === 0.2 (2008-01-02)
 
 * Removed deprecated Model.recreate_table method.

data/Rakefile

@@ -9,7 +9,7 @@ include FileUtils
 # Configuration
 ##############################################################################
 NAME = "sequel_model"
-VERS = "0.2"
+VERS = "0.3"
 CLEAN.include ["**/.*.sw?", "pkg/*", ".config", "doc/*", "coverage/*"]
 RDOC_OPTS = [
   "--quiet", 
@@ -66,7 +66,6 @@ spec = Gem::Specification.new do |s|
   end
 
   s.add_dependency("sequel_core", '>= 0.5')
-  s.add_dependency("validatable")
   
   s.files = %w(COPYING README Rakefile) + Dir.glob("{doc,spec,lib}/**/*")
 
@@ -128,6 +127,11 @@ Spec::Rake::SpecTask.new("spec_no_cov") do |t|
   t.spec_opts  = File.read("spec/spec.opts").split("\n")
 end
 
+desc "check documentation coverage"
+task :dcov do
+  sh "find lib -name '*.rb' | xargs dcov"
+end
+
 ##############################################################################
 # Statistics
 ##############################################################################

data/lib/sequel_model/record.rb

@@ -127,9 +127,9 @@ module Sequel
     
     # Creates new instance with values set to passed-in Hash ensuring that
     # new? returns true.
-    def self.create(values = {})
+    def self.create(values = {}, &block)
       db.transaction do
-        obj = new(values, true)
+        obj = new(values, true, &block)
         obj.save
         obj
       end
@@ -173,7 +173,7 @@ module Sequel
     # This method guesses whether the record exists when
     # <tt>new_record</tt> is set to false.
     def initialize(values = {}, new_record = false, &block)
-      @values = values
+      @values = values || {}
       @changed_columns = []
 
       @new = new_record
@@ -251,6 +251,7 @@ module Sequel
       @values = this.first || raise(Error, "Record not found")
       self
     end
+    alias_method :reload, :refresh
 
     # Like delete but runs hooks before and after delete.
     def destroy

data/lib/sequel_model/relations.rb

@@ -85,5 +85,70 @@ module Sequel
         class_def(name) {from.filter(key => pk)}
       end
     end
+    
+    # TODO: Add/Replace current relations with the following specifications:
+    # ======================================================================
+    
+    # Database modelling is generally done with an ER (Entity Relationship) diagram.
+    # Shouldn't ORM's facilitate simlilar specification?
+
+    #   class Post < Sequel::Model(:users)
+    #     relationships do
+    #       # Specify the relationships that exist with the User model (users table)
+    #       # These relationships are precisely the ER diagram connecting arrows.
+    #     end
+    #   end
+
+    #
+    # = Relationships 
+    #
+    # are specifications of the ends of the ER diagrams connectors that are touching
+    # the current model.
+    #
+    # one_to_one,   has_one
+    # many_to_one,  belongs_to
+    # many_to_many, has_many
+    # ?parameters may be :zero, :one, :many which specifies the cardinality of the connection
+
+    # Example:
+    #   class Post < Sequel::Model(:users)
+    #     relationships do
+    #       has :one,  :blog, :required => true # blog_id field, cannot be null
+    #       has :one,  :account # account_id field
+    #       has :many, :comments # comments_posts join table
+    #       has :many, :authors, :required => true  # authors_posts join table, requires at least one author
+    #     end
+    #   end
+
+    #
+    # Relationship API Details
+    #
+
+    #
+    # == belongs_to
+    #
+
+    # Defines an blog and blog= method
+    #   belongs_to :blog
+
+    # Same, but uses "b_id" as the blog's id field.
+    #   belongs_to :blog, :key => :b_id
+
+    #   has_many   :comments
+    # * Defines comments method which will query the join table appropriately.
+    # * Checks to see if a "comments_posts" join table exists (alphabetical order)
+    # ** If it does not exist, will create the join table. 
+    # ** If options are passed in these will be used to further define the join table.
+
+
+    # Benefits:
+    # * Normalized DB
+    # * Easy to define join objects
+    # * Efficient queries, database gets to use indexed fields (pkeys) instead of a string field and an id.
+    # 
+    # For example, polymorphic associations now become:
+    # [user]      1-* [addresses_users]     *-1 [addresses]
+    # [companies] 1-* [addresses_companies] *-1 [addresses]
+    # [clients]   1-* [addresses_clients]   *-1 [addresses]
   end
 end

data/lib/sequel_model/validations.rb

@@ -1,113 +1,253 @@
-require 'validatable'
+gem 'assistance', '>= 0.1.1' # because we need Array#extract_options!
 
 module Sequel
-  class Model
-    # =Basic Sequel Validations
-    #
-    # Sequel validations are based on the Validatable gem http://validatable.rubyforge.org/
-    # 
-    # To assign default validations to a sequel model:
-    # 
-    # class MyModel < SequelModel(:items)
-    #   validates do
-    #     format_of...
-    #     presence_of...
-    #     acceptance_of...
-    #     confirmation_of...
-    #     length_of...
-    #     true_for...
-    #     numericality_of...
-    #     format_of...
-    #     validates_base...
-    #     validates_each...
-    #   end
-    # end
-    #
-    # You may also perform the usual 'longhand' way to assign default model validates 
-    # directly within the model class itself:
-    #
-    #   class MyModel < SequelModel(:items)
-    #     validates_format_of...
-    #     validates_presence_of...
-    #     validates_acceptance_of...
-    #     validates_confirmation_of...
-    #     validates_length_of...
-    #     validates_true_for...
-    #     validates_numericality_of...
-    #     validates_format_of...
-    #     validates_base...
-    #     validates_each...
-    #   end
-    #
-    # Each validation allows for arguments:
-    #   TODO: fill the argument options in here
-    #
-    # =Advanced Sequel Validations
-    #
-    # TODO: verify that advanced validates work as stated (aka write specs)
-    # NOTE: experimental
-    #
-    #  To store validates for conditional usage simply specify a name with which to store them
-    #    class User < Sequel::Model
-    #
-    #      # This set of validates becomes stored as :default and gets injected into the model.
-    #      validates do
-    #        # standard validates calls
-    #      end
-    #      
-    #      validates(:registration) do
-    #        # user registration specific validates 
-    #      end
-    #      
-    #      validates(:promotion) do
-    #        # user promotion validates
-    #      end
-    #
-    #    end
-    #
-    # To use the above validates:
-    #
-    #   @user.valid?                # Runs the default validations only.
-    #   @user.valid?(:registration) # Runs both default and registration validations
-    #   @user.valid?(:promotion)    # Runs both default and promotion validations
-    #
-    # You may determine whether the model has validates via:
-    #
-    #   has_validations? # will return true / false based on existence of validations on the model.
-    #
-    # You may also retrieve the validations block if needed:
-    #
-    #   validates(:registration) # returns the registration validation block.
-    #
-    # validates() method parameters:
-    #   a validations block - runs the validations block on the model & stores as :default
-    #   a name and a validations block - stores the block under the name
-    #   a name - returns a stored block of that name or nil
-    #   nothing - returns true / false based on if validations exist for the model.
-    #
-    module Validations
-      class Generator
-        def initialize(model_class ,&block)
-          @model_class = model_class
-          instance_eval(&block)
-        end
+  # The Validatable module provides validation capabilities as a mixin. When
+  # included into a class, it enhances the class with class and instance
+  # methods for defining validations and validating class instances.
+  # 
+  # The Validatable emulates the validation capabilities of ActiveRecord, and
+  # provides methods for validating acceptance, confirmation, presence, format, 
+  # length and numericality of attributes.
+  #
+  # To use validations, you need to include the Validatable module in your
+  # class:
+  #
+  #   class MyClass
+  #     include Sequel::Validatable
+  #     validates_length_of :password, :minimum => 6
+  #   end
+  module Validatable
+    # Includes the Validatable class methods into the including class.
+    def self.included(c)
+      c.extend ClassMethods
+    end
+    
+    # Returns the validation errors associated with the object.
+    def errors
+      @errors ||= Errors.new
+    end
+
+    # Validates the object.
+    def validate
+      errors.clear
+      self.class.validate(self)
+    end
 
-        def method_missing(method, *args)
-          method = :"validates_#{method}"
-          @model_class.send(method, *args)
+    # Validates the object and returns true if no errors are reported.
+    def valid?
+      validate
+      errors.empty?
+    end
+
+    # Validatable::Errors represents validation errors.
+    class Errors
+      # Initializes a new instance of validation errors.
+      def initialize
+        @errors = Hash.new {|h, k| h[k] = []}
+      end
+      
+      # Returns true if no errors are stored.
+      def empty?
+        @errors.empty?
+      end
+      
+      # Clears all errors.
+      def clear
+        @errors.clear
+      end
+      
+      # Returns the errors for the given attribute.
+      def on(att)
+        @errors[att]
+      end
+      alias_method :[], :on
+      
+      # Adds an error for the given attribute.
+      def add(att, msg)
+        @errors[att] << msg
+      end
+      
+      # Returns an array of fully-formatted error messages.
+      def full_messages
+        @errors.inject([]) do |m, kv| att, errors = *kv
+          errors.each {|e| m << "#{att} #{e}"}
+          m
         end
       end
     end
+    
+    # The Generator class is used to generate validation definitions using 
+    # the validates {} idiom.
+    class Generator
+      # Initializes a new generator.
+      def initialize(receiver ,&block)
+        @receiver = receiver
+        instance_eval(&block)
+      end
 
-    include ::Validatable
+      # Delegates method calls to the receiver by calling receiver.validates_xxx.
+      def method_missing(m, *args)
+        @receiver.send(:"validates_#{m}", *args)
+      end
+    end
+    
+    # Validatable class methods.
+    module ClassMethods
+      # Defines validations by converting a longhand block into a series of 
+      # shorthand definitions. For example:
+      #
+      #   class MyClass
+      #     include Sequel::Validatable
+      #     validates do
+      #       length_of :name, :minimum => 6
+      #       length_of :password, :minimum => 8
+      #     end
+      #   end
+      #
+      # is equivalent to:
+      #   class MyClass
+      #     include Sequel::Validatable
+      #     validates_length_of :name, :minimum => 6
+      #     validates_length_of :password, :minimum => 8
+      #   end
+      def validates(&block)
+        Generator.new(self, &block)
+      end
 
-    def self.validates(&block)
-      Validations::Generator.new(self, &block)
+      # Returns the validations hash for the class.
+      def validations
+        @validations ||= Hash.new {|h, k| h[k] = []}
+      end
+      
+      # Returns true if validations are defined.
+      def has_validations?
+        !validations.empty?
+      end
+
+      # Validates the given instance.
+      def validate(o)
+        validations.each do |att, procs|
+          v = o.send(att)
+          procs.each {|p| p[o, att, v]}
+        end
+      end
+      
+      # Adds a validation for each of the given attributes using the supplied
+      # block. The block must accept three arguments: instance, attribute and 
+      # value, e.g.:
+      #
+      #   validates_each :name, :password do |object, attribute, value|
+      #     object.errors[attribute] << 'is not nice' unless value.nice?
+      #   end
+      def validates_each(*atts, &block)
+        atts.each {|a| validations[a] << block}
+      end
+
+      # Validates acceptance of an attribute.
+      def validates_acceptance_of(*atts)
+        opts = {
+          :message => 'is not accepted',
+          :allow_nil => true,
+          :accept => '1'
+        }.merge!(atts.extract_options!)
+        
+        validates_each(*atts) do |o, a, v|
+          next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
+          o.errors[a] << opts[:message] unless v == opts[:accept]
+        end
+      end
+
+      # Validates confirmation of an attribute.
+      def validates_confirmation_of(*atts)
+        opts = {
+          :message => 'is not confirmed',
+        }.merge!(atts.extract_options!)
+        
+        validates_each(*atts) do |o, a, v|
+          next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
+          c = o.send(:"#{a}_confirmation")
+          o.errors[a] << opts[:message] unless v == c
+        end
+      end
+
+      # Validates the format of an attribute.
+      def validates_format_of(*atts)
+        opts = {
+          :message => 'is invalid',
+        }.merge!(atts.extract_options!)
+        
+        unless opts[:with].is_a?(Regexp)
+          raise Sequel::Error, "A regular expression must be supplied as the :with option of the options hash"
+        end
+        
+        validates_each(*atts) do |o, a, v|
+          next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
+          o.errors[a] << opts[:message] unless v.to_s =~ opts[:with]
+        end
+      end
+
+      # Validates the length of an attribute.
+      def validates_length_of(*atts)
+        opts = {
+          :too_long     => 'is too long',
+          :too_short    => 'is too short',
+          :wrong_length => 'is the wrong length'
+        }.merge!(atts.extract_options!)
+        
+        validates_each(*atts) do |o, a, v|
+          next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
+          if m = opts[:maximum]
+            o.errors[a] << (opts[:message] || opts[:too_long]) unless v && v.size <= m
+          end
+          if m = opts[:minimum]
+            o.errors[a] << (opts[:message] || opts[:too_short]) unless v && v.size >= m
+          end
+          if i = opts[:is]
+            o.errors[a] << (opts[:message] || opts[:wrong_length]) unless v && v.size == i
+          end
+          if w = opts[:within]
+            o.errors[a] << (opts[:message] || opts[:wrong_length]) unless v && w.include?(v.size)
+          end
+        end
+      end
+
+      NUMBER_RE = /^\d*\.{0,1}\d+$/
+      INTEGER_RE = /\A[+-]?\d+\Z/
+
+      # Validates whether an attribute is a number.
+      def validates_numericality_of(*atts)
+        opts = {
+          :message => 'is not a number',
+        }.merge!(atts.extract_options!)
+        
+        re = opts[:only_integer] ? INTEGER_RE : NUMBER_RE
+        
+        validates_each(*atts) do |o, a, v|
+          next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
+          o.errors[a] << opts[:message] unless v.to_s =~ re
+        end
+      end
+
+      # Validates the presence of an attribute.
+      def validates_presence_of(*atts)
+        opts = {
+          :message => 'is not present',
+        }.merge!(atts.extract_options!)
+        
+        validates_each(*atts) do |o, a, v|
+          o.errors[a] << opts[:message] unless v && !v.blank?
+        end
+      end
     end
+  end
 
-    # return true if there are validations stored, false otherwise
-    def self.has_validations?
-      validations.length > 0 ? true : false
+  class Model
+    include Validatable
+    
+    alias_method :save!, :save
+    def save(*args)
+      return false unless valid?
+      save!(*args)
     end
   end
 end

data/spec/model_spec.rb

@@ -401,27 +401,6 @@ describe Sequel::Model, "(:tablename)" do
 
 end
 
-describe Sequel::Model, ".create" do
-
-  before(:each) do
-    MODEL_DB.reset
-    @c = Class.new(Sequel::Model(:items))
-  end
-
-  it "should be able to create rows in the associated table" do
-    o = @c.create(:x => 1)
-    o.class.should == @c
-    MODEL_DB.sqls.should == ['INSERT INTO items (x) VALUES (1)',  "SELECT * FROM items WHERE (id IN ('INSERT INTO items (x) VALUES (1)')) LIMIT 1"]
-  end
-
-  it "should be able to create rows without any values specified" do
-    o = @c.create
-    o.class.should == @c
-    MODEL_DB.sqls.should == ["INSERT INTO items DEFAULT VALUES", "SELECT * FROM items WHERE (id IN ('INSERT INTO items DEFAULT VALUES')) LIMIT 1"]
-  end
-
-end
-
 describe Sequel::Model, "A model class without a primary key" do
 
   before(:each) do

data/spec/record_spec.rb

@@ -409,3 +409,91 @@ describe Sequel::Model, "#===" do
   end
 end
 
+describe Sequel::Model, "#initialize" do
+  setup do
+    @c = Class.new(Sequel::Model) do
+    end
+  end
+  
+  specify "should accept values" do
+    m = @c.new(:id => 1, :x => 2)
+    m.values.should == {:id => 1, :x => 2}
+  end
+  
+  specify "should accept no values" do
+    m = @c.new
+    m.values.should == {}
+  end
+  
+  specify "should accept nil values" do
+    m = @c.new(nil)
+    m.values.should == {}
+  end
+  
+  specify "should accept a block to execute" do
+    m = @c.new {|o| o[:id] = 1234}
+    m.id.should == 1234
+  end
+end
+
+describe Sequel::Model, ".create" do
+
+  before(:each) do
+    MODEL_DB.reset
+    @c = Class.new(Sequel::Model(:items)) do
+      def columns; [:x]; end
+    end
+  end
+
+  it "should be able to create rows in the associated table" do
+    o = @c.create(:x => 1)
+    o.class.should == @c
+    MODEL_DB.sqls.should == ['INSERT INTO items (x) VALUES (1)',  "SELECT * FROM items WHERE (id IN ('INSERT INTO items (x) VALUES (1)')) LIMIT 1"]
+  end
+
+  it "should be able to create rows without any values specified" do
+    o = @c.create
+    o.class.should == @c
+    MODEL_DB.sqls.should == ["INSERT INTO items DEFAULT VALUES", "SELECT * FROM items WHERE (id IN ('INSERT INTO items DEFAULT VALUES')) LIMIT 1"]
+  end
+
+  it "should accept a block and run it" do
+    o1, o2, o3 =  nil, nil, nil
+    o = @c.create {|o3| o1 = o3; o2 = :blah; o3.x = 333}
+    o.class.should == @c
+    o1.should === o
+    o3.should === o
+    o2.should == :blah
+    MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (333)", "SELECT * FROM items WHERE (id IN ('INSERT INTO items (x) VALUES (333)')) LIMIT 1"]
+  end
+end
+
+describe Sequel::Model, "#refresh" do
+  setup do
+    MODEL_DB.reset
+    @c = Class.new(Sequel::Model(:items)) do
+      def columns; [:x]; end
+    end
+  end
+
+  specify "should reload the instance values from the database" do
+    @m = @c.new(:id => 555)
+    @m[:x] = 'blah'
+    @m.this.should_receive(:first).and_return({:x => 'kaboom', :id => 555})
+    @m.refresh
+    @m[:x].should == 'kaboom'
+  end
+  
+  specify "should raise if the instance is not found" do
+    @m = @c.new(:id => 555)
+    @m.this.should_receive(:first).and_return(nil)
+    proc {@m.refresh}.should raise_error(Sequel::Error)
+  end
+  
+  specify "should be aliased by #reload" do
+    @m = @c.new(:id => 555)
+    @m.this.should_receive(:first).and_return({:x => 'kaboom', :id => 555})
+    @m.reload
+    @m[:x].should == 'kaboom'
+  end
+end

data/spec/spec_helper.rb

@@ -1,4 +1,7 @@
 require 'rubygems'
+unless Object.const_defined?('Sequel')
+  require 'sequel_core'
+end
 require File.join(File.dirname(__FILE__), "../lib/sequel_model")
 
 class MockDataset < Sequel::Dataset

data/spec/validations_spec.rb

@@ -1,5 +1,295 @@
 require File.join(File.dirname(__FILE__), "spec_helper")
 
+describe "Sequel::Validatable::Errors" do
+  setup do
+    @errors = Sequel::Validatable::Errors.new
+    class Sequel::Validatable::Errors
+      attr_accessor :errors
+    end
+  end
+  
+  specify "should be clearable using #clear" do
+    @errors.errors = {1 => 2, 3 => 4}
+    @errors.clear
+    @errors.errors.should == {}
+  end
+  
+  specify "should be empty if no errors are added" do
+    @errors.should be_empty
+    @errors[:blah] << "blah"
+    @errors.should_not be_empty
+  end
+  
+  specify "should return errors for a specific attribute using #on or #[]" do
+    @errors[:blah].should == []
+    @errors.on(:blah).should == []
+
+    @errors[:blah] << 'blah'
+    @errors[:blah].should == ['blah']
+    @errors.on(:blah).should == ['blah']
+
+    @errors[:bleu].should == []
+    @errors.on(:bleu).should == []
+  end
+  
+  specify "should accept errors using #[] << or #add" do
+    @errors[:blah] << 'blah'
+    @errors[:blah].should == ['blah']
+    
+    @errors.add :blah, 'zzzz'
+    @errors[:blah].should == ['blah', 'zzzz']
+  end
+  
+  specify "should return full messages using #full_messages" do
+    @errors.full_messages.should == []
+    
+    @errors[:blow] << 'blieuh'
+    @errors[:blow] << 'blich'
+    @errors[:blay] << 'bliu'
+    msgs = @errors.full_messages
+    msgs.size.should == 3
+    msgs.should include('blow blieuh', 'blow blich', 'blay bliu')
+  end
+end
+
+describe Sequel::Validatable do
+  setup do
+    @c = Class.new do
+      include Sequel::Validatable
+      
+      def self.validates_coolness_of(attr)
+        validates_each(attr) {|o, a, v| o.errors[a] << 'is not cool' if v != :cool}
+      end
+    end
+    
+    @d = Class.new do
+      attr_accessor :errors
+      def initialize; @errors = Sequel::Validatable::Errors.new; end
+    end
+  end
+  
+  specify "should respond to validates, validations, has_validations?" do
+    @c.should respond_to(:validations)
+    @c.should respond_to(:has_validations?)
+  end
+  
+  specify "should acccept validation definitions using validates_each" do
+    @c.validates_each(:xx, :yy) {|o, a, v| o.errors[a] << 'too low' if v < 50}
+    
+    @c.validations[:xx].size.should == 1
+    @c.validations[:yy].size.should == 1
+    
+    o = @d.new
+    @c.validations[:xx].first.call(o, :aa, 40)
+    @c.validations[:yy].first.call(o, :bb, 60)
+    
+    o.errors.full_messages.should == ['aa too low']
+  end
+
+  specify "should return true/false for has_validations?" do
+    @c.has_validations?.should == false
+    @c.validates_each(:xx) {1}
+    @c.has_validations?.should == true
+  end
+  
+  specify "should provide a validates method that takes block with validation definitions" do
+    @c.validates do
+      coolness_of :blah
+    end
+    @c.validations[:blah].should_not be_empty
+
+    o = @d.new
+    @c.validations[:blah].first.call(o, :ttt, 40)
+    o.errors.full_messages.should == ['ttt is not cool']
+    o.errors.clear
+    @c.validations[:blah].first.call(o, :ttt, :cool)
+    o.errors.should be_empty
+  end
+end
+
+describe "A Validatable instance" do
+  setup do
+    @c = Class.new do
+      attr_accessor :score
+      
+      include Sequel::Validatable
+      
+      validates_each :score do |o, a, v|
+        o.errors[a] << 'too low' if v < 87
+      end
+    end
+    
+    @o = @c.new
+  end
+  
+  specify "should supply a #valid? method that returns true if validations pass" do
+    @o.score = 50
+    @o.should_not be_valid
+    @o.score = 100
+    @o.should be_valid
+  end
+  
+  specify "should provide an errors object" do
+    @o.score = 100
+    @o.should be_valid
+    @o.errors.should be_empty
+    
+    @o.score = 86
+    @o.should_not be_valid
+    @o.errors[:score].should == ['too low']
+    @o.errors[:blah].should be_empty
+  end
+end
+
+describe Sequel::Validatable::Generator do
+  setup do
+    $testit = nil
+    
+    @c = Class.new do
+      include Sequel::Validatable
+      
+      def self.validates_blah
+        $testit = 1324
+      end
+    end
+  end
+  
+  specify "should instance_eval the block, sending everything to its receiver" do
+    Sequel::Validatable::Generator.new(@c) do
+      blah
+    end
+    $testit.should == 1324
+  end
+end
+
+describe "Sequel validations" do
+  setup do
+    @c = Class.new do
+      attr_accessor :value
+      include Sequel::Validatable
+    end
+    @m = @c.new
+  end
+
+  specify "should validate acceptance_of" do
+    @c.validates_acceptance_of :value
+    @m.should be_valid
+    @m.value = '1'
+    @m.should be_valid
+  end
+  
+  specify "should validate acceptance_of with accept" do
+    @c.validates_acceptance_of :value, :accept => 'true'
+    @m.value = '1'
+    @m.should_not be_valid
+    @m.value = 'true'
+    @m.should be_valid
+  end
+  
+  specify "should validate acceptance_of with allow_nil => false" do
+    @c.validates_acceptance_of :value, :allow_nil => false
+    @m.should_not be_valid
+  end
+
+  specify "should validate confirmation_of" do
+    @c.send(:attr_accessor, :value_confirmation)
+    @c.validates_confirmation_of :value
+    
+    @m.value = 'blah'
+    @m.should_not be_valid
+    
+    @m.value_confirmation = 'blah'
+    @m.should be_valid
+  end
+
+  specify "should validate format_of" do
+    @c.validates_format_of :value, :with => /.+_.+/
+    @m.value = 'abc_'
+    @m.should_not be_valid
+    @m.value = 'abc_def'
+    @m.should be_valid
+  end
+  
+  specify "should raise for validate_format_of without regexp" do
+    proc {@c.validates_format_of :value}.should raise_error(Sequel::Error)
+    proc {@c.validates_format_of :value, :with => :blah}.should raise_error(Sequel::Error)
+  end
+  
+  specify "should validate length_of with maximum" do
+    @c.validates_length_of :value, :maximum => 5
+    @m.should_not be_valid
+    @m.value = '12345'
+    @m.should be_valid
+    @m.value = '123456'
+    @m.should_not be_valid
+  end
+
+  specify "should validate length_of with minimum" do
+    @c.validates_length_of :value, :minimum => 5
+    @m.should_not be_valid
+    @m.value = '12345'
+    @m.should be_valid
+    @m.value = '1234'
+    @m.should_not be_valid
+  end
+
+  specify "should validate length_of with within" do
+    @c.validates_length_of :value, :within => 2..5
+    @m.should_not be_valid
+    @m.value = '12345'
+    @m.should be_valid
+    @m.value = '1'
+    @m.should_not be_valid
+    @m.value = '123456'
+    @m.should_not be_valid
+  end
+
+  specify "should validate length_of with is" do
+    @c.validates_length_of :value, :is => 3
+    @m.should_not be_valid
+    @m.value = '123'
+    @m.should be_valid
+    @m.value = '12'
+    @m.should_not be_valid
+    @m.value = '1234'
+    @m.should_not be_valid
+  end
+  
+  specify "should validate length_of with allow_nil" do
+    @c.validates_length_of :value, :is => 3, :allow_nil => true
+    @m.should be_valid
+  end
+
+  specify "should validate numericality_of" do
+    @c.validates_numericality_of :value
+    @m.value = 'blah'
+    @m.should_not be_valid
+    @m.value = '123'
+    @m.should be_valid
+    @m.value = '123.1231'
+    @m.should be_valid
+  end
+
+  specify "should validate numericality_of with only_integer" do
+    @c.validates_numericality_of :value, :only_integer => true
+    @m.value = 'blah'
+    @m.should_not be_valid
+    @m.value = '123'
+    @m.should be_valid
+    @m.value = '123.1231'
+    @m.should_not be_valid
+  end
+  
+  specify "should validate presence_of" do
+    @c.validates_presence_of :value
+    @m.should_not be_valid
+    @m.value = ''
+    @m.should_not be_valid
+    @m.value = 1234
+    @m.should be_valid
+  end
+end
+
 describe Sequel::Model, "Validations" do
 
   before(:all) do
@@ -31,35 +321,18 @@ describe Sequel::Model, "Validations" do
     end
   end
   
-  it "should have a hook before validating" do
-    class Person < Sequel::Model(:people)      
-      before_validation do
-        self.name = "default name"
-      end
-      validations.clear
-      validates_presence_of :name
-    end
-
-    @person = Person.new
-    @person.valid?.should be_true
-  end
-  
-  it "should include errors from other models" do
-    pending("Waiting for Wayne's amazing associations!")
-  end
-  
   it "should validate the acceptance of a column" do
-    class Cow < Sequel::Model(:cows)      
+    class Cow < Sequel::Model(:cows)
       validations.clear
-      validates_acceptance_of :got_milk
+      validates_acceptance_of :got_milk, :accept => 'blah', :allow_nil => false
     end
     
     @cow = Cow.new
-    @cow.valid?.should be_false
-    @cow.errors.on(:got_milk).should == "must be accepted"
+    @cow.should_not be_valid
+    @cow.errors.full_messages.should == ["got_milk is not accepted"]
     
-    @cow.got_milk = "true"
-    @cow.valid?.should be_true
+    @cow.got_milk = "blah"
+    @cow.should be_valid
   end
   
   it "should validate the confirmation of a column" do
@@ -73,29 +346,11 @@ describe Sequel::Model, "Validations" do
     end
     
     @user = User.new
-    @user.valid?.should be_false
-    @user.errors.on(:password).should == "doesn't match confirmation"
+    @user.should_not be_valid
+    @user.errors.full_messages.should == ["password is not confirmed"]
     
     @user.password = "test"
-    @user.valid?.should be_true
-  end
-  
-  it "should validate each with logic" do
-    class ZipCodeService; end
-    
-    class Address < Sequel::Model(:addresses)      
-      validations.clear
-      validates_each :zip_code, :logic => lambda { errors.add(:zip_code, "is not valid") unless ZipCodeService.allows(zip_code) }
-    end
-    
-    @address = Address.new :zip_code => "48108"
-    ZipCodeService.should_receive(:allows).with("48108").and_return(false)
-    @address.valid?.should be_false
-    @address.errors.on(:zip_code).should == "is not valid"
-    
-    @address2 = Address.new :zip_code => "48104"
-    ZipCodeService.should_receive(:allows).with("48104").and_return(true)
-    @address2.valid?.should be_true
+    @user.should be_valid
   end
   
   it "should validate format of column" do
@@ -109,9 +364,9 @@ describe Sequel::Model, "Validations" do
     @person.valid?.should be_true
   end
   
-  it "should allow for :with_exactly => /[a-zA-Z]/, which wraps the supplied regex with ^<regex>$" do
-    pending("TODO: Add this option to Validatable#validates_format_of")
-  end
+  # it "should allow for :with_exactly => /[a-zA-Z]/, which wraps the supplied regex with ^<regex>$" do
+  #   pending("TODO: Add this option to Validatable#validates_format_of")
+  # end
 
   it "should validate length of column" do
     class Person < Sequel::Model(:people)
@@ -129,17 +384,20 @@ describe Sequel::Model, "Validations" do
       :middle_name => "danger"
     )
     
-    @person.valid?.should be_false
-    @person.errors.on(:first_name).should  == "is invalid"
-    @person.errors.on(:last_name).should   == "is invalid"
-    @person.errors.on(:initials).should    == "is invalid"
-    @person.errors.on(:middle_name).should == "is invalid"
+    @person.should_not be_valid
+    @person.errors.full_messages.size.should == 4
+    @person.errors.full_messages.should include(
+      'first_name is too long',
+      'last_name is too short',
+      'middle_name is the wrong length',
+      'initials is the wrong length'
+    )
     
     @person.first_name  = "Lancelot"
     @person.last_name   = "1234567890123456789012345678901"
     @person.initials    = "LC"
     @person.middle_name = "Will"
-    @person.valid?.should be_true
+    @person.should be_valid
   end
   
   it "should validate numericality of column" do
@@ -149,42 +407,27 @@ describe Sequel::Model, "Validations" do
     end
     
     @person = Person.new :age => "Twenty"
-    @person.valid?.should be_false
-    @person.errors.on(:age).should == "must be a number"
+    @person.should_not be_valid
+    @person.errors.full_messages.should == ['age is not a number']
     
     @person.age = 20
-    @person.valid?.should be_true
+    @person.should be_valid
   end
   
   it "should validate the presence of a column" do
-    class Cow < Sequel::Model(:cows)      
+    class Cow < Sequel::Model(:cows)
       validations.clear
       validates_presence_of :name
     end
     
     @cow = Cow.new
-    @cow.valid?.should be_false
-    @cow.errors.on(:name).should == "can't be empty"
-    @cow.errors.full_messages.first.should == "Name can't be empty"
+    @cow.should_not be_valid
+    @cow.errors.full_messages.should == ['name is not present']
     
     @cow.name = "Betsy"
-    @cow.valid?.should be_true
+    @cow.should be_valid
   end
   
-  it "should validate true for a column" do
-    class Person < Sequel::Model(:people)
-      validations.clear
-      validates_true_for :first_name, :logic => lambda { first_name == "Alison" }
-    end
-
-    @person = Person.new :first_name => "Nina"
-    @person.valid?.should be_false
-    @person.errors.on(:first_name).should == "is invalid"
-    
-    @person.first_name = "Alison"
-    @person.valid?.should be_true
-  end
-    
   it "should have a validates block that calls multple validations" do
     class Person < Sequel::Model(:people)
       validations.clear
@@ -194,7 +437,7 @@ describe Sequel::Model, "Validations" do
       end
     end
 
-    Person.validations.length.should eql(2)
+    Person.validations[:first_name].size.should == 2
     
     @person = Person.new :first_name => "Lancelot99"
     @person.valid?.should be_false
@@ -203,12 +446,6 @@ describe Sequel::Model, "Validations" do
     @person2.valid?.should be_true
   end
 
-  it "should require and include the validatable gem" do
-    Gem.loaded_specs["validatable"].should_not be_nil
-    Sequel::Model.should respond_to(:validates_format_of) # validatable gem
-    Sequel::Model.should respond_to(:validations)         # Validations module
-  end
-    
   it "should allow 'longhand' validations direcly within the model." do
     lambda {
       class Person < Sequel::Model(:people)
@@ -219,26 +456,6 @@ describe Sequel::Model, "Validations" do
     Person.validations.length.should eql(1)
   end
 
-  it "should validates do should allow shorthand method for every longhand validates_* method" do
-    class Person
-      validations.clear
-      validates do
-        format_of       :first_name, :with => /^[a-zA-Z]+$/
-        length_of       :first_name, :maximum => 30
-        presence_of     :first_name
-        numericality_of :age
-        acceptance_of   :terms
-        confirmation_of :password
-        true_for        :first_name, :logic => lambda { first_name == "Alison" }
-        #validates_each :last_name, :logic => lambda { errors.add(:zip_code, "is not valid") unless ZipCodeService.allows(zip_code) }
-        #base
-      end
-      
-      # Now check to make sure that each validation exists in the model's validations.
-    end
-    pending("finish this spec for each case")
-  end
-
   it "should define a has_validations? method which returns true if the model has validations, false otherwise" do
     class Person < Sequel::Model(:people)
       validations.clear
@@ -255,22 +472,53 @@ describe Sequel::Model, "Validations" do
     Person.should have_validations
     Smurf.should_not have_validations
   end
-
 end
 
-describe Sequel::Model, "validates" do
+describe "Model#save!" do
+  setup do
+    @c = Class.new(Sequel::Model(:people)) do
+      def columns; [:id]; end
+      
+      validates_each :id do |o, a, v|
+        o.errors[a] << 'blah' unless v == 5
+      end
+    end
+    @m = @c.new(:id => 4)
+    MODEL_DB.reset
+  end
   
+  specify "should save regardless of validations" do
+    @m.should_not be_valid
+    @m.save!
+    MODEL_DB.sqls.should == ['UPDATE people SET id = 4 WHERE (id = 4)']
+  end
+end
 
-  before(:all) do
-    class Person < Sequel::Model(:people)
-      def columns
-        [:id,:name,:first_name,:last_name,:middle_name,:initials,:age]
+describe "Model#save!" do
+  setup do
+    @c = Class.new(Sequel::Model(:people)) do
+      def columns; [:id]; end
+
+      validates_each :id do |o, a, v|
+        o.errors[a] << 'blah' unless v == 5
       end
     end
+    @m = @c.new(:id => 4)
+    MODEL_DB.reset
+  end
+
+  specify "should save only if validations pass" do
+    @m.should_not be_valid
+    @m.save
+    MODEL_DB.sqls.should be_empty
+    
+    @m.id = 5
+    @m.should be_valid
+    @m.save
+    MODEL_DB.sqls.should == ['UPDATE people SET id = 5 WHERE (id = 5)']
   end
   
-  it "should runs the validations block on the model & store as :default when only a validations block is passed in"
-  it "should store the block under the name passed in when both a name and a validations block are passed in"
-  it "should return the stored validations block corresponding to the name given, if only a name is given (no block)"
-  it "should return true or false based on if validations exist on the model if no arguments are given"
-end
+  specify "should return false if validations fail" do
+    @m.save.should == false
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sequel_model
 version: !ruby/object:Gem::Version 
-  version: "0.2"
+  version: "0.3"
 platform: ruby
 authors: 
 - Sharon Rosner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-01-02 00:00:00 +02:00
+date: 2008-01-18 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -21,15 +21,6 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "0.5"
     version: 
-- !ruby/object:Gem::Dependency 
-  name: validatable
-  version_requirement: 
-  version_requirements: !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-    version: 
 description: Lightweight ORM for Ruby
 email: ciconia@gmail.com
 executables: []