sequel 0.2.0.2 → 0.2.1

data/CHANGELOG

@@ -1,3 +1,67 @@
+=== 0.2.1 (2007-09-24)
+
+* Added default implementation of Model.primary_key_hash.
+
+* Fixed Sequel::Model() to set dataset for inherited classes.
+
+* Rewrote Model.serialize to use Dataset#transform.
+
+* Implemented Dataset#transform.
+
+* Added gem spec for Windows (without ParseTree dependency).
+
+* Added support for dynamic strings in Sequelizer (#49).
+
+* Query branch merged into trunk.
+
+* Implemented self-changing methods.
+
+* Add support for ternary operator to Sequelizer.
+
+* Fixed sequelizer to evaluate expressions if they don't involve symbols or literal strings.
+
+* Added protection against using #each, #delete, #insert, #update inside query blocks.
+
+* Improved Model#method_missing to deal with invalid attributes.
+
+* Implemented Dataset#query.
+
+* Added Dataset#group_by as alias for Dataset#group.
+
+* Added Dataset#order_by as alias for Dataset#order.
+
+* More model refactoring. Added support for composite keys.
+
+* Added Dataset#empty? method (#46).
+
+* Fixed Symbol#to_field_name to support names with numbers and upper-case characters (#45).
+
+* Added install_no_doc rake task.
+
+* Partial refactoring of model code.
+
+* Refactored dataset-model association and added Dataset#set_row_filter method.
+
+* Added support for case-sensitive regexps to mysql adapter.
+
+* Changed mysql adapter to support encoding option as well.
+
+* Added charset/encoding option to postgres adapter.
+
+* Implemented Model.serialize (thanks Aman Gupta.)
+
+* Changed Model.create to INSERT DEFAULT VALUES instead of (id) VALUES (null) (brings back #41.)
+
+* Fixed Model.new to work without arguments.
+
+* Added Model.no_primary_key method to allow models without primary keys.
+
+* Added Model#this method (#42 thanks Duane Johnson).
+
+* Fixed Dataset#insert_sql to use DEFAULT VALUES clause if argument is an empty hash.
+
+* Fixed Model.create to work correctly when no argument is passed (#41).
+
 === 0.2.0.2 (2007-09-07)
 
 * Dataset#insert can now accept subqueries.

data/Rakefile

@@ -6,7 +6,7 @@ require 'fileutils'
 include FileUtils
 
 NAME = "sequel"
-VERS = "0.2.0.2"
+VERS = "0.2.1"
 CLEAN.include ['**/.*.sw?', 'pkg/*', '.config', 'doc/*', 'coverage/*']
 RDOC_OPTS = ['--quiet', '--title', "Sequel: Concise ORM for Ruby",
   "--opname", "index.html",
@@ -55,16 +55,51 @@ spec = Gem::Specification.new do |s|
   s.bindir = "bin"
 end
 
+win_spec = Gem::Specification.new do |s|
+  s.name = NAME
+  s.version = VERS
+  s.platform = Gem::Platform::WIN32
+  s.has_rdoc = true
+  s.extra_rdoc_files = ["README", "CHANGELOG", "COPYING"]
+  s.rdoc_options += RDOC_OPTS + 
+    ['--exclude', '^(examples|extras)\/', '--exclude', 'lib/sequel.rb']
+  s.summary = "Lightweight ORM library for Ruby"
+  s.description = s.summary
+  s.author = "Sharon Rosner"
+  s.email = 'ciconia@gmail.com'
+  s.homepage = 'http://sequel.rubyforge.org'
+  s.executables = ['sequel']
+
+  s.add_dependency('metaid')
+  
+  s.required_ruby_version = '>= 1.8.4'
+
+  s.files = %w(COPYING README Rakefile) + Dir.glob("{bin,doc,spec,lib}/**/*")
+      
+  s.require_path = "lib"
+  s.bindir = "bin"
+end
+
 Rake::GemPackageTask.new(spec) do |p|
   p.need_tar = true
   p.gem_spec = spec
 end
 
+Rake::GemPackageTask.new(win_spec) do |p|
+  p.need_tar = true
+  p.gem_spec = win_spec
+end
+
 task :install do
   sh %{rake package}
   sh %{sudo gem install pkg/#{NAME}-#{VERS}}
 end
 
+task :install_no_docs do
+  sh %{rake package}
+  sh %{sudo gem install pkg/#{NAME}-#{VERS} --no-rdoc --no-ri}
+end
+
 task :uninstall => [:clean] do
   sh %{sudo gem uninstall #{NAME}}
 end
@@ -83,6 +118,11 @@ Spec::Rake::SpecTask.new('spec') do |t|
   t.rcov = true
 end
 
+desc "Run specs without coverage"
+Spec::Rake::SpecTask.new('spec_no_cov') do |t|
+  t.spec_files = FileList['spec/*_spec.rb']
+end
+
 desc "Run adapter specs without coverage"
 Spec::Rake::SpecTask.new('spec_adapters') do |t|
   t.spec_files = FileList['spec/adapters/*_spec.rb']

data/lib/sequel.rb

@@ -1,37 +1,37 @@
-require 'metaid'
-
-files = %w[
-  core_ext error connection_pool pretty_table
-  dataset migration model schema database 
-]
-dir = File.join(File.dirname(__FILE__), 'sequel')
-files.each {|f| require(File.join(dir, f))}
-
-module Sequel #:nodoc:
-  class << self
-    # call-seq:
-    #   Sequel::Database.connect(conn_string)
-    #   Sequel.connect(conn_string)
-    #   Sequel.open(conn_string)
-    #
-    # Creates a new database object based on the supplied connection string.
-    # The specified scheme determines the database class used, and the rest
-    # of the string specifies the connection options. For example:
-    #   DB = Sequel.open 'sqlite:///blog.db'
-    def connect(*args)
-      Database.connect(*args)
-    end
-    
-    alias_method :open, :connect
-    
-    def single_threaded=(value)
-      Database.single_threaded = value
-    end
-  end
-end
-
-class Object
-  def Sequel(*args)
-    Sequel.connect(*args)
-  end
-end
+require 'metaid'
+
+files = %w[
+  core_ext error connection_pool pretty_table
+  dataset migration model schema database 
+]
+dir = File.join(File.dirname(__FILE__), 'sequel')
+files.each {|f| require(File.join(dir, f))}
+
+module Sequel #:nodoc:
+  class << self
+    # call-seq:
+    #   Sequel::Database.connect(conn_string)
+    #   Sequel.connect(conn_string)
+    #   Sequel.open(conn_string)
+    #
+    # Creates a new database object based on the supplied connection string.
+    # The specified scheme determines the database class used, and the rest
+    # of the string specifies the connection options. For example:
+    #   DB = Sequel.open 'sqlite:///blog.db'
+    def connect(*args)
+      Database.connect(*args)
+    end
+    
+    alias_method :open, :connect
+    
+    def single_threaded=(value)
+      Database.single_threaded = value
+    end
+  end
+end
+
+class Object
+  def Sequel(*args)
+    Sequel.connect(*args)
+  end
+end

data/lib/sequel/core_ext.rb

@@ -106,9 +106,9 @@ class Symbol
   include FieldCompositionMethods
   
 
-  FIELD_REF_RE1 = /^([a-z_]+)__([a-z_]+)___([a-z_]+)/.freeze
-  FIELD_REF_RE2 = /^([a-z_]+)___([a-z_]+)$/.freeze
-  FIELD_REF_RE3 = /^([a-z_]+)__([a-z_]+)$/.freeze
+  FIELD_REF_RE1 = /^(\w+)__(\w+)___(\w+)/.freeze
+  FIELD_REF_RE2 = /^(\w+)___(\w+)$/.freeze
+  FIELD_REF_RE3 = /^(\w+)__(\w+)$/.freeze
   
   # Converts a symbol into a field name. This method supports underscore
   # notation in order to express qualified (two underscores) and aliased 

data/lib/sequel/database.rb

@@ -60,9 +60,15 @@ module Sequel
     
     # Returns a blank dataset
     def dataset
-      Sequel::Dataset.new(self)
+      ds = Sequel::Dataset.new(self)
     end
-
+    
+    # Converts a query block into a dataset. For more information see 
+    # Dataset#query.
+    def query(&block)
+      dataset.query(&block)
+    end
+    
     # Returns a new dataset with the from method invoked. If a block is given,
     # it is used as a filter on the dataset.
     def from(*args, &block)

data/lib/sequel/dataset.rb

@@ -1,8 +1,8 @@
 require 'time'
 require 'date'
 
-require File.join(File.dirname(__FILE__), 'dataset/sequelizer')
 require File.join(File.dirname(__FILE__), 'dataset/sql')
+require File.join(File.dirname(__FILE__), 'dataset/sequelizer')
 require File.join(File.dirname(__FILE__), 'dataset/convenience')
 
 module Sequel
@@ -86,6 +86,7 @@ module Sequel
     def initialize(db, opts = nil)
       @db = db
       @opts = opts || {}
+      @row_proc = nil
     end
     
     # Returns a new instance of the dataset with with the give options merged.
@@ -154,7 +155,7 @@ module Sequel
     def each(opts = nil, &block)
       fetch_rows(select_sql(opts), &block)
     end
-    
+
     # Returns the the model classes associated with the dataset as a hash.
     def model_classes
       @opts[:models]
@@ -220,17 +221,22 @@ module Sequel
       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
+        remove_row_proc
+        # extend_with_stock_each
       when Class:
         # isomorphic model
         @opts.merge!(:naked => nil, :models => {nil => key}, :polymorphic_key => nil)
-        extend_with_model(key, *args)
+        set_row_proc {|h| key.new(h, *args)}
         extend_with_destroy
       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, *args)
+        set_row_proc do |h|
+          c = hash[h[key]] || hash[nil] || \
+            raise(SequelError, "No matching model class for record (#{polymorphic_key} => #{h[polymorphic_key].inspect})")
+          c.new(h, *args)
+        end
         extend_with_destroy
       else
         raise SequelError, "Invalid parameters specified"
@@ -238,41 +244,106 @@ module Sequel
       self
     end
     
-    private
-    # Overrides the each method to convert records to model instances.
-    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)
-          if opts && opts[:naked]
-            fetch_rows(select_sql(opts), &block)
-          else
-            fetch_rows(select_sql(opts)) {|r| block.call(make_model_instance(r))}
-          end
-        end
+    # Overrides the each method to pass the values through a filter. The filter
+    # receives as argument a hash containing the column values for the current
+    # record. The filter should return a value which is then passed to the 
+    # iterating block. In order to elucidate, here's a contrived example:
+    #
+    #   dataset.set_row_proc {|h| h.merge(:xxx => 'yyy')}
+    #   dataset.first[:xxx] #=> "yyy" # always!
+    #
+    def set_row_proc(&filter)
+      @row_proc = filter
+      update_each_method
+    end
+    
+    # Removes the row making proc.
+    def remove_row_proc
+      @row_proc = nil
+      update_each_method
+    end
+    
+    # Sets a value transform which is used to convert values loaded and saved
+    # to/from the database. The transform should be supplied as a hash. Each
+    # value in the hash should be an array containing two proc objects - one
+    # for transforming loaded values, and one for transforming saved values.
+    # The following example demonstrates how to store Ruby objects in a dataset
+    # using Marshal serialization:
+    #
+    #   dataset.transform(:obj => [
+    #     proc {|v| Marshal.load(v)},
+    #     proc {|v| Marshal.dump(v)}
+    #   ])
+    #
+    #   dataset.insert_sql(:obj => 1234) #=>
+    #   "INSERT INTO items (obj) VALUES ('\004\bi\002\322\004')"
+    #   
+    def transform(t)
+      @transform = t
+      update_each_method
+    end
+    
+    # Applies the value transform for data loaded from the database.
+    def transform_load(r)
+      r.inject({}) do |m, kv|
+        k, v = kv[0], kv[1]
+        m[k] = (tt = @transform[k]) ? tt[0][v] : v
+        m
       end
-      extend(m)
+      # 
+      # @transform.each do |k, tt|
+      #   r[k] = tt[0][r[k]]
+      # end
+      # r
     end
     
-    # 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, *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)
+    # Applies the value transform for data saved to the database.
+    def transform_save(r)
+      r.inject({}) do |m, kv|
+        k, v = kv[0], kv[1]
+        m[k] = (tt = @transform[k]) ? tt[1][v] : v
+        m
       end
-      m = Module.new do
-        def each(opts = nil, &block)
-          if opts && opts[:naked]
+    end
+    
+    private
+    # Updates the each method according to whether @row_proc and @transform are
+    # set or not.
+    def update_each_method
+      # warning: ugly code generation ahead
+      if @row_proc && @transform
+        class << self
+          def each(opts = nil, &block)
+            if opts && opts[:naked]
+              fetch_rows(select_sql(opts)) {|r| block[transform_load(r)]}
+            else
+              fetch_rows(select_sql(opts)) {|r| block[@row_proc[transform_load(r)]]}
+            end
+          end
+        end
+      elsif @row_proc
+        class << self
+          def each(opts = nil, &block)
+            if opts && opts[:naked]
+              fetch_rows(select_sql(opts), &block)
+            else
+              fetch_rows(select_sql(opts)) {|r| block[@row_proc[r]]}
+            end
+          end
+        end
+      elsif @transform
+        class << self
+          def each(opts = nil, &block)
+            fetch_rows(select_sql(opts)) {|r| block[transform_load(r)]}
+          end
+        end
+      else
+        class << self
+          def each(opts = nil, &block)
             fetch_rows(select_sql(opts), &block)
-          else
-            fetch_rows(select_sql(opts)) {|r| block.call(make_model_instance(r))}
           end
         end
       end
-      extend(m)
     end
     
     # Extends the dataset with a destroy method, that calls destroy for each
@@ -287,16 +358,6 @@ module Sequel
         end
       end
     end
-    
-    # Restores the stock #each implementation.
-    def extend_with_stock_each
-      m = Module.new do
-        def each(opts = nil, &block)
-          fetch_rows(select_sql(opts), &block)
-        end
-      end
-      extend(m)
-    end
   end
 end