sequel 0.1.9.10 → 0.1.9.11

data/CHANGELOG

@@ -1,14 +1,18 @@
+=== 0.19.11 (2007-08-24)
+
+* Changed Dataset#set_model to allow supplying additional arguments to the model's initialize method (#35). Thanks Sunny Hirai.
+
 === 0.19.10 (2007-08-22)
 
 * Changed schema generation code to generate separate statements for CREATE TABLE and each CREATE INDEX (#34).
 
-* Refactored Dataset::SQL#field_name for better support of different quoting schemes by specific adapters.
+* Refactored Dataset::SQL#field_name for better support of different field quoting standards by specific adapters.
 
 * Added #current_page_record_count for paginated datasets.
 
 * Removed Database#literal and included Dataset::SQL instead.
 
-* Sequel::Dataset:SQL#field_name can now take a hash (as well as #select and any method that uses #field_name) for aliasing column names.  E.g. Dataset.new(nil).from(:test).select(:_qqa => 'Date').sql #=> 'SELECT _qqa AS 'Date' FROM test'.
+* Sequel::Dataset:SQL#field_name can now take a hash (as well as #select and any method that uses #field_name) for aliasing column names.  E.g. DB[:test].select(:_qqa => 'Date').sql #=> 'SELECT _qqa AS Date FROM test'.
 
 * Moved SingleThreadedPool to lib/sequel/connection_pool.rb.
 

data/Rakefile

@@ -6,7 +6,7 @@ require 'fileutils'
 include FileUtils
 
 NAME = "sequel"
-VERS = "0.1.9.10"
+VERS = "0.1.9.11"
 CLEAN.include ['**/.*.sw?', 'pkg/*', '.config', 'doc/*', 'coverage/*']
 RDOC_OPTS = ['--quiet', '--title', "Sequel: Concise ORM for Ruby",
   "--opname", "index.html",

data/lib/sequel/dataset.rb

@@ -179,33 +179,56 @@ module Sequel
     #   class MyModel
     #     def initialize(values)
     #       @values = values
+    #       ...
     #     end
     #   end
     # 
     #   dataset.set_model(MyModel)
     #
+    # You can also provide additional arguments to be passed to the model's
+    # initialize method:
+    #
+    #   class MyModel
+    #     def initialize(values, options)
+    #       @values = values
+    #       ...
+    #     end
+    #   end
+    # 
+    #   dataset.set_model(MyModel, :allow_delete => false)
+    #  
     # The dataset can be made polymorphic by specifying a column name as the
     # polymorphic key and a hash mapping column values to model classes.
     #
     #   dataset.set_model(:kind, {1 => Person, 2 => Business})
     #
-    def set_model(*args)
-      if args.empty? || (args.first == nil)
-        # If no argument or nil is provided, the dataset is denuded
+    # You can also set a default model class to fall back on by specifying a
+    # class corresponding to nil:
+    #
+    #   dataset.set_model(:kind, {nil => DefaultClass, 1 => Person, 2 => Business})
+    # 
+    # To disassociate a model from the dataset, you can call the #set_model 
+    # and specify nil as the class:
+    # 
+    #   dataset.set_model(nil)
+    #
+    def set_model(key, *args)
+      # pattern matching
+      case key
+      when nil: # set_model(nil) => no
+        # no argument provided, so the dataset is denuded
         @opts.merge!(:naked => true, :models => nil, :polymorphic_key => nil)
         extend_with_stock_each
-      elsif args.size == 1
-        # If a single argument is provided, it is regarded the model class
-        c = args.first
-        @opts.merge!(:naked => nil, :models => {nil => c}, :polymorphic_key => nil)
-        extend_with_model(c)
+      when Class:
+        # isomorphic model
+        @opts.merge!(:naked => nil, :models => {nil => key}, :polymorphic_key => nil)
+        extend_with_model(key, *args)
         extend_with_destroy
-      elsif args.size == 2
-        # If two arguments are provided, the first is considered the
-        # polymorphic key, and the second a hash of classes.
-        key, hash = args
+      when Symbol:
+        # polymorphic model
+        hash = args.shift || raise(SequelError, "No class hash supplied for polymorphic model")
         @opts.merge!(:naked => true, :models => hash, :polymorphic_key => key)
-        extend_with_polymorphic_model(key, hash)
+        extend_with_polymorphic_model(key, hash, *args)
         extend_with_destroy
       else
         raise SequelError, "Invalid parameters specified"
@@ -215,15 +238,14 @@ module Sequel
     
     private
     # Overrides the each method to convert records to model instances.
-    def extend_with_model(c)
-      meta_def(:model_class) {c}
+    def extend_with_model(c, *args)
+      meta_def(:make_model_instance) {|r| c.new(r, *args)}
       m = Module.new do
         def each(opts = nil, &block)
-          c = model_class
           if opts && opts[:naked]
             fetch_rows(select_sql(opts), &block)
           else
-            fetch_rows(select_sql(opts)) {|r| block.call(c.new(r))}
+            fetch_rows(select_sql(opts)) {|r| block.call(make_model_instance(r))}
           end
         end
       end
@@ -233,21 +255,18 @@ module Sequel
     # Overrides the each method to convert records to polymorphic model
     # instances. The model class is determined according to the value in the
     # key column.
-    def extend_with_polymorphic_model(key, hash)
-      meta_def(:model_class) {|r| hash[r[key]] || hash[nil]}
+    def extend_with_polymorphic_model(key, hash, *args)
+      meta_def(:make_model_instance) do |r|
+        c = hash[r[key]] || hash[nil] || \
+          raise(SequelError, "No matching model class for record (#{polymorphic_key} => #{r[polymorphic_key].inspect})")
+        c.new(r, *args)
+      end
       m = Module.new do
         def each(opts = nil, &block)
           if opts && opts[:naked]
             fetch_rows(select_sql(opts), &block)
           else
-            fetch_rows(select_sql(opts)) do |r|
-              c = model_class(r)
-              if c
-                block.call(c.new(r))
-              else
-                raise SequelError, "No matching model class for record (#{polymorphic_key} = #{r[polymorphic_key].inspect})"
-              end
-            end
+            fetch_rows(select_sql(opts)) {|r| block.call(make_model_instance(r))}
           end
         end
       end

data/spec/dataset_spec.rb

@@ -1150,35 +1150,36 @@ context "Dataset#set_model" do
   setup do
     @c = Class.new(Sequel::Dataset) do
       def fetch_rows(sql, &block)
-        (1..10).each(&block)
+        # yield a hash with kind as the 1 bit of a number
+        (1..10).each {|i| block.call({:kind => i[0]})}
       end
     end
     @dataset = @c.new(nil).from(:items)
     @m = Class.new do
-      attr_accessor :c
-      def initialize(c); @c = c; end
-      def ==(o); @c == o.c; end
+      attr_accessor :c, :args
+      def initialize(c, *args); @c = c; @args = args; end
+      def ==(o); (@c == o.c) && (@args = o.args); end
     end
   end
   
   specify "should clear the models hash and restore the stock #each if nil is specified" do
     @dataset.set_model(@m)
     @dataset.set_model(nil)
-    @dataset.first.should == 1
+    @dataset.first.should == {:kind => 1}
     @dataset.model_classes.should be_nil
   end
   
   specify "should clear the models hash and restore the stock #each if nothing is specified" do
     @dataset.set_model(@m)
-    @dataset.set_model
-    @dataset.first.should == 1
+    @dataset.set_model(nil)
+    @dataset.first.should == {:kind => 1}
     @dataset.model_classes.should be_nil
   end
   
   specify "should alter #each to provide model instances" do
-    @dataset.first.should == 1
+    @dataset.first.should == {:kind => 1}
     @dataset.set_model(@m)
-    @dataset.first.should == @m.new(1)
+    @dataset.first.should == @m.new({:kind => 1})
   end
   
   specify "should extend the dataset with a #destroy method" do
@@ -1193,20 +1194,43 @@ context "Dataset#set_model" do
     @dataset.opts[:naked].should be_nil
   end
   
+  specify "should send additional arguments to the models' initialize method" do
+    @dataset.set_model(@m, 7, 6, 5)
+    @dataset.first.should == @m.new({:kind => 1}, 7, 6, 5)
+  end
+  
   specify "should provide support for polymorphic model instantiation" do
     @m1 = Class.new(@m)
     @m2 = Class.new(@m)
-    @dataset.set_model(0, 0 => @m1, 1 => @m2)
+    @dataset.set_model(:kind, 0 => @m1, 1 => @m2)
+    @dataset.opts[:polymorphic_key].should == :kind
     all = @dataset.all
     all[0].class.should == @m2
     all[1].class.should == @m1
     all[2].class.should == @m2
     all[3].class.should == @m1
     #...
+    
+    # denude model
+    @dataset.set_model(nil)
+    @dataset.first.should == {:kind => 1}
+  end
+  
+  specify "should send additional arguments for polymorphic models as well" do
+    @m1 = Class.new(@m)
+    @m2 = Class.new(@m)
+    @dataset.set_model(:kind, {0 => @m1, 1 => @m2}, :hey => :wow)
+    all = @dataset.all
+    all[0].class.should == @m2; all[0].args.should == [{:hey => :wow}]
+    all[1].class.should == @m1; all[1].args.should == [{:hey => :wow}]
+    all[2].class.should == @m2; all[2].args.should == [{:hey => :wow}]
+    all[3].class.should == @m1; all[3].args.should == [{:hey => :wow}]
   end
   
-  specify "should raise an error if more than two arguments are supplied" do
-    proc {@dataset.set_model(1, 2, 3)}.should raise_error(SequelError)
+  specify "should raise for invalid parameters" do
+    proc {@dataset.set_model('kind')}.should raise_error(SequelError)
+    proc {@dataset.set_model(0)}.should raise_error(SequelError)
+    proc {@dataset.set_model(:kind)}.should raise_error(SequelError) # no hash given
   end
 end
 
@@ -1238,7 +1262,7 @@ context "Dataset#model_classes" do
   specify "should return the polymorphic hash for a polymorphic model dataset" do
     @m1 = Class.new(@m)
     @m2 = Class.new(@m)
-    @dataset.set_model(0, 0 => @m1, 1 => @m2)
+    @dataset.set_model(:key, 0 => @m1, 1 => @m2)
     @dataset.model_classes.should == {0 => @m1, 1 => @m2}
   end
 end
@@ -1295,7 +1319,7 @@ context "A polymorphic model dataset" do
   setup do
     @c = Class.new(Sequel::Dataset) do
       def fetch_rows(sql, &block)
-        (1..10).each(&block)
+        (1..10).each {|i| block.call(:bit => i[0])}
       end
     end
     @dataset = @c.new(nil).from(:items)
@@ -1308,7 +1332,7 @@ context "A polymorphic model dataset" do
   
   specify "should use a nil key in the polymorphic hash to specify the default model class" do
     @m2 = Class.new(@m)
-    @dataset.set_model(0, nil => @m, 1 => @m2)
+    @dataset.set_model(:bit, nil => @m, 1 => @m2)
     all = @dataset.all
     all[0].class.should == @m2
     all[1].class.should == @m
@@ -1319,13 +1343,13 @@ context "A polymorphic model dataset" do
   
   specify "should raise SequelError if no suitable class is found in the polymorphic hash" do
     @m2 = Class.new(@m)
-    @dataset.set_model(0, 1 => @m2)
+    @dataset.set_model(:bit, 1 => @m2)
     proc {@dataset.all}.should raise_error(SequelError)
   end
 
   specify "should supply naked records if the naked option is specified" do
-    @dataset.set_model(0, nil => @m)
-    @dataset.each(:naked => true) {|r| r.class.should == Fixnum}
+    @dataset.set_model(:bit, nil => @m)
+    @dataset.each(:naked => true) {|r| r.class.should == Hash}
   end
 end
 

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: sequel
 version: !ruby/object:Gem::Version 
-  version: 0.1.9.10
-date: 2007-08-23 00:00:00 +03:00
+  version: 0.1.9.11
+date: 2007-08-24 00:00:00 +03:00
 summary: Lightweight ORM library for Ruby
 require_paths: 
 - lib