sequel 3.0.0 → 3.1.0

data/spec/integration/eager_loader_test.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(__FILE__), 'spec_helper.rb')
 
 describe "Eagerly loading a tree structure" do
   before do
-    INTEGRATION_DB.instance_variable_set(:@schemas, nil)
+    INTEGRATION_DB.instance_variable_set(:@schemas, {})
     INTEGRATION_DB.create_table!(:nodes) do
       primary_key :id
       foreign_key :parent_id, :nodes
@@ -144,7 +144,7 @@ describe "Association Extensions" do
         first(:name=>name) || model.create(:name=>name, :author_id=>model_object.pk)
       end
     end
-    INTEGRATION_DB.instance_variable_set(:@schemas, nil)
+    INTEGRATION_DB.instance_variable_set(:@schemas, {})
     INTEGRATION_DB.create_table!(:authors) do
       primary_key :id
     end
@@ -201,7 +201,7 @@ end
 
 describe "has_many :through has_many and has_one :through belongs_to" do
   before do
-    INTEGRATION_DB.instance_variable_set(:@schemas, nil)
+    INTEGRATION_DB.instance_variable_set(:@schemas, {})
     INTEGRATION_DB.create_table!(:firms) do
       primary_key :id
     end
@@ -361,7 +361,7 @@ end
 
 describe "Polymorphic Associations" do
   before do
-    INTEGRATION_DB.instance_variable_set(:@schemas, nil)
+    INTEGRATION_DB.instance_variable_set(:@schemas, {})
     INTEGRATION_DB.create_table!(:assets) do
       primary_key :id
       Integer :attachable_id
@@ -402,7 +402,7 @@ describe "Polymorphic Associations" do
       primary_key :id
     end
     class ::Post < Sequel::Model
-      one_to_many :assets, :key=>:attachable_id do |ds|
+      one_to_many :assets, :key=>:attachable_id, :reciprocal=>:attachable do |ds|
         ds.filter(:attachable_type=>'Post')
       end 
       
@@ -428,7 +428,7 @@ describe "Polymorphic Associations" do
       primary_key :id
     end
     class ::Note < Sequel::Model
-      one_to_many :assets, :key=>:attachable_id do |ds|
+      one_to_many :assets, :key=>:attachable_id, :reciprocal=>:attachable do |ds|
         ds.filter(:attachable_type=>'Note')
       end 
       
@@ -533,7 +533,7 @@ end
 
 describe "many_to_one/one_to_many not referencing primary key" do
   before do
-    INTEGRATION_DB.instance_variable_set(:@schemas, nil)
+    INTEGRATION_DB.instance_variable_set(:@schemas, {})
     INTEGRATION_DB.create_table!(:clients) do
       primary_key :id
       String :name

data/spec/integration/spec_helper.rb

@@ -8,7 +8,6 @@ begin
 rescue LoadError
 end
 
-Sequel.virtual_row_instance_eval = true
 Sequel::Model.use_transactions = false
 
 $sqls = []

data/spec/integration/transaction_test.rb

@@ -3,7 +3,7 @@ require File.join(File.dirname(__FILE__), 'spec_helper.rb')
 describe "Database transactions" do
   before do
     INTEGRATION_DB.drop_table(:items) if INTEGRATION_DB.table_exists?(:items)
-    INTEGRATION_DB.create_table(:items){String :name; Integer :value}
+    INTEGRATION_DB.create_table(:items, :engine=>'InnoDB'){String :name; Integer :value}
     @d = INTEGRATION_DB[:items]
     clear_sqls
   end
@@ -69,6 +69,33 @@ describe "Database transactions" do
     end}.should raise_error(Interrupt)
     @d.count.should == 0
   end 
+  
+  if INTEGRATION_DB.supports_savepoints?
+    specify "should support nested transactions through savepoints using the savepoint option" do
+      @db = INTEGRATION_DB
+      @db.transaction do
+        @d << {:name => '1'}
+        @db.transaction(:savepoint=>true) do
+          @d << {:name => '2'}
+          @db.transaction do
+            @d << {:name => '3'}
+            raise Sequel::Rollback
+          end
+        end
+        @d << {:name => '4'}
+        @db.transaction do
+          @d << {:name => '6'}
+          @db.transaction(:savepoint=>true) do
+            @d << {:name => '7'}
+            raise Sequel::Rollback
+          end
+        end
+        @d << {:name => '5'}
+      end
+
+      @d.order(:name).map(:name).should == %w{1 4 5 6}
+    end
+  end
 
   specify "should handle returning inside of the block by committing" do
     def INTEGRATION_DB.ret_commit

data/spec/model/association_reflection_spec.rb

@@ -37,6 +37,17 @@ describe Sequel::Model::Associations::AssociationReflection, "#primary_key" do
 end
 
 describe Sequel::Model::Associations::AssociationReflection, "#reciprocal" do
+  before do
+    class ::ParParent < Sequel::Model; end
+    class ::ParParentTwo < Sequel::Model; end
+    class ::ParParentThree < Sequel::Model; end
+  end
+  after do
+    Object.send(:remove_const, :ParParent)
+    Object.send(:remove_const, :ParParentTwo)
+    Object.send(:remove_const, :ParParentThree)
+  end
+
   it "should use the :reciprocal value if present" do
     @c = Class.new(Sequel::Model)
     @d = Class.new(Sequel::Model)
@@ -45,10 +56,25 @@ describe Sequel::Model::Associations::AssociationReflection, "#reciprocal" do
     @c.association_reflection(:c).reciprocal.should == :xx
   end
 
+  it "should require the associated class is the current class to be a reciprocal" do
+    ParParent.many_to_one :par_parent_two, :key=>:blah
+    ParParent.many_to_one :par_parent_three, :key=>:blah
+    ParParentTwo.one_to_many :par_parents, :key=>:blah
+    ParParentThree.one_to_many :par_parents, :key=>:blah
+
+    ParParentTwo.association_reflection(:par_parents).reciprocal.should == :par_parent_two
+    ParParentThree.association_reflection(:par_parents).reciprocal.should == :par_parent_three
+
+    ParParent.many_to_many :par_parent_twos, :left_key=>:l, :right_key=>:r, :join_table=>:jt
+    ParParent.many_to_many :par_parent_threes, :left_key=>:l, :right_key=>:r, :join_table=>:jt
+    ParParentTwo.many_to_many :par_parents, :right_key=>:l, :left_key=>:r, :join_table=>:jt
+    ParParentThree.many_to_many :par_parents, :right_key=>:l, :left_key=>:r, :join_table=>:jt
+
+    ParParentTwo.association_reflection(:par_parents).reciprocal.should == :par_parent_twos
+    ParParentThree.association_reflection(:par_parents).reciprocal.should == :par_parent_threes
+  end
+
   it "should figure out the reciprocal if the :reciprocal value is not present" do
-    class ::ParParent < Sequel::Model; end
-    class ::ParParentTwo < Sequel::Model; end
-    class ::ParParentThree < Sequel::Model; end
     ParParent.many_to_one :par_parent_two
     ParParentTwo.one_to_many :par_parents
     ParParent.many_to_many :par_parent_threes

data/spec/model/associations_spec.rb

@@ -1225,6 +1225,7 @@ describe Sequel::Model, "many_to_many" do
     a = n.attributes_dataset
     a.should be_a_kind_of(Sequel::Dataset)
     a.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) WHERE (a = 32)'
+    n.attributes.should == [@c1.load({})]
   end
   
   it "should support an order option" do

data/spec/model/eager_loading_spec.rb

@@ -22,6 +22,7 @@ describe Sequel::Model, "#eager" do
       one_to_many :albums, :class=>'EagerAlbum', :key=>:band_id, :eager=>:tracks
       one_to_many :graph_albums, :class=>'EagerAlbum', :key=>:band_id, :eager_graph=>:tracks
       many_to_many :members, :class=>'EagerBandMember', :left_key=>:band_id, :right_key=>:member_id, :join_table=>:bm
+      many_to_many :graph_members, :clone=>:members, :eager_graph=>:bands
       one_to_many :good_albums, :class=>'EagerAlbum', :key=>:band_id, :eager_block=>proc{|ds| ds.filter(:name=>'good')} do |ds|
         ds.filter(:name=>'Good')
       end
@@ -299,6 +300,27 @@ describe Sequel::Model, "#eager" do
     MODEL_DB.sqls.length.should == 2
   end
   
+  it "should cascade eagerly loading when the :eager_graph association option is used with a many_to_many association" do
+    EagerBandMember.dataset.extend(Module.new {
+      def columns
+        [:id]
+      end
+      def fetch_rows(sql)
+        @db << sql
+        yield({:id=>5, :bands_id=>2, :p_k=>6, :x_foreign_key_x=>2})
+        yield({:id=>5, :bands_id=>3, :p_k=>6, :x_foreign_key_x=>2})
+      end
+    })
+    a = EagerBand.eager(:graph_members).all
+    a.should == [EagerBand.load(:id=>2)]
+    MODEL_DB.sqls.should == ['SELECT * FROM bands', 
+                             'SELECT members.id, bands.id AS bands_id, bands.p_k, bm.band_id AS x_foreign_key_x FROM members INNER JOIN bm ON ((bm.member_id = members.id) AND (bm.band_id IN (2))) LEFT OUTER JOIN bm AS bm_0 ON (bm_0.member_id = members.id) LEFT OUTER JOIN bands ON (bands.id = bm_0.band_id) ORDER BY bands.id']
+    a = a.first
+    a.graph_members.should == [EagerBandMember.load(:id=>5)]
+    a.graph_members.first.bands.should == [EagerBand.load(:id=>2, :p_k=>6), EagerBand.load(:id=>3, :p_k=>6)]
+    MODEL_DB.sqls.length.should == 2
+  end
+  
   it "should respect :eager_graph when lazily loading an association" do
     a = EagerBand.all
     a.should be_a_kind_of(Array)
@@ -328,6 +350,24 @@ describe Sequel::Model, "#eager" do
     MODEL_DB.sqls.length.should == 2
   end
   
+  it "should respect :eager_graph when lazily loading a many_to_many association" do
+    EagerBandMember.dataset.extend(Module.new {
+      def columns
+        [:id]
+      end
+      def fetch_rows(sql)
+        @db << sql
+        yield({:id=>5, :bands_id=>2, :p_k=>6})
+        yield({:id=>5, :bands_id=>3, :p_k=>6})
+      end
+    })
+    a = EagerBand.load(:id=>2)
+    a.graph_members.should == [EagerBandMember.load(:id=>5)]
+    MODEL_DB.sqls.should == ['SELECT members.id, bands.id AS bands_id, bands.p_k FROM members INNER JOIN bm ON ((bm.member_id = members.id) AND (bm.band_id = 2)) LEFT OUTER JOIN bm AS bm_0 ON (bm_0.member_id = members.id) LEFT OUTER JOIN bands ON (bands.id = bm_0.band_id) ORDER BY bands.id']
+    a.graph_members.first.bands.should == [EagerBand.load(:id=>2, :p_k=>6), EagerBand.load(:id=>3, :p_k=>6)]
+    MODEL_DB.sqls.length.should == 1
+  end
+  
   it "should respect :conditions when eagerly loading" do
     EagerBandMember.many_to_many :good_bands, :clone=>:bands, :conditions=>{:a=>32}
     a = EagerBandMember.eager(:good_bands).all
@@ -816,6 +856,20 @@ describe Sequel::Model, "#eager_graph" do
     a.members.last.values.should == {:id => 5}
   end
 
+  it "should respect the :cartesian_product_number option" do 
+    GraphBand.many_to_one :other_vocalist, :class=>'GraphBandMember', :key=>:vocalist_id, :cartesian_product_number=>1
+    ds = GraphBand.eager_graph(:members, :other_vocalist)
+    ds.sql.should == 'SELECT bands.id, bands.vocalist_id, members.id AS members_id, other_vocalist.id AS other_vocalist_id FROM bands LEFT OUTER JOIN bm ON (bm.band_id = bands.id) LEFT OUTER JOIN members ON (members.id = bm.member_id) LEFT OUTER JOIN members AS other_vocalist ON (other_vocalist.id = bands.vocalist_id)'
+    def ds.fetch_rows(sql, &block)
+      yield({:id=>2, :vocalist_id=>6, :members_id=>5, :other_vocalist_id=>6})
+      yield({:id=>2, :vocalist_id=>6, :members_id=>5, :other_vocalist_id=>6})
+    end
+    a = ds.all
+    a.should == [GraphBand.load(:id=>2, :vocalist_id => 6)]
+    a.first.other_vocalist.should == GraphBandMember.load(:id=>6)
+    a.first.members.should == [GraphBandMember.load(:id=>5)]
+  end
+
   it "should drop duplicate items that occur in sequence if the graph could be a cartesian product" do
     ds = GraphBand.eager_graph(:members, :genres)
     ds.sql.should == 'SELECT bands.id, bands.vocalist_id, members.id AS members_id, genres.id AS genres_id FROM bands LEFT OUTER JOIN bm ON (bm.band_id = bands.id) LEFT OUTER JOIN members ON (members.id = bm.member_id) LEFT OUTER JOIN bg ON (bg.band_id = bands.id) LEFT OUTER JOIN genres ON (genres.id = bg.genre_id)'
@@ -1032,7 +1086,7 @@ describe Sequel::Model, "#eager_graph" do
     GraphAlbum.eager_graph(:inner_genres).sql.should == 'SELECT albums.id, albums.band_id, inner_genres.id AS inner_genres_id FROM albums INNER JOIN ag ON (ag.album_id = albums.id) INNER JOIN genres AS inner_genres ON (inner_genres.id = ag.genre_id)'
   end
 
-  it "should respect the association's :graph_join_type option" do 
+  it "should respect the association's :graph_join_table_join_type option" do 
     GraphAlbum.many_to_many :inner_genres, :class=>'GraphGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :graph_join_table_join_type=>:inner
     GraphAlbum.eager_graph(:inner_genres).sql.should == 'SELECT albums.id, albums.band_id, inner_genres.id AS inner_genres_id FROM albums INNER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS inner_genres ON (inner_genres.id = ag.genre_id)'
 
@@ -1162,4 +1216,19 @@ describe Sequel::Model, "#eager_graph" do
     GraphAlbum.one_to_many :b_tracks, :class=>'GraphTrack', :key=>:album_id, :graph_conditions=>{:a=>:b}
     GraphAlbum.eager_graph(:a_genres, :b_tracks).sql.should == 'SELECT albums.id, albums.band_id, a_genres.id AS a_genres_id, b_tracks.id AS b_tracks_id, b_tracks.album_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS a_genres ON (a_genres.id = ag.genre_id) LEFT OUTER JOIN tracks AS b_tracks ON ((b_tracks.album_id = albums.id) AND (b_tracks.a = albums.b))'
   end
+
+  it "should eagerly load associated records for classes that do not have a primary key" do
+    GraphAlbum.no_primary_key
+    GraphGenre.no_primary_key
+    GraphAlbum.many_to_many :inner_genres, :class=>'GraphGenre', :left_key=>:album_id, :left_primary_key=>:band_id, :right_key=>:genre_id, :right_primary_key=>:xxx, :join_table=>:ag
+    ds = GraphAlbum.eager_graph(:inner_genres)
+    ds.sql.should == 'SELECT albums.id, albums.band_id, inner_genres.id AS inner_genres_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.band_id) LEFT OUTER JOIN genres AS inner_genres ON (inner_genres.xxx = ag.genre_id)'
+    def ds.fetch_rows(sql, &block)
+      yield({:id=>3, :band_id=>2, :inner_genres_id=>5, :xxx=>12})
+      yield({:id=>3, :band_id=>2, :inner_genres_id=>6, :xxx=>22})
+    end
+    as = ds.all
+    as.should == [GraphAlbum.load(:id=>3, :band_id=>2)]
+    as.first.inner_genres.should == [GraphGenre.load(:id=>5), GraphGenre.load(:id=>6)]
+  end
 end

data/spec/model/plugins_spec.rb

@@ -1,72 +1,258 @@
 require File.join(File.dirname(__FILE__), "spec_helper")
 
-module Sequel::Plugins
+describe Sequel::Model, ".plugin" do
+  before do
+    module Sequel::Plugins
+      module Timestamped
+        module InstanceMethods
+          def get_stamp(*args); @values[:stamp] end
+          def abc; 123; end
+        end
+        
+        module ClassMethods
+          def def; 234; end
+        end
 
-  module Timestamped
-    def self.apply(m, opts)
-      m.meta_def(:stamp_opts) {opts}
-      m.send(:define_method, :before_save){@values[:stamp] = Time.now}
-    end
-    
-    module InstanceMethods
-      def get_stamp(*args); @values[:stamp] end
-      def abc; timestamped_opts; end
-    end
-    
-    module ClassMethods
-      def deff; timestamped_opts; end
-    end
-
-    module DatasetMethods
-      def ghi; timestamped_opts; end
+        module DatasetMethods
+          def ghi; 345; end
+        end
+      end
     end
+    @c = Class.new(Sequel::Model(:items))
+    @t = Sequel::Plugins::Timestamped
+  end
+  after do
+    Sequel::Plugins.send(:remove_const, :Timestamped)
+  end
+  
+  it "should raise LoadError if the plugin is not found" do
+    proc{@c.plugin :something_or_other}.should raise_error(LoadError)
+  end
+  
+  it "should store the plugin in .plugins" do
+    @c.plugins.should_not include(@t)
+    @c.plugin @t
+    @c.plugins.should include(@t)
+  end
+  
+  it "should be inherited in subclasses" do
+    @c.plugins.should_not include(@t)
+    c1 = Class.new(@c)
+    @c.plugin @t
+    c2 = Class.new(@c)
+    @c.plugins.should include(@t)
+    c1.plugins.should_not include(@t)
+    c2.plugins.should include(@t)
+  end
+  
+  it "should accept a symbol and load the module from the Sequel::Plugins namespace" do
+    @c.plugin :timestamped
+    @c.plugins.should include(@t)
   end
 
-end
+  it "should accept a module" do
+    m = Module.new
+    @c.plugin m
+    @c.plugins.should include(m)
+  end
 
-describe Sequel::Model, "using a plugin" do
+  it "should not attempt to load a plugin twice" do
+    @c.plugins.should_not include(@t)
+    @c.plugin @t
+    @c.plugins.reject{|m| m != @t}.length.should == 1
+    @c.plugin @t
+    @c.plugins.reject{|m| m != @t}.length.should == 1
+  end
 
-  it "should fail if the plugin is not found" do
-    proc do
-      c = Class.new(Sequel::Model)
-      c.class_eval do
-        plugin :something_or_other
+  it "should call apply and configure if the plugin responds to it, with the args and block used" do
+    m = Module.new do
+      def self.args; @args; end
+      def self.block; @block; end
+      def self.block_call; @block.call; end
+      def self.args2; @args2; end
+      def self.block2; @block2; end
+      def self.block2_call; @block2.call; end
+      def self.apply(model, *args, &block)
+        @args = args
+        @block = block
+        model.send(:define_method, :blah){43}
+      end
+      def self.configure(model, *args, &block)
+        @args2 = args
+        @block2 = block
+        model.send(:define_method, :blag){44}
       end
-    end.should raise_error(LoadError)
+    end
+    b = lambda{42}
+    @c.plugin(m, 123, 1=>2, &b)
+    
+    m.args.should == [123, {1=>2}]
+    m.block.should == b
+    m.block_call.should == 42
+    @c.new.blah.should == 43
+    
+    m.args2.should == [123, {1=>2}]
+    m.block2.should == b
+    m.block2_call.should == 42
+    @c.new.blag.should == 44
   end
   
-  it "should apply the plugin to the class" do
-    c = nil
-    proc do
-      c = Class.new(Sequel::Model)
-      c.class_eval do
-        set_dataset MODEL_DB[:items]
-        plugin :timestamped, :a => 1, :b => 2
+  it "should call configure even if the plugin has already been loaded" do
+    m = Module.new do
+      @args = []
+      def self.args; @args; end
+      def self.configure(model, *args, &block)
+        @args << [block, *args]
       end
-    end.should_not raise_error(LoadError)
+    end
     
-    c.should respond_to(:stamp_opts)
-    c.stamp_opts.should == {:a => 1, :b => 2}
+    b = lambda{42}
+    @c.plugin(m, 123, 1=>2, &b)
+    m.args.should == [[b, 123, {1=>2}]]
+    
+    b2 = lambda{44}
+    @c.plugin(m, 234, 2=>3, &b2)
+    m.args.should == [[b, 123, {1=>2}], [b2, 234, {2=>3}]]
+  end
+  
+  it "should call things in the following order: apply, InstanceMethods, ClassMethods, DatasetMethods, configure" do
+    m = Module.new do
+      @args = []
+      def self.args; @args; end
+      def self.apply(model, *args, &block)
+        @args << :apply
+      end
+      def self.configure(model, *args, &block)
+        @args << :configure
+      end
+      im = Module.new do
+        def self.included(model)
+          model.plugins.last.args << :im
+        end
+      end
+      cm = Module.new do
+        def self.extended(model)
+          model.plugins.last.args << :cm
+        end
+      end
+      dm = Module.new do
+        def self.extended(dataset)
+          dataset.model.plugins.last.args << :dm
+        end
+      end
+      const_set(:InstanceMethods, im)
+      const_set(:ClassMethods, cm)
+      const_set(:DatasetMethods, dm)
+    end
     
-    # instance methods
-    m = c.new
+    b = lambda{44}
+    @c.plugin(m, 123, 1=>2, &b)
+    m.args.should == [:apply, :im, :cm, :dm, :configure]
+    @c.plugin(m, 234, 2=>3, &b)
+    m.args.should == [:apply, :im, :cm, :dm, :configure, :configure]
+  end
+
+  it "should include an InstanceMethods module in the class if the plugin includes it" do
+    @c.plugin @t
+    m = @c.new
     m.should respond_to(:get_stamp)
     m.should respond_to(:abc)
-    m.abc.should == {:a => 1, :b => 2}
+    m.abc.should == 123
     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}
+  end
+
+  it "should define a plugin_opts instance method if the plugin has an InstanceMethods module" do
+    @c.plugin :timestamped, 1, 2=>3
+    @c.new.timestamped_opts.should == [1, {2=>3}]
+  end
+
+  it "should extend the class with a ClassMethods module if the plugin includes it" do
+    @c.plugin @t
+    @c.def.should == 234
+  end
+
+  it "should define a plugin_opts class method if the plugin has a ClassMethods module" do
+    @c.plugin :timestamped, 1, 2=>3
+    @c.timestamped_opts.should == [1, {2=>3}]
+  end
+
+  it "should extend the class's dataset with a DatasetMethods module if the plugin includes it" do
+    @c.plugin @t
+    @c.dataset.ghi.should == 345
+    @c.ghi.should == 345
+  end
+
+  it "should define a plugin_opts dataset method if the plugin has a DatasetMethods module" do
+    @c.plugin :timestamped, 1, 2=>3
+    @c.dataset.timestamped_opts.should == [1, {2=>3}]
+  end
+  
+  it "should use a single arg for the plugin_opts method if only a single arg was given" do
+    @c.plugin :timestamped, 1
+    @c.new.timestamped_opts.should == 1
+    @c.timestamped_opts.should == 1
+    @c.dataset.timestamped_opts.should == 1
+  end
+  
+  it "should save the DatasetMethods module and apply it later if the class doesn't have a dataset" do
+    c = Class.new(Sequel::Model)
+    c.plugin @t
+    proc{c.ghi}.should raise_error(Sequel::Error)
+    c.dataset = MODEL_DB[:i]
+    c.dataset.ghi.should == 345
+    c.ghi.should == 345
+  end
+  
+  it "should save the DatasetMethods module and apply it later if the class has a dataset" do
+    @c.plugin @t
+    @c.dataset = MODEL_DB[:i]
+    @c.dataset.ghi.should == 345
+    @c.ghi.should == 345
+  end
+
+  it "should define class methods for all public instance methods in DatasetMethod" do
+    m = Module.new do
+      dm = Module.new do
+        def a; 1; end
+        def b; 2; end
+      end
+      const_set(:DatasetMethods, dm)
+    end
+    @c.plugin m
+    @c.dataset.a.should == 1
+    @c.dataset.b.should == 2
+    @c.a.should == 1
+    @c.b.should == 2
+  end
+  
+  it "should define class methods for all public instance methods in DatasetMethod" do
+    m = Module.new do
+      dm = Module.new do
+        def b; 2; end
+        private
+        def a; 1; end
+      end
+      const_set(:DatasetMethods, dm)
+    end
+    @c.plugin m
+    @c.dataset.b.should == 2
+    lambda{@c.dataset.a}.should raise_error(NoMethodError)
+    @c.dataset.send(:a).should == 1
+    @c.b.should == 2
+    lambda{@c.a}.should raise_error(NoMethodError)
+    lambda{@c.send(:a)}.should raise_error(NoMethodError)
+  end
 
-    # dataset methods called on the class
-    c.should respond_to(:ghi)
-    c.ghi.should == {:a => 1, :b => 2}
+  it "should not raise an error if the DatasetMethod module has no public instance methods" do
+    m = Module.new do
+      dm = Module.new do
+        private
+        def a; 1; end
+      end
+      const_set(:DatasetMethods, dm)
+    end
+    lambda{@c.plugin m}.should_not raise_error
   end
 end