sequel_model 0.3.2.1 → 0.3.3

data/CHANGELOG

@@ -1,3 +1,7 @@
+=== 0.3.3 (2008-01-25)
+
+* Finalized support for virtual attributes.
+
 === 0.3.2.1 (2008-01-24)
 
 * Fixed Model.dataset to correctly set the dataset if using implicit naming or inheriting the superclass dataset (thanks celldee).

data/Rakefile

@@ -9,7 +9,7 @@ include FileUtils
 # Configuration
 ##############################################################################
 NAME = "sequel_model"
-VERS = "0.3.2.1"
+VERS = "0.3.3"
 CLEAN.include ["**/.*.sw?", "pkg/*", ".config", "doc/*", "coverage/*"]
 RDOC_OPTS = [
   "--quiet", 

data/lib/sequel_model/record.rb

@@ -129,7 +129,7 @@ module Sequel
     # new? returns true.
     def self.create(values = {}, &block)
       db.transaction do
-        obj = new(values, true, &block)
+        obj = new(values, &block)
         obj.save
         obj
       end
@@ -185,13 +185,27 @@ module Sequel
     #
     # This method guesses whether the record exists when
     # <tt>new_record</tt> is set to false.
-    def initialize(values = {}, new_record = false, &block)
-      @values = values || {}
+    def initialize(values = nil, from_db = false, &block)
       @changed_columns = []
+      unless from_db
+        @values = {}
+        if values
+          values.each do |k, v| m = :"#{k}="
+            if respond_to?(m)
+              send(m, v)
+              values.delete(k)
+            end
+          end
+          @values.merge!(values)
+        end
+      else
+        @values = values || {}
+      end
 
-      @new = new_record
-      unless @new # determine if it's a new record
-        k = self.class.primary_key
+      k = primary_key
+      if from_db
+        @new = k == nil
+      else
         # if there's no primary key for the model class, or
         # @values doesn't contain a primary key value, then 
         # we regard this instance as new.
@@ -202,6 +216,10 @@ module Sequel
       after_initialize
     end
     
+    def self.load(values)
+      new(values, true)
+    end
+    
     # Returns true if the current instance represents a new record.
     def new?
       @new

data/lib/sequel_model/relationships.rb

@@ -80,9 +80,8 @@ module Sequel
         end
       end
     end
-
+    
     class << self
-      cattr_reader :model_relationships
       @@model_relationships = []
 
       def relationship_exists?(arity,relation)
@@ -97,21 +96,19 @@ module Sequel
       # has :one,  :account # account_id field
       # has :many, :comments # comments_posts join table
       def has(arity, klass, options = {})
+
+        # Commence with the sanity checks!
         unless [:one,:many].include? arity
           raise Sequel::Error, "Arity must be specified {:one, :many}." 
         end
 
-        #unless const_defined?(klass.to_s.camel_case)
-          #raise Sequel::Error, "#{klass.to_s.camel_case} does not exist"
-        #end
+        if relationship_exists?(arity, klass)
+          raise Sequel::Error, "The relationship '#{self} has #{arity} #{klass}' is already defined."
+        end
 
         # Make sure the join table exists
         auto_create_join_table(klass, options)
 
-        if relationship_exists?(arity, klass)
-          raise Sequel::Error, "The relationship #{self.class.name} has #{arity}, #{klass} is already defined."
-        end
-
         # Store the relationship
         @@model_relationships << { 
           :arity => arity, 
@@ -200,17 +197,11 @@ module Sequel
       def has_relationships?
         model_relationships.length > 0 ? true : false
       end
-
-      # TODO: figure out what we want to do with these...
-      # "FooBar".snake_case #=> "foo_bar"
-      def snake_case
-        gsub(/\B[A-Z]/, '_\&').downcase
+      
+      def model_relationships
+        @@model_relationships
       end
 
-      # "foo_bar".camel_case #=> "FooBar"
-      def camel_case
-        split('_').map{|e| e.capitalize}.join
-      end
     end
 
     # Defines relationship method from the current class to the klass specified
@@ -218,13 +209,13 @@ module Sequel
       if arity == :one
         self.instance_eval "
           def #{relation}
-            self.db.dataset.left_outer_join(#{relation}, :id => :#{relation.to_s.singularize}_id).limit(1)
+            self.dataset.left_outer_join(#{relation}, :id => :#{self.class.table_name.to_s.singularize}_id).limit(1)
           end
         "
       elsif arity == :many
         self.instance_eval "
           def #{relation}
-            self.db.dataset.left_outer_join(#{relation}, :id => :#{relation.to_s.singularize}_id)
+            self.dataset.left_outer_join(#{relation}, :id => :#{self.class.table_name.to_s.singularize}_id)
           end
         "
       end

data/spec/record_spec.rb

@@ -476,6 +476,15 @@ describe Sequel::Model, "#initialize" do
     m = @c.new {|o| o[:id] = 1234}
     m.id.should == 1234
   end
+  
+  specify "should accept virtual attributes" do
+    @c.class_def(:blah=) {|x| @blah = x}
+    @c.class_def(:blah) {@blah}
+    
+    m = @c.new(:id => 1, :x => 2, :blah => 3)
+    m.values.should == {:id => 1, :x => 2}
+    m.blah.should == 3
+  end
 end
 
 describe Sequel::Model, ".create" do

data/spec/relationships_spec.rb

@@ -1,12 +1,191 @@
 require File.join(File.dirname(__FILE__), "spec_helper")
 
-__END__
+#__END__
 
-describe Sequel::Model::Relationships, "has :one" do
-end
+# class Post < Sequel::Model
+#   relationships do
+#     has :one,  :blog, :required => true, :normalized => false # uses a blog_id field, which cannot be null, in the Post model
+#     has :one,  :account # uses a join table called accounts_posts to link the post with it's account.
+#     has :many, :comments # uses a comments_posts join table
+#     has :many, :authors, :required => true  # authors_posts join table, requires at least one author
+#   end
+# end
+describe Sequel::Model, "relationships" do
+  before :all do
+    class Smurf < Sequel::Model
+    end
+  end
+  
+  after :each do
+    Smurf.model_relationships.clear
+  end
+  
+  describe "has" do
+    
+    it "should raise an exception if an arity {:one, :many} is not specified" do
+      Smurf.should_not_receive(:auto_create_join_table).with(:smurfette, {}).and_return(true)
+      Smurf.should_not_receive(:relationship_exists?).with(:one, :smurfette).and_return(true)
+      Smurf.stub!(:after_initialize)
+      lambda {
+      class Smurf
+        relationships do
+          has :sex, :with_smurfette
+        end
+      end
+      }.should raise_error Sequel::Error, "Arity must be specified {:one, :many}." 
+    end
+    
+    it "should check to see if the relationship exists" do
+      Smurf.should_not_receive(:relationship_exists?).with(:one, :smurfette).and_return(true)
+      Smurf.stub!(:after_initialize)
+      lambda {
+      class Smurf
+        relationships do
+          has :sex, :with_smurfette
+        end
+      end
+      }.should raise_error Sequel::Error, "Arity must be specified {:one, :many}."
+    end
+    
+    it "should raise an exception if the relationship has already been specified" do
+      Smurf.should_receive(:relationship_exists?).with(:one, :smurfette).and_return(true)
+      Smurf.stub!(:after_initialize)
+      lambda {
+      class Smurf
+        relationships do
+          has :one, :smurfette
+        end
+      end
+      }.should raise_error Sequel::Error, "The relationship 'Smurf has one smurfette' is already defined."
+    end
+    
+    it "should establish a has :one relationship" do
+      Smurf.stub!(:auto_create_join_table)
+      Smurf.should_receive(:relationship_exists?).with(:one, :smurfette).and_return(false)
+      Smurf.should_receive(:after_initialize)
+      class Smurf
+        relationships do
+          has :one, :smurfette 
+        end
+      end
+      
+      @smurf = Smurf.new
+    
+    end
+    
+    it "should establish a has :many relationship" do
+      Smurf.should_receive(:auto_create_join_table).with(:smurfette, {}).and_return(true)
+      Smurf.should_receive(:relationship_exists?).with(:many, :smurfette).and_return(false)
+      Smurf.should_receive(:after_initialize)
+      class Smurf
+        relationships do
+          has :many, :smurfette 
+        end
+      end
+      
+      @smurf = Smurf.new
+    end
+    
+    it "should call the auto_create_join_table method" do
+      Smurf.should_receive(:auto_create_join_table).with(:smurfette, {}).and_return(true)
 
-describe Sequel::Model::Relationships, "has :many" do
-end
+      class Smurf
+        relationships do
+          has :one, :smurfette
+        end
+      end
+    end
+    
+    it "should store the relationship to ensure there is no duplication" do
+      class Smurf
+        relationships do
+          has :one, :smurfette
+          has :many, :legs
+        end
+      end
+      
+      Smurf.model_relationships.should == [
+        {:arity=>:one, :options=>{}, :klass=>:smurfette},
+        {:arity=>:many, :options=>{}, :klass=>:legs}
+      ]
+      
+    end
+    
+    it "should create an instance method for the has one relationship" do
+      class Smurf
+        relationships do
+          has :one, :smurfette
+        end
+      end
+      
+      @smurf = Smurf.new
+      @smurf.should respond_to(:smurfette)
+      @smurf.should_not respond_to(:smurfettes)
+    end
+    
+    it "should create an instance method for the has many relationship" do
+      class Smurf
+        relationships do
+          has :one, :smurfettes
+        end
+      end
+      
+      @smurf = Smurf.new
+      @smurf.should respond_to(:smurfettes)
+      @smurf.should_not respond_to(:smurf)
+    end
+  end
+  
+  describe "has_one" do
+    it "should be an alias for has :one" do
+      Smurf.should_receive(:has).with(:one, :smurfette, {})
+      class Smurf
+        relationships do
+          has_one :smurfette
+        end
+      end
+    end
+  end
+  
+  describe "has_many" do
+    it "should be an alias for has :many" do
+      Smurf.should_receive(:has).with(:many, :smurfette, {})
+      class Smurf
+        relationships do
+          has_many :smurfette
+        end
+      end
+    end
+  end
+
+  describe "belongs_to" do
+    it "should be an alias for has :one" do
+      Smurf.should_receive(:has).with(:one, :smurfette, {})
+      class Smurf
+        relationships do
+          belongs_to :smurfette
+        end
+      end
+    end
+  end
+  
+  describe "has_relationships?" do
+    it "should return true if the class has any relationships" do
+      class Smurf
+        relationships do
+          belongs_to :smurfette
+        end
+      end
+      
+      Smurf.has_relationships?.should be_true
+    end
+    
+    it "should return false if the class has no relationships" do
+      class Smurf
+      end
+      
+      Smurf.has_relationships?.should be_false
+    end
+  end
 
-describe Sequel::Model::Relationships, "belongs_to" do
 end

data/spec/validations_spec.rb

@@ -138,7 +138,7 @@ describe Sequel::Model, "Validations" do
     @cow.should be_valid
   end
   
-  it "should have a validates block that calls multple validations" do
+  it "should have a validates block that calls multiple validations" do
     class Person < Sequel::Model
       validations.clear
       validates do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sequel_model
 version: !ruby/object:Gem::Version 
-  version: 0.3.2.1
+  version: 0.3.3
 platform: ruby
 authors: 
 - Sharon Rosner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-01-24 00:00:00 +02:00
+date: 2008-01-25 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency