sequel_model 0.1 → 0.2

data/CHANGELOG

@@ -1,3 +1,21 @@
+=== 0.2 (2008-01-02)
+
+* Removed deprecated Model.recreate_table method.
+
+* Removed deprecated :class and :on options from one_to_many macro.
+
+* Removed deprecated :class option from one_to_one macro.
+
+* Removed deprecated Model#pkey method.
+
+* Changed dependency to sequel_core.
+
+* Removed examples from sequel core.
+
+* Additional specs. We're now at 100% coverage.
+
+* Refactored hooks code. Hooks are now inheritable, and can be defined by supplying a block or a method name, or by overriding the hook instance method. Hook chains can now be broken by returning false (#111, #112).
+
 === 0.1 (2007-12-30)
 
 * Moved model code from sequel into separate model sub-project.

data/Rakefile

@@ -9,7 +9,7 @@ include FileUtils
 # Configuration
 ##############################################################################
 NAME = "sequel_model"
-VERS = "0.1"
+VERS = "0.2"
 CLEAN.include ["**/.*.sw?", "pkg/*", ".config", "doc/*", "coverage/*"]
 RDOC_OPTS = [
   "--quiet", 
@@ -30,7 +30,7 @@ Rake::RDocTask.new do |rdoc|
   rdoc.options += RDOC_OPTS
   rdoc.main = "README"
   rdoc.title = "Sequel: Lightweight ORM for Ruby"
-  rdoc.rdoc_files.add ["README", "COPYING", "lib/sequel.rb", "lib/**/*.rb"]
+  rdoc.rdoc_files.add ["README", "COPYING", "lib/sequel_model.rb", "lib/**/*.rb"]
 end
 
 ##############################################################################
@@ -42,13 +42,13 @@ task :package => [:clean]
 
 spec = Gem::Specification.new do |s|
   s.name = NAME
-  s.rubyforge_project = NAME
+  s.rubyforge_project = 'sequel'
   s.version = VERS
   s.platform = Gem::Platform::RUBY
   s.has_rdoc = true
   s.extra_rdoc_files = ["README", "CHANGELOG", "COPYING"]
   s.rdoc_options += RDOC_OPTS + 
-    ["--exclude", "^(examples|extras)\/", "--exclude", "lib/sequel.rb"]
+    ["--exclude", "^(examples|extras)\/", "--exclude", "lib/sequel_model.rb"]
   s.summary = "Lightweight ORM for Ruby"
   s.description = s.summary
   s.author = "Sharon Rosner"
@@ -65,7 +65,7 @@ spec = Gem::Specification.new do |s|
     s.platform = Gem::Platform::RUBY
   end
 
-  s.add_dependency("sequel", '>= 0.5')
+  s.add_dependency("sequel_core", '>= 0.5')
   s.add_dependency("validatable")
   
   s.files = %w(COPYING README Rakefile) + Dir.glob("{doc,spec,lib}/**/*")

data/lib/sequel_model/base.rb

@@ -19,8 +19,8 @@ module Sequel
 
     # Returns the dataset associated with the Model class.
     def self.dataset
-      @dataset || super_dataset or
-      raise Error, "No dataset associated with #{self}"
+      (@dataset ||= super_dataset) ||
+        (raise Error, "No dataset associated with #{self}")
     end
     
     def self.super_dataset # :nodoc:

data/lib/sequel_model/hooks.rb

@@ -1,122 +1,55 @@
 module Sequel
   class Model
-    # This Hash translates verbs to methodnames used in chain manipulation
-    # methods.
-    VERB_TO_METHOD = {:prepend => :unshift, :append => :push}
-
-    # Returns @hooks which is an instance of Hash with its hook identifier
-    # (Symbol) as key and the chain of hooks (Array) as value.
-    #
-    # If it is not already set it'll be with an empty set of hooks.
-    # This behaviour will change in the future to allow inheritance.
-    #
-    # For the time being, you should be able to do:
-    #
-    #   class A < Sequel::Model(:a)
-    #     before_save { 'Do something...' }
-    #   end
-    #
-    #   class B < A
-    #     @hooks = superclass.hooks.clone
-    #     before_save # => [#<Proc:0x0000c6e8@(example.rb):123>]
-    #   end
-    #
-    # In this case you should remember that the clone doesn't create any new
-    # instances of your chains, so if you change the chain here it changes in
-    # its superclass, too.
-    def self.hooks
-      @hooks ||= Hash.new { |h, k| h[k] = [] }
-    end
-
-    # Adds block to chain of Hooks for <tt>:before_save</tt>.
-    # It can either be prepended (default) or appended.
-    #
-    # Returns the chain itself.
-    #
-    # Valid verbs are <tt>:prepend</tt> and <tt>:append</tt>.
-    def self.before_save(verb = :prepend, &block)
-      hooks[:before_save].send VERB_TO_METHOD.fetch(verb), block if block
-      hooks[:before_save]
-    end
-    # Adds block to chain of Hooks for <tt>:before_create</tt>.
-    # It can either be prepended (default) or appended.
-    #
-    # Returns the chain itself.
-    #
-    # Valid verbs are <tt>:prepend</tt> and <tt>:append</tt>.
-    def self.before_create(verb = :prepend, &block)
-      hooks[:before_create].send VERB_TO_METHOD.fetch(verb), block if block
-      hooks[:before_create]
-    end
-    # Adds block to chain of Hooks for <tt>:before_update</tt>.
-    # It can either be prepended (default) or appended.
-    #
-    # Returns the chain itself.
-    #
-    # Valid verbs are <tt>:prepend</tt> and <tt>:append</tt>.
-    def self.before_update(verb = :prepend, &block)
-      hooks[:before_update].send VERB_TO_METHOD.fetch(verb), block if block
-      hooks[:before_update]
-    end
-    # Adds block to chain of Hooks for <tt>:before_destroy</tt>.
-    # It can either be prepended (default) or appended.
-    #
-    # Returns the chain itself.
-    #
-    # Valid verbs are <tt>:prepend</tt> and <tt>:append</tt>.
-    def self.before_destroy(verb = :prepend, &block)
-      hooks[:before_destroy].send VERB_TO_METHOD.fetch(verb), block if block
-      hooks[:before_destroy]
-    end
-
-    # Adds block to chain of Hooks for <tt>:after_save</tt>.
-    # It can either be prepended or appended (default).
-    #
-    # Returns the chain itself.
-    #
-    # Valid verbs are <tt>:prepend</tt> and <tt>:append</tt>.
-    def self.after_save(verb = :append, &block)
-      hooks[:after_save].send VERB_TO_METHOD.fetch(verb), block if block
-      hooks[:after_save]
-    end
-    # Adds block to chain of Hooks for <tt>:after_create</tt>.
-    # It can either be prepended or appended (default).
-    #
-    # Returns the chain itself.
-    #
-    # Valid verbs are <tt>:prepend</tt> and <tt>:append</tt>.
-    def self.after_create(verb = :append, &block)
-      hooks[:after_create].send VERB_TO_METHOD.fetch(verb), block if block
-      hooks[:after_create]
+    HOOKS = [
+      :after_initialize,
+      :before_create,
+      :after_create,
+      :before_update,
+      :after_update,
+      :before_save,
+      :after_save,
+      :before_destroy,
+      :after_destroy
+    ]
+    
+    # Some fancy code generation here in order to define the hook class methods...
+    HOOK_METHOD_STR = %Q{
+      def self.%s(method = nil, &block)
+        unless block
+          (raise SequelError, 'No hook method specified') unless method
+          block = proc {send method}
+        end
+        add_hook(%s, &block)
+      end
+    }
+    
+    def self.def_hook_method(m) #:nodoc:
+      instance_eval(HOOK_METHOD_STR % [m.to_s, m.inspect])
     end
-    # Adds block to chain of Hooks for <tt>:after_update</tt>.
-    # It can either be prepended or appended (default).
-    #
-    # Returns the chain itself.
-    #
-    # Valid verbs are <tt>:prepend</tt> and <tt>:append</tt>.
-    def self.after_update(verb = :append, &block)
-      hooks[:after_update].send VERB_TO_METHOD.fetch(verb), block if block
-      hooks[:after_update]
+    
+    HOOKS.each {|h| define_method(h) {}}
+    HOOKS.each {|h| def_hook_method(h)}
+    
+    # Returns the hooks hash for the model class.
+    def self.hooks #:nodoc:
+      @hooks ||= Hash.new {|h, k| h[k] = []}
     end
-    # Adds block to chain of Hooks for <tt>:after_destroy</tt>.
-    # It can either be prepended or appended (default).
-    #
-    # Returns the chain itself.
-    #
-    # Valid verbs are <tt>:prepend</tt> and <tt>:append</tt>.
-    def self.after_destroy(verb = :append, &block)
-      hooks[:after_destroy].send VERB_TO_METHOD.fetch(verb), block if block
-      hooks[:after_destroy]
+    
+    def self.add_hook(hook, &block) #:nodoc:
+      chain = hooks[hook]
+      chain << block
+      define_method(hook) do 
+        return false if super == false
+        chain.each {|h| break false if instance_eval(&h) == false}
+      end
     end
 
-    # Evaluates specified chain of Hooks through <tt>instance_eval</tt>.
-    def run_hooks(key)
-      model.hooks[key].each {|h| instance_eval(&h)}
-    end
-    
+    # Returns true if the model class or any of its ancestors have defined
+    # hooks for the given hook key. Notice that this method cannot detect 
+    # hooks defined using overridden methods.
     def self.has_hooks?(key)
-      hooks[key] && !hooks[key].empty?
+      has = hooks[key] && !hooks[key].empty?
+      has || ((self != Model) && superclass.has_hooks?(key))
     end
   end
-end
+end

data/lib/sequel_model/plugins.rb

@@ -19,6 +19,9 @@ module Sequel
           metaclass.send(:include, m::ClassMethods)
         end
         if m.const_defined?("DatasetMethods")
+          unless @dataset
+            raise Sequel::Error, "Plugin cannot be applied because the model class has no dataset"
+          end
           dataset.meta_def(:"#{plugin}_opts") {args.first}
           dataset.metaclass.send(:include, m::DatasetMethods)
         end

data/lib/sequel_model/record.rb

@@ -158,12 +158,6 @@ module Sequel
       @primary_key ||= self.class.primary_key
     end
     
-    # Returns value for primary key.
-    def pkey
-      warn "Model#pkey is deprecated. Please use Model#pk instead."
-      @pkey ||= @values[self.class.primary_key]
-    end
-    
     # Returns the primary key value identifying the model instance. Stock implementation.
     def pk
       @pk ||= @values[:id]
@@ -192,6 +186,7 @@ module Sequel
       end
       
       block[self] if block
+      after_initialize
     end
     
     # Returns true if the current instance represents a new record.
@@ -208,9 +203,9 @@ module Sequel
     # Creates or updates the associated record. This method can also
     # accept a list of specific columns to update.
     def save(*columns)
-      run_hooks(:before_save)
+      before_save
       if @new
-        run_hooks(:before_create)
+        before_create
         iid = model.dataset.insert(@values)
         # if we have a regular primary key and it's not set in @values,
         # we assume it's the last inserted id
@@ -222,9 +217,9 @@ module Sequel
           refresh
         end
         @new = false
-        run_hooks(:after_create)
+        after_create
       else
-        run_hooks(:before_update)
+        before_update
         if columns.empty?
           this.update(@values)
           @changed_columns = []
@@ -232,9 +227,9 @@ module Sequel
           this.update(@values.reject {|k, v| !columns.include?(k)})
           @changed_columns.reject! {|c| columns.include?(c)}
         end
-        run_hooks(:after_update)
+        after_update
       end
-      run_hooks(:after_save)
+      after_save
       self
     end
     
@@ -260,9 +255,9 @@ module Sequel
     # Like delete but runs hooks before and after delete.
     def destroy
       db.transaction do
-        run_hooks(:before_destroy)
+        before_destroy
         delete
-        run_hooks(:after_destroy)
+        after_destroy
       end
     end
     

data/lib/sequel_model/relations.rb

@@ -28,12 +28,6 @@ module Sequel
     #   node.producer_id #=> 1234
     #
     def self.one_to_one(name, opts)
-      # deprecation
-      if opts[:class]
-        warn "The :class option has been deprecated. Please use :from instead."
-        opts[:from] = opts[:class]
-      end
-      
       from = opts[:from]
       from || (raise Error, "No association source defined (use :from option)")
       key = opts[:key] || (name.to_s + ID_POSTFIX).to_sym
@@ -80,18 +74,6 @@ module Sequel
     #   one_to_many :books, :from => Book, :key => :author_id
     #
     def self.one_to_many(name, opts)
-      # deprecation
-      if opts[:class]
-        warn "The :class option has been deprecated. Please use :from instead."
-        opts[:from] = opts[:class]
-      end
-      # deprecation
-      if opts[:on]
-        warn "The :on option has been deprecated. Please use :key instead."
-        opts[:key] = opts[:on]
-      end
-      
-      
       from = opts[:from]
       from || (raise Error, "No association source defined (use :from option)")
       key = opts[:key] || (self.to_s + ID_POSTFIX).to_sym

data/lib/sequel_model/schema.rb

@@ -5,7 +5,9 @@ module Sequel
     # This is only needed if you want to use the create_table or drop_table
     # methods.
     def self.set_schema(name = nil, &block)
-      name ? set_dataset(db[name]) : name = table_name
+      if name
+        set_dataset(db[name])
+      end
       @schema = Schema::Generator.new(db, &block)
       if @schema.primary_key_name
         set_primary_key @schema.primary_key_name
@@ -42,11 +44,5 @@ module Sequel
       drop_table if table_exists?
       create_table
     end
-    
-    # Deprecated, use create_table! instead.
-    def self.recreate_table
-      warn "Model.recreate_table is deprecated. Please use Model.create_table! instead."
-      create_table!
-    end
   end
 end

data/lib/sequel_model/validations.rb

@@ -1,3 +1,5 @@
+require 'validatable'
+
 module Sequel
   class Model
     # =Basic Sequel Validations
@@ -96,22 +98,16 @@ module Sequel
         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
+
+    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
   end
-end
+end

data/lib/sequel_model.rb

@@ -1,6 +1,3 @@
-gem 'sequel', '>= 0.5'
-require 'sequel'
-
 module Sequel
   # == Sequel Models
   # 
@@ -108,7 +105,7 @@ module Sequel
   #       set(:created_at => Time.now)
   #     end
   # 
-  #     after_destroy
+  #     after_destroy do
   #       author.update_post_count
   #     end
   #   end
@@ -287,11 +284,7 @@ module Sequel
 
     # 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)
-        dataset.destroy
-      else
-        dataset.delete
-      end
+      dataset.destroy
     end
         
     def self.is_dataset_magic_method?(m)

data/spec/hooks_spec.rb

@@ -1,107 +1,269 @@
 require File.join(File.dirname(__FILE__), "spec_helper")
 
-describe Sequel::Model, "hooks" do
-
+describe "Model hooks" do
   before do
     MODEL_DB.reset
-    Sequel::Model.hooks.clear
 
-    @hooks = %w[
-      before_save before_create before_update before_destroy
-      after_save after_create after_update after_destroy
-    ].select { |hook| !hook.empty? }
+    @hooks = [
+      :after_initialize,
+      :before_create,
+      :after_create,
+      :before_update,
+      :after_update,
+      :before_save,
+      :after_save,
+      :before_destroy,
+      :after_destroy
+    ]
+    
+    # @hooks.each {|h| Sequel::Model.class_def(h) {}}
   end
-
-  it "should have hooks for everything" do
-    Sequel::Model.methods.should include('hooks')
-    Sequel::Model.methods.should include(*@hooks)
-    @hooks.each do |hook|
-      Sequel::Model.hooks[hook.to_sym].should be_an_instance_of(Array)
+  
+  specify "should be definable using def <hook name>" do
+    c = Class.new(Sequel::Model) do
+      def before_save
+        "hi there"
+      end
     end
+    
+    c.new.before_save.should == 'hi there'
   end
-
-  it "should be inherited" do
-    pending 'soon'
-
-    @hooks.each do |hook|
-      Sequel::Model.send(hook.to_sym) { nil }
+  
+  specify "should be definable using a block" do
+    $adds = []
+    c = Class.new(Sequel::Model) do
+      before_save {$adds << 'hi'}
     end
-
-    model = Class.new Sequel::Model(:models)
-    model.hooks.should == Sequel::Model.hooks
+    
+    c.new.before_save
+    $adds.should == ['hi']
   end
-
-  it "should run hooks" do
-    pending 'soon'
-
-    test = mock 'Test'
-    test.should_receive(:run).exactly(@hooks.length)
-
-    @hooks.each do |hook|
-      Sequel::Model.send(hook.to_sym) { test.run }
+  
+  specify "should be definable using a method name" do
+    $adds = []
+    c = Class.new(Sequel::Model) do
+      def bye; $adds << 'bye'; end
+      before_save :bye
     end
-
-    model = Class.new Sequel::Model(:models)
-    model.hooks.should == Sequel::Model.hooks
-
-    model_instance = model.new
-    @hooks.each { |hook| model_instance.run_hooks(hook) }
+    
+    c.new.before_save
+    $adds.should == ['bye']
   end
-
-  it "should run hooks around save and create" do
-    pending 'test execution'
+  
+  specify "should be additive" do
+    $adds = []
+    c = Class.new(Sequel::Model) do
+      before_save {$adds << 'hyiyie'}
+      before_save {$adds << 'byiyie'}
+    end
+    
+    c.new.before_save
+    $adds.should == ['hyiyie', 'byiyie']
   end
-
-  it "should run hooks around save and update" do
-    pending 'test execution'
+  
+  specify "should be inheritable" do
+    # pending
+    
+    $adds = []
+    a = Class.new(Sequel::Model) do
+      before_save {$adds << '123'}
+    end
+    
+    b = Class.new(a) do
+      before_save {$adds << '456'}
+      before_save {$adds << '789'}
+    end
+    
+    b.new.before_save
+    $adds.should == ['123', '456', '789']
   end
-
-  it "should run hooks around delete" do
-    pending 'test execution'
+  
+  specify "should be overridable in descendant classes" do
+    $adds = []
+    a = Class.new(Sequel::Model) do
+      before_save {$adds << '123'}
+    end
+    
+    b = Class.new(a) do
+      def before_save; $adds << '456'; end
+    end
+    
+    a.new.before_save
+    $adds.should == ['123']
+    $adds = []
+    b.new.before_save
+    $adds.should == ['456']
   end
+  
+  specify "should stop processing if a hook returns false" do
+    $flag = true
+    $adds = []
+    
+    a = Class.new(Sequel::Model) do
+      before_save {$adds << 'blah'; $flag}
+      before_save {$adds << 'cruel'}
+    end
+    
+    a.new.before_save
+    $adds.should == ['blah', 'cruel']
 
+    # chain should not break on nil
+    $adds = []
+    $flag = nil
+    a.new.before_save
+    $adds.should == ['blah', 'cruel']
+    
+    $adds = []
+    $flag = false
+    a.new.before_save
+    $adds.should == ['blah']
+    
+    b = Class.new(a) do
+      before_save {$adds << 'mau'}
+    end
+    
+    $adds = []
+    b.new.before_save
+    $adds.should == ['blah']
+  end
 end
 
-describe "Model.after_create" do
+describe "Model#after_initialize" do
+  specify "should be called after initialization" do
+    $values1 = nil
+    
+    a = Class.new(Sequel::Model) do
+      after_initialize do
+        $values1 = @values.clone
+        raise Sequel::Error if @values[:blow]
+      end
+    end
+    
+    a.new(:x => 1, :y => 2)
+    $values1.should == {:x => 1, :y => 2}
+    
+    proc {a.new(:blow => true)}.should raise_error(Sequel::Error)
+  end
+end
 
-  before(:each) do
+describe "Model#before_create && Model#after_create" do
+  setup do
     MODEL_DB.reset
 
     @c = Class.new(Sequel::Model(:items)) do
-      def columns
-        [:id, :x, :y]
-      end
+      no_primary_key
+      
+      before_create {MODEL_DB << "BLAH before"}
+      after_create {MODEL_DB << "BLAH after"}
     end
+  end
+  
+  specify "should be called around new record creation" do
+    @c.create(:x => 2)
+    MODEL_DB.sqls.should == [
+      'BLAH before',
+      'INSERT INTO items (x) VALUES (2)',
+      'BLAH after'
+    ]
+  end
+end
 
-    ds = @c.dataset
-    def ds.insert(*args)
-      super(*args)
-      1
+describe "Model#before_update && Model#after_update" do
+  setup do
+    MODEL_DB.reset
+
+    @c = Class.new(Sequel::Model(:items)) do
+      before_update {MODEL_DB << "BLAH before"}
+      after_update {MODEL_DB << "BLAH after"}
     end
   end
+  
+  specify "should be called around record update" do
+    m = @c.new(:id => 2233)
+    m.save
+    MODEL_DB.sqls.should == [
+      'BLAH before',
+      'UPDATE items SET id = 2233 WHERE (id = 2233)',
+      'BLAH after'
+    ]
+  end
+end
 
-  it "should be called after creation" do
-    s = []
+describe "Model#before_save && Model#after_save" do
+  setup do
+    MODEL_DB.reset
 
-    @c.after_create do
-      s = MODEL_DB.sqls.dup
+    @c = Class.new(Sequel::Model(:items)) do
+      before_save {MODEL_DB << "BLAH before"}
+      after_save {MODEL_DB << "BLAH after"}
     end
-
-    n = @c.create(:x => 1)
-    MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
-    s.should == ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
   end
+  
+  specify "should be called around record update" do
+    m = @c.new(:id => 2233)
+    m.save
+    MODEL_DB.sqls.should == [
+      'BLAH before',
+      'UPDATE items SET id = 2233 WHERE (id = 2233)',
+      'BLAH after'
+    ]
+  end
+  
+  specify "should be called around record creation" do
+    @c.no_primary_key
+    @c.create(:x => 2)
+    MODEL_DB.sqls.should == [
+      'BLAH before',
+      'INSERT INTO items (x) VALUES (2)',
+      'BLAH after'
+    ]
+  end
+end
 
-  it "should allow calling save in the hook" do
-    @c.after_create do
-      values.delete(:x)
-      self.id = 2
-      save
-    end
+describe "Model#before_destroy && Model#after_destroy" do
+  setup do
+    MODEL_DB.reset
 
-    n = @c.create(:id => 1)
-    MODEL_DB.sqls.should == ["INSERT INTO items (id) VALUES (1)", "SELECT * FROM items WHERE (id = 1) LIMIT 1", "UPDATE items SET id = 2 WHERE (id = 1)"]
+    @c = Class.new(Sequel::Model(:items)) do
+      before_destroy {MODEL_DB << "BLAH before"}
+      after_destroy {MODEL_DB << "BLAH after"}
+      
+      def delete
+        MODEL_DB << "DELETE BLAH"
+      end
+    end
+  end
+  
+  specify "should be called around record update" do
+    m = @c.new(:id => 2233)
+    m.destroy
+    MODEL_DB.sqls.should == [
+      'BLAH before',
+      'DELETE BLAH',
+      'BLAH after'
+    ]
   end
-
 end
 
+describe "Model#has_hooks?" do
+  setup do
+    @c = Class.new(Sequel::Model)
+  end
+  
+  specify "should return false if no hooks are defined" do
+    @c.has_hooks?(:before_save).should be_false
+  end
+  
+  specify "should return true if hooks are defined" do
+    @c.before_save {'blah'}
+    @c.has_hooks?(:before_save).should be_true
+  end
+  
+  specify "should return true if hooks are inherited" do
+    @d = Class.new(@c)
+    @d.has_hooks?(:before_save).should be_false
+    
+    @c.before_save :blah
+    @d.has_hooks?(:before_save).should be_true
+  end
+end

data/spec/model_spec.rb

@@ -344,23 +344,15 @@ describe Sequel::Model, ".destroy_all" do
   end
 
   it "should delete all records in the dataset" do
+    @c.dataset.meta_def(:destroy) {MODEL_DB << "DESTROY this stuff"}
     @c.destroy_all
-    MODEL_DB.sqls.should == ["DELETE FROM items"]
+    MODEL_DB.sqls.should == ["DESTROY this stuff"]
   end
   
-  it "should call dataset destroy method if *_destroy hooks exist" do
-    @c.dataset.stub!(:destroy).and_return(true)
-    @c.should_receive(:has_hooks?).with(:before_destroy).and_return(true)
+  it "should call dataset.destroy" do
+    @c.dataset.should_receive(:destroy).and_return(true)
     @c.destroy_all
   end
-  
-  it "should call dataset delete method if no hooks are present" do
-    @c.dataset.stub!(:delete).and_return(true)
-    @c.should_receive(:has_hooks?).with(:before_destroy).and_return(false)
-    @c.should_receive(:has_hooks?).with(:after_destroy).and_return(false)
-    @c.destroy_all
-  end
-
 end
 
 describe Sequel::Model, ".join" do

data/spec/plugins_spec.rb

@@ -17,10 +17,9 @@ module Sequel::Plugins
       def deff; timestamped_opts; end
     end
 
-    # ??
-    # module DatasetMethods
-    #   def ghi; timestamped_opts; end
-    # end
+    module DatasetMethods
+      def ghi; timestamped_opts; end
+    end
   end
 
 end
@@ -39,6 +38,7 @@ describe Sequel::Model, "using a plugin" do
     c = nil
     proc do
       c = Class.new(Sequel::Model) do
+        set_dataset MODEL_DB[:items]
         is :timestamped, :a => 1, :b => 2
       end
     end.should_not raise_error(LoadError)
@@ -46,6 +46,7 @@ describe Sequel::Model, "using a plugin" do
     c.should respond_to(:stamp_opts)
     c.stamp_opts.should == {:a => 1, :b => 2}
     
+    # instance methods
     m = c.new
     m.should respond_to(:get_stamp)
     m.should respond_to(:abc)
@@ -54,8 +55,20 @@ describe Sequel::Model, "using a plugin" do
     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 fail to apply if the plugin has DatasetMethod and the model has no datset" do
+    proc do
+      Class.new(Sequel::Model) do
+        is :timestamped, :a => 1, :b => 2
+      end
+    end.should raise_error(Sequel::Error)
+  end
 end

data/spec/record_spec.rb

@@ -217,7 +217,6 @@ describe Sequel::Model, "with this" do
 end
 
 describe "Model#pk" do
-  
   before(:each) do
     @m = Class.new(Sequel::Model)
   end
@@ -248,11 +247,9 @@ describe "Model#pk" do
     m = @m.new(:id => 111, :x => 2, :y => 3)
     proc {m.pk}.should raise_error(Sequel::Error)
   end
-  
 end
 
 describe "Model#pk_hash" do
-
   before(:each) do
     @m = Class.new(Sequel::Model)
   end
@@ -345,18 +342,70 @@ describe Sequel::Model, "#destroy" do
 end
 
 describe Sequel::Model, "#exists?" do
-
   before(:each) do
     @model = Class.new(Sequel::Model(:items))
-    @model_a = @model.new
+    @m = @model.new
+  end
+
+  it "should returns true when #this.count > 0" do
+    @m.this.meta_def(:count) {1}
+    @m.exists?.should be_true
+  end
+
+  it "should return false when #this.count == 0" do
+    @m.this.meta_def(:count) {0}
+    @m.exists?.should be_false
+  end
+end
+
+describe Sequel::Model, "#each" do
+  setup do
+    @model = Class.new(Sequel::Model(:items))
+    @m = @model.new(:a => 1, :b => 2, :id => 4444)
+  end
+  
+  specify "should iterate over the values" do
+    h = {}
+    @m.each {|k, v| h[k] = v}
+    h.should == {:a => 1, :b => 2, :id => 4444}
+  end
+end
+
+describe Sequel::Model, "#keys" do
+  setup do
+    @model = Class.new(Sequel::Model(:items))
+    @m = @model.new(:a => 1, :b => 2, :id => 4444)
   end
+  
+  specify "should return the value keys" do
+    @m.keys.size.should == 3
+    @m.keys.should include(:a, :b, :id)
+    
+    @m = @model.new()
+    @m.keys.should == []
+  end
+end
 
-  it "should returns true when current instance exists" do
-    @model_a.exists?.should be_true
+describe Sequel::Model, "#===" do
+  specify "should compare instances by values" do
+    a = Sequel::Model.new(:id => 1, :x => 3)
+    b = Sequel::Model.new(:id => 1, :x => 4)
+    c = Sequel::Model.new(:id => 1, :x => 3)
+    
+    a.should_not == b
+    a.should == c
+    b.should_not == c
   end
+end
 
-  it "should return false when the current instance does not exist" do
-    pending("how would this be false?")
+describe Sequel::Model, "#===" do
+  specify "should compare instances by pk only" do
+    a = Sequel::Model.new(:id => 1, :x => 3)
+    b = Sequel::Model.new(:id => 1, :x => 4)
+    c = Sequel::Model.new(:id => 2, :x => 3)
+    
+    a.should === b
+    a.should_not === c
   end
+end
 
-end

data/spec/relations_spec.rb

@@ -120,7 +120,7 @@ describe Sequel::Model, "one_to_many" do
     a.should be_a_kind_of(Sequel::Dataset)
     a.sql.should == 'SELECT * FROM attributes WHERE (node_id = 1234)'
   end
-
+  
   it "should support plain dataset in the from option" do
     @c2.one_to_many :attributes, :from => MODEL_DB[:xyz], :key => :node_id
 

data/spec/schema_spec.rb

@@ -19,16 +19,18 @@ describe Sequel::Model, "create_table" do
 
   before(:each) do
     MODEL_DB.reset
-    @model = Class.new(Sequel::Model(:items))
+    @model = Class.new(Sequel::Model) do
+      set_dataset MODEL_DB[:items]
+      set_schema do
+        text :name
+        float :price, :null => false
+      end
+    end
   end
 
   it "should get the create table SQL list from the db and execute it line by line" do
-    #db.create_table_sql_list(table_name, *schema.create_info).each {|s| db << s} 
-    @model.should_receive(:table_name).and_return(:items)
-    @model.schema.should_receive(:create_info)
-    @model.db.should_receive(:create_table_sql_list)
-    pending("Finish specing this")
     @model.create_table
+    MODEL_DB.sqls.should == ['CREATE TABLE items (name text, price float NOT NULL)']
   end
 
 end
@@ -65,18 +67,3 @@ describe Sequel::Model, "create_table!" do
   end
 
 end
-
-describe Sequel::Model, "recreate_table" do
-
-  before(:each) do
-    MODEL_DB.reset
-    @model = Class.new(Sequel::Model(:items))
-  end
-
-  it "should raise a depreciation warning and then call create_table!" do
-    @model.should_receive(:warn)
-    @model.should_receive(:create_table!).and_return(true)
-    @model.recreate_table
-  end
-
-end

data/spec/validations_spec.rb

@@ -109,7 +109,7 @@ describe Sequel::Model, "Validations" do
     @person.valid?.should be_true
   end
   
-  it "should allow for :with_exactly => /[a-zA-Z/, which wraps the supplied regex with ^<regex>$" do
+  it "should allow for :with_exactly => /[a-zA-Z]/, which wraps the supplied regex with ^<regex>$" do
     pending("TODO: Add this option to Validatable#validates_format_of")
   end
 
@@ -208,13 +208,7 @@ describe Sequel::Model, "Validations" do
     Sequel::Model.should respond_to(:validates_format_of) # validatable gem
     Sequel::Model.should respond_to(:validations)         # Validations module
   end
-  
-  it "should description" do
-    Sequel::Model.should_receive(:require).with("validatable").and_raise(LoadError)
-    STDERR.should_receive(:puts)
-    load File.join(File.dirname(__FILE__), "../lib/sequel_model/validations.rb")
-  end
-  
+    
   it "should allow 'longhand' validations direcly within the model." do
     lambda {
       class Person < Sequel::Model(:people)
@@ -275,20 +269,8 @@ describe Sequel::Model, "validates" do
     end
   end
   
-  it "should runs the validations block on the model & store as :default when only a validations block is passed in" do
-    pending
-  end
-
-  it "should store the block under the name passed in when both a name and a validations block are passed in" do
-    pending
-  end
-
-  it "should return the stored validations block corresponding to the name given, if only a name is given (no block)" do
-    pending
-  end
-
-  it "should return true or false based on if validations exist on the model if no arguments are given" do
-    pending
-  end
-
+  it "should runs the validations block on the model & store as :default when only a validations block is passed in"
+  it "should store the block under the name passed in when both a name and a validations block are passed in"
+  it "should return the stored validations block corresponding to the name given, if only a name is given (no block)"
+  it "should return true or false based on if validations exist on the model if no arguments are given"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sequel_model
 version: !ruby/object:Gem::Version 
-  version: "0.1"
+  version: "0.2"
 platform: ruby
 authors: 
 - Sharon Rosner
@@ -9,11 +9,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2007-12-30 00:00:00 +02:00
+date: 2008-01-02 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: sequel
+  name: sequel_core
   version_requirement: 
   version_requirements: !ruby/object:Gem::Requirement 
     requirements: 
@@ -44,7 +44,6 @@ files:
 - COPYING
 - README
 - Rakefile
-- doc/rdoc
 - spec/base_spec.rb
 - spec/caching_spec.rb
 - spec/hooks_spec.rb
@@ -85,7 +84,7 @@ rdoc_options:
 - --exclude
 - ^(examples|extras)/
 - --exclude
-- lib/sequel.rb
+- lib/sequel_model.rb
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -102,7 +101,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   version: 
 requirements: []
 
-rubyforge_project: sequel_model
+rubyforge_project: sequel
 rubygems_version: 1.0.1
 signing_key: 
 specification_version: 2