sequel 2.12.0 → 3.0.0

data/spec/model/inflector_spec.rb

@@ -1,126 +1,26 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
-describe String do
-  deprec_specify "#camelize and #camelcase should transform the word to CamelCase" do
-    "egg_and_hams".camelize.should == "EggAndHams"
-    "egg_and_hams".camelize(false).should == "eggAndHams"
-    "post".camelize.should == "Post"
-    "post".camelcase.should == "Post"
-  end
-
-  deprec_specify "#constantize should eval the string to get a constant" do
-    "String".constantize.should == String
-    "String::Inflections".constantize.should == String::Inflections
-    proc{"BKSDDF".constantize}.should raise_error
-    proc{"++A++".constantize}.should raise_error
-  end
-  
-  deprec_specify "#dasherize should transform underscores to dashes" do
-    "egg_and_hams".dasherize.should == "egg-and-hams"
-    "post".dasherize.should == "post"
-  end
-  
-  deprec_specify "#demodulize should remove any preceding modules" do
-    "String::Inflections::Blah".demodulize.should == "Blah"
-    "String::Inflections".demodulize.should == "Inflections"
-    "String".demodulize.should == "String"
-  end
-  
-  deprec_specify "#humanize should remove _i, transform underscore to spaces, and capitalize" do
-    "egg_and_hams".humanize.should == "Egg and hams"
-    "post".humanize.should == "Post"
-    "post_id".humanize.should == "Post"
-  end
-  
-  deprec_specify "#titleize and #titlecase should underscore, humanize, and capitalize all words" do
-    "egg-and: hams".titleize.should == "Egg And: Hams"
-    "post".titleize.should == "Post"
-    "post".titlecase.should == "Post"
-  end
-  
-  deprec_specify "#underscore should add underscores between CamelCased words, change :: to / and - to _, and downcase" do
-    "EggAndHams".underscore.should == "egg_and_hams"
-    "EGGAndHams".underscore.should == "egg_and_hams"
-    "Egg::And::Hams".underscore.should == "egg/and/hams"
-    "post".underscore.should == "post"
-    "post-id".underscore.should == "post_id"
-  end
-
-  deprec_specify "#pluralize should transform words from singular to plural" do
-    "post".pluralize.should == "posts"
-    "octopus".pluralize.should =="octopi"
-    "the blue mailman".pluralize.should == "the blue mailmen"
-    "CamelOctopus".pluralize.should == "CamelOctopi"
-  end
-  
-  deprec_specify "#singularize should transform words from plural to singular" do
-    "posts".singularize.should == "post"
-    "octopi".singularize.should == "octopus"
-    "the blue mailmen".singularize.should == "the blue mailman"
-    "CamelOctopi".singularize.should == "CamelOctopus"
-  end
-  
-  deprec_specify "#tableize should transform class names to table names" do
-    "RawScaledScorer".tableize.should == "raw_scaled_scorers"
-    "egg_and_ham".tableize.should == "egg_and_hams"
-    "fancyCategory".tableize.should == "fancy_categories"
-  end
-  
-  deprec_specify "#classify should tranform table names to class names" do
-    "egg_and_hams".classify.should == "EggAndHam"
-    "post".classify.should == "Post"
-  end
-  
-  deprec_specify "#foreign_key should create a foreign key name from a class name" do
-    "Message".foreign_key.should == "message_id"
-    "Message".foreign_key(false).should == "messageid"
-    "Admin::Post".foreign_key.should == "post_id"
-  end
-end
-
-describe String::Inflections do
+describe Sequel::Inflections do
   before do
-    deprec do
-      @plurals, @singulars, @uncountables = String.inflections.plurals.dup, String.inflections.singulars.dup, String.inflections.uncountables.dup
-    end
+    @plurals, @singulars, @uncountables = Sequel.inflections.plurals.dup, Sequel.inflections.singulars.dup, Sequel.inflections.uncountables.dup
   end
   after do
-    deprec do
-      String.inflections.plurals.replace(@plurals)
-      String.inflections.singulars.replace(@singulars)
-      String.inflections.uncountables.replace(@uncountables)
-      Sequel.inflections.plurals.replace(@plurals)
-      Sequel.inflections.singulars.replace(@singulars)
-      Sequel.inflections.uncountables.replace(@uncountables)
-    end
-  end
-
-  deprec_specify "should be possible to clear the list of singulars, plurals, and uncountables" do
-    String.inflections.clear(:plurals)
-    String.inflections.plurals.should == []
-    String.inflections.plural('blah', 'blahs')
-    String.inflections.clear
-    String.inflections.plurals.should == []
-    String.inflections.singulars.should == []
-    String.inflections.uncountables.should == []
+    Sequel.inflections.plurals.replace(@plurals)
+    Sequel.inflections.singulars.replace(@singulars)
+    Sequel.inflections.uncountables.replace(@uncountables)
   end
 
-  deprec_specify "should be able to specify new inflection rules" do
-    String.inflections do |i|
-      i.plural(/xx$/i, 'xxx')
-      i.singular(/ttt$/i, 'tt')
-      i.irregular('yy', 'yyy')
-      i.uncountable(%w'zz')
-    end
-    'roxx'.pluralize.should == 'roxxx'
-    'rottt'.singularize.should == 'rott'
-    'yy'.pluralize.should == 'yyy'
-    'yyy'.singularize.should == 'yy'
-    'zz'.pluralize.should == 'zz'
-    'zz'.singularize.should == 'zz'
+  it "should be possible to clear the list of singulars, plurals, and uncountables" do
+    Sequel.inflections.clear(:plurals)
+    Sequel.inflections.plurals.should == []
+    Sequel.inflections.plural('blah', 'blahs')
+    Sequel.inflections.clear
+    Sequel.inflections.plurals.should == []
+    Sequel.inflections.singulars.should == []
+    Sequel.inflections.uncountables.should == []
   end
 
-  deprec_specify "should be yielded and returned by String.inflections" do
-    String.inflections{|i| i.should == String::Inflections}.should == String::Inflections
+  it "should be yielded and returned by Sequel.inflections" do
+    Sequel.inflections{|i| i.should == Sequel::Inflections}.should == Sequel::Inflections
   end
 end

data/spec/model/model_spec.rb

@@ -64,22 +64,6 @@ describe Sequel::Model, "dataset & schema" do
     ds.should respond_to(:destroy)
   end
 
-  deprec_specify "sets schema with implicit table name" do
-    @model.set_schema do
-      primary_key :ssn, :string
-    end
-    @model.primary_key.should == :ssn
-    @model.table_name.should == :items
-  end
-
-  deprec_specify "sets schema with explicit table name" do
-    @model.set_schema :foo do
-      primary_key :id
-    end
-    @model.primary_key.should == :id
-    @model.table_name.should == :foo
-  end
-
   it "doesn't raise an error on set_dataset if there is an error raised getting the schema" do
     @model.meta_def(:get_db_schema){raise Sequel::Error}
     proc{@model.set_dataset(MODEL_DB[:foo])}.should_not raise_error
@@ -91,60 +75,6 @@ describe Sequel::Model, "dataset & schema" do
   end
 end
 
-describe Sequel::Model, "#sti_key" do
-  before do
-    deprec do
-      class ::StiTest < Sequel::Model
-        def kind=(x); self[:kind] = x; end
-        def refresh; end
-        set_sti_key :kind
-      end
-    end
-    class ::StiTestSub1 < StiTest
-    end
-    class ::StiTestSub2 < StiTest
-    end
-    @ds = StiTest.dataset
-    MODEL_DB.reset
-  end
-  
-  deprec_specify "should return rows with the correct class based on the polymorphic_key value" do
-    def @ds.fetch_rows(sql)
-      yield({:kind=>'StiTest'})
-      yield({:kind=>'StiTestSub1'})
-      yield({:kind=>'StiTestSub2'})
-    end
-    StiTest.all.collect{|x| x.class}.should == [StiTest, StiTestSub1, StiTestSub2]
-  end
-
-  deprec_specify "should fallback to the main class if polymophic_key value is NULL" do
-    def @ds.fetch_rows(sql)
-      yield({:kind=>nil})
-    end
-    StiTest.all.collect{|x| x.class}.should == [StiTest]
-  end
-  
-  deprec_specify "should fallback to the main class if the given class does not exist" do
-    def @ds.fetch_rows(sql)
-      yield({:kind=>'StiTestSub3'})
-    end
-    StiTest.all.collect{|x| x.class}.should == [StiTest]
-  end
-  
-  deprec_specify "should add a before_create hook that sets the model class name for the key" do
-    StiTest.new.save
-    StiTestSub1.new.save
-    StiTestSub2.new.save
-    MODEL_DB.sqls.should == ["INSERT INTO sti_tests (kind) VALUES ('StiTest')", "INSERT INTO sti_tests (kind) VALUES ('StiTestSub1')", "INSERT INTO sti_tests (kind) VALUES ('StiTestSub2')"]
-  end
-  
-  deprec_specify "should add a filter to model datasets inside subclasses hook to only retreive objects with the matching key" do
-    StiTest.dataset.sql.should == "SELECT * FROM sti_tests"
-    StiTestSub1.dataset.sql.should == "SELECT * FROM sti_tests WHERE (kind = 'StiTestSub1')"
-    StiTestSub2.dataset.sql.should == "SELECT * FROM sti_tests WHERE (kind = 'StiTestSub2')"
-  end
-end
-
 describe Sequel::Model, "constructor" do
   
   before(:each) do
@@ -327,47 +257,6 @@ describe Sequel::Model, ".find_or_create" do
   end
 end
 
-describe Sequel::Model, ".delete_all" do
-
-  before(:each) do
-    MODEL_DB.reset
-    @c = Class.new(Sequel::Model(:items)) do
-      no_primary_key
-    end
-    
-    @c.dataset.meta_def(:delete) {MODEL_DB << delete_sql}
-  end
-
-  deprec_specify "should delete all records in the dataset" do
-    @c.delete_all
-    MODEL_DB.sqls.should == ["DELETE FROM items"]
-  end
-
-end
-
-describe Sequel::Model, ".destroy_all" do
-
-  before(:each) do
-    MODEL_DB.reset
-    @c = Class.new(Sequel::Model(:items)) do
-      no_primary_key
-    end
-
-    @c.dataset.meta_def(:delete) {MODEL_DB << delete_sql}
-  end
-
-  deprec_specify "should delete all records in the dataset" do
-    @c.dataset.meta_def(:destroy) {MODEL_DB << "DESTROY this stuff"}
-    @c.destroy_all
-    MODEL_DB.sqls.should == ["DESTROY this stuff"]
-  end
-  
-  deprec_specify "should call dataset.destroy" do
-    @c.dataset.should_receive(:destroy).and_return(true)
-    @c.destroy_all
-  end
-end
-
 describe Sequel::Model, ".all" do
   
   before(:each) do
@@ -582,12 +471,3 @@ context "Model.db_schema" do
     @c.db_schema.should == {:x=>{}}
   end
 end
-
-context "Model.str_columns" do
-  deprec_specify "should return the columns as frozen strings" do
-    c = Class.new(Sequel::Model)
-    c.meta_def(:columns){[:a, :b]}
-    c.orig_str_columns.should == %w'a b'
-    proc{c.orig_str_columns.first << 'a'}.should raise_error
-  end
-end

data/spec/model/plugins_spec.rb

@@ -69,74 +69,4 @@ describe Sequel::Model, "using a plugin" do
     c.should respond_to(:ghi)
     c.ghi.should == {:a => 1, :b => 2}
   end
-  
-  deprec_specify "should have an .is alias" do
-    c = nil
-    proc do
-      c = Class.new(Sequel::Model)
-      c.class_eval do
-        set_dataset MODEL_DB[:items]
-        is :timestamped, :a => 1, :b => 2
-      end
-    end.should_not raise_error(LoadError)
-    
-    c.should respond_to(:stamp_opts)
-    c.stamp_opts.should == {:a => 1, :b => 2}
-    
-    # instance methods
-    m = c.new
-    m.should respond_to(:get_stamp)
-    m.should respond_to(:abc)
-    m.abc.should == {:a => 1, :b => 2}
-    t = Time.now
-    m[:stamp] = t
-    m.get_stamp.should == t
-    
-    # class methods
-    c.should respond_to(:deff)
-    c.deff.should == {:a => 1, :b => 2}
-    
-    # dataset methods
-    c.dataset.should respond_to(:ghi)
-    c.dataset.ghi.should == {:a => 1, :b => 2}
-
-    # dataset methods called on the class
-    c.should respond_to(:ghi)
-    c.ghi.should == {:a => 1, :b => 2}
-  end
-  
-  deprec_specify "should have an .is_a alias" do
-    c = nil
-    proc do
-      c = Class.new(Sequel::Model)
-      c.class_eval do
-        set_dataset MODEL_DB[:items]
-        is_a :timestamped, :a => 1, :b => 2
-      end
-    end.should_not raise_error(LoadError)
-    
-    c.should respond_to(:stamp_opts)
-    c.stamp_opts.should == {:a => 1, :b => 2}
-    
-    # instance methods
-    m = c.new
-    m.should respond_to(:get_stamp)
-    m.should respond_to(:abc)
-    m.abc.should == {:a => 1, :b => 2}
-    t = Time.now
-    m[:stamp] = t
-    m.get_stamp.should == t
-    
-    # class methods
-    c.should respond_to(:deff)
-    c.deff.should == {:a => 1, :b => 2}
-    
-    # dataset methods
-    c.dataset.should respond_to(:ghi)
-    c.dataset.ghi.should == {:a => 1, :b => 2}
-
-    # dataset methods called on the class
-    c.should respond_to(:ghi)
-    c.ghi.should == {:a => 1, :b => 2}
-  end
 end

data/spec/model/record_spec.rb

@@ -1,5 +1,39 @@
 require File.join(File.dirname(__FILE__), "spec_helper")
 
+describe "Model#save server use" do
+  
+  before(:each) do
+    @c = Class.new(Sequel::Model(:items)) do
+      columns :id, :x, :y
+    end
+    @c.db = MockDatabase.new
+    db2 = @db2 = MockDatabase.new
+    @c.class_eval do
+      define_method(:after_save) do
+        model.db = db2
+        ds = model.dataset
+        def ds.fetch_rows(sql)
+          yield @db.execute(sql, @opts[:server])
+        end
+        @this = nil
+      end
+    end
+  end
+
+  it "should use the :default server if the model doesn't have one already specified" do
+    @c.db.should_receive(:execute).with("INSERT INTO items (x) VALUES (1)").and_return(10)
+    @db2.should_receive(:execute).with('SELECT * FROM items WHERE (id = 10) LIMIT 1', :default).and_return(:x=>1, :id=>10)
+    @c.new(:x=>1).save
+  end
+
+  it "should use the model's server if the model has one already specified" do
+    @c.dataset = @c.dataset.server(:blah)
+    @c.db.should_receive(:execute).with("INSERT INTO items (x) VALUES (1)").and_return(10)
+    @db2.should_receive(:execute).with('SELECT * FROM items WHERE (id = 10) LIMIT 1', :blah).and_return(:x=>1, :id=>10)
+    @c.new(:x=>1).save
+  end
+end
+
 describe "Model#save" do
   
   before(:each) do
@@ -228,73 +262,6 @@ describe "Model#save_changes" do
   end
 end
 
-describe "Model#update_values" do
-  before(:each) do
-    MODEL_DB.reset
-
-    @c = Class.new(Sequel::Model(:items)) do
-      unrestrict_primary_key
-      columns :id, :x, :y
-    end
-  end
-  
-  deprec_specify "should generate an update statement" do
-    o = @c.new(:id => 1)
-    o.update_values(:x => 1)
-    MODEL_DB.sqls.first.should == "UPDATE items SET x = 1 WHERE (id = 1)"
-  end
-  
-  deprec_specify "should update attribute values" do
-    o = @c.new(:id => 1)
-    o.x.should be_nil
-    o.update_values(:x => 1)
-    o.x.should == 1
-  end
-  
-  deprec_specify "should support string keys" do
-    o = @c.new(:id => 1)
-    o.x.should be_nil
-    o.update_values('x' => 1)
-    o.x.should == 1
-    MODEL_DB.sqls.first.should == "UPDATE items SET x = 1 WHERE (id = 1)"
-  end
-end
-
-describe "Model#set_values" do
-  before(:each) do
-    MODEL_DB.reset
-
-    @c = Class.new(Sequel::Model(:items)) do
-      unrestrict_primary_key
-      columns :id, :x, :y
-    end
-  end
-  
-  deprec_specify "should not touch the database" do
-    o = @c.new(:id => 1)
-    o.set_values(:x => 1)
-    MODEL_DB.sqls.should == []
-  end
-  
-  deprec_specify "should update attribute values" do
-    o = @c.new(:id => 1)
-    o.x.should be_nil
-    o.set_values(:x => 1)
-    o.x.should == 1
-  end
-  
-  deprec_specify "should support string keys" do
-    o = @c.new(:id => 1)
-    o.x.should be_nil
-    o.set_values('x' => 1)
-    o.x.should == 1
-  end
-
-  deprec_specify "should raise an error if used with a non-String, non-Symbol key" do
-    proc{@c.new.set_values(1=>2)}.should raise_error(Sequel::Error)
-  end
-end
-
 describe "Model#new?" do
   
   before(:each) do
@@ -506,23 +473,11 @@ describe Sequel::Model, "#set" do
     MODEL_DB.sqls.should == []
   end
 
-  deprec_specify "should be aliased as set_with_params" do
-    @o1.set_with_params(:x => 1, :z => 2)
-    @o1.values.should == {:x => 1}
-    MODEL_DB.sqls.should == []
-  end
-  
   it "should return self" do
     returned_value = @o1.set(:x => 1, :z => 2)
     returned_value.should == @o1
     MODEL_DB.sqls.should == []
   end
-
-  deprec_specify "should assume it is a column if no column information is present and the key is a symbol" do
-    @c.instance_variable_set(:@columns, nil)
-    o = @c.new.set(:x123=>1)
-    o[:x123].should == 1
-  end
 end
 
 describe Sequel::Model, "#update" do
@@ -562,11 +517,6 @@ describe Sequel::Model, "#update" do
     @o2.values.should == {:y => 1, :id=> 5}
     MODEL_DB.sqls.first.should == "UPDATE items SET y = 1 WHERE (id = 5)"
   end
-
-  deprec_specify "should be aliased as update_with_params" do
-    @o1.update_with_params(:x => 1, :z => 2)
-    MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (1)"
-  end
 end
 
 describe Sequel::Model, "#(set|update)_(all|except|only)" do
@@ -950,14 +900,6 @@ describe Sequel::Model, "typecasting" do
     m.x.should == '1'
   end
 
-  deprec_specify "should not convert if serializing the field" do
-    @c.serialize :x
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:string}})
-    m = @c.new
-    m.x =[1, 2]
-    m.x.should == [1, 2]
-  end
-
   specify "should convert to integer for an integer field" do
     @c.instance_variable_set(:@db_schema, {:x=>{:type=>:integer}})
     m = @c.new
@@ -1065,7 +1007,7 @@ describe Sequel::Model, "typecasting" do
   specify "should convert to BigDecimal for a decimal field" do
     @c.instance_variable_set(:@db_schema, {:x=>{:type=>:decimal}})
     m = @c.new
-    bd = '1.0'.to_d
+    bd = BigDecimal.new('1.0')
     m.x = '1.0'
     m.x.should == bd
     m.x = 1.0