sequel 3.21.0 → 3.36.0

data/spec/extensions/dirty_spec.rb

@@ -0,0 +1,155 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::Dirty" do
+  before do
+    @db = Sequel.mock(:fetch=>{:initial=>'i', :initial_changed=>'ic'}, :numrows=>1)
+    @c = Class.new(Sequel::Model(@db[:c]))
+    @c.plugin :dirty
+    @c.columns :initial, :initial_changed, :missing, :missing_changed
+  end
+
+  shared_examples_for "dirty plugin" do
+    it "initial_value should be the current value if value has not changed" do
+      @o.initial_value(:initial).should == 'i'
+      @o.initial_value(:missing).should == nil
+    end
+
+    it "initial_value should be the intial value if value has changed" do
+      @o.initial_value(:initial_changed).should == 'ic'
+      @o.initial_value(:missing_changed).should == nil
+    end
+
+    it "initial_value should handle case where initial value is reassigned later" do
+      @o.initial_changed = 'ic'
+      @o.initial_value(:initial_changed).should == 'ic'
+      @o.missing_changed = nil
+      @o.initial_value(:missing_changed).should == nil
+    end
+
+    it "changed_columns should handle case where initial value is reassigned later" do
+      @o.changed_columns.should == [:initial_changed, :missing_changed]
+      @o.initial_changed = 'ic'
+      @o.changed_columns.should == [:missing_changed]
+      @o.missing_changed = nil
+      @o.changed_columns.should == [:missing_changed]
+    end
+
+    it "column_change should give initial and current values if there has been a change made" do
+      @o.column_change(:initial_changed).should == ['ic', 'ic2']
+      @o.column_change(:missing_changed).should == [nil, 'mc2']
+    end
+
+    it "column_change should be nil if no change has been made" do
+      @o.column_change(:initial).should == nil
+      @o.column_change(:missing).should == nil
+    end
+
+    it "column_changed? should return whether the column has changed" do
+      @o.column_changed?(:initial).should == false
+      @o.column_changed?(:initial_changed).should == true
+      @o.column_changed?(:missing).should == false
+      @o.column_changed?(:missing_changed).should == true
+    end
+
+    it "column_changed? should handle case where initial value is reassigned later" do
+      @o.initial_changed = 'ic'
+      @o.column_changed?(:initial_changed).should == false
+      @o.missing_changed = nil
+      @o.column_changed?(:missing_changed).should == false
+    end
+
+    it "changed_columns should handle case where initial value is reassigned later" do
+      @o.changed_columns.should == [:initial_changed, :missing_changed]
+      @o.initial_changed = 'ic'
+      @o.changed_columns.should == [:missing_changed]
+      @o.missing_changed = nil
+      @o.changed_columns.should == [:missing_changed]
+    end
+
+    it "column_changes should give initial and current values" do
+      @o.column_changes.should == {:initial_changed=>['ic', 'ic2'], :missing_changed=>[nil, 'mc2']}
+    end
+
+    it "reset_column should reset the column to its initial value" do
+      @o.reset_column(:initial)
+      @o.initial.should == 'i'
+      @o.reset_column(:initial_changed)
+      @o.initial_changed.should == 'ic'
+      @o.reset_column(:missing)
+      @o.missing.should == nil
+      @o.reset_column(:missing_changed)
+      @o.missing_changed.should == nil
+    end
+
+    it "reset_column should remove missing values from the values" do
+      @o.reset_column(:missing)
+      @o.values.has_key?(:missing).should == false
+      @o.reset_column(:missing_changed)
+      @o.values.has_key?(:missing_changed).should == false
+    end
+    
+    it "refresh should clear the cached initial values" do
+      @o.refresh
+      @o.column_changes.should == {}
+    end
+    
+    it "will_change_column should be used to signal in-place modification to column" do
+      @o.will_change_column(:initial)
+      @o.initial << 'b'
+      @o.column_change(:initial).should == ['i', 'ib']
+      @o.will_change_column(:initial_changed)
+      @o.initial_changed << 'b'
+      @o.column_change(:initial_changed).should == ['ic', 'ic2b']
+      @o.will_change_column(:missing)
+      @o.values[:missing] = 'b'
+      @o.column_change(:missing).should == [nil, 'b']
+      @o.will_change_column(:missing_changed)
+      @o.missing_changed << 'b'
+      @o.column_change(:missing_changed).should == [nil, 'mc2b']
+    end
+
+    it "will_change_column should different types of existing objects" do
+      [nil, true, false, Class.new{undef_method :clone}.new, Class.new{def clone; raise TypeError; end}.new].each do |v|
+        o = @c.new(:initial=>v)
+        o.will_change_column(:initial)
+        o.initial = 'a'
+        o.column_change(:initial).should == [v, 'a']
+      end
+    end
+
+    it "save should clear the cached initial values" do
+      @o.save
+      @o.column_changes.should == {}
+    end
+
+    it "save_changes should clear the cached initial values" do
+      @o.save_changes
+      @o.column_changes.should == {}
+    end
+  end
+
+  describe "with new instance" do
+    before do
+      @o = @c.new(:initial=>'i', :initial_changed=>'ic')
+      @o.initial_changed = 'ic2'
+      @o.missing_changed = 'mc2'
+    end
+
+    it_should_behave_like "dirty plugin"
+  end
+
+  describe "with existing instance" do
+    before do
+      @o = @c[1]
+      @o.initial_changed = 'ic2'
+      @o.missing_changed = 'mc2'
+    end
+
+    it_should_behave_like "dirty plugin"
+
+    it "previous_changes should be the previous changes after saving" do
+      @o.save
+      @o.previous_changes.should == {:initial_changed=>['ic', 'ic2'], :missing_changed=>[nil, 'mc2']}
+    end
+  end
+end

data/spec/extensions/eager_each_spec.rb

@@ -0,0 +1,34 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::EagerEach" do
+  before do
+    @c = Class.new(Sequel::Model(:items))
+    @c.columns :id, :parent_id
+    @c.plugin :eager_each
+    @c.one_to_many :children, :class=>@c, :key=>:parent_id
+    @c.db.sqls
+  end
+
+  it "should make #each on an eager dataset do eager loading" do
+    a = []
+    ds = @c.eager(:children)
+    ds._fetch = [{:id=>1, :parent_id=>nil}, {:id=>2, :parent_id=>nil}]
+    @c.dataset._fetch = [{:id=>3, :parent_id=>1}, {:id=>4, :parent_id=>1}, {:id=>5, :parent_id=>2}, {:id=>6, :parent_id=>2}]
+    ds.each{|c| a << c}
+    a.should == [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>2, :parent_id=>nil)]
+    a.map{|c| c.associations[:children]}.should == [[@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)], [@c.load(:id=>5, :parent_id=>2), @c.load(:id=>6, :parent_id=>2)]]
+    @c.db.sqls.should == ['SELECT * FROM items', 'SELECT * FROM items WHERE (items.parent_id IN (1, 2))']
+  end
+
+  it "should make #each on an eager_graph dataset do eager loading" do
+    a = []
+    ds = @c.eager_graph(:children)
+    ds._fetch = []
+    ds._fetch = [{:id=>1, :parent_id=>nil, :children_id=>3, :children_parent_id=>1}, {:id=>1, :parent_id=>nil, :children_id=>4, :children_parent_id=>1}, {:id=>2, :parent_id=>nil, :children_id=>5, :children_parent_id=>2}, {:id=>2, :parent_id=>nil, :children_id=>6, :children_parent_id=>2}]
+    ds.each{|c| a << c}
+    a.should == [@c.load(:id=>1, :parent_id=>nil), @c.load(:id=>2, :parent_id=>nil)]
+    a.map{|c| c.associations[:children]}.should == [[@c.load(:id=>3, :parent_id=>1), @c.load(:id=>4, :parent_id=>1)], [@c.load(:id=>5, :parent_id=>2), @c.load(:id=>6, :parent_id=>2)]]
+    @c.db.sqls.should == ['SELECT items.id, items.parent_id, children.id AS children_id, children.parent_id AS children_parent_id FROM items LEFT OUTER JOIN items AS children ON (children.parent_id = items.id)']
+  end
+
+end

data/spec/extensions/force_encoding_spec.rb

@@ -74,12 +74,13 @@ describe "force_encoding plugin" do
   
   specify "should work when saving new model instances" do
     o = @c.new
-    @c.dataset = ds = MODEL_DB[:a]
+    ds = MODEL_DB[:a]
     def ds.first
       s = 'blah'
       s.force_encoding('US-ASCII')
       {:id=>1, :x=>s}
     end
+    @c.dataset = ds
     o.save
     o.x.should == 'blah'
     o.x.encoding.should == @e1
@@ -87,12 +88,13 @@ describe "force_encoding plugin" do
   
   specify "should work when refreshing model instances" do
     o = @c.load(:id=>1, :x=>'as')
-    @c.dataset = ds = MODEL_DB[:a]
+    ds = MODEL_DB[:a]
     def ds.first
       s = 'blah'
       s.force_encoding('US-ASCII')
       {:id=>1, :x=>s}
     end
+    @c.dataset = ds
     o.refresh
     o.x.should == 'blah'
     o.x.encoding.should == @e1

data/spec/extensions/hook_class_methods_spec.rb

@@ -6,187 +6,185 @@ describe "Model hooks" do
   end
   
   specify "should be definable using a block" do
-    $adds = []
+    adds = []
     c = Class.new(Sequel::Model)
     c.class_eval do
-      before_save {$adds << 'hi'}
+      before_save{adds << 'hi'}
     end
     
     c.new.before_save
-    $adds.should == ['hi']
+    adds.should == ['hi']
   end
   
   specify "should be definable using a method name" do
-    $adds = []
+    adds = []
     c = Class.new(Sequel::Model)
     c.class_eval do
-      def bye; $adds << 'bye'; end
+      define_method(:bye){adds << 'bye'}
       before_save :bye
     end
     
     c.new.before_save
-    $adds.should == ['bye']
+    adds.should == ['bye']
   end
 
   specify "should be additive" do
-    $adds = []
+    adds = []
     c = Class.new(Sequel::Model)
     c.class_eval do
-      after_save {$adds << 'hyiyie'}
-      after_save {$adds << 'byiyie'}
+      after_save{adds << 'hyiyie'}
+      after_save{adds << 'byiyie'}
     end
 
     c.new.after_save
-    $adds.should == ['hyiyie', 'byiyie']
+    adds.should == ['hyiyie', 'byiyie']
   end
   
   specify "before hooks should run in reverse order" do
-    $adds = []
+    adds = []
     c = Class.new(Sequel::Model)
     c.class_eval do
-      before_save {$adds << 'hyiyie'}
-      before_save {$adds << 'byiyie'}
+      before_save{adds << 'hyiyie'}
+      before_save{adds << 'byiyie'}
     end
     
     c.new.before_save
-    $adds.should == ['byiyie', 'hyiyie']
+    adds.should == ['byiyie', 'hyiyie']
   end
 
   specify "should not be additive if the method or tag already exists" do
-    $adds = []
+    adds = []
     c = Class.new(Sequel::Model)
     c.class_eval do
-      def bye; $adds << 'bye'; end
+      define_method(:bye){adds << 'bye'}
       before_save :bye
       before_save :bye
     end
     
     c.new.before_save
-    $adds.should == ['bye']
+    adds.should == ['bye']
 
-    $adds = []
+    adds = []
     d = Class.new(Sequel::Model)
     d.class_eval do
-      before_save(:bye){$adds << 'hyiyie'}
-      before_save(:bye){$adds << 'byiyie'}
+      before_save(:bye){adds << 'hyiyie'}
+      before_save(:bye){adds << 'byiyie'}
     end
     
     d.new.before_save
-    $adds.should == ['byiyie']
+    adds.should == ['byiyie']
 
-    $adds = []
+    adds = []
     e = Class.new(Sequel::Model)
     e.class_eval do
-      def bye; $adds << 'bye'; end
+      define_method(:bye){adds << 'bye'}
       before_save :bye
-      before_save(:bye){$adds << 'byiyie'}
+      before_save(:bye){adds << 'byiyie'}
     end
     
     e.new.before_save
-    $adds.should == ['byiyie']
+    adds.should == ['byiyie']
 
-    $adds = []
+    adds = []
     e = Class.new(Sequel::Model)
     e.class_eval do
-      def bye; $adds << 'bye'; end
-      before_save(:bye){$adds << 'byiyie'}
+      define_method(:bye){adds << 'bye'}
+      before_save(:bye){adds << 'byiyie'}
       before_save :bye
     end
     
     e.new.before_save
-    $adds.should == ['bye']
+    adds.should == ['bye']
   end
   
   specify "should be inheritable" do
-    # pending
-    
-    $adds = []
+    adds = []
     a = Class.new(Sequel::Model)
     a.class_eval do
-      after_save {$adds << '123'}
+      after_save{adds << '123'}
     end
     
     b = Class.new(a)
     b.class_eval do
-      after_save {$adds << '456'}
-      after_save {$adds << '789'}
+      after_save{adds << '456'}
+      after_save{adds << '789'}
     end
     
     b.new.after_save
-    $adds.should == ['123', '456', '789']
+    adds.should == ['123', '456', '789']
   end
   
   specify "should be overridable in descendant classes" do
-    $adds = []
+    adds = []
     a = Class.new(Sequel::Model)
     a.class_eval do
-      before_save {$adds << '123'}
+      before_save{adds << '123'}
     end
     
     b = Class.new(a)
     b.class_eval do
-      def before_save; $adds << '456'; end
+      define_method(:before_save){adds << '456'}
     end
     
     a.new.before_save
-    $adds.should == ['123']
-    $adds = []
+    adds.should == ['123']
+    adds = []
     b.new.before_save
-    $adds.should == ['456']
+    adds.should == ['456']
   end
   
   specify "should stop processing if a before hook returns false" do
-    $flag = true
-    $adds = []
+    flag = true
+    adds = []
     
     a = Class.new(Sequel::Model)
     a.class_eval do
-      before_save {$adds << 'cruel'; $flag}
-      before_save {$adds << 'blah'; $flag}
+      before_save{adds << 'cruel'; flag}
+      before_save{adds << 'blah'; flag}
     end
     
     a.new.before_save
-    $adds.should == ['blah', 'cruel']
+    adds.should == ['blah', 'cruel']
 
     # chain should not break on nil
-    $adds = []
-    $flag = nil
+    adds = []
+    flag = nil
     a.new.before_save
-    $adds.should == ['blah', 'cruel']
+    adds.should == ['blah', 'cruel']
     
-    $adds = []
-    $flag = false
+    adds = []
+    flag = false
     a.new.before_save
-    $adds.should == ['blah']
+    adds.should == ['blah']
     
     b = Class.new(a)
     b.class_eval do
-      before_save {$adds << 'mau'}
+      before_save{adds << 'mau'}
     end
     
-    $adds = []
+    adds = []
     b.new.before_save
-    $adds.should == ['mau', 'blah']
+    adds.should == ['mau', 'blah']
   end
 end
 
 describe "Model#after_initialize" do
   specify "should be called after initialization" do
-    $values1 = nil
-    $reached_after_initialized = false
+    values1 = nil
+    reached_after_initialized = false
     
     a = Class.new(Sequel::Model)
     a.class_eval do
       columns :x, :y
       after_initialize do
-        $values1 = @values.clone
-        $reached_after_initialized = true
+        values1 = @values.clone
+        reached_after_initialized = true
       end
     end
     
     a.new(:x => 1, :y => 2)
-    $values1.should == {:x => 1, :y => 2}
-    $reached_after_initialized.should == true
+    values1.should == {:x => 1, :y => 2}
+    reached_after_initialized.should == true
   end
 end
 
@@ -206,11 +204,7 @@ describe "Model#before_create && Model#after_create" do
   specify "should be called around new record creation" do
     @c.before_create {MODEL_DB << "BLAH before"}
     @c.create(:x => 2)
-    MODEL_DB.sqls.should == [
-      'BLAH before',
-      'INSERT INTO items (x) VALUES (2)',
-      'BLAH after'
-    ]
+    MODEL_DB.sqls.should == ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after']
   end
 
   specify ".create should cancel the save and raise an error if before_create returns false and raise_on_save_failure is true" do
@@ -242,11 +236,7 @@ describe "Model#before_update && Model#after_update" do
     @c.before_update {MODEL_DB << "BLAH before"}
     m = @c.load(:id => 2233, :x=>123)
     m.save
-    MODEL_DB.sqls.should == [
-      'BLAH before',
-      'UPDATE items SET x = 123 WHERE (id = 2233)',
-      'BLAH after'
-    ]
+    MODEL_DB.sqls.should == ['BLAH before', 'UPDATE items SET x = 123 WHERE (id = 2233)', 'BLAH after']
   end
 
   specify "#save should cancel the save and raise an error if before_update returns false and raise_on_save_failure is true" do
@@ -279,22 +269,14 @@ describe "Model#before_save && Model#after_save" do
     @c.before_save {MODEL_DB << "BLAH before"}
     m = @c.load(:id => 2233, :x=>123)
     m.save
-    MODEL_DB.sqls.should == [
-      'BLAH before',
-      'UPDATE items SET x = 123 WHERE (id = 2233)',
-      'BLAH after'
-    ]
+    MODEL_DB.sqls.should == ['BLAH before', 'UPDATE items SET x = 123 WHERE (id = 2233)', 'BLAH after']
   end
   
   specify "should be called around record creation" do
     @c.before_save {MODEL_DB << "BLAH before"}
     @c.no_primary_key
     @c.create(:x => 2)
-    MODEL_DB.sqls.should == [
-      'BLAH before',
-      'INSERT INTO items (x) VALUES (2)',
-      'BLAH after'
-    ]
+    MODEL_DB.sqls.should == ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after']
   end
 
   specify "#save should cancel the save and raise an error if before_save returns false and raise_on_save_failure is true" do
@@ -319,10 +301,6 @@ describe "Model#before_destroy && Model#after_destroy" do
     @c = Class.new(Sequel::Model(:items))
     @c.class_eval do
       after_destroy {MODEL_DB << "BLAH after"}
-      
-      def delete
-        MODEL_DB << "DELETE BLAH"
-      end
     end
   end
   
@@ -330,11 +308,7 @@ describe "Model#before_destroy && Model#after_destroy" do
     @c.before_destroy {MODEL_DB << "BLAH before"}
     m = @c.load(:id => 2233)
     m.destroy
-    MODEL_DB.sqls.should == [
-      'BLAH before',
-      'DELETE BLAH',
-      'BLAH after'
-    ]
+    MODEL_DB.sqls.should == ['BLAH before', "DELETE FROM items WHERE id = 2233", 'BLAH after']
   end
 
   specify "#destroy should cancel the destroy and raise an error if before_destroy returns false and raise_on_save_failure is true" do
@@ -428,7 +402,7 @@ end
 
 describe "Model#add_hook_type" do
   before do
-    class Foo < Sequel::Model(:items)
+    class ::Foo < Sequel::Model(:items)
       add_hook_type :before_bar, :after_bar
 
       def bar
@@ -439,6 +413,9 @@ describe "Model#add_hook_type" do
     end
     @f = Class.new(Foo)
   end
+  after do
+    Object.send(:remove_const, :Foo)
+  end
 
   specify "should have before_bar and after_bar class methods" do
     @f.should respond_to(:before_bar)