sequel_model 0.4.2 → 0.5

data/spec/deprecated_relations_spec.rb

@@ -0,0 +1,153 @@
+require File.join(File.dirname(__FILE__), "spec_helper")
+
+describe Sequel::Model, "one_to_one" do
+
+  before(:each) do
+    MODEL_DB.reset
+
+    @c1 = Class.new(Sequel::Model(:attributes)) do
+    end
+
+    @c2 = Class.new(Sequel::Model(:nodes)) do
+      def columns; [:id, :parent_id]; end
+    end
+
+    @dataset = @c2.dataset
+
+    @dataset.extend(Module.new {
+      def fetch_rows(sql)
+        @db << sql
+        yield({:hey => 1})
+      end
+    })
+  end
+
+  it "should use implicit key if omitted" do
+    @c2.one_to_one :parent, :from => @c2
+
+    d = @c2.new(:id => 1, :parent_id => 234)
+    p = d.parent
+    p.class.should == @c2
+    p.values.should == {:hey => 1}
+
+    MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE (id = 234) LIMIT 1"]
+  end
+
+  it "should use explicit key if given" do
+    @c2.one_to_one :parent, :from => @c2, :key => :blah
+
+    d = @c2.new(:id => 1, :blah => 567)
+    p = d.parent
+    p.class.should == @c2
+    p.values.should == {:hey => 1}
+
+    MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE (id = 567) LIMIT 1"]
+  end
+
+  # the new implementation doesn't support plain datasets as associations
+  # it "should support plain dataset in the from option" do
+  #   @c2.one_to_one :parent, :from => MODEL_DB[:xyz]
+  #   
+  #   d = @c2.new(:id => 1, :parent_id => 789)
+  #   p = d.parent
+  #   p.class.should == Hash
+  #   
+  #   MODEL_DB.sqls.should == ["SELECT * FROM xyz WHERE (id = 789) LIMIT 1"]
+  # end
+
+  # the new implementation doesn't support plain datasets as associations
+  # it "should support table name in the from option" do
+  #   @c2.one_to_one :parent, :from => :abc
+  # 
+  #   d = @c2.new(:id => 1, :parent_id => 789)
+  #   p = d.parent
+  #   p.class.should == Hash
+  # 
+  #   MODEL_DB.sqls.should == ["SELECT * FROM abc WHERE (id = 789) LIMIT 1"]
+  # end
+
+  it "should return nil if key value is nil" do
+    @c2.one_to_one :parent, :from => @c2
+
+    d = @c2.new(:id => 1)
+    d.parent.should == nil
+  end
+
+  it "should define a setter method" do
+    @c2.one_to_one :parent, :from => @c2
+
+    d = @c2.load(:id => 1)
+    d.parent = @c2.new(:id => 4321)
+    d.values.should == {:id => 1, :parent_id => 4321}
+    d.save_changes
+    MODEL_DB.sqls.last.should == "UPDATE nodes SET parent_id = 4321 WHERE (id = 1)"
+
+    d.parent = nil
+    d.values.should == {:id => 1, :parent_id => nil}
+    d.save_changes
+    MODEL_DB.sqls.last.should == "UPDATE nodes SET parent_id = NULL WHERE (id = 1)"
+
+    e = @c2.new(:id => 6677)
+    d.parent = e
+    d.values.should == {:id => 1, :parent_id => 6677}
+    d.save_changes
+    MODEL_DB.sqls.last.should == "UPDATE nodes SET parent_id = 6677 WHERE (id = 1)"
+  end
+end
+
+describe Sequel::Model, "one_to_many" do
+
+  before(:each) do
+    MODEL_DB.reset
+
+    @c1 = Class.new(Sequel::Model(:attributes)) do
+    end
+
+    @c2 = Class.new(Sequel::Model(:nodes)) do
+    end
+  end
+
+  it "should define a getter method" do
+    @c2.one_to_many :attributes, :from => @c1, :key => :node_id
+
+    n = @c2.new(:id => 1234)
+    a = n.attributes
+    a.should be_a_kind_of(Sequel::Dataset)
+    a.sql.should == 'SELECT * FROM attributes WHERE (node_id = 1234)'
+  end
+  
+  # the new implementation doesn't support plain datasets as associations
+  # it "should support plain dataset in the from option" do
+  #   @c2.one_to_many :attributes, :from => MODEL_DB[:xyz], :key => :node_id
+  # 
+  #   n = @c2.new(:id => 1234)
+  #   a = n.attributes
+  #   a.should be_a_kind_of(Sequel::Dataset)
+  #   a.sql.should == 'SELECT * FROM xyz WHERE (node_id = 1234)'
+  # end
+
+  # the new implementation doesn't support plain datasets as associations
+  # it "should support table name in the from option" do
+  #   @c2.one_to_many :attributes, :from => :abc, :key => :node_id
+  # 
+  #   n = @c2.new(:id => 1234)
+  #   a = n.attributes
+  #   a.should be_a_kind_of(Sequel::Dataset)
+  #   a.sql.should == 'SELECT * FROM abc WHERE (node_id = 1234)'
+  # end
+  
+  it "should support implicit key names" do
+    $c1 = @c1
+    
+    module Music
+      class BlueNote < Sequel::Model
+        one_to_many :attributes, :from => $c1
+      end
+    end
+    
+    n = Music::BlueNote.new(:id => 1234)
+    a = n.attributes
+    a.should be_a_kind_of(Sequel::Dataset)
+    a.sql.should == 'SELECT * FROM attributes WHERE (blue_note_id = 1234)'
+  end
+end

data/spec/spec_helper.rb

@@ -13,6 +13,10 @@ class MockDataset < Sequel::Dataset
     @db.execute update_sql(*args)
   end
   
+  def delete(*args)
+    @db.execute delete_sql(*args)
+  end
+  
   def fetch_rows(sql)
     @db.execute(sql)
     yield({:id => 1, :x => 1})

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sequel_model
 version: !ruby/object:Gem::Version 
-  version: 0.4.2
+  version: "0.5"
 platform: ruby
 authors: 
 - Sharon Rosner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-02-29 00:00:00 +02:00
+date: 2008-03-08 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -30,7 +30,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: "1.0"
     version: 
-description: Lightweight ORM for Ruby
+description: Model classes for Sequel
 email: ciconia@gmail.com
 executables: []
 
@@ -44,26 +44,27 @@ files:
 - COPYING
 - README
 - Rakefile
+- spec/associations_spec.rb
 - spec/base_spec.rb
 - spec/caching_spec.rb
+- spec/deprecated_relations_spec.rb
 - spec/hooks_spec.rb
 - spec/model_spec.rb
 - spec/plugins_spec.rb
 - spec/rcov.opts
 - spec/record_spec.rb
-- spec/relations_spec.rb
 - spec/schema_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
 - spec/validations_spec.rb
 - lib/sequel_model
+- lib/sequel_model/associations.rb
 - lib/sequel_model/base.rb
 - lib/sequel_model/caching.rb
 - lib/sequel_model/hooks.rb
 - lib/sequel_model/plugins.rb
 - lib/sequel_model/pretty_table.rb
 - lib/sequel_model/record.rb
-- lib/sequel_model/relations.rb
 - lib/sequel_model/schema.rb
 - lib/sequel_model/validations.rb
 - lib/sequel_model.rb
@@ -74,7 +75,7 @@ post_install_message:
 rdoc_options: 
 - --quiet
 - --title
-- "Sequel Model: Lightweight ORM for Ruby"
+- "Sequel: The Database Toolkit for Ruby"
 - --opname
 - index.html
 - --line-numbers
@@ -105,6 +106,6 @@ rubyforge_project: sequel
 rubygems_version: 1.0.1
 signing_key: 
 specification_version: 2
-summary: Lightweight ORM for Ruby
+summary: Model classes for Sequel
 test_files: []
 

data/lib/sequel_model/relations.rb

@@ -1,154 +0,0 @@
-module Sequel
-  class Model
-    ID_POSTFIX = '_id'.freeze
-    
-    # Creates a 1-1 relationship by defining an association method, e.g.:
-    # 
-    #   class Session < Sequel::Model
-    #   end
-    #
-    #   class Node < Sequel::Model
-    #     one_to_one :producer, :from => Session
-    #     # which is equivalent to
-    #     def producer
-    #       Session[producer_id] if producer_id
-    #     end
-    #   end
-    #
-    # You can also set the foreign key explicitly by including a :key option:
-    #
-    #   one_to_one :producer, :from => Session, :key => :producer_id
-    #
-    # The one_to_one macro also creates a setter, which accepts nil, a hash or
-    # a model instance, e.g.:
-    #
-    #   p = Producer[1234]
-    #   node = Node[:path => '/']
-    #   node.producer = p
-    #   node.producer_id #=> 1234
-    #
-    def self.one_to_one(name, opts)
-      from = opts[:from]
-      from || (raise Error, "No association source defined (use :from option)")
-      key = opts[:key] || (name.to_s + ID_POSTFIX).to_sym
-      
-      setter_name = "#{name}=".to_sym
-      
-      case from
-      when Symbol
-        class_def(name) {(k = @values[key]) ? db[from][:id => k] : nil}
-      when Sequel::Dataset
-        class_def(name) {(k = @values[key]) ? from[:id => k] : nil}
-      else
-        class_def(name) {(k = @values[key]) ? from[k] : nil}
-      end
-      class_def(setter_name) do |v|
-        case v
-        when nil
-          set(key => nil)
-        when Sequel::Model
-          set(key => v.pk)
-        when Hash
-          set(key => v[:id])
-        end
-      end
-
-      # define_method name, &eval(ONE_TO_ONE_PROC % [key, from])
-    end
-  
-    # Creates a 1-N relationship by defining an association method, e.g.:
-    # 
-    #   class Book < Sequel::Model
-    #   end
-    #
-    #   class Author < Sequel::Model
-    #     one_to_many :books, :from => Book
-    #     # which is equivalent to
-    #     def books
-    #       Book.filter(:author_id => id)
-    #     end
-    #   end
-    #
-    # You can also set the foreign key explicitly by including a :key option:
-    #
-    #   one_to_many :books, :from => Book, :key => :author_id
-    #
-    def self.one_to_many(name, opts)
-      from = opts[:from]
-      from || (raise Error, "No association source defined (use :from option)")
-      key = opts[:key] || (self.name.demodulize.underscore.to_s + ID_POSTFIX).to_sym
-      
-      case from
-      when Symbol
-        class_def(name) {db[from].filter(key => pk)}
-      else
-        class_def(name) {from.filter(key => pk)}
-      end
-    end
-    
-    # TODO: Add/Replace current relations with the following specifications:
-    # ======================================================================
-    
-    # Database modelling is generally done with an ER (Entity Relationship) diagram.
-    # Shouldn't ORM's facilitate simlilar specification?
-
-    #   class Post < Sequel::Model
-    #     relationships do
-    #       # Specify the relationships that exist with the User model (users table)
-    #       # These relationships are precisely the ER diagram connecting arrows.
-    #     end
-    #   end
-
-    #
-    # = Relationships 
-    #
-    # are specifications of the ends of the ER diagrams connectors that are touching
-    # the current model.
-    #
-    # one_to_one,   has_one
-    # many_to_one,  belongs_to
-    # many_to_many, has_many
-    # ?parameters may be :zero, :one, :many which specifies the cardinality of the connection
-
-    # Example:
-    #   class Post < Sequel::Model
-    #     relationships do
-    #       has :one,  :blog, :required => true # blog_id field, cannot be null
-    #       has :one,  :account # account_id field
-    #       has :many, :comments # comments_posts join table
-    #       has :many, :authors, :required => true  # authors_posts join table, requires at least one author
-    #     end
-    #   end
-
-    #
-    # Relationship API Details
-    #
-
-    #
-    # == belongs_to
-    #
-
-    # Defines an blog and blog= method
-    #   belongs_to :blog
-
-    # Same, but uses "b_id" as the blog's id field.
-    #   belongs_to :blog, :key => :b_id
-
-    #   has_many   :comments
-    # * Defines comments method which will query the join table appropriately.
-    # * Checks to see if a "comments_posts" join table exists (alphabetical order)
-    # ** If it does not exist, will create the join table. 
-    # ** If options are passed in these will be used to further define the join table.
-
-
-    # Benefits:
-    # * Normalized DB
-    # * Easy to define join objects
-    # * Efficient queries, database gets to use indexed fields (pkeys) instead of a string field and an id.
-    # 
-    # For example, polymorphic associations now become:
-    # [user]      1-* [addresses_users]     *-1 [addresses]
-    # [companies] 1-* [addresses_companies] *-1 [addresses]
-    # [clients]   1-* [addresses_clients]   *-1 [addresses]
-  end
-end

data/spec/relations_spec.rb

@@ -1,149 +0,0 @@
-require File.join(File.dirname(__FILE__), "spec_helper")
-
-describe Sequel::Model, "one_to_one" do
-
-  before(:each) do
-    MODEL_DB.reset
-
-    @c1 = Class.new(Sequel::Model(:attributes)) do
-    end
-
-    @c2 = Class.new(Sequel::Model(:nodes)) do
-    end
-
-    @dataset = @c2.dataset
-
-    $sqls = []
-    @dataset.extend(Module.new {
-      def fetch_rows(sql)
-        $sqls << sql
-        yield({:hey => 1})
-      end
-
-      def update(values)
-        $sqls << update_sql(values)
-      end
-    }
-    )
-  end
-
-  it "should use implicit key if omitted" do
-    @c2.one_to_one :parent, :from => @c2
-
-    d = @c2.new(:id => 1, :parent_id => 234)
-    p = d.parent
-    p.class.should == @c2
-    p.values.should == {:hey => 1}
-
-    $sqls.should == ["SELECT * FROM nodes WHERE (id = 234) LIMIT 1"]
-  end
-
-  it "should use explicit key if given" do
-    @c2.one_to_one :parent, :from => @c2, :key => :blah
-
-    d = @c2.new(:id => 1, :blah => 567)
-    p = d.parent
-    p.class.should == @c2
-    p.values.should == {:hey => 1}
-
-    $sqls.should == ["SELECT * FROM nodes WHERE (id = 567) LIMIT 1"]
-  end
-
-  it "should support plain dataset in the from option" do
-    @c2.one_to_one :parent, :from => MODEL_DB[:xyz]
-
-    d = @c2.new(:id => 1, :parent_id => 789)
-    p = d.parent
-    p.class.should == Hash
-
-    MODEL_DB.sqls.should == ["SELECT * FROM xyz WHERE (id = 789) LIMIT 1"]
-  end
-
-  it "should support table name in the from option" do
-    @c2.one_to_one :parent, :from => :abc
-
-    d = @c2.new(:id => 1, :parent_id => 789)
-    p = d.parent
-    p.class.should == Hash
-
-    MODEL_DB.sqls.should == ["SELECT * FROM abc WHERE (id = 789) LIMIT 1"]
-  end
-
-  it "should return nil if key value is nil" do
-    @c2.one_to_one :parent, :from => @c2
-
-    d = @c2.new(:id => 1)
-    d.parent.should == nil
-  end
-
-  it "should define a setter method" do
-    @c2.one_to_one :parent, :from => @c2
-
-    d = @c2.new(:id => 1)
-    d.parent = {:id => 4321}
-    d.values.should == {:id => 1, :parent_id => 4321}
-    $sqls.last.should == "UPDATE nodes SET parent_id = 4321 WHERE (id = 1)"
-
-    d.parent = nil
-    d.values.should == {:id => 1, :parent_id => nil}
-    $sqls.last.should == "UPDATE nodes SET parent_id = NULL WHERE (id = 1)"
-
-    e = @c2.new(:id => 6677)
-    d.parent = e
-    d.values.should == {:id => 1, :parent_id => 6677}
-    $sqls.last.should == "UPDATE nodes SET parent_id = 6677 WHERE (id = 1)"
-  end
-end
-
-describe Sequel::Model, "one_to_many" do
-
-  before(:each) do
-    MODEL_DB.reset
-
-    @c1 = Class.new(Sequel::Model(:attributes)) do
-    end
-
-    @c2 = Class.new(Sequel::Model(:nodes)) do
-    end
-  end
-
-  it "should define a getter method" do
-    @c2.one_to_many :attributes, :from => @c1, :key => :node_id
-
-    n = @c2.new(:id => 1234)
-    a = n.attributes
-    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
-
-    n = @c2.new(:id => 1234)
-    a = n.attributes
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT * FROM xyz WHERE (node_id = 1234)'
-  end
-
-  it "should support table name in the from option" do
-    @c2.one_to_many :attributes, :from => :abc, :key => :node_id
-
-    n = @c2.new(:id => 1234)
-    a = n.attributes
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT * FROM abc WHERE (node_id = 1234)'
-  end
-  
-  it "should support implicit key names" do
-    module Music
-      class BlueNote < Sequel::Model
-        one_to_many :attributes, :from => :abc
-      end
-    end
-    
-    n = Music::BlueNote.new(:id => 1234)
-    a = n.attributes
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT * FROM abc WHERE (blue_note_id = 1234)'
-  end
-end