sequel 1.5.1 → 2.0.0

data/spec/inflector_spec.rb

@@ -1,6 +1,6 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
-describe Inflector do
+describe String do
   it "should transform words from singular to plural" do
     "post".pluralize.should == "posts"
     "octopus".pluralize.should =="octopi"
@@ -31,4 +31,4 @@ describe Inflector do
     "Message".foreign_key(false).should == "messageid"
     "Admin::Post".foreign_key.should == "post_id"
   end
-end
+end

data/spec/model_spec.rb

@@ -4,7 +4,7 @@ describe Sequel::Model do
   it "should have class method aliased as model" do
     Sequel::Model.instance_methods.should include("model")
 
-    model_a = Class.new Sequel::Model
+    model_a = Class.new(Sequel::Model(:items))
     model_a.new.model.should be(model_a)
   end
 
@@ -48,6 +48,23 @@ describe Sequel::Model, "dataset & schema" do
     @model.table_name.should == :foo
   end
 
+  it "set_dataset should take a symbol" do
+    @model.db = MODEL_DB
+    @model.set_dataset(:foo)
+    @model.table_name.should == :foo
+  end
+
+  it "set_dataset should raise an error unless given a Symbol or Dataset" do
+    proc{@model.set_dataset(Object.new)}.should raise_error(Sequel::Error)
+  end
+
+  it "set_dataset should add the destroy method to the dataset" do
+    ds = MODEL_DB[:foo]
+    ds.should_not respond_to(:destroy)
+    @model.set_dataset(ds)
+    ds.should respond_to(:destroy)
+  end
+
   it "sets schema with implicit table name" do
     @model.set_schema do
       primary_key :ssn, :string
@@ -142,7 +159,7 @@ describe Sequel::Model, ".subset" do
     @c = Class.new(Sequel::Model(:items))
   end
 
-  it "should create a filter on the underlying dataset" do
+  pt_specify "should create a filter on the underlying dataset" do
     proc {@c.new_only}.should raise_error(NoMethodError)
     
     @c.subset(:new_only) {:age == 'new'}
@@ -156,8 +173,8 @@ describe Sequel::Model, ".subset" do
     @c.dataset.pricey.sql.should == "SELECT * FROM items WHERE (price > 100)"
     
     # check if subsets are composable
-    @c.pricey.new_only.sql.should == "SELECT * FROM items WHERE (price > 100) AND (age = 'new')"
-    @c.new_only.pricey.sql.should == "SELECT * FROM items WHERE (age = 'new') AND (price > 100)"
+    @c.pricey.new_only.sql.should == "SELECT * FROM items WHERE ((price > 100) AND (age = 'new'))"
+    @c.new_only.pricey.sql.should == "SELECT * FROM items WHERE ((age = 'new') AND (price > 100))"
   end
 
 end
@@ -184,11 +201,11 @@ describe Sequel::Model, ".find" do
     @c.find(:name => 'sharon').should be_a_kind_of(@c)
     $sqls.last.should == "SELECT * FROM items WHERE (name = 'sharon') LIMIT 1"
 
-    @c.find {"name LIKE 'abc%'".lit}.should be_a_kind_of(@c)
-    $sqls.last.should == "SELECT * FROM items WHERE name LIKE 'abc%' LIMIT 1"
+    @c.find(:name.like('abc%')).should be_a_kind_of(@c)
+    $sqls.last.should == "SELECT * FROM items WHERE (name LIKE 'abc%') LIMIT 1"
   end
   
-  it "should accept filter blocks" do
+  pt_specify "should accept filter blocks" do
     @c.find {:id == 1}.should be_a_kind_of(@c)
     $sqls.last.should == "SELECT * FROM items WHERE (id = 1) LIMIT 1"
 
@@ -217,73 +234,6 @@ describe Sequel::Model, ".fetch" do
   
 end
 
-### DEPRECATED
-describe Sequel::Model, "magic methods" do
-
-  before(:each) do
-    @c = Class.new(Sequel::Dataset) do
-      @@sqls = []
-    
-      def self.sqls; @@sqls; end
-    
-      def fetch_rows(sql)
-        @@sqls << sql
-        yield({:id => 123, :name => 'hey'})
-      end
-    end
-  
-    @m = Class.new(Sequel::Model(@c.new(nil).from(:items)))
-  end
-  
-  it "should support order_by_xxx" do
-    @m.order_by_name.should be_a_kind_of(@c)
-    @m.order_by_name.sql.should == "SELECT * FROM items ORDER BY name"
-  end
-
-  it "should support group_by_xxx" do
-    @m.group_by_name.should be_a_kind_of(@c)
-    @m.group_by_name.sql.should == "SELECT * FROM items GROUP BY name"
-  end
-
-  it "should support count_by_xxx" do
-    @m.count_by_name.should be_a_kind_of(@c)
-    @m.count_by_name.sql.should == "SELECT name, count(*) AS count FROM items GROUP BY name ORDER BY count"
-  end
-
-  it "should support filter_by_xxx" do
-    @m.filter_by_name('sharon').should be_a_kind_of(@c)
-    @m.filter_by_name('sharon').sql.should == "SELECT * FROM items WHERE (name = 'sharon')"
-  end
-  
-  it "should support all_by_xxx" do
-    all = @m.all_by_name('sharon')
-    all.class.should == Array
-    all.size.should == 1
-    all.first.should be_a_kind_of(@m)
-    all.first.values.should == {:id => 123, :name => 'hey'}
-    @c.sqls.should == ["SELECT * FROM items WHERE (name = 'sharon')"]
-  end
-  
-  it "should support find_by_xxx" do
-    @m.find_by_name('sharon').should be_a_kind_of(@m)
-    @m.find_by_name('sharon').values.should == {:id => 123, :name => 'hey'}
-    @c.sqls.should == ["SELECT * FROM items WHERE (name = 'sharon') LIMIT 1"] * 2
-  end
-
-  it "should support first_by_xxx" do
-    @m.first_by_name('sharon').should be_a_kind_of(@m)
-    @m.first_by_name('sharon').values.should == {:id => 123, :name => 'hey'}
-    @c.sqls.should == ["SELECT * FROM items ORDER BY name LIMIT 1"] * 2
-  end
-
-  it "should support last_by_xxx" do
-    @m.last_by_name('sharon').should be_a_kind_of(@m)
-    @m.last_by_name('sharon').values.should == {:id => 123, :name => 'hey'}
-    @c.sqls.should == ["SELECT * FROM items ORDER BY name DESC LIMIT 1"] * 2
-  end
-  
-end
-
 describe Sequel::Model, ".find_or_create" do
 
   before(:each) do
@@ -420,14 +370,17 @@ describe Sequel::Model, "A model class without a primary key" do
 end
 
 describe Sequel::Model, "attribute accessors" do
+  after do
+    Sequel::Model.lazy_load_schema = false
+  end
 
-  before(:each) do
+  before do
     MODEL_DB.reset
 
     @c = Class.new(Sequel::Model) do
       def self.columns; orig_columns; end
     end
-    @dataset = Object.new
+    @dataset = Sequel::Dataset.new(MODEL_DB)
     def @dataset.db; end
     def @dataset.set_model(blah); end
     def @dataset.naked; self; end
@@ -435,7 +388,7 @@ describe Sequel::Model, "attribute accessors" do
     def @dataset.def_mutation_method(*names);  end
   end
 
-  it "should be created on set_dataset" do
+  it "should be created on set_dataset unless lazy loading schema" do
     %w'x y x= y='.each do |x|
       @c.instance_methods.include?(x).should == false
     end
@@ -453,6 +406,28 @@ describe Sequel::Model, "attribute accessors" do
     o.x.should == 34
   end
 
+  it "should be created on first initialization if lazy loading schema" do
+    Sequel::Model.lazy_load_schema = true
+    %w'x y x= y='.each do |x|
+      @c.instance_methods.include?(x).should == false
+    end
+    @c.set_dataset(@dataset)
+    %w'x y x= y='.each do |x|
+      @c.instance_methods.include?(x).should == false 
+    end
+    o = @c.new
+    %w'x y x= y='.each do |x|
+      @c.instance_methods.include?(x).should == true
+    end
+    %w'x y x= y='.each do |x|
+      o.methods.include?(x).should == true
+    end
+
+    o.x.should be_nil
+    o.x = 34
+    o.x.should == 34
+  end
+
   it "should be only accept one argument for the write accessor" do
     @c.set_dataset(@dataset)
     o = @c.new
@@ -505,7 +480,7 @@ describe Sequel::Model, ".[]" do
     @c.set_primary_key [:node_id, :kind]
     @c[3921, 201].should be_a_kind_of(@c)
     $sqls.last.should =~ \
-    /^SELECT \* FROM items WHERE (\(node_id = 3921\) AND \(kind = 201\))|(\(kind = 201\) AND \(node_id = 3921\)) LIMIT 1$/
+    /^SELECT \* FROM items WHERE \((\(node_id = 3921\) AND \(kind = 201\))|(\(kind = 201\) AND \(node_id = 3921\))\) LIMIT 1$/
   end
 end
 
@@ -518,3 +493,60 @@ context "Model#inspect" do
     @o.inspect.should == '#<Sequel::Model @values={:x=>333}>'
   end
 end
+
+context "Model.db_schema" do
+  setup do
+    @c = Class.new(Sequel::Model(:items)) do
+      def self.columns; orig_columns; end
+    end
+    @dataset = Sequel::Dataset.new(nil).from(:items)
+    @dataset.meta_def(:db){@db ||= Sequel::Database.new}
+    def @dataset.set_model(blah); end
+    def @dataset.naked; self; end
+    def @dataset.columns; []; end
+    def @dataset.def_mutation_method(*names);  end
+  end
+  
+  specify "should use the database's schema_for_table and set the columns" do
+    d = @dataset.db
+    def d.schema(table)
+      [[:x, {:type=>:integer}], [:y, {:type=>:string}]]
+    end
+    @c.dataset = @dataset
+    @c.db_schema.should == {:x=>{:type=>:integer}, :y=>{:type=>:string}}
+    @c.columns.should == [:x, :y]
+  end
+
+  specify "should restrict the schema and columns for datasets with a :select option" do
+    ds = @dataset.select(:x, :y___z)
+    d = ds.db
+    def d.schema(table)
+      [[:x, {:type=>:integer}], [:y, {:type=>:string}]]
+    end
+    def @c.columns; [:x, :z]; end
+    @c.dataset = ds
+    @c.db_schema.should == {:x=>{:type=>:integer}, :z=>{}}
+  end
+
+  specify "should not use schema_for_table if the dataset uses multiple tables or custom sql" do
+    ds = @dataset.join(:x, :id)
+    d = ds.db
+    e = false
+    d.meta_def(:schema){|table| e = true}
+    def @c.columns; [:x]; end
+    @c.dataset = ds
+    @c.db_schema.should == {:x=>{}}
+    e.should == false
+  end
+
+  specify "should fallback to fetching records if schema_for_table raises an error" do
+    ds = @dataset.join(:x, :id)
+    d = ds.db
+    def d.schema(table)
+      raise StandardError
+    end
+    def @c.columns; [:x]; end
+    @c.dataset = ds
+    @c.db_schema.should == {:x=>{}}
+  end
+end

data/spec/plugins_spec.rb

@@ -62,6 +62,10 @@ describe Sequel::Model, "using a plugin" do
     # 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
   
   it "should fail to apply if the plugin has DatasetMethod and the model has no datset" do

data/spec/rcov.opts

@@ -1,4 +1,4 @@
 --exclude
 gems
 --exclude
-spec
+spec

data/spec/record_spec.rb

@@ -185,16 +185,6 @@ describe "Model#new?" do
     n.save
     n.should_not be_new
   end
-  
-  ### DEPRECATED
-  it "should alias new_record? to new?" do
-    n = @c.new(:x => 1)
-    n.should respond_to(:new_record?)
-    n.should be_new_record
-    n.save
-    n.should_not be_new_record
-  end
-  
 end
 
 describe Sequel::Model, "w/ primary key" do
@@ -254,8 +244,8 @@ describe Sequel::Model, "with this" do
 
     parts = [
       'SELECT * FROM examples WHERE %s LIMIT 1',
-      '(x = 4) AND (y = 5)', 
-      '(y = 5) AND (x = 4)'
+      '((x = 4) AND (y = 5))', 
+      '((y = 5) AND (x = 4))'
     ].map { |expr| Regexp.escape expr }
     regexp = Regexp.new parts.first % "(?:#{parts[1]}|#{parts[2]})"
 
@@ -398,16 +388,6 @@ describe Sequel::Model, "update_with_params" do
     MODEL_DB.sqls.first.should == "UPDATE items SET y = 1 WHERE (id = 5)"
   end
   
-  ### DEPRECATE
-  it "should be aliased by update_with" do
-    @o1.update_with(:x => 1, :z => 2)
-    MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (1)"
-
-    MODEL_DB.reset
-    @o2.update_with(:y => 1, :abc => 2)
-    MODEL_DB.sqls.first.should == "UPDATE items SET y = 1 WHERE (id = 5)"
-  end
-  
   it "should support virtual attributes" do
     @c.class_def(:blah=) {|v| self.x = v}
     @o1.update_with_params(:blah => 333)
@@ -415,43 +395,6 @@ describe Sequel::Model, "update_with_params" do
   end
 end
 
-### DEPRECATE
-describe Sequel::Model, "create_with_params" do
-
-  before(:each) do
-    MODEL_DB.reset
-    
-    @c = Class.new(Sequel::Model(:items)) do
-      columns :x, :y
-    end
-    @c.instance_variable_set(:@columns, true)
-  end
-  
-  it "should filter the given params using the model columns" do
-    @c.create_with_params(:x => 1, :z => 2)
-    MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (1)"
-
-    MODEL_DB.reset
-    @c.create_with_params(:y => 1, :abc => 2)
-    MODEL_DB.sqls.first.should == "INSERT INTO items (y) VALUES (1)"
-  end
-  
-  it "should be aliased by create_with" do
-    @c.create_with(:x => 1, :z => 2)
-    MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (1)"
-
-    MODEL_DB.reset
-    @c.create_with(:y => 1, :abc => 2)
-    MODEL_DB.sqls.first.should == "INSERT INTO items (y) VALUES (1)"
-  end
-  
-  it "should support virtual attributes" do
-    @c.class_def(:blah=) {|v| self.x = v}
-    o = @c.create_with(:blah => 333)
-    MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (333)"
-  end
-end
-
 describe Sequel::Model, "#destroy" do
 
   before(:each) do
@@ -749,3 +692,161 @@ describe Sequel::Model, "#refresh" do
     @m.instance_variable_get(:@tags).should == nil
   end
 end
+
+describe Sequel::Model, "typecasting" do
+  setup do
+    MODEL_DB.reset
+    @c = Class.new(Sequel::Model(:items)) do
+      columns :x
+    end
+  end
+
+  specify "should not convert if typecasting is turned off" do
+    @c.typecast_on_assignment = false
+    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:integer}})
+    m = @c.new
+    m.x = '1'
+    m.x.should == '1'
+  end
+
+  specify "should convert to integer for an integer field" do
+    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:integer}})
+    m = @c.new
+    m.x = '1'
+    m.x.should == 1
+    m.x = 1
+    m.x.should == 1
+    m.x = 1.3
+    m.x.should == 1
+  end
+
+  specify "should not typecast nil if NULLs are allowed" do
+    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:integer,:allow_null=>true}})
+    m = @c.new
+    m.x = nil
+    m.x.should == nil
+  end
+
+  specify "should raise an error if attempting to typecast nil and NULLs are not allowed" do
+    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:integer,:allow_null=>false}})
+    proc{@c.new.x = nil}.should raise_error(Sequel::Error)
+  end
+
+  specify "should not raise an error if NULLs are not allowed and typecasting is turned off" do
+    @c.typecast_on_assignment = false
+    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:integer,:allow_null=>false}})
+    m = @c.new
+    m.x = nil
+    m.x.should == nil
+  end
+
+  specify "should raise an error if invalid data is used in an integer field" do
+    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:integer}})
+    proc{@c.new.x = 'a'}.should raise_error
+  end
+
+  specify "should convert to float for a float field" do
+    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:float}})
+    m = @c.new
+    m.x = '1.3'
+    m.x.should == 1.3
+    m.x = 1
+    m.x.should == 1.0
+    m.x = 1.3
+    m.x.should == 1.3
+  end
+
+  specify "should raise an error if invalid data is used in an float field" do
+    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:float}})
+    proc{@c.new.x = 'a'}.should raise_error
+  end
+
+  specify "should convert to string for a string field" do
+    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:string}})
+    m = @c.new
+    m.x = '1.3'
+    m.x.should == '1.3'
+    m.x = 1
+    m.x.should == '1'
+    m.x = 1.3
+    m.x.should == '1.3'
+  end
+
+  specify "should convert to boolean for a boolean field" do
+    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:boolean}})
+    m = @c.new
+    m.x = '1.3'
+    m.x.should == true
+    m.x = 1
+    m.x.should == true
+    m.x = 1.3
+    m.x.should == true
+    m.x = 't'
+    m.x.should == true
+    m.x = 'T'
+    m.x.should == true
+    m.x = true
+    m.x.should == true
+    m.x = nil
+    m.x.should == nil
+    m.x = ''
+    m.x.should == nil
+    m.x = []
+    m.x.should == nil
+    m.x = 'f'
+    m.x.should == false
+    m.x = 'F'
+    m.x.should == false
+    m.x = 'false'
+    m.x.should == false
+    m.x = 'FALSE'
+    m.x.should == false
+    m.x = '0'
+    m.x.should == false
+    m.x = 0
+    m.x.should == false
+    m.x = false
+    m.x.should == false
+  end
+
+  specify "should convert to date for a date field" do
+    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:date}})
+    m = @c.new
+    y = Date.new(2007,10,21)
+    m.x = '2007-10-21'
+    m.x.should == y
+    m.x = '2007-10-21'.to_date
+    m.x.should == y
+    m.x = '2007-10-21'.to_time
+    m.x.should == y
+    m.x = '2007-10-21'.to_datetime
+    m.x.should == y
+  end
+
+  specify "should raise an error if invalid data is used in a date field" do
+    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:date}})
+    proc{@c.new.x = 'a'}.should raise_error
+  end
+
+  specify "should convert to date for a datetime field" do
+    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:datetime}})
+    m = @c.new
+    m.x = '2007-10-21 10:20:30'
+    m.x.should == '2007-10-21 10:20:30'.to_datetime
+    y = DateTime.new(2007,10,21,10,20,30)
+    m.x = '2007-10-21 10:20:30'
+    m.x.should == y
+    m.x = '2007-10-21 10:20:30'.to_datetime
+    m.x.should == y
+    m.x = '2007-10-21 10:20:30'.to_time
+    m.x.should == y
+    m.x = '2007-10-21'.to_date
+    m.x.should == DateTime.new(2007,10,21)
+  end
+
+  specify "should raise an error if invalid data is used in a datetime field" do
+    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:datetime}})
+    proc{@c.new.x = 'a'}.should raise_error
+  end
+
+end