sequel 0.4.4.2 → 0.4.5

data/Rakefile

@@ -5,19 +5,24 @@ require "rake/rdoctask"
 require "fileutils"
 include FileUtils
 
+##############################################################################
+# Configuration
+##############################################################################
 NAME = "sequel"
-VERS = "0.4.4.2"
+VERS = "0.4.5"
 CLEAN.include ["**/.*.sw?", "pkg/*", ".config", "doc/*", "coverage/*"]
-RDOC_OPTS = ["--quiet", "--title", "Sequel: Concise ORM for Ruby",
+RDOC_OPTS = [
+  "--quiet", 
+  "--title", "Sequel: Concise ORM for Ruby",
   "--opname", "index.html",
   "--line-numbers", 
   "--main", "README",
-  "--inline-source"]
-
-desc "Packages up Sequel."
-task :default => [:package]
-task :package => [:clean]
+  "--inline-source"
+]
 
+##############################################################################
+# RDoc
+##############################################################################
 task :doc => [:rdoc]
 
 Rake::RDocTask.new do |rdoc|
@@ -28,8 +33,16 @@ Rake::RDocTask.new do |rdoc|
   rdoc.rdoc_files.add ["README", "COPYING", "lib/sequel.rb", "lib/**/*.rb"]
 end
 
+##############################################################################
+# Gem packaging
+##############################################################################
+desc "Packages up Sequel."
+task :default => [:package]
+task :package => [:clean]
+
 spec = Gem::Specification.new do |s|
   s.name = NAME
+  s.rubyforge_project = NAME
   s.version = VERS
   s.platform = Gem::Platform::RUBY
   s.has_rdoc = true
@@ -42,40 +55,25 @@ spec = Gem::Specification.new do |s|
   s.email = "ciconia@gmail.com"
   s.homepage = "http://sequel.rubyforge.org"
   s.executables = ["sequel"]
-
-  s.add_dependency("metaid")
-  s.add_dependency("ParseTree", ">= 2.0.0")
-  s.add_dependency("ruby2ruby")
-  
   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
-
-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")
+  # Instead of requiring this, how about we simply use it if it's available
+  # by rescuing LoadError where we require it in model/validations.rb?
+  # s.add_dependency("validatable")
+  case RUBY_PLATFORM
+  when /mswin/
+    s.platform = Gem::Platform::CURRENT
+  when /java/
+    s.platform = "jruby"
+  else
+    s.platform = Gem::Platform::RUBY
+    s.add_dependency("metaid")
+    s.add_dependency("ParseTree", ">= 2.0.0")
+    s.add_dependency("ruby2ruby")
+  end
   
-  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
@@ -85,11 +83,9 @@ Rake::GemPackageTask.new(spec) do |p|
   p.gem_spec = spec
 end
 
-Rake::GemPackageTask.new(win_spec) do |p|
-  p.need_tar = true
-  p.gem_spec = win_spec
-end
-
+##############################################################################
+# installation & removal
+##############################################################################
 task :install do
   sh %{rake package}
   sh %{sudo gem install pkg/#{NAME}-#{VERS}}
@@ -104,6 +100,9 @@ task :uninstall => [:clean] do
   sh %{sudo gem uninstall #{NAME}}
 end
 
+##############################################################################
+# gem and rdoc release
+##############################################################################
 task :release => [:package] do
   sh %{rubyforge login}
   sh %{rubyforge add_release sequel sequel #{VERS} pkg/sequel-#{VERS}.tgz}
@@ -117,29 +116,44 @@ task :doc_rforge do
   sh %{scp -r doc/rdoc/* ciconia@rubyforge.org:/var/www/gforge-projects/sequel}
 end
 
+##############################################################################
+# specs
+##############################################################################
 require "spec/rake/spectask"
 
 desc "Run specs with coverage"
 Spec::Rake::SpecTask.new("spec") do |t|
   t.spec_files = FileList["spec/*_spec.rb"]
-  t.rcov_opts = ["--exclude", "gems", "--exclude", "spec"]
+  t.spec_opts  = File.read("spec/spec.opts").split("\n")
+  t.rcov_opts  = File.read("spec/rcov.opts").split("\n")
   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"]
+  t.spec_opts  = File.read("spec/spec.opts").split("\n")
 end
 
 desc "Run adapter specs without coverage"
 Spec::Rake::SpecTask.new("spec_adapters") do |t|
   t.spec_files = FileList["spec/adapters/*_spec.rb"]
+  t.spec_opts  = File.read("spec/spec.opts").split("\n")
 end
 
 desc "Run all specs with coverage"
 Spec::Rake::SpecTask.new("spec_all") do |t|
   t.spec_files = FileList["spec/*_spec.rb", "spec/adapters/*_spec.rb"]
-  t.rcov_opts = ["--exclude", "gems", "--exclude", "spec"]
+  t.rcov_opts  = File.read("spec/rcov.opts").split("\n")
+  t.spec_opts  = File.read("spec/spec.opts").split("\n")
+  t.rcov = true
+end
+
+desc "Run rcov only"
+Spec::Rake::SpecTask.new("rcov") do |t|
+  t.rcov_opts  = File.read("spec/rcov.opts").split("\n")
+  t.spec_opts  = File.read("spec/spec.opts").split("\n")
+  t.spec_files = FileList["spec/*_spec.rb"]
   t.rcov = true
 end
 

data/lib/sequel/database.rb

@@ -188,39 +188,86 @@ module Sequel
       names.each {|n| execute(drop_table_sql(n))}
     end
     
+    # Renames a table:
+    #
+    #   DB.tables #=> [:items]
+    #   DB.rename_table :items, :old_items
+    #   DB.tables #=> [:old_items]
     def rename_table(*args)
       execute(rename_table_sql(*args))
     end
     
+    # Alters the given table with the specified block. Here are the currently
+    # available operations:
+    #
+    #   DB.alter_table :items do
+    #     add_column :category, :text, :default => 'ruby'
+    #     drop_column :category
+    #     rename_column :cntr, :counter
+    #     set_column_type :value, :float
+    #     set_column_default :value, :float
+    #     add_index [:group, :category]
+    #     drop_index [:group, :category]
+    #   end
+    #
+    # Note that #add_column accepts all the options available for column
+    # definitions using create_table, and #add_index accepts all the options
+    # available for index definition.
     def alter_table(name, &block)
       g = Schema::AlterTableGenerator.new(self, &block)
       alter_table_sql_list(name, g.operations).each {|sql| execute(sql)}
     end
     
+    # Adds a column to the specified table. This method expects a column name,
+    # a datatype and optionally a hash with additional constraints and options:
+    #
+    #   DB.add_column :items, :name, :text, :unique => true, :null => false
+    #   DB.add_column :items, :category, :text, :default => 'ruby'
     def add_column(table, *args)
       alter_table(table) {add_column(*args)}
     end
     
+    # Removes a column from the specified table:
+    #
+    #   DB.drop_column :items, :category
     def drop_column(table, *args)
       alter_table(table) {drop_column(*args)}
     end
     
+    # Renames a column in the specified table. This method expects the current
+    # column name and the new column name:
+    #
+    #   DB.rename_column :items, :cntr, :counter
     def rename_column(table, *args)
       alter_table(table) {rename_column(*args)}
     end
     
+    # Set the data type for the given column in the given table:
+    #
+    #   DB.set_column_type :items, :price, :float
     def set_column_type(table, *args)
       alter_table(table) {set_column_type(*args)}
     end
     
+    # Sets the default value for the given column in the given table:
+    #
+    #   DB.set_column_default :items, :category, 'perl!'
+    def set_column_default(table, *args)
+      alter_table(table) {set_column_default(*args)}
+    end
+    
     # Adds an index to a table for the given columns:
     # 
-    #   DB.add_index(:posts, :title)
-    #   DB.add_index(:posts, [:author, :title], :unique => true)
+    #   DB.add_index :posts, :title
+    #   DB.add_index :posts, [:author, :title], :unique => true
     def add_index(table, *args)
       alter_table(table) {add_index(*args)}
     end
     
+    # Removes an index for the given table and column/s:
+    #
+    #   DB.drop_index :posts, :title
+    #   DB.drop_index :posts, [:author, :title]
     def drop_index(table, *args)
       alter_table(table) {drop_index(*args)}
     end
@@ -236,16 +283,27 @@ module Sequel
       false
     end
     
+    # Creates a view based on a dataset or an SQL string:
+    #
+    #   DB.create_view(:cheap_items, "SELECT * FROM items WHERE price < 100")
+    #   DB.create_view(:ruby_items, DB[:items].filter(:category => 'ruby'))
     def create_view(name, source)
       source = source.sql if source.is_a?(Dataset)
       execute("CREATE VIEW #{name} AS #{source}")
     end
     
+    # Creates a view, replacing it if it already exists:
+    #
+    #   DB.create_or_replace_view(:cheap_items, "SELECT * FROM items WHERE price < 100")
+    #   DB.create_or_replace_view(:ruby_items, DB[:items].filter(:category => 'ruby'))
     def create_or_replace_view(name, source)
       source = source.sql if source.is_a?(Dataset)
       execute("CREATE OR REPLACE VIEW #{name} AS #{source}")
     end
     
+    # Drops a view:
+    #
+    #   DB.drop_view(:cheap_items)
     def drop_view(name)
       execute("DROP VIEW #{name}")
     end

data/lib/sequel/dataset.rb

@@ -88,6 +88,7 @@ module Sequel
       @db = db
       @opts = opts || {}
       @row_proc = nil
+      @transform = nil
     end
     
     # Returns a new instance of the dataset with with the give options merged.

data/lib/sequel/dataset/sql.rb

@@ -454,7 +454,8 @@ module Sequel
               "INSERT INTO #{@opts[:from]} DEFAULT VALUES"
             elsif values.keys
               fl = values.keys.map {|f| literal(f.to_sym)}
-              vl = transform_save(values.values).map {|v| literal(v)}
+              vl = @transform ? transform_save(values.values) : values.values
+              vl.map! {|v| literal(v)}
               "INSERT INTO #{@opts[:from]} (#{fl.join(COMMA_SEPARATOR)}) VALUES (#{vl.join(COMMA_SEPARATOR)})"
             else
               "INSERT INTO #{@opts[:from]} VALUES (#{literal(values)})"
@@ -498,7 +499,11 @@ module Sequel
           if values.is_a?(Hash)
             # get values from hash
             values = transform_save(values) if @transform
-            set = values.map {|k, v| "#{literal(k)} = #{literal(v)}"}.join(COMMA_SEPARATOR)
+            set = values.map do |k, v|
+              # convert string key into symbol
+              k = k.to_sym if String === k
+              "#{literal(k)} = #{literal(v)}"
+            end.join(COMMA_SEPARATOR)
           else
             # copy values verbatim
             set = values

data/lib/sequel/model.rb

@@ -227,18 +227,22 @@ module Sequel
   class Model
     alias_method :model, :class
   end
+
 end
 
-require File.join(File.dirname(__FILE__), 'model/base')
-require File.join(File.dirname(__FILE__), 'model/hooks')
-require File.join(File.dirname(__FILE__), 'model/record')
-require File.join(File.dirname(__FILE__), 'model/schema')
-require File.join(File.dirname(__FILE__), 'model/relations')
-require File.join(File.dirname(__FILE__), 'model/caching')
-require File.join(File.dirname(__FILE__), 'model/plugins')
+require File.join(File.dirname(__FILE__), "model/base")
+require File.join(File.dirname(__FILE__), "model/hooks")
+require File.join(File.dirname(__FILE__), "model/record")
+require File.join(File.dirname(__FILE__), "model/schema")
+require File.join(File.dirname(__FILE__), "model/relations")
+require File.join(File.dirname(__FILE__), "model/caching")
+require File.join(File.dirname(__FILE__), "model/plugins")
+require File.join(File.dirname(__FILE__), "model/validations")
 
 module Sequel
+  
   class Model
+    
     # Defines a method that returns a filtered dataset.
     def self.subset(name, *args, &block)
       dataset.meta_def(name) {filter(*args, &block)}
@@ -253,6 +257,7 @@ module Sequel
       dataset.filter(*args, &block).first
     end
     
+    # TODO: doc
     def self.[](*args)
       args = args.first if (args.size == 1)
       if args === true || args === false
@@ -261,6 +266,7 @@ module Sequel
       dataset[(Hash === args) ? args : primary_key_hash(args)]
     end
     
+    # TODO: doc
     def self.fetch(*args)
       db.fetch(*args).set_model(self)
     end
@@ -273,6 +279,11 @@ module Sequel
 
     ############################################################################
 
+    # Deletes all records in the model's table.
+    def self.delete_all
+      dataset.delete
+    end
+
     # Like delete_all, but invokes before_destroy and after_destroy hooks if used.
     def self.destroy_all
       if has_hooks?(:before_destroy) || has_hooks?(:after_destroy)
@@ -281,11 +292,7 @@ module Sequel
         dataset.delete
       end
     end
-    # Deletes all records.
-    def self.delete_all
-      dataset.delete
-    end
-    
+        
     def self.is_dataset_magic_method?(m)
       method_name = m.to_s
       Sequel::Dataset::MAGIC_METHODS.each_key do |r|
@@ -303,15 +310,16 @@ module Sequel
       respond_to?(m) ? send(m, *args, &block) : super(m, *args)
     end
 
-    # Comprehensive description goes here!
+    # TODO: Comprehensive description goes here!
     def self.join(*args)
       table_name = dataset.opts[:from].first
       dataset.join(*args).select(table_name.to_sym.ALL)
     end
     
-    # Returns an array containing all model records
+    # Returns an array containing all of the models records.
     def self.all
       dataset.all
     end
   end
+
 end

data/lib/sequel/model/base.rb

@@ -93,4 +93,5 @@ module Sequel
       end
     end
   end
+  
 end

data/lib/sequel/model/record.rb

@@ -198,6 +198,7 @@ module Sequel
     def new?
       @new
     end
+    alias :new_record? :new?
     
     # Returns true when current instance exists, false otherwise.
     def exists?
@@ -248,6 +249,7 @@ module Sequel
       this.update(values)
       values.each {|k, v| @values[k] = v}
     end
+    alias_method :update, :set
     
     # Reloads values from database and returns self.
     def refresh

data/lib/sequel/model/schema.rb

@@ -49,4 +49,4 @@ module Sequel
       create_table!
     end
   end
-end
+end

data/lib/sequel/model/validations.rb

@@ -0,0 +1,117 @@
+module Sequel
+  class Model
+    # =Basic Sequel Validations
+    #
+    # Sequel validations are based on the Validatable gem http://validatable.rubyforge.org/
+    # 
+    # To assign default validations to a sequel model:
+    # 
+    # class MyModel < SequelModel(:items)
+    #   validates do
+    #     format_of...
+    #     presence_of...
+    #     acceptance_of...
+    #     confirmation_of...
+    #     length_of...
+    #     true_for...
+    #     numericality_of...
+    #     format_of...
+    #     validates_base...
+    #     validates_each...
+    #   end
+    # end
+    #
+    # You may also perform the usual 'longhand' way to assign default model validates 
+    # directly within the model class itself:
+    #
+    #   class MyModel < SequelModel(:items)
+    #     validates_format_of...
+    #     validates_presence_of...
+    #     validates_acceptance_of...
+    #     validates_confirmation_of...
+    #     validates_length_of...
+    #     validates_true_for...
+    #     validates_numericality_of...
+    #     validates_format_of...
+    #     validates_base...
+    #     validates_each...
+    #   end
+    #
+    # Each validation allows for arguments:
+    #   TODO: fill the argument options in here
+    #
+    # =Advanced Sequel Validations
+    #
+    # TODO: verify that advanced validates work as stated (aka write specs)
+    # NOTE: experimental
+    #
+    #  To store validates for conditional usage simply specify a name with which to store them
+    #    class User < Sequel::Model
+    #
+    #      # This set of validates becomes stored as :default and gets injected into the model.
+    #      validates do
+    #        # standard validates calls
+    #      end
+    #      
+    #      validates(:registration) do
+    #        # user registration specific validates 
+    #      end
+    #      
+    #      validates(:promotion) do
+    #        # user promotion validates
+    #      end
+    #
+    #    end
+    #
+    # To use the above validates:
+    #
+    #   @user.valid?                # Runs the default validations only.
+    #   @user.valid?(:registration) # Runs both default and registration validations
+    #   @user.valid?(:promotion)    # Runs both default and promotion validations
+    #
+    # You may determine whether the model has validates via:
+    #
+    #   has_validations? # will return true / false based on existence of validations on the model.
+    #
+    # You may also retrieve the validations block if needed:
+    #
+    #   validates(:registration) # returns the registration validation block.
+    #
+    # validates() method parameters:
+    #   a validations block - runs the validations block on the model & stores as :default
+    #   a name and a validations block - stores the block under the name
+    #   a name - returns a stored block of that name or nil
+    #   nothing - returns true / false based on if validations exist for the model.
+    #
+    module Validations
+      class Generator
+        def initialize(model_class ,&block)
+          @model_class = model_class
+          instance_eval(&block)
+        end
+
+        def method_missing(method, *args)
+          method = :"validates_#{method}"
+          @model_class.send(method, *args)
+        end
+      end
+    end
+    
+    begin
+      require "validatable"
+      include ::Validatable
+      def self.validates(&block)
+        Validations::Generator.new(self, &block)
+      end
+      # return true if there are validations stored, false otherwise
+      def self.has_validations?
+        validations.length > 0 ? true : false
+      end
+    rescue LoadError
+      STDERR.puts <<-MESSAGE
+      Install the validatable gem in order to use Sequel Model validations
+      If you would like model validations to work, install the validatable gem
+      MESSAGE
+    end
+  end
+end