sequel 0.2.1 → 0.2.1.1

data/CHANGELOG

@@ -1,3 +1,21 @@
+=== 0.2.1.1 (2007-10-07)
+
+* Added Date literalization to sqlite adapter (#60).
+
+* Changed Model.serialize to allow calling it after the class is defined (#59).
+
+* Fixed after_create hooks to allow calling save inside the hook (#58).
+
+* Fixed MySQL quoting of sql functions (#57).
+
+* Implemented rollback! global method for cancelling transactions in progress.
+
+* Fixed =~ operator in Sequelizer.
+
+* Fixed ODBC::Dataset#fetch_rows (thanks Dusty).
+
+* Renamed Model.recreate_table to create_table!. recreate_table is deprecated and will issue a warning (#56).
+
 === 0.2.1 (2007-09-24)
 
 * Added default implementation of Model.primary_key_hash.

data/Rakefile

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

data/lib/sequel/database.rb

@@ -161,7 +161,7 @@ module Sequel
           result
         rescue => e
           conn.execute(SQL_ROLLBACK)
-          raise e
+          raise e unless SequelRollbackError === e
         ensure
           @transactions.delete(Thread.current)
         end

data/lib/sequel/dataset/sequelizer.rb

@@ -236,7 +236,7 @@ class Sequel::Dataset
         "(#{e[1..-1].map {|i| pt_expr(i, b)}.join(" AND ")})"
       when :or # x || y
         "(#{pt_expr(e[1], b)} OR #{pt_expr(e[2], b)})"
-      when :call, :vcall, :iter # method calls, blocks
+      when :call, :vcall, :iter, :match3 # method calls, blocks
         eval_expr(e, b)
       else # literals
         if e == [:lvar, :block]

data/lib/sequel/error.rb

@@ -1,2 +1,11 @@
 class SequelError < StandardError
+end
+
+class SequelRollbackError < StandardError
+end
+
+class Object
+  def rollback!
+    raise SequelRollbackError
+  end
 end

data/lib/sequel/model/base.rb

@@ -70,6 +70,7 @@ module Sequel
         m[c] = filters
         m
       end
+      @dataset.transform(@transform) if @dataset
     end
   end
 

data/lib/sequel/model/record.rb

@@ -89,6 +89,7 @@ module Sequel
           @this = nil # remove memoized this dataset
           refresh
         end
+        @new = false
         run_hooks(:after_create)
       else
         run_hooks(:before_update)
@@ -96,7 +97,6 @@ module Sequel
         run_hooks(:after_update)
       end
       run_hooks(:after_save)
-      @new = false
       self
     end
 

data/lib/sequel/model/schema.rb

@@ -28,9 +28,15 @@ module Sequel
       db.execute db.drop_table_sql(table_name)
     end
     
-    def self.recreate_table
+    def self.create_table!
       drop_table if table_exists?
       create_table
+      
+    end
+    
+    def self.recreate_table
+      warn "Model.recreate_table is deprecated. Please use Model.create_table! instead."
+      create_table!
     end
   end
 end

data/lib/sequel/mysql.rb

@@ -133,7 +133,7 @@ module Sequel
             result
           rescue => e
             conn.query(SQL_ROLLBACK)
-            raise e
+            raise e unless SequelRollbackError === e
           ensure
             @transactions.delete(Thread.current)
           end
@@ -144,10 +144,10 @@ module Sequel
     class Dataset < Sequel::Dataset
       UNQUOTABLE_FIELD_RE = /^(`(.+)`)|\*$/.freeze
       def quote_field(f)
-        f =~ UNQUOTABLE_FIELD_RE ? f : "`#{f}`"
+        (f.nil? || f.empty? || f =~ UNQUOTABLE_FIELD_RE) ? f : "`#{f}`"
       end
       
-      FIELD_EXPR_RE = /^([^\(]+\()?([^\.]+\.)?([^\s\)]+)(\))?(\sAS\s(.+))?$/i.freeze
+      FIELD_EXPR_RE = /^([^\(]+\()?([^\.]+\.)?([^\s\)]+)?(\))?(\sAS\s(.+))?$/i.freeze
       FIELD_ORDER_RE = /^(.*) (DESC|ASC)$/i.freeze
       def quoted_field_name(name)
         case name

data/lib/sequel/odbc.rb

@@ -46,7 +46,7 @@ module Sequel
 
       def fetch_rows(sql, &block)
         @db.synchronize do
-          s = @db.execute select_sql(sql)
+          s = @db.execute sql
           begin
             @columns = s.columns(true).map {|c| c.name.to_sym}
             rows = s.fetch_all

data/lib/sequel/postgres.rb

@@ -260,7 +260,7 @@ module Sequel
             rescue => e
               @logger.info(SQL_ROLLBACK) if @logger
               conn.async_exec(SQL_ROLLBACK) rescue nil
-              raise e
+              raise e unless SequelRollbackError === e
             ensure
               conn.transaction_in_progress = nil
             end

data/lib/sequel/sqlite.rb

@@ -99,6 +99,7 @@ module Sequel
       def literal(v)
         case v
         when Time: literal(v.iso8601)
+        when Date: literal(v.to_s)
         else
           super
         end

data/spec/adapters/mysql_spec.rb

@@ -79,6 +79,9 @@ context "A MySQL dataset" do
 
     @d.select(:value.MAX).sql.should == \
       'SELECT max(`value`) FROM items'
+      
+    @d.select(:NOW[]).sql.should == \
+    'SELECT NOW() FROM items'
 
     @d.select(:items__value.MAX).sql.should == \
       'SELECT max(items.`value`) FROM items'

data/spec/database_spec.rb

@@ -289,6 +289,16 @@ context "Database#transaction" do
     proc {@db.transaction {raise RuntimeError}}.should raise_error(RuntimeError)
   end
   
+  specify "should issue ROLLBACK if rollback! is called in the transaction" do
+    @db.transaction do
+      @db.drop_table(:a)
+      rollback!
+      @db.drop_table(:b)
+    end
+    
+    @db.sql.should == ['BEGIN', 'DROP TABLE a;', 'ROLLBACK']
+  end
+  
   specify "should be re-entrant" do
     stop = false
     cc = nil

data/spec/model_spec.rb

@@ -252,6 +252,38 @@ context "Model#serialize" do
     ]
   end
   
+
+  specify "should support calling after the class is defined" do
+    @c = Class.new(Sequel::Model(:items)) do
+      no_primary_key
+    end
+    
+    @c.serialize :def
+
+    @c.create(:def => 1)
+    @c.create(:def => "hello")
+    
+    MODEL_DB.sqls.should == [ \
+      "INSERT INTO items (def) VALUES ('--- 1\n');", \
+      "INSERT INTO items (def) VALUES ('--- hello\n');", \
+    ]
+  end
+  
+  specify "should support using the Marshal format" do
+    @c = Class.new(Sequel::Model(:items)) do
+      no_primary_key
+      serialize :abc, :format => :marshal
+    end
+
+    @c.create(:abc => 1)
+    @c.create(:abc => "hello")
+    
+    MODEL_DB.sqls.should == [ \
+      "INSERT INTO items (abc) VALUES ('\004\bi\006');", \
+      "INSERT INTO items (abc) VALUES ('\004\b\"\nhello');", \
+    ]
+  end
+  
   specify "should translate values to and from YAML using accessor methods" do
     @c = Class.new(Sequel::Model(:items)) do
       serialize :abc, :def
@@ -338,4 +370,71 @@ context "Model attribute accessors" do
     proc {o.x = 3}.should_not raise_error
     proc {o.yy = 4}.should raise_error
   end
+end
+
+context "Model#new?" do
+  setup do
+    MODEL_DB.reset
+
+    @c = Class.new(Sequel::Model(:items)) do
+      def columns
+        [:id, :x, :y]
+      end
+    end
+  end
+  
+  specify "should be true for a new instance" do
+    n = @c.new(:x => 1)
+    n.should be_new
+  end
+  
+  specify "should be false after saving" do
+    n = @c.new(:x => 1)
+    n.save
+    n.should_not be_new
+  end
+end
+
+context "Model.after_create" do
+  setup do
+    MODEL_DB.reset
+
+    @c = Class.new(Sequel::Model(:items)) do
+      def columns
+        [:id, :x, :y]
+      end
+    end
+    
+    ds = @c.dataset
+    def ds.insert(*args)
+      super(*args)
+      1
+    end
+  end
+
+  specify "should be called after creation" do
+    s = []
+    
+    @c.after_create do
+      s = MODEL_DB.sqls.dup
+    end
+    
+    n = @c.create(:x => 1)
+    MODEL_DB.sqls.should == ['INSERT INTO items (x) VALUES (1);']
+    s.should == ['INSERT INTO items (x) VALUES (1);']
+  end
+  
+  specify "should allow calling save in the hook" do
+    @c.after_create do
+      values.delete(:x)
+      self.id = 2
+      save
+    end
+    
+    n = @c.create(:id => 1)
+    MODEL_DB.sqls.should == ['INSERT INTO items (id) VALUES (1);', 'UPDATE items SET id = 2 WHERE (id = 1)']
+  end
+end
+
+context "Model.serialize" do
 end

data/spec/sequelizer_spec.rb

@@ -9,7 +9,18 @@ context "Proc#to_sql" do
       DS.proc_to_sql(self)
     end
   end
-
+  
+  def DS.match_expr(l, r)
+    case r
+    when String:
+      "(#{literal(l)} LIKE #{literal(r)})"
+    when Regexp:
+      "(#{literal(l)} ~ #{literal(r.source)})"
+    else
+      raise SequelError, "Unsupported match pattern class (#{r.class})."
+    end
+  end
+  
   specify "should support <sym> <op> <lit>" do
     proc {:x > 100}.to_sql.should == '(x > 100)'
     proc {:x < 100}.to_sql.should == '(x < 100)'
@@ -79,11 +90,11 @@ context "Proc#to_sql" do
   specify "should support =~ operator" do
     # stock SQL version does not know about regexps
     proc {:x =~ '123'}.to_sql.should == "(x LIKE '123')"
+
+    proc {:x =~ /^123/}.to_sql.should == "(x ~ '^123')"
   end
   
   specify "should raise on =~ operator for unsupported types" do
-    # stock SQL version does not know about regexps
-    proc {proc {:x =~ /123/}.to_sql}.should raise_error(SequelError)
     proc {proc {:x =~ 123}.to_sql}.should raise_error(SequelError)
   end
   

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.4
 specification_version: 1
 name: sequel
 version: !ruby/object:Gem::Version 
-  version: 0.2.1
-date: 2007-09-24 00:00:00 +02:00
+  version: 0.2.1.1
+date: 2007-10-07 00:00:00 +02:00
 summary: Lightweight ORM library for Ruby
 require_paths: 
 - lib