sequel 2.0.1 → 2.1.0

data/lib/sequel_model/validations.rb

@@ -1,115 +1,59 @@
-# The Validations 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 Validation 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 Validation module in your
-# class:
-#
-#   class MyClass
-#     include Validation
-#     validates_length_of :password, :minimum => 6
-#   end
-module Validation
-  # Includes the Validation 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
-    return false if before_validation == false
-    self.class.validate(self)
-    after_validation
-    nil
-  end
-
-  # Validates the object and returns true if no errors are reported.
-  def valid?
-    return false if validate == false
-    errors.empty?
-  end
+module Sequel
+  class Model
+    # The Validation module houses a couple of subclasses used by Sequel's
+    # validation code.
+    module Validation
+      # Validation::Errors represents validation errors, a simple hash subclass
+      # with a few convenience methods.
+      class Errors < ::Hash
+        # Assign an array of messages for each attribute on access
+        def initialize
+          super{|h,k| h[k] = []}
+        end
 
-  # Validation::Errors represents validation errors.
-  class Errors
-    # Initializes a new instance of validation errors.
-    def initialize
-      @errors = Hash.new {|h, k| h[k] = []}
-    end
-    
-    # Adds an error for the given attribute.
-    def add(att, msg)
-      @errors[att] << msg
-    end
-    
-    # Clears all errors.
-    def clear
-      @errors.clear
-    end
-    
-    # Iterates over errors
-    def each(&block)
-      @errors.each(&block)
-    end
-    
-    # Returns true if no errors are stored.
-    def empty?
-      @errors.empty?
-    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
+        # Adds an error for the given attribute.
+        def add(att, msg)
+          self[att] << msg
+        end
+        
+        # Returns an array of fully-formatted error messages.
+        def full_messages
+          inject([]) do |m, kv| 
+            att, errors = *kv
+            errors.each {|e| m << "#{att} #{e}"}
+            m
+          end
+        end
+        
+        # Returns the errors for the given attribute.
+        def on(att)
+          self[att]
+        end
       end
-    end
-    
-    # Returns the errors for the given attribute.
-    def on(att)
-      @errors[att]
-    end
-    alias_method :[], :on
-    
-    # Returns size of errors array
-    def size
-      @errors.size
-    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)
+      # 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
+    
+        # Delegates method calls to the receiver by calling receiver.validates_xxx.
+        def method_missing(m, *args, &block)
+          @receiver.send(:"validates_#{m}", *args, &block)
+        end
+      end
     end
 
-    # Delegates method calls to the receiver by calling receiver.validates_xxx.
-    def method_missing(m, *args, &block)
-      @receiver.send(:"validates_#{m}", *args, &block)
-    end
-  end
-  
-  # Validation class methods.
-  module ClassMethods
     # Returns true if validations are defined.
-    def has_validations?
+    def self.has_validations?
       !validations.empty?
     end
 
     # Instructs the model to skip validations defined in superclasses
-    def skip_superclass_validations
+    def self.skip_superclass_validations
       @skip_superclass_validations = true
     end
     
@@ -130,12 +74,12 @@ module Validation
     #     validates_length_of :name, :minimum => 6
     #     validates_length_of :password, :minimum => 8
     #   end
-    def validates(&block)
-      Generator.new(self, &block)
+    def self.validates(&block)
+      Validation::Generator.new(self, &block)
     end
 
     # Validates the given instance.
-    def validate(o)
+    def self.validate(o)
       if superclass.respond_to?(:validate) && !@skip_superclass_validations
         superclass.validate(o)
       end
@@ -146,7 +90,7 @@ module Validation
     end
     
     # Validates acceptance of an attribute.
-    def validates_acceptance_of(*atts)
+    def self.validates_acceptance_of(*atts)
       opts = {
         :message => 'is not accepted',
         :allow_nil => true,
@@ -154,18 +98,20 @@ module Validation
       }.merge!(atts.extract_options!)
       
       validates_each(*atts) do |o, a, v|
+        next unless o.instance_eval(&if_proc(opts))
         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)
+    def self.validates_confirmation_of(*atts)
       opts = {
         :message => 'is not confirmed',
       }.merge!(atts.extract_options!)
       
       validates_each(*atts) do |o, a, v|
+        next unless o.instance_eval(&if_proc(opts))
         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
@@ -179,12 +125,12 @@ module Validation
     #   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}
+    def self.validates_each(*atts, &block)
+      atts.each{|a| validations[a] << block}
     end
 
     # Validates the format of an attribute.
-    def validates_format_of(*atts)
+    def self.validates_format_of(*atts)
       opts = {
         :message => 'is invalid',
       }.merge!(atts.extract_options!)
@@ -194,13 +140,14 @@ module Validation
       end
       
       validates_each(*atts) do |o, a, v|
+        next unless o.instance_eval(&if_proc(opts))
         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)
+    def self.validates_length_of(*atts)
       opts = {
         :too_long     => 'is too long',
         :too_short    => 'is too short',
@@ -208,6 +155,7 @@ module Validation
       }.merge!(atts.extract_options!)
       
       validates_each(*atts) do |o, a, v|
+        next unless o.instance_eval(&if_proc(opts))
         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
@@ -225,12 +173,13 @@ module Validation
     end
 
     # Validates whether an attribute is a number.
-    def validates_numericality_of(*atts)
+    def self.validates_numericality_of(*atts)
       opts = {
         :message => 'is not a number',
       }.merge!(atts.extract_options!)
       
       validates_each(*atts) do |o, a, v|
+        next unless o.instance_eval(&if_proc(opts))
         next if (v.nil? && opts[:allow_nil]) || (v.blank? && opts[:allow_blank])
         begin
           if opts[:only_integer]
@@ -245,12 +194,13 @@ module Validation
     end
 
     # Validates the presence of an attribute.
-    def validates_presence_of(*atts)
+    def self.validates_presence_of(*atts)
       opts = {
         :message => 'is not present',
       }.merge!(atts.extract_options!)
       
       validates_each(*atts) do |o, a, v|
+        next unless o.instance_eval(&if_proc(opts))
         o.errors[a] << opts[:message] unless v && !v.blank?
       end
     end
@@ -258,12 +208,13 @@ module Validation
     # Validates only if the fields in the model (specified by atts) are
     # unique in the database.  You should also add a unique index in the
     # database, as this suffers from a fairly obvious race condition.
-    def validates_uniqueness_of(*atts)
+    def self.validates_uniqueness_of(*atts)
       opts = {
         :message => 'is already taken',
       }.merge!(atts.extract_options!)
 
       validates_each(*atts) do |o, a, v|
+        next unless o.instance_eval(&if_proc(opts))
         next if v.blank? 
         num_dups = o.class.filter(a => v).count
         allow = if num_dups == 0
@@ -287,8 +238,43 @@ module Validation
     end
 
     # Returns the validations hash for the class.
-    def validations
+    def self.validations
       @validations ||= Hash.new {|h, k| h[k] = []}
     end
+    
+    ### Private Class Methods ###
+
+    def self.if_proc(opts)
+      case opts[:if]
+      when Symbol then proc{send opts[:if]}
+      when Proc then opts[:if]
+      when nil then proc{true}
+      else raise(::Sequel::Error, "invalid value for :if validation option")
+      end
+    end
+
+    private_class_method :if_proc
+
+    ### Instance Methods ###
+  
+    # Returns the validation errors associated with the object.
+    def errors
+      @errors ||= Validation::Errors.new
+    end
+
+    # Validates the object.
+    def validate
+      errors.clear
+      return false if before_validation == false
+      self.class.validate(self)
+      after_validation
+      nil
+    end
+
+    # Validates the object and returns true if no errors are reported.
+    def valid?
+      return false if validate == false
+      errors.empty?
+    end
   end
 end

data/spec/association_reflection_spec.rb

@@ -40,9 +40,9 @@ describe Sequel::Model::Associations::AssociationReflection, "#reciprocal" do
   it "should use the :reciprocal value if present" do
     @c = Class.new(Sequel::Model)
     @d = Class.new(Sequel::Model)
-    @c.many_to_one :c, :class=>@d, :reciprocal=>:@xx
+    @c.many_to_one :c, :class=>@d, :reciprocal=>:xx
     @c.association_reflection(:c).should include(:reciprocal)
-    @c.association_reflection(:c).reciprocal.should == :@xx
+    @c.association_reflection(:c).reciprocal.should == :xx
   end
 
   it "should figure out the reciprocal if the :reciprocal value is not present" do
@@ -55,13 +55,13 @@ describe Sequel::Model::Associations::AssociationReflection, "#reciprocal" do
     ParParentThree.many_to_many :par_parents
 
     ParParent.association_reflection(:par_parent_two).should_not include(:reciprocal)
-    ParParent.association_reflection(:par_parent_two).reciprocal.should == :@par_parents
+    ParParent.association_reflection(:par_parent_two).reciprocal.should == :par_parents
     ParParentTwo.association_reflection(:par_parents).should_not include(:reciprocal)
-    ParParentTwo.association_reflection(:par_parents).reciprocal.should == :@par_parent_two
+    ParParentTwo.association_reflection(:par_parents).reciprocal.should == :par_parent_two
     ParParent.association_reflection(:par_parent_threes).should_not include(:reciprocal)
-    ParParent.association_reflection(:par_parent_threes).reciprocal.should == :@par_parents
+    ParParent.association_reflection(:par_parent_threes).reciprocal.should == :par_parents
     ParParentThree.association_reflection(:par_parents).should_not include(:reciprocal)
-    ParParentThree.association_reflection(:par_parents).reciprocal.should == :@par_parent_threes
+    ParParentThree.association_reflection(:par_parents).reciprocal.should == :par_parent_threes
   end
 end
 

data/spec/associations_spec.rb

@@ -144,12 +144,12 @@ describe Sequel::Model, "many_to_one" do
     d = @c2.create_new(:id => 1)
     MODEL_DB.reset
     d.parent_id = 234
-    d.instance_variable_get("@parent").should == nil
+    d.associations[:parent].should == nil
     ds = @c2.dataset
     def ds.fetch_rows(sql, &block); MODEL_DB.sqls << sql; yield({:id=>234}) end
     e = d.parent 
     MODEL_DB.sqls.should == ["SELECT nodes.* FROM nodes WHERE (id = 234) LIMIT 1"]
-    d.instance_variable_get("@parent").should == e
+    d.associations[:parent].should == e
   end
 
   it "should set cached instance variable when assigned" do
@@ -157,10 +157,10 @@ describe Sequel::Model, "many_to_one" do
 
     d = @c2.create(:id => 1)
     MODEL_DB.reset
-    d.instance_variable_get("@parent").should == nil
+    d.associations[:parent].should == nil
     d.parent = @c2.new(:id => 234)
     e = d.parent 
-    d.instance_variable_get("@parent").should == e
+    d.associations[:parent].should == e
     MODEL_DB.sqls.should == []
   end
 
@@ -169,7 +169,7 @@ describe Sequel::Model, "many_to_one" do
 
     d = @c2.create(:id => 1, :parent_id => 234)
     MODEL_DB.reset
-    d.instance_variable_set(:@parent, 42)
+    d.associations[:parent] = 42
     d.parent.should == 42
     MODEL_DB.sqls.should == []
   end
@@ -180,7 +180,7 @@ describe Sequel::Model, "many_to_one" do
     d = @c2.create(:id => 1)
     MODEL_DB.reset
     d.parent_id = 234
-    d.instance_variable_set(:@parent, 42)
+    d.associations[:parent] = 42
     d.parent(true).should_not == 42 
     MODEL_DB.sqls.should == ["SELECT nodes.* FROM nodes WHERE (id = 234) LIMIT 1"]
   end
@@ -234,18 +234,31 @@ describe Sequel::Model, "many_to_one" do
     MODEL_DB.sqls.should == []
   end
 
+  it "should not create the setter method if :read_only option is used" do
+    @c2.many_to_one :parent, :class => @c2, :read_only=>true
+    @c2.instance_methods.should(include('parent'))
+    @c2.instance_methods.should_not(include('parent='))
+  end
+
+  it "should raise an error if trying to set a model object that doesn't have a valid primary key" do
+    @c2.many_to_one :parent, :class => @c2
+    p = @c2.new
+    c = @c2.load(:id=>123)
+    proc{c.parent = p}.should raise_error(Sequel::Error)
+  end
+
   it "should have belongs_to alias" do
     @c2.belongs_to :parent, :class => @c2
 
     d = @c2.create_new(:id => 1)
     MODEL_DB.reset
     d.parent_id = 234
-    d.instance_variable_get("@parent").should == nil
+    d.associations[:parent].should == nil
     ds = @c2.dataset
     def ds.fetch_rows(sql, &block); MODEL_DB.sqls << sql; yield({:id=>234}) end
     e = d.parent 
     MODEL_DB.sqls.should == ["SELECT nodes.* FROM nodes WHERE (id = 234) LIMIT 1"]
-    d.instance_variable_get("@parent").should == e
+    d.associations[:parent].should == e
   end
 end
 
@@ -350,6 +363,26 @@ describe Sequel::Model, "one_to_many" do
     MODEL_DB.sqls.should == ['UPDATE attributes SET node_id = NULL WHERE (id = 2345)']
   end
   
+  it "should raise an error in add_ and remove_ if the passed object returns false to save (is not valid)" do
+    @c2.one_to_many :attributes, :class => @c1
+    n = @c2.new(:id => 1234)
+    a = @c1.new(:id => 2345)
+    def a.valid?; false; end
+    proc{n.add_attribute(a)}.should raise_error(Sequel::Error)
+    proc{n.remove_attribute(a)}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise an error if the model object doesn't have a valid primary key" do
+    @c2.one_to_many :attributes, :class => @c1 
+    a = @c2.new
+    n = @c1.load(:id=>123)
+    proc{a.attributes_dataset}.should raise_error(Sequel::Error)
+    proc{a.attributes}.should raise_error(Sequel::Error)
+    proc{a.add_attribute(n)}.should raise_error(Sequel::Error)
+    proc{a.remove_attribute(n)}.should raise_error(Sequel::Error)
+    proc{a.remove_all_attributes}.should raise_error(Sequel::Error)
+  end
+  
   it "should support a select option" do
     @c2.one_to_many :attributes, :class => @c1, :select => [:id, :name]
 
@@ -414,14 +447,33 @@ describe Sequel::Model, "one_to_many" do
     MODEL_DB.sqls.should == ['SELECT attributes.* FROM attributes WHERE ((node_id = 1234) AND (xxx IS NULL)) ORDER BY kind']
   end
   
+  it "should have the block argument affect the _dataset method" do
+    @c2.one_to_many :attributes, :class => @c1 do |ds|
+      ds.filter(:xxx => 456)
+    end
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes WHERE ((node_id = 1234) AND (xxx = 456))'
+  end
+  
+  it "should support a :limit option" do
+    @c2.one_to_many :attributes, :class => @c1 , :limit=>10
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes WHERE (node_id = 1234) LIMIT 10'
+    @c2.one_to_many :attributes, :class => @c1 , :limit=>[10,10]
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes WHERE (node_id = 1234) LIMIT 10 OFFSET 10'
+  end
+
+  it "should have the :eager option affect the _dataset method" do
+    @c2.one_to_many :attributes, :class => @c2 , :eager=>:attributes
+    @c2.new(:id => 1234).attributes_dataset.opts[:eager].should == {:attributes=>nil}
+  end
+  
   it "should set cached instance variable when accessed" do
     @c2.one_to_many :attributes, :class => @c1
 
     n = @c2.new(:id => 1234)
     MODEL_DB.reset
-    n.instance_variables.include?("@attributes").should == false
+    n.associations.include?(:attributes).should == false
     atts = n.attributes
-    atts.should == n.instance_variable_get("@attributes")
+    atts.should == n.associations[:attributes]
     MODEL_DB.sqls.should == ['SELECT attributes.* FROM attributes WHERE (node_id = 1234)']
   end
 
@@ -430,7 +482,7 @@ describe Sequel::Model, "one_to_many" do
 
     n = @c2.new(:id => 1234)
     MODEL_DB.reset
-    n.instance_variable_set(:@attributes, 42)
+    n.associations[:attributes] = 42
     n.attributes.should == 42
     MODEL_DB.sqls.should == []
   end
@@ -440,7 +492,7 @@ describe Sequel::Model, "one_to_many" do
 
     n = @c2.new(:id => 1234)
     MODEL_DB.reset
-    n.instance_variable_set(:@attributes, 42)
+    n.associations[:attributes] = 42
     n.attributes(true).should_not == 42
     MODEL_DB.sqls.should == ['SELECT attributes.* FROM attributes WHERE (node_id = 1234)']
   end
@@ -452,7 +504,7 @@ describe Sequel::Model, "one_to_many" do
     att = @c1.new(:id => 345)
     MODEL_DB.reset
     a = []
-    n.instance_variable_set(:@attributes, a)
+    n.associations[:attributes] = a
     n.add_attribute(att)
     a.should == [att]
   end
@@ -470,11 +522,11 @@ describe Sequel::Model, "one_to_many" do
   it "should remove item from cached instance variable if it exists when calling remove_" do
     @c2.one_to_many :attributes, :class => @c1
 
-    n = @c2.new(:id => 1234)
-    att = @c1.new(:id => 345)
+    n = @c2.load(:id => 1234)
+    att = @c1.load(:id => 345)
     MODEL_DB.reset
     a = [att]
-    n.instance_variable_set(:@attributes, a)
+    n.associations[:attributes] = a
     n.remove_attribute(att)
     a.should == []
   end
@@ -485,12 +537,22 @@ describe Sequel::Model, "one_to_many" do
 
     n = @c2.new(:id => 1234)
     att = @c1.new(:id => 345)
-    att.instance_variable_set(:@node, n)
+    att.associations[:node] = n
     att.node.should == n
     n.remove_attribute(att)
     att.node.should == nil
   end
 
+  it "should not create the add_, remove_, or remove_all_ methods if :read_only option is used" do
+    @c2.one_to_many :attributes, :class => @c1, :read_only=>true
+    im = @c2.instance_methods
+    im.should(include('attributes'))
+    im.should(include('attributes_dataset'))
+    im.should_not(include('add_attribute'))
+    im.should_not(include('remove_attribute'))
+    im.should_not(include('remove_all_attributes'))
+  end
+
   it "should have has_many alias" do
     @c2.has_many :attributes, :class => @c1
     
@@ -521,7 +583,7 @@ describe Sequel::Model, "one_to_many" do
   end
   
   it "should use an explicit reciprocal instance variable if given" do
-    @c2.one_to_many :attributes, :class => @c1, :key => :node_id, :reciprocal=>'@wxyz'
+    @c2.one_to_many :attributes, :class => @c1, :key => :node_id, :reciprocal=>:wxyz
     
     n = @c2.new(:id => 1234)
     atts = n.attributes
@@ -530,7 +592,7 @@ describe Sequel::Model, "one_to_many" do
     atts.size.should == 1
     atts.first.should be_a_kind_of(@c1)
     atts.first.values.should == {}
-    atts.first.instance_variable_get('@wxyz').should == n
+    atts.first.associations[:wxyz].should == n
     
     MODEL_DB.sqls.length.should == 1
   end
@@ -545,7 +607,7 @@ describe Sequel::Model, "one_to_many" do
     @c2.one_to_many :attributes, :class => @c1
     node = @c2.new(:id => 1234)
     node.remove_all_attributes
-    node.instance_variable_get(:@attributes).should == []
+    node.associations[:attributes].should == []
   end
 
   it "remove_all should return the array of previously associated items if the cached instance variable exists" do
@@ -555,9 +617,9 @@ describe Sequel::Model, "one_to_many" do
     d = @c1.dataset
     def d.fetch_rows(s); end
     node.attributes.should == []
-    def attrib.save!; end
+    def attrib.save!; self end
     node.add_attribute(attrib)
-    node.instance_variable_get(:@attributes).should == [attrib]
+    node.associations[:attributes].should == [attrib]
     node.remove_all_attributes.should == [attrib]
   end
 
@@ -577,11 +639,69 @@ describe Sequel::Model, "one_to_many" do
     node = @c2.new(:id => 1234)
     node.attributes.should == []
     attrib.node.should == nil
-    def attrib.save!; end
+    def attrib.save!; self end
     node.add_attribute(attrib)
-    attrib.instance_variable_get(:@node).should == node 
+    attrib.associations[:node].should == node 
     node.remove_all_attributes
-    attrib.instance_variable_get(:@node).should == :null
+    attrib.associations.fetch(:node, 2).should == nil
+  end
+
+  it "should add a getter method if the :one_to_one option is true" do
+    @c2.one_to_many :attributes, :class => @c1, :one_to_one=>true
+    att = @c2.new(:id => 1234).attribute
+    MODEL_DB.sqls.should == ['SELECT attributes.* FROM attributes WHERE (node_id = 1234)']
+    att.should be_a_kind_of(@c1)
+    att.values.should == {}
+  end
+
+  it "should not add a getter method if the :one_to_one option is true and :read_only option is true" do
+    @c2.one_to_many :attributes, :class => @c1, :one_to_one=>true, :read_only=>true
+    im = @c2.instance_methods
+    im.should(include('attribute'))
+    im.should_not(include('attribute='))
+  end
+
+  it "should have the getter method raise an error if more than one record is found" do
+    @c2.one_to_many :attributes, :class => @c1, :one_to_one=>true
+    d = @c1.dataset
+    def d.fetch_rows(s); 2.times{yield Hash.new} end
+    proc{@c2.new(:id => 1234).attribute}.should raise_error(Sequel::Error)
+  end
+
+  it "should add a setter method if the :one_to_one option is true" do
+    @c2.one_to_many :attributes, :class => @c1, :one_to_one=>true
+    attrib = @c1.new(:id=>3)
+    d = @c1.dataset
+    def d.fetch_rows(s); yield({:id=>3}) end
+    @c2.new(:id => 1234).attribute = attrib
+    ['INSERT INTO attributes (node_id, id) VALUES (1234, 3)',
+      'INSERT INTO attributes (id, node_id) VALUES (3, 1234)'].should(include(MODEL_DB.sqls.first))
+    MODEL_DB.sqls.last.should == 'UPDATE attributes SET node_id = NULL WHERE ((node_id = 1234) AND (id != 3))'
+    MODEL_DB.sqls.length.should == 2
+    @c2.new(:id => 1234).attribute.should == attrib
+    MODEL_DB.sqls.clear
+    attrib = @c1.load(:id=>3)
+    @c2.new(:id => 1234).attribute = attrib
+    MODEL_DB.sqls.should == ['UPDATE attributes SET node_id = 1234, id = 3 WHERE (id = 3)',
+      'UPDATE attributes SET node_id = NULL WHERE ((node_id = 1234) AND (id != 3))']
+  end
+
+  it "should raise an error if the one_to_one getter would be the same as the association name" do
+    proc{@c2.one_to_many :song, :class => @c1, :one_to_one=>true}.should raise_error(Sequel::Error)
+  end
+
+  it "should not create remove_ and remove_all methods if :one_to_one option is used" do
+    @c2.one_to_many :attributes, :class => @c1, :one_to_one=>true
+    @c2.new.should_not(respond_to(:remove_attribute))
+    @c2.new.should_not(respond_to(:remove_all_attributes))
+  end
+
+  it "should make non getter and setter methods private if :one_to_one option is used" do 
+    @c2.one_to_many :attributes, :class => @c1, :one_to_one=>true do |ds| end
+    meths = @c2.private_instance_methods(false)
+    meths.should(include("attributes"))
+    meths.should(include("add_attribute"))
+    meths.should(include("attributes_dataset"))
   end
 end
 
@@ -723,6 +843,25 @@ describe Sequel::Model, "many_to_many" do
     MODEL_DB.sqls.first.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) WHERE (xxx = 555) ORDER BY blah1, blah2'
   end
 
+  it "should have the block argument affect the _dataset method" do
+    @c2.many_to_many :attributes, :class => @c1 do |ds|
+      ds.filter(:xxx => 456)
+    end
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) WHERE (xxx = 456)'
+  end
+  
+  it "should support a :limit option" do
+    @c2.many_to_many :attributes, :class => @c1 , :limit=>10
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) LIMIT 10'
+    @c2.many_to_many :attributes, :class => @c1 , :limit=>[10, 10]
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) LIMIT 10 OFFSET 10'
+  end
+
+  it "should have the :eager option affect the _dataset method" do
+    @c2.many_to_many :attributes, :class => @c2 , :eager=>:attributes
+    @c2.new(:id => 1234).attributes_dataset.opts[:eager].should == {:attributes=>nil}
+  end
+  
   it "should define an add_ method" do
     @c2.many_to_many :attributes, :class => @c1
     
@@ -743,6 +882,25 @@ describe Sequel::Model, "many_to_many" do
     MODEL_DB.sqls.first.should == 'DELETE FROM attributes_nodes WHERE ((node_id = 1234) AND (attribute_id = 2345))'
   end
 
+  it "should raise an error if the model object doesn't have a valid primary key" do
+    @c2.many_to_many :attributes, :class => @c1 
+    a = @c2.new
+    n = @c1.load(:id=>123)
+    proc{a.attributes_dataset}.should raise_error(Sequel::Error)
+    proc{a.attributes}.should raise_error(Sequel::Error)
+    proc{a.add_attribute(n)}.should raise_error(Sequel::Error)
+    proc{a.remove_attribute(n)}.should raise_error(Sequel::Error)
+    proc{a.remove_all_attributes}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise an error if trying to add/remove a model object that doesn't have a valid primary key" do
+    @c2.many_to_many :attributes, :class => @c1 
+    n = @c1.new
+    a = @c2.load(:id=>123)
+    proc{a.add_attribute(n)}.should raise_error(Sequel::Error)
+    proc{a.remove_attribute(n)}.should raise_error(Sequel::Error)
+  end
+
   it "should provide an array with all members of the association" do
     @c2.many_to_many :attributes, :class => @c1
     
@@ -760,9 +918,9 @@ describe Sequel::Model, "many_to_many" do
 
     n = @c2.new(:id => 1234)
     MODEL_DB.reset
-    n.instance_variables.include?("@attributes").should == false
+    n.associations.include?(:attributes).should == false
     atts = n.attributes
-    atts.should == n.instance_variable_get("@attributes")
+    atts.should == n.associations[:attributes]
     MODEL_DB.sqls.length.should == 1
   end
 
@@ -771,7 +929,7 @@ describe Sequel::Model, "many_to_many" do
 
     n = @c2.new(:id => 1234)
     MODEL_DB.reset
-    n.instance_variable_set(:@attributes, 42)
+    n.associations[:attributes] = 42
     n.attributes.should == 42
     MODEL_DB.sqls.should == []
   end
@@ -781,7 +939,7 @@ describe Sequel::Model, "many_to_many" do
 
     n = @c2.new(:id => 1234)
     MODEL_DB.reset
-    n.instance_variable_set(:@attributes, 42)
+    n.associations[:attributes] = 42
     n.attributes(true).should_not == 42
     MODEL_DB.sqls.length.should == 1
   end
@@ -793,7 +951,7 @@ describe Sequel::Model, "many_to_many" do
     att = @c1.new(:id => 345)
     MODEL_DB.reset
     a = []
-    n.instance_variable_set(:@attributes, a)
+    n.associations[:attributes] = a
     n.add_attribute(att)
     a.should == [att]
   end
@@ -804,7 +962,7 @@ describe Sequel::Model, "many_to_many" do
 
     n = @c2.new(:id => 1234)
     att = @c1.new(:id => 345)
-    att.instance_variable_set(:@nodes, [])
+    att.associations[:nodes] = []
     n.add_attribute(att)
     att.nodes.should == [n]
   end
@@ -816,7 +974,7 @@ describe Sequel::Model, "many_to_many" do
     att = @c1.new(:id => 345)
     MODEL_DB.reset
     a = [att]
-    n.instance_variable_set(:@attributes, a)
+    n.associations[:attributes] = a
     n.remove_attribute(att)
     a.should == []
   end
@@ -827,11 +985,21 @@ describe Sequel::Model, "many_to_many" do
 
     n = @c2.new(:id => 1234)
     att = @c1.new(:id => 345)
-    att.instance_variable_set(:@nodes, [n])
+    att.associations[:nodes] = [n]
     n.remove_attribute(att)
     att.nodes.should == []
   end
 
+  it "should not create the add_, remove_, or remove_all_ methods if :read_only option is used" do
+    @c2.many_to_many :attributes, :class => @c1, :read_only=>true
+    im = @c2.instance_methods
+    im.should(include('attributes'))
+    im.should(include('attributes_dataset'))
+    im.should_not(include('add_attribute'))
+    im.should_not(include('remove_attribute'))
+    im.should_not(include('remove_all_attributes'))
+  end
+
   it "should have has_and_belongs_to_many alias" do
     @c2.has_and_belongs_to_many :attributes, :class => @c1 
 
@@ -851,7 +1019,7 @@ describe Sequel::Model, "many_to_many" do
     @c2.many_to_many :attributes, :class => @c1
     node = @c2.new(:id => 1234)
     node.remove_all_attributes
-    node.instance_variable_get(:@attributes).should == []
+    node.associations[:attributes].should == []
   end
 
   it "remove_all should return the array of previously associated items if the cached instance variable exists" do
@@ -862,7 +1030,7 @@ describe Sequel::Model, "many_to_many" do
     def d.fetch_rows(s); end
     node.attributes.should == []
     node.add_attribute(attrib)
-    node.instance_variable_get(:@attributes).should == [attrib]
+    node.associations[:attributes].should == [attrib]
     node.remove_all_attributes.should == [attrib]
   end
 
@@ -883,9 +1051,9 @@ describe Sequel::Model, "many_to_many" do
     node.attributes.should == []
     attrib.nodes.should == []
     node.add_attribute(attrib)
-    attrib.instance_variable_get(:@nodes).should == [node]
+    attrib.associations[:nodes].should == [node]
     node.remove_all_attributes
-    attrib.instance_variable_get(:@nodes).should == []
+    attrib.associations[:nodes].should == []
   end
 end