sequel 4.43.0 → 4.44.0

data/spec/extensions/nested_attributes_spec.rb

@@ -694,4 +694,9 @@ describe "NestedAttributes plugin" do
     @Tag.columns :id, :name, :number
     proc{@Album.load(:id=>10, :name=>'Al').set_nested_attributes(:tags, [{:id=>30, :name=>'T2', :number=>3}], :fields=>[:name])}.must_raise(Sequel::Error)
   end
+
+  it "should freeze nested_attributes_module when freezing model class" do
+    @Artist.freeze
+    @Artist.nested_attributes_module.frozen?.must_equal true
+  end
 end

data/spec/extensions/pg_array_associations_spec.rb

@@ -735,3 +735,49 @@ describe Sequel::Model, "pg_array_associations" do
     t.artists.must_equal [a]
   end
 end
+
+describe "Sequel::Model.finalize_associations" do
+  before do
+    class ::Foo < Sequel::Model
+      plugin :pg_array_associations
+      many_to_pg_array :items
+    end
+    class ::Item < Sequel::Model
+      plugin :pg_array_associations
+      pg_array_to_many :foos
+    end
+    [Foo, Item].each(&:finalize_associations)
+  end
+  after do
+    Object.send(:remove_const, :Item)
+    Object.send(:remove_const, :Foo)
+  end
+
+  it "should finalize pg_array_to_many associations" do
+    r = Item.association_reflection(:foos)
+    r[:class].must_equal Foo
+    r[:_dataset].sql.must_equal "SELECT * FROM foos"
+    r[:associated_eager_dataset].sql.must_equal "SELECT * FROM foos"
+    r.fetch(:_eager_limit_strategy).must_be_nil
+    r[:filter_by_associations_conditions_dataset].sql.must_equal "SELECT array_agg(foos.id) FROM foos WHERE (foos.id IS NOT NULL)"
+    r[:predicate_key].must_equal Sequel.qualify(:foos, :id)
+    r[:predicate_keys].must_equal [Sequel.qualify(:foos, :id)]
+    r[:reciprocal].must_equal :items
+    r[:array_type].must_equal :integer
+    r[:primary_key].must_equal :id
+    r[:primary_key_method].must_equal :id
+  end
+
+  it "should finalize many_to_pg_array associations" do
+    r = Foo.association_reflection(:items)
+    r[:class].must_equal Item
+    r[:_dataset].sql.must_equal "SELECT * FROM items"
+    r[:associated_eager_dataset].sql.must_equal  "SELECT * FROM items"
+    r.fetch(:_eager_limit_strategy).must_be_nil
+    r[:filter_by_associations_conditions_dataset].sql.must_equal "SELECT unnest(items.foo_ids) FROM items WHERE (items.foo_ids IS NOT NULL)"
+    r[:predicate_key].must_equal Sequel.qualify(:items, :foo_ids)
+    r[:predicate_keys].must_equal [Sequel.qualify(:items, :foo_ids)]
+    r[:reciprocal].must_equal :foos
+    r[:array_type].must_equal :integer
+  end
+end

data/spec/extensions/pg_typecast_on_load_spec.rb

@@ -60,4 +60,9 @@ describe Sequel::Model, "PgTypecastOnLoad plugin" do
   it "should not mark the object as modified" do
     @c.first.modified?.must_equal false
   end
+
+  it "should freeze pg_typecast_on_load_columns" do
+    @c.freeze
+    @c.pg_typecast_on_load_columns.frozen?.must_equal true
+  end
 end

data/spec/extensions/prepared_statements_safe_spec.rb

@@ -58,4 +58,9 @@ describe "prepared_statements_safe plugin" do
     c1.prepared_statements_column_defaults.must_equal(:name=>'foo')
     Class.new(c1).prepared_statements_column_defaults.must_equal(:name=>'foo')
   end
+
+  it "should freeze prepared statement column defaults when freezing model class" do
+    @c.freeze
+    @c.prepared_statements_column_defaults.frozen?.must_equal true
+  end
 end

data/spec/extensions/serialization_spec.rb

@@ -361,4 +361,11 @@ describe "Serialization plugin" do
     o.column_changes.must_equal(:abc=>[1, 2], :def=>["hello", "hello2"])
   end
 
+  it "should freeze serialization metadata when freezing model class" do
+    @c.plugin :serialization, :yaml, :abc, :def
+    @c.freeze
+    @c.serialization_map.frozen?.must_equal true
+    @c.deserialization_map.frozen?.must_equal true
+    @c.serialization_module.frozen?.must_equal true
+  end
 end

data/spec/extensions/single_table_inheritance_spec.rb

@@ -19,6 +19,16 @@ describe Sequel::Model, "single table inheritance plugin" do
     Object.send(:remove_const, :StiTest)
   end
 
+  it "should freeze sti metadata when freezing model class" do
+    StiTest.freeze
+    StiTest.sti_dataset.frozen?.must_equal true
+
+    StiTestSub1.freeze
+    StiTestSub1.sti_key_array.frozen?.must_equal true
+
+    proc{class ::StiTestSub1Sub1 < StiTestSub1; end}.must_raise RuntimeError, TypeError
+  end
+
   it "should have simple_table = nil" do
     StiTest.simple_table.must_equal "sti_tests"
     StiTestSub1.simple_table.must_be_nil
@@ -180,8 +190,15 @@ describe Sequel::Model, "single table inheritance plugin" do
     end
     after do
       Object.send(:remove_const, :StiTest2)
-      Object.send(:remove_const, :StiTest3)
-      Object.send(:remove_const, :StiTest4)
+      Object.send(:remove_const, :StiTest3) if defined?(StiTest3)
+      Object.send(:remove_const, :StiTest4) if defined?(StiTest4)
+    end
+
+    it "should freeze sti key and model map if given as hashes when freezing model class" do
+      StiTest2.plugin :single_table_inheritance, :kind, :model_map=>{0=>StiTest2, 1=>:StiTest3, 2=>'StiTest4'}, :key_map=>{StiTest2=>4, 'StiTest3'=>5, 'StiTest4'=>6}
+      StiTest2.freeze
+      StiTest2.sti_key_map.frozen?.must_equal true
+      StiTest2.sti_model_map.frozen?.must_equal true
     end
 
     it "should have working row_proc if using set_dataset in subclass to remove columns" do

data/spec/extensions/subclasses_spec.rb

@@ -50,6 +50,19 @@ describe Sequel::Model, "Subclasses plugin" do
     sssc1.descendents.must_equal []
   end
 
+  it "#freeze_descendents should finalize the associations for all descendents" do
+    sc1 = Class.new(@c)
+    sc1.set_dataset :bars
+    sc1.set_primary_key :foo
+    sc2 = Class.new(@c)
+    sc2.set_dataset :bazs
+    sc2.many_to_one :bar, :class=>sc1
+    @c.freeze_descendents
+    sc1.frozen?.must_equal true
+    sc2.frozen?.must_equal true
+    sc2.association_reflection(:bar)[:primary_key].must_equal :foo
+  end
+
   it "plugin block should be called with each subclass created" do
     c = Class.new(Sequel::Model)
     a = []

data/spec/extensions/to_dot_spec.rb

@@ -80,7 +80,7 @@ END
   end
 
   it "should handle LiteralStrings" do
-    dot(@ds.filter('a')).must_equal ["1 -> 2 [label=\"where\"];", "2 [label=\"\\\"(a)\\\".lit\"];"]
+    dot(@ds.filter('a')).must_equal ["1 -> 2 [label=\"where\"];", "2 [label=\"Sequel.lit(\\\"(a)\\\")\"];"]
   end
 
   it "should handle true, false, nil" do

data/spec/extensions/touch_spec.rb

@@ -208,4 +208,10 @@ describe "Touch plugin" do
     DB.sqls.must_equal ["UPDATE artists SET modified_on = CURRENT_TIMESTAMP WHERE (id = 4)",
       "UPDATE albums SET modified_on = CURRENT_TIMESTAMP WHERE (albums.artist_id = 4)"]
   end
+
+  it "should freeze touched associations when freezing model class" do
+    @Artist.plugin :touch, :associations=>:albums
+    @Artist.freeze
+    @Artist.touched_associations.frozen?.must_equal true
+  end
 end

data/spec/extensions/tree_spec.rb

@@ -274,5 +274,11 @@ describe Sequel::Model, "tree plugin with composite keys" do
       @c.dataset = @c.dataset.with_fetch(:id=>1, :id2=>6, :parent_id=>nil, :parent_id2=>2, :name=>'r')
       @c.root.update(:name => 'fdsa') 
     end
+
+    it "freezes tree_order if it is an array" do
+      @c.tree_order = [:id]
+      @c.freeze
+      @c.tree_order.frozen?.must_equal true
+    end
   end
 end

data/spec/extensions/typecast_on_load_spec.rb

@@ -77,4 +77,10 @@ describe Sequel::Model, "TypecastOnLoad plugin" do
     @c.plugin :typecast_on_load, :b
     @c.load(:id=>1, :b=>"1", :y=>"0").modified?.must_equal false
   end
+
+  it "should freeze typecast_on_load columns when freezing model class" do
+    @c.plugin :typecast_on_load, :b
+    @c.freeze
+    @c.typecast_on_load_columns.frozen?.must_equal true
+  end
 end

data/spec/extensions/update_refresh_spec.rb

@@ -38,7 +38,6 @@ describe "Sequel::Plugins::UpdateRefresh" do
     o.name.must_equal 'b'
   end
 
-
   it "should refresh the instance after updating when returning specific columns" do
     @db.extend_datasets{def supports_returning?(x) true end; def update_sql(*); sql = super; update_returning_sql(sql); sql end}
     @c.plugin :insert_returning_select
@@ -50,4 +49,11 @@ describe "Sequel::Plugins::UpdateRefresh" do
     @db.sqls.must_equal ["UPDATE test SET name = 'a' WHERE (id = 1) RETURNING id, name"]
     o.name.must_equal 'b'
   end
+
+  it "should freeze update refresh columns when freezing model class" do
+    @db.extend_datasets{def supports_returning?(x) true end; def update_sql(*); sql = super; update_returning_sql(sql); sql end}
+    @c.plugin :update_refresh, :columns => [ :a ]
+    @c.freeze
+    @c.update_refresh_columns.frozen?.must_equal true
+  end
 end

data/spec/extensions/validation_class_methods_spec.rb

@@ -16,6 +16,19 @@ describe Sequel::Model do
     end
   end
   
+  it "should freeze validation metadata when freezing model class" do
+    @c.validates_acceptance_of(:a)
+    @c.freeze
+    @c.validations.frozen?.must_equal true
+    @c.validations.values.all?(&:frozen?).must_equal true
+    @c.validation_reflections.frozen?.must_equal true
+    @c.validation_reflections.values.all? do |vs|
+      vs.frozen? && vs.all? do |v|
+        v.frozen? && v.last.frozen?
+      end
+    end.must_equal true
+  end
+
   it "should respond to validations, has_validations?, and validation_reflections" do
     @c.must_respond_to(:validations)
     @c.must_respond_to(:has_validations?)

data/spec/model/association_reflection_spec.rb

@@ -15,6 +15,19 @@ describe Sequel::Model::Associations::AssociationReflection, "#associated_class"
     @c.association_reflection(:c).associated_class.must_equal ParParent
   end
 
+  it "should have inspect include association class and representation of association definition " do
+    ParParent.many_to_one :c
+    ParParent.association_reflection(:c).inspect.must_equal "#<Sequel::Model::Associations::ManyToOneAssociationReflection ParParent.many_to_one :c>"
+    ParParent.many_to_one :c, :class=>ParParent
+    ParParent.association_reflection(:c).inspect.must_equal "#<Sequel::Model::Associations::ManyToOneAssociationReflection ParParent.many_to_one :c, :class=>ParParent>"
+    ParParent.many_to_one :c, :class=>ParParent, :key=>:c_id
+    ["#<Sequel::Model::Associations::ManyToOneAssociationReflection ParParent.many_to_one :c, :key=>:c_id, :class=>ParParent>",
+     "#<Sequel::Model::Associations::ManyToOneAssociationReflection ParParent.many_to_one :c, :class=>ParParent, :key=>:c_id>"].must_include ParParent.association_reflection(:c).inspect
+
+    @c.one_to_many :foos do |ds| ds end
+    @c.association_reflection(:foos).inspect.must_equal "#<Sequel::Model::Associations::OneToManyAssociationReflection #{@c.to_s}.one_to_many :foos, :block=>#{@c.association_reflection(:foos)[:block].inspect}>"
+  end
+
   it "should figure out the class if the :class value is not present" do
     @c.many_to_one :c, :class=>'ParParent'
     @c.association_reflection(:c).keys.wont_include(:class)
@@ -30,6 +43,17 @@ describe Sequel::Model::Associations::AssociationReflection, "#associated_class"
     ParParent.many_to_one :par_parent, :class=>'ParParent', :class_namespace=>'ParParent'
     ParParent.association_reflection(:par_parent).associated_class.must_equal ParParent::ParParent
   end
+
+  it "should include association inspect output if an exception would be raised" do
+    r = @c.many_to_one(:c)
+
+    begin
+      r.associated_class
+    rescue NameError => e
+    end
+
+    e.message.must_include r.inspect
+  end
 end
 
 describe Sequel::Model::Associations::AssociationReflection, "#primary_key" do
@@ -563,3 +587,156 @@ describe Sequel::Model::Associations::AssociationReflection, "with default assoc
     r[:bar].must_equal 2
   end
 end
+
+describe "Sequel::Model.freeze" do
+  it "should freeze the model class and not allow any changes to associations" do
+    model = Class.new(Sequel::Model(:items))
+    model.many_to_one :foo, :class=>model, :key=>:id
+    model.default_association_options = {:read_only=>true}
+    model.freeze
+
+    model.association_reflections.frozen?.must_equal true
+    model.association_reflection(:foo).frozen?.must_equal true
+    model.autoreloading_associations.frozen?.must_equal true
+    model.autoreloading_associations[:id].frozen?.must_equal true
+    model.default_association_options.frozen?.must_equal true
+  end
+
+  it "should allow subclasses of frozen model classes to modify associations" do
+    model = Class.new(Sequel::Model(:items))
+    model.many_to_one :foo, :class=>model, :key=>:id
+    model.freeze
+    model = Class.new(model)
+    model.dataset = :items2
+
+    model.association_reflection(:foo).frozen?.must_equal true
+    model.autoreloading_associations.frozen?.must_equal false
+    model.autoreloading_associations[:id].frozen?.must_equal false
+
+    model.many_to_one :bar, :class=>model, :key=>:id
+    model.many_to_one :foo, :class=>model, :key=>:id
+    model.association_reflections.frozen?.must_equal false
+    model.association_reflection(:foo).frozen?.must_equal false
+    model.association_reflection(:bar).frozen?.must_equal false
+
+    model.default_association_options.frozen?.wont_equal true
+    model.default_association_options = {:read_only=>true}
+    model.default_association_options.frozen?.wont_equal true
+  end
+end
+
+describe "Sequel::Model.finalize_associations" do
+  before do
+    class ::MtmItem < Sequel::Model
+      set_primary_key :mtm_id
+      many_to_many :items
+      many_to_one :item
+    end
+    class ::OtoItem < Sequel::Model
+      set_primary_key :oto_id
+    end
+    class ::Item < Sequel::Model
+      many_to_one :item
+      one_to_many :items, :limit=>10
+      one_to_one :mtm_item
+      many_to_many :mtm_items
+      one_through_one :oto_item
+    end
+    [MtmItem, OtoItem, Item].each(&:finalize_associations)
+  end
+  after do
+    Object.send(:remove_const, :Item)
+    Object.send(:remove_const, :MtmItem)
+    Object.send(:remove_const, :OtoItem)
+  end
+
+  it "should finalize many_to_one associations" do
+    r = Item.association_reflection(:item)
+    r[:class].must_equal Item
+    r[:_dataset].sql.must_equal "SELECT * FROM items LIMIT 1"
+    r[:associated_eager_dataset].sql.must_equal "SELECT * FROM items"
+    r[:filter_by_associations_conditions_dataset].sql.must_equal "SELECT items.id FROM items WHERE (items.id IS NOT NULL)"
+    r[:placeholder_loader].wont_be_nil
+    r[:predicate_key].must_equal Sequel.qualify(:items, :id)
+    r[:primary_key].must_equal :id
+    r[:primary_keys].must_equal [:id]
+    r[:primary_key_method].must_equal :id
+    r[:primary_key_methods].must_equal [:id]
+    r[:qualified_primary_key].must_equal Sequel.qualify(:items, :id)
+    r.fetch(:reciprocal_type).must_equal :one_to_many
+    r.fetch(:reciprocal).must_equal :items
+  end
+
+  it "should finalize one_to_many associations" do
+    r = Item.association_reflection(:items)
+    r[:class].must_equal Item
+    r[:_dataset].sql.must_equal "SELECT * FROM items LIMIT 10"
+    r[:associated_eager_dataset].sql.must_equal "SELECT * FROM items"
+    r[:_eager_limit_strategy].must_equal :union
+    r[:filter_by_associations_conditions_dataset].sql.must_equal "SELECT items.item_id FROM items WHERE ((items.item_id IS NOT NULL) AND (items.id IN (SELECT t1.id FROM items AS t1 WHERE (t1.item_id = items.item_id) LIMIT 10)))"
+    r[:placeholder_loader].wont_be_nil
+    r[:predicate_key].must_equal Sequel.qualify(:items, :item_id)
+    r[:predicate_keys].must_equal [Sequel.qualify(:items, :item_id)]
+    r[:qualified_primary_key].must_equal Sequel.qualify(:items, :id)
+    r.fetch(:reciprocal).must_equal :item
+  end
+
+  it "should finalize one_to_one associations" do
+    r = Item.association_reflection(:mtm_item)
+    r[:class].must_equal MtmItem
+    r[:_dataset].sql.must_equal "SELECT * FROM mtm_items LIMIT 1"
+    r[:associated_eager_dataset].sql.must_equal "SELECT * FROM mtm_items"
+    r[:_eager_limit_strategy].must_be_nil
+    r[:filter_by_associations_conditions_dataset].sql.must_equal "SELECT mtm_items.item_id FROM mtm_items WHERE (mtm_items.item_id IS NOT NULL)"
+    r[:placeholder_loader].wont_be_nil
+    r[:predicate_key].must_equal Sequel.qualify(:mtm_items, :item_id)
+    r[:predicate_keys].must_equal [Sequel.qualify(:mtm_items, :item_id)]
+    r[:qualified_primary_key].must_equal Sequel.qualify(:items, :id)
+    r.fetch(:reciprocal).must_equal :item
+  end
+
+  it "should finalize many_to_many associations" do
+    r = Item.association_reflection(:mtm_items)
+    r[:class].must_equal MtmItem
+    r[:_dataset].sql.must_equal "SELECT mtm_items.* FROM mtm_items INNER JOIN items_mtm_items ON (items_mtm_items.mtm_item_id = mtm_items.mtm_id)"
+    r[:associated_eager_dataset].sql.must_equal "SELECT mtm_items.* FROM mtm_items INNER JOIN items_mtm_items ON (items_mtm_items.mtm_item_id = mtm_items.mtm_id)"
+    r[:_eager_limit_strategy].must_be_nil
+    r[:filter_by_associations_conditions_dataset].sql.must_equal "SELECT items_mtm_items.item_id FROM mtm_items INNER JOIN items_mtm_items ON (items_mtm_items.mtm_item_id = mtm_items.mtm_id) WHERE (items_mtm_items.item_id IS NOT NULL)"
+    r[:placeholder_loader].wont_be_nil
+    r[:predicate_key].must_equal Sequel.qualify(:items_mtm_items, :item_id)
+    r[:predicate_keys].must_equal [Sequel.qualify(:items_mtm_items, :item_id)]
+    r.fetch(:reciprocal).must_equal :items
+    r[:associated_key_array].must_equal [Sequel.qualify(:items_mtm_items, :item_id).as(:x_foreign_key_x)]
+    r[:qualified_right_key].must_equal Sequel.qualify(:items_mtm_items, :mtm_item_id)
+    r[:join_table_source].must_equal :items_mtm_items
+    r[:join_table_alias].must_equal :items_mtm_items
+    r[:qualified_right_primary_key].must_equal Sequel.qualify(:mtm_items, :mtm_id)
+    r[:right_primary_key].must_equal :mtm_id
+    r[:right_primary_keys].must_equal [:mtm_id]
+    r[:right_primary_key_method].must_equal :mtm_id
+    r[:right_primary_key_methods].must_equal [:mtm_id]
+    r[:select].must_equal Sequel::SQL::ColumnAll.new(:mtm_items)
+  end
+
+  it "should finalize one_through_one associations" do
+    r = Item.association_reflection(:oto_item)
+    r[:class].must_equal OtoItem
+    r[:_dataset].sql.must_equal "SELECT oto_items.* FROM oto_items INNER JOIN items_oto_items ON (items_oto_items.oto_item_id = oto_items.oto_id) LIMIT 1"
+    r[:associated_eager_dataset].sql.must_equal "SELECT oto_items.* FROM oto_items INNER JOIN items_oto_items ON (items_oto_items.oto_item_id = oto_items.oto_id)"
+    r[:_eager_limit_strategy].must_be_nil
+    r[:filter_by_associations_conditions_dataset].sql.must_equal "SELECT items_oto_items.item_id FROM oto_items INNER JOIN items_oto_items ON (items_oto_items.oto_item_id = oto_items.oto_id) WHERE (items_oto_items.item_id IS NOT NULL)"
+    r[:placeholder_loader].wont_be_nil
+    r[:predicate_key].must_equal Sequel.qualify(:items_oto_items, :item_id)
+    r[:predicate_keys].must_equal [Sequel.qualify(:items_oto_items, :item_id)]
+    r[:associated_key_array].must_equal [Sequel.qualify(:items_oto_items, :item_id).as(:x_foreign_key_x)]
+    r[:qualified_right_key].must_equal Sequel.qualify(:items_oto_items, :oto_item_id)
+    r[:join_table_source].must_equal :items_oto_items
+    r[:join_table_alias].must_equal :items_oto_items
+    r[:qualified_right_primary_key].must_equal Sequel.qualify(:oto_items, :oto_id)
+    r[:right_primary_key].must_equal :oto_id
+    r[:right_primary_keys].must_equal [:oto_id]
+    r[:right_primary_key_method].must_equal :oto_id
+    r[:right_primary_key_methods].must_equal [:oto_id]
+    r[:select].must_equal Sequel::SQL::ColumnAll.new(:oto_items)
+  end
+end

data/spec/model/associations_spec.rb

@@ -4624,3 +4624,19 @@ describe "association autoreloading" do
     DB.sqls.must_equal ['SELECT * FROM artists WHERE id = 1']
   end
 end
+
+describe Sequel::Model, ".dataset_module" do
+  before do
+    @c = Class.new(Sequel::Model(:items))
+  end
+  
+  it "should have dataset_module support an eager method" do
+    @c.many_to_one :foo, :class=>@c
+    @c.many_to_one :bar, :class=>@c
+    @c.many_to_one :baz, :class=>@c
+    @c.many_to_one :quux, :class=>@c
+    @c.dataset_module{eager(:foo, {:foo=>{:bar=>:baz}}, :quux)}
+    @c.foo.opts[:eager].must_equal(:foo=>{:bar=>:baz}, :quux=>nil)
+    @c.where(:bar).foo.opts[:eager].must_equal(:foo=>{:bar=>:baz}, :quux=>nil)
+  end
+end