sequel 1.4.0 → 1.5.0

data/spec/associations_spec.rb

@@ -23,7 +23,12 @@ describe Sequel::Model, "many_to_one" do
     MODEL_DB.reset
 
     @c2 = Class.new(Sequel::Model(:nodes)) do
-      def columns; [:id, :parent_id]; end
+      columns :id, :parent_id, :par_parent_id, :blah
+      def self.create_new(values)
+        obj = self.new(values)
+        obj.instance_variable_set(:@new, false)
+        obj
+      end
     end
 
     @dataset = @c2.dataset
@@ -53,6 +58,21 @@ describe Sequel::Model, "many_to_one" do
     MODEL_DB.sqls.should == ["SELECT * FROM par_parents WHERE (id = 234) LIMIT 1"]
   end
 
+  it "should use class inside module if given as a string" do
+    module Par 
+      class Parent < Sequel::Model
+      end
+    end
+    
+    @c2.many_to_one :par_parent, :class=>"Par::Parent"
+    
+    d = @c2.new(:id => 1, :par_parent_id => 234)
+    p = d.par_parent
+    p.class.should == Par::Parent
+    
+    MODEL_DB.sqls.should == ["SELECT * FROM parents WHERE (id = 234) LIMIT 1"]
+  end
+
   it "should use explicit key if given" do
     @c2.many_to_one :parent, :class => @c2, :key => :blah
 
@@ -71,6 +91,21 @@ describe Sequel::Model, "many_to_one" do
     d.parent.should == nil
   end
 
+  it "should cache negative lookup" do
+    @c2.many_to_one :parent, :class => @c2
+    ds = @c2.dataset
+    def ds.fetch_rows(sql, &block)
+      MODEL_DB.sqls << sql
+    end
+
+    d = @c2.new(:id => 1, :parent_id=>555)
+    MODEL_DB.sqls.should == []
+    d.parent.should == nil
+    MODEL_DB.sqls.should == ['SELECT * FROM nodes WHERE (id = 555) LIMIT 1']
+    d.parent.should == nil
+    MODEL_DB.sqls.should == ['SELECT * FROM nodes WHERE (id = 555) LIMIT 1']
+  end
+
   it "should define a setter method" do
     @c2.many_to_one :parent, :class => @c2
 
@@ -89,7 +124,7 @@ describe Sequel::Model, "many_to_one" do
   it "should not persist changes until saved" do
     @c2.many_to_one :parent, :class => @c2
 
-    d = @c2.create(:id => 1)
+    d = @c2.create_new(:id => 1)
     MODEL_DB.reset
     d.parent = @c2.new(:id => 345)
     MODEL_DB.sqls.should == []
@@ -100,10 +135,12 @@ describe Sequel::Model, "many_to_one" do
   it "should set cached instance variable when accessed" do
     @c2.many_to_one :parent, :class => @c2
 
-    d = @c2.create(:id => 1)
+    d = @c2.create_new(:id => 1)
     MODEL_DB.reset
     d.parent_id = 234
-    d.instance_variables.include?("@parent").should == false
+    d.instance_variable_get("@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 * FROM nodes WHERE (id = 234) LIMIT 1"]
     d.instance_variable_get("@parent").should == e
@@ -114,7 +151,7 @@ describe Sequel::Model, "many_to_one" do
 
     d = @c2.create(:id => 1)
     MODEL_DB.reset
-    d.instance_variables.include?("@parent").should == false
+    d.instance_variable_get("@parent").should == nil
     d.parent = @c2.new(:id => 234)
     e = d.parent 
     d.instance_variable_get("@parent").should == e
@@ -142,13 +179,64 @@ describe Sequel::Model, "many_to_one" do
     MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE (id = 234) LIMIT 1"]
   end
   
+  it "should have the setter add to the reciprocal one_to_many cached association list if it exists" do
+    @c2.many_to_one :parent, :class => @c2
+    @c2.one_to_many :children, :class => @c2, :key=>:parent_id
+    ds = @c2.dataset
+    def ds.fetch_rows(sql, &block)
+      MODEL_DB.sqls << sql
+    end
+
+    d = @c2.new(:id => 1)
+    e = @c2.new(:id => 2)
+    MODEL_DB.sqls.should == []
+    d.parent = e
+    e.children.should_not(include(d))
+    MODEL_DB.sqls.should == ['SELECT * FROM nodes WHERE (parent_id = 2)']
+
+    MODEL_DB.reset
+    d = @c2.new(:id => 1)
+    e = @c2.new(:id => 2)
+    e.children.should_not(include(d))
+    MODEL_DB.sqls.should == ['SELECT * FROM nodes WHERE (parent_id = 2)']
+    d.parent = e
+    e.children.should(include(d))
+    MODEL_DB.sqls.should == ['SELECT * FROM nodes WHERE (parent_id = 2)']
+  end
+
+  it "should have the setter remove the object from the previous associated object's reciprocal one_to_many cached association list if it exists" do
+    @c2.many_to_one :parent, :class => @c2
+    @c2.one_to_many :children, :class => @c2, :key=>:parent_id
+    ds = @c2.dataset
+    def ds.fetch_rows(sql, &block)
+      MODEL_DB.sqls << sql
+    end
+
+    d = @c2.new(:id => 1)
+    e = @c2.new(:id => 2)
+    f = @c2.new(:id => 3)
+    e.children.should_not(include(d))
+    f.children.should_not(include(d))
+    MODEL_DB.reset
+    d.parent = e
+    e.children.should(include(d))
+    d.parent = f
+    f.children.should(include(d))
+    e.children.should_not(include(d))
+    d.parent = nil
+    f.children.should_not(include(d))
+    MODEL_DB.sqls.should == []
+  end
+
   it "should have belongs_to alias" do
     @c2.belongs_to :parent, :class => @c2
 
-    d = @c2.create(:id => 1)
+    d = @c2.create_new(:id => 1)
     MODEL_DB.reset
     d.parent_id = 234
-    d.instance_variables.include?("@parent").should == false
+    d.instance_variable_get("@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 * FROM nodes WHERE (id = 234) LIMIT 1"]
     d.instance_variable_get("@parent").should == e
@@ -161,7 +249,7 @@ describe Sequel::Model, "one_to_many" do
     MODEL_DB.reset
 
     @c1 = Class.new(Sequel::Model(:attributes)) do
-      def columns; [:id, :node_id]; end
+      columns :id, :node_id
     end
 
     @c2 = Class.new(Sequel::Model(:nodes)) do
@@ -169,6 +257,7 @@ describe Sequel::Model, "one_to_many" do
       
       def self.name; 'Node'; end
       def self.to_s; 'Node'; end
+      columns :id
     end
     @dataset = @c2.dataset
     
@@ -209,6 +298,21 @@ describe Sequel::Model, "one_to_many" do
     v.model_classes.should == {nil => HistoricalValue}
   end
   
+  it "should use class inside a module if given as a string" do
+    module Historical
+      class Value < Sequel::Model
+      end
+    end
+    
+    @c2.one_to_many :historical_values, :class=>'Historical::Value'
+    
+    n = @c2.new(:id => 1234)
+    v = n.historical_values_dataset
+    v.should be_a_kind_of(Sequel::Dataset)
+    v.sql.should == 'SELECT * FROM values WHERE (node_id = 1234)'
+    v.model_classes.should == {nil => Historical::Value}
+  end
+
   it "should use explicit key if given" do
     @c2.one_to_many :attributes, :class => @c1, :key => :nodeid
     
@@ -340,6 +444,16 @@ describe Sequel::Model, "one_to_many" do
     a.should == [att]
   end
 
+  it "should set object to item's reciprocal cached association variable when calling add_" do
+    @c2.one_to_many :attributes, :class => @c1
+    @c1.many_to_one :node, :class => @c2
+
+    n = @c2.new(:id => 1234)
+    att = @c1.new(:id => 345)
+    n.add_attribute(att)
+    att.node.should == n
+  end
+
   it "should remove item from cached instance variable if it exists when calling remove_" do
     @c2.one_to_many :attributes, :class => @c1
 
@@ -352,6 +466,18 @@ describe Sequel::Model, "one_to_many" do
     a.should == []
   end
 
+  it "should remove item's reciprocal cached association variable when calling remove_" do
+    @c2.one_to_many :attributes, :class => @c1
+    @c1.many_to_one :node, :class => @c2
+
+    n = @c2.new(:id => 1234)
+    att = @c1.new(:id => 345)
+    att.instance_variable_set(:@node, n)
+    att.node.should == n
+    n.remove_attribute(att)
+    att.node.should == nil
+  end
+
   it "should have has_many alias" do
     @c2.has_many :attributes, :class => @c1
     
@@ -405,6 +531,7 @@ describe Sequel::Model, "many_to_many" do
     @c1 = Class.new(Sequel::Model(:attributes)) do
       def self.name; 'Attribute'; end
       def self.to_s; 'Attribute'; end
+      columns :id
     end
 
     @c2 = Class.new(Sequel::Model(:nodes)) do
@@ -412,6 +539,7 @@ describe Sequel::Model, "many_to_many" do
       
       def self.name; 'Node'; end
       def self.to_s; 'Node'; end
+      columns :id
     end
     @dataset = @c2.dataset
 
@@ -450,6 +578,22 @@ describe Sequel::Model, "many_to_many" do
     ].should(include(a.sql))
   end
   
+  it "should use class inside module if given as a string" do
+    module Historical
+      class Tag < Sequel::Model
+      end
+    end
+    
+    @c2.many_to_many :tags, :class=>'::Historical::Tag'
+
+    n = @c2.new(:id => 1234)
+    a = n.tags_dataset
+    a.should be_a_kind_of(Sequel::Dataset)
+    ['SELECT tags.* FROM tags INNER JOIN nodes_tags ON (nodes_tags.tag_id = tags.id) AND (nodes_tags.node_id = 1234)',
+     'SELECT tags.* FROM tags INNER JOIN nodes_tags ON (nodes_tags.node_id = 1234) AND (nodes_tags.tag_id = tags.id)'
+    ].should(include(a.sql))
+  end
+  
   it "should use explicit key values and join table if given" do
     @c2.many_to_many :attributes, :class => @c1, :left_key => :nodeid, :right_key => :attributeid, :join_table => :attribute2node
     
@@ -495,7 +639,7 @@ describe Sequel::Model, "many_to_many" do
   end
   
   it "should support an array for the select option" do
-    @c2.many_to_many :attributes, :class => @c1, :select => [:attributes.all, :attribute_nodes__blah2]
+    @c2.many_to_many :attributes, :class => @c1, :select => [:attributes.*, :attribute_nodes__blah2]
 
     n = @c2.new(:id => 1234)
     a = n.attributes_dataset
@@ -616,6 +760,17 @@ describe Sequel::Model, "many_to_many" do
     a.should == [att]
   end
 
+  it "should add item to reciprocal cached instance variable if it exists when calling add_" do
+    @c2.many_to_many :attributes, :class => @c1
+    @c1.many_to_many :nodes, :class => @c2
+
+    n = @c2.new(:id => 1234)
+    att = @c1.new(:id => 345)
+    att.instance_variable_set(:@nodes, [])
+    n.add_attribute(att)
+    att.nodes.should == [n]
+  end
+
   it "should remove item from cached instance variable if it exists when calling remove_" do
     @c2.many_to_many :attributes, :class => @c1
 
@@ -628,6 +783,17 @@ describe Sequel::Model, "many_to_many" do
     a.should == []
   end
 
+  it "should remove item from reciprocal cached instance variable if it exists when calling remove_" do
+    @c2.many_to_many :attributes, :class => @c1
+    @c1.many_to_many :nodes, :class => @c2
+
+    n = @c2.new(:id => 1234)
+    att = @c1.new(:id => 345)
+    att.instance_variable_set(:@nodes, [n])
+    n.remove_attribute(att)
+    att.nodes.should == []
+  end
+
   it "should have has_and_belongs_to_many alias" do
     @c2.has_and_belongs_to_many :attributes, :class => @c1 
 

data/spec/base_spec.rb

@@ -6,9 +6,7 @@ describe "Model attribute setters" do
     MODEL_DB.reset
 
     @c = Class.new(Sequel::Model(:items)) do
-      def columns
-        [:id, :x, :y]
-      end
+      columns :id, :x, :y
     end
   end
 
@@ -43,6 +41,7 @@ describe "Model#serialize" do
     @c = Class.new(Sequel::Model(:items)) do
       no_primary_key
       serialize :abc
+      columns :abc
     end
 
     @c.create(:abc => 1)
@@ -57,6 +56,7 @@ describe "Model#serialize" do
   it "should support calling after the class is defined" do
     @c = Class.new(Sequel::Model(:items)) do
       no_primary_key
+      columns :def
     end
 
     @c.serialize :def
@@ -74,6 +74,7 @@ describe "Model#serialize" do
     @c = Class.new(Sequel::Model(:items)) do
       no_primary_key
       serialize :abc, :format => :marshal
+      columns :abc
     end
 
     @c.create(:abc => 1)
@@ -88,6 +89,7 @@ describe "Model#serialize" do
   it "should translate values to and from YAML using accessor methods" do
     @c = Class.new(Sequel::Model(:items)) do
       serialize :abc, :def
+      columns :abc, :def
     end
 
     ds = @c.dataset
@@ -124,7 +126,7 @@ describe "Model#serialize" do
     o.abc.should == 1
     o.def.should == "hello"
 
-    o.set(:abc => 23)
+    o.update_values(:abc => 23)
     ds.sqls.should == "UPDATE items SET abc = '#{23.to_yaml}' WHERE (id = 1)"
 
     ds.raw = {:id => 1, :abc => "--- 1\n", :def => "--- hello\n"}
@@ -134,21 +136,8 @@ describe "Model#serialize" do
 
 end
 
-describe Sequel::Model, "super_dataset" do
-  setup do
-    MODEL_DB.reset
-    class SubClass < Sequel::Model(:items) ; end
-  end
-  
-  it "should call the superclass's dataset" do
-    SubClass.should_receive(:superclass).exactly(3).times.and_return(Sequel::Model(:items))
-    Sequel::Model(:items).should_receive(:dataset)
-    SubClass.super_dataset
-  end
-end
-
 describe Sequel::Model, "dataset" do
-  setup do
+  before do
     @a = Class.new(Sequel::Model(:items))
     @b = Class.new(Sequel::Model)
     
@@ -193,6 +182,36 @@ describe Sequel::Model, "dataset" do
   end
 end
 
+describe Sequel::Model, "def_dataset_method" do
+  setup do
+    @c = Class.new(Sequel::Model(:items)) do
+      @dataset = Object.new
+    end
+  end
+  
+  it "should add a method to the dataset and model if called with a block argument" do
+    @c.instance_eval do
+      def_dataset_method(:return_3){3}
+    end
+    @c.return_3.should == 3
+    @c.dataset.return_3.should == 3
+  end
+
+  it "should add all passed methods to the model if called without a block argument" do
+    @c.instance_eval do
+      def_dataset_method(:return_3, :return_4)
+    end
+    proc{@c.return_3}.should raise_error(NoMethodError)
+    proc{@c.return_4}.should raise_error(NoMethodError)
+    @c.dataset.instance_eval do
+      def return_3; 3; end
+      def return_4; 4; end
+    end
+    @c.return_3.should == 3
+    @c.return_4.should == 4
+  end
+end
+
 describe "A model class with implicit table name" do
   setup do
     class Donkey < Sequel::Model

data/spec/caching_spec.rb

@@ -16,9 +16,7 @@ describe Sequel::Model, "caching" do
     @c = Class.new(Sequel::Model(:items)) do
       set_cache cache
       
-      def self.columns
-        [:name, :id]
-      end
+      columns :name, :id
     end
     
     $cache_dataset_row = {:name => 'sharon', :id => 1}
@@ -88,6 +86,11 @@ describe Sequel::Model, "caching" do
     proc {m.cache_key}.should_not raise_error(Sequel::Error)
   end
   
+  it "should not raise error if trying to save a new record" do
+    proc {@c.new(:name=>'blah').save}.should_not raise_error
+    proc {@c.create(:name=>'blah')}.should_not raise_error
+  end
+  
   it "should set the cache when reading from the database" do
     $sqls.should == []
     @cache.should be_empty
@@ -109,7 +112,7 @@ describe Sequel::Model, "caching" do
     m = @c[1]
     @cache[m.cache_key].should == m
     
-    m.set(:name => 'tutu')
+    m.update_values(:name => 'tutu')
     @cache.has_key?(m.cache_key).should be_false
     $sqls.last.should == "UPDATE items SET name = 'tutu' WHERE (id = 1)"
     

data/spec/deprecated_relations_spec.rb

@@ -9,7 +9,7 @@ describe Sequel::Model, "one_to_one" do
     end
 
     @c2 = Class.new(Sequel::Model(:nodes)) do
-      def columns; [:id, :parent_id]; end
+      columns :id, :parent_id, :blah
     end
 
     @dataset = @c2.dataset
@@ -44,28 +44,6 @@ describe Sequel::Model, "one_to_one" do
     MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE (id = 567) LIMIT 1"]
   end
 
-  # the new implementation doesn't support plain datasets as associations
-  # it "should support plain dataset in the from option" do
-  #   @c2.one_to_one :parent, :from => MODEL_DB[:xyz]
-  #   
-  #   d = @c2.new(:id => 1, :parent_id => 789)
-  #   p = d.parent
-  #   p.class.should == Hash
-  #   
-  #   MODEL_DB.sqls.should == ["SELECT * FROM xyz WHERE (id = 789) LIMIT 1"]
-  # end
-
-  # the new implementation doesn't support plain datasets as associations
-  # it "should support table name in the from option" do
-  #   @c2.one_to_one :parent, :from => :abc
-  # 
-  #   d = @c2.new(:id => 1, :parent_id => 789)
-  #   p = d.parent
-  #   p.class.should == Hash
-  # 
-  #   MODEL_DB.sqls.should == ["SELECT * FROM abc WHERE (id = 789) LIMIT 1"]
-  # end
-
   it "should return nil if key value is nil" do
     @c2.one_to_one :parent, :from => @c2
 
@@ -104,6 +82,7 @@ describe Sequel::Model, "one_to_many" do
     end
 
     @c2 = Class.new(Sequel::Model(:nodes)) do
+      columns :id
     end
   end
 
@@ -116,32 +95,13 @@ describe Sequel::Model, "one_to_many" do
     a.sql.should == 'SELECT * FROM attributes WHERE (node_id = 1234)'
   end
   
-  # the new implementation doesn't support plain datasets as associations
-  # it "should support plain dataset in the from option" do
-  #   @c2.one_to_many :attributes, :from => MODEL_DB[:xyz], :key => :node_id
-  # 
-  #   n = @c2.new(:id => 1234)
-  #   a = n.attributes
-  #   a.should be_a_kind_of(Sequel::Dataset)
-  #   a.sql.should == 'SELECT * FROM xyz WHERE (node_id = 1234)'
-  # end
-
-  # the new implementation doesn't support plain datasets as associations
-  # it "should support table name in the from option" do
-  #   @c2.one_to_many :attributes, :from => :abc, :key => :node_id
-  # 
-  #   n = @c2.new(:id => 1234)
-  #   a = n.attributes
-  #   a.should be_a_kind_of(Sequel::Dataset)
-  #   a.sql.should == 'SELECT * FROM abc WHERE (node_id = 1234)'
-  # end
-  
   it "should support implicit key names" do
     $c1 = @c1
     
     module Music
       class BlueNote < Sequel::Model
         one_to_many :attributes, :from => $c1
+        columns :id
       end
     end