sequel_model 0.3.3 → 0.4

data/CHANGELOG

@@ -1,3 +1,11 @@
+=== 0.4 (2008-02-05)
+
+* Fixed Model#set to work with string keys (#143).
+
+* Fixed Model.create to correctly initialize instances marked as new (#135).
+
+* Fixed Model#initialize to convert string keys into symbol keys. This also fixes problem with validating objects initialized with string keys (#136).
+
 === 0.3.3 (2008-01-25)
 
 * Finalized support for virtual attributes.

data/COPYING

@@ -1,4 +1,4 @@
-Copyright (c) 2006-2007 Sharon Rosner
+Copyright (c) 2007-2008 Sharon Rosner
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to

data/Rakefile

@@ -9,7 +9,7 @@ include FileUtils
 # Configuration
 ##############################################################################
 NAME = "sequel_model"
-VERS = "0.3.3"
+VERS = "0.4"
 CLEAN.include ["**/.*.sw?", "pkg/*", ".config", "doc/*", "coverage/*"]
 RDOC_OPTS = [
   "--quiet", 
@@ -117,7 +117,7 @@ require "spec/rake/spectask"
 
 desc "Run specs with coverage"
 Spec::Rake::SpecTask.new("spec") do |t|
-  t.spec_files = FileList["spec/*_spec.rb"]
+  t.spec_files = FileList["spec/**/*_spec.rb"]
   t.spec_opts  = File.read("spec/spec.opts").split("\n")
   t.rcov_opts  = File.read("spec/rcov.opts").split("\n")
   t.rcov = true
@@ -125,7 +125,7 @@ end
 
 desc "Run specs without coverage"
 Spec::Rake::SpecTask.new("spec_no_cov") do |t|
-  t.spec_files = FileList["spec/*_spec.rb"]
+  t.spec_files = FileList["spec/**/*_spec.rb"]
   t.spec_opts  = File.read("spec/spec.opts").split("\n")
 end
 

data/lib/sequel_model/record.rb

@@ -171,7 +171,9 @@ module Sequel
       @primary_key ||= self.class.primary_key
     end
     
-    # Returns the primary key value identifying the model instance. Stock implementation.
+    # Returns the primary key value identifying the model instance. If the
+    # model's primary key is changed (using #set_primary_key or #no_primary_key)
+    # this method is redefined accordingly.
     def pk
       @pk ||= @values[:id]
     end
@@ -196,26 +198,22 @@ module Sequel
               values.delete(k)
             end
           end
-          @values.merge!(values)
+          values.inject(@values) {|m, kv| m[kv[0].to_sym] = kv[1]; m}
+          # @values.merge!(values)
         end
       else
         @values = values || {}
       end
 
       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.
-        @new = (k == nil) || (!(Array === k) && !@values[k])
-      end
+      @new = !from_db
       
       block[self] if block
       after_initialize
     end
     
+    # Initializes a model instance as an existing record. This constructor is 
+    # used by Sequel to initialize model instances when fetching records.
     def self.load(values)
       new(values, true)
     end
@@ -272,8 +270,9 @@ module Sequel
 
     # Updates and saves values to database from the passed-in Hash.
     def set(values)
-      this.update(values)
-      values.each {|k, v| @values[k] = v}
+      v = values.inject({}) {|m, kv| m[kv[0].to_sym] = kv[1]; m}
+      this.update(v)
+      v.each {|k, v| @values[k] = v}
     end
     alias_method :update, :set
     

data/lib/sequel_model/validations.rb

@@ -1,4 +1,6 @@
-gem 'assistance', '>= 0.1.2' # because we need Validations
+gem "assistance", ">= 0.1.2" # because we need Validations
+
+require "assistance"
 
 module Sequel
   class Model

data/lib/sequel_model.rb

@@ -213,7 +213,7 @@ module Sequel
   #       primary_key :id
   #       text :title
   #       text :category
-  #       foreign_key :author_id, :table => authors
+  #       foreign_key :author_id, :table => :authors
   #     end
   #   end
   # 

data/spec/hooks_spec.rb

@@ -179,7 +179,7 @@ describe "Model#before_update && Model#after_update" do
   end
   
   specify "should be called around record update" do
-    m = @c.new(:id => 2233)
+    m = @c.load(:id => 2233)
     m.save
     MODEL_DB.sqls.should == [
       'BLAH before',
@@ -200,7 +200,7 @@ describe "Model#before_save && Model#after_save" do
   end
   
   specify "should be called around record update" do
-    m = @c.new(:id => 2233)
+    m = @c.load(:id => 2233)
     m.save
     MODEL_DB.sqls.should == [
       'BLAH before',

data/spec/model_spec.rb

@@ -128,7 +128,7 @@ describe Sequel::Model, "new" do
     o.save
     o.id.should == 1234
 
-    o = @m.new(:x => 1, :id => 333)
+    o = @m.load(:x => 1, :id => 333)
     o.save
     o.id.should == 333
   end

data/spec/record_spec.rb

@@ -20,7 +20,7 @@ describe "Model#save" do
   end
 
   it "should update a record for an existing model instance" do
-    o = @c.new(:id => 3, :x => 1)
+    o = @c.load(:id => 3, :x => 1)
     o.save
     
     MODEL_DB.sqls.first.should =~ 
@@ -28,7 +28,7 @@ describe "Model#save" do
   end
   
   it "should update only the given columns if given" do
-    o = @c.new(:id => 3, :x => 1, :y => nil)
+    o = @c.load(:id => 3, :x => 1, :y => nil)
     o.save(:y)
     
     MODEL_DB.sqls.first.should == "UPDATE items SET y = NULL WHERE (id = 3)"
@@ -63,10 +63,15 @@ describe "Model#save_changes" do
     o.save_changes
     
     MODEL_DB.sqls.should be_empty
+
+    o = @c.load(:id => 3, :x => 1, :y => nil)
+    o.save_changes
+    
+    MODEL_DB.sqls.should be_empty
   end
   
   it "should update only changed columns" do
-    o = @c.new(:id => 3, :x => 1, :y => nil)
+    o = @c.load(:id => 3, :x => 1, :y => nil)
     o.x = 2
 
     o.save_changes
@@ -111,6 +116,14 @@ describe "Model#set" do
     o.x.should == 1
   end
   
+  it "should support string keys" do
+    o = @c.new(:id => 1)
+    o.x.should be_nil
+    o.set('x' => 1)
+    o.x.should == 1
+    MODEL_DB.sqls.first.should == "UPDATE items SET x = 1 WHERE (id = 1)"
+  end
+  
   it "should be aliased by #update" do
     o = @c.new(:id => 1)
     o.update(:x => 1)
@@ -291,7 +304,7 @@ describe Sequel::Model, "update_with_params" do
       def self.columns; [:x, :y]; end
     end
     @o1 = @c.new
-    @o2 = @c.new(:id => 5)
+    @o2 = @c.load(:id => 5)
   end
   
   it "should filter the given params using the model columns" do
@@ -485,6 +498,11 @@ describe Sequel::Model, "#initialize" do
     m.values.should == {:id => 1, :x => 2}
     m.blah.should == 3
   end
+  
+  specify "should convert string keys into symbol keys" do
+    m = @c.new('id' => 1, 'x' => 2)
+    m.values.should == {:id => 1, :x => 2}
+  end
 end
 
 describe Sequel::Model, ".create" do
@@ -517,6 +535,13 @@ describe Sequel::Model, ".create" do
     o2.should == :blah
     MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (333)", "SELECT * FROM items WHERE (id IN ('INSERT INTO items (x) VALUES (333)')) LIMIT 1"]
   end
+  
+  it "should create a row for a model with custom primary key" do
+    @c.set_primary_key :x
+    o = @c.create(:x => 30)
+    o.class.should == @c
+    MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (30)", "SELECT * FROM items WHERE (x = 30) LIMIT 1"]
+  end
 end
 
 describe Sequel::Model, "#refresh" do

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 multiple validations" do
+  it "should have a validates block that contains multiple validations" do
     class Person < Sequel::Model
       validations.clear
       validates do
@@ -182,6 +182,18 @@ describe Sequel::Model, "Validations" do
     Person.should have_validations
     Smurf.should_not have_validations
   end
+
+  it "should validate correctly instances initialized with string keys" do
+    class Can < Sequel::Model
+      def columns; [:id, :name]; end
+      
+      validates_length_of :name, :minimum => 4
+    end
+    
+    Can.new('name' => 'ab').should_not be_valid
+    Can.new('name' => 'abcd').should be_valid
+  end
+  
 end
 
 describe "Model#save!" do
@@ -193,7 +205,7 @@ describe "Model#save!" do
         o.errors[a] << 'blah' unless v == 5
       end
     end
-    @m = @c.new(:id => 4)
+    @m = @c.load(:id => 4)
     MODEL_DB.reset
   end
   
@@ -204,7 +216,7 @@ describe "Model#save!" do
   end
 end
 
-describe "Model#save!" do
+describe "Model#save" do
   setup do
     @c = Class.new(Sequel::Model(:people)) do
       def columns; [:id]; end
@@ -213,7 +225,7 @@ describe "Model#save!" do
         o.errors[a] << 'blah' unless v == 5
       end
     end
-    @m = @c.new(:id => 4)
+    @m = @c.load(:id => 4)
     MODEL_DB.reset
   end
 
@@ -224,7 +236,7 @@ describe "Model#save!" do
     
     @m.id = 5
     @m.should be_valid
-    @m.save
+    @m.save.should_not be_false
     MODEL_DB.sqls.should == ['UPDATE people SET id = 5 WHERE (id = 5)']
   end
   

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: sequel_model
 version: !ruby/object:Gem::Version 
-  version: 0.3.3
+  version: "0.4"
 platform: ruby
 authors: 
 - Sharon Rosner
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-01-25 00:00:00 +02:00
+date: 2008-02-05 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -44,30 +44,28 @@ files:
 - COPYING
 - README
 - Rakefile
+- spec/hooks_spec.rb
 - spec/base_spec.rb
 - spec/caching_spec.rb
-- spec/hooks_spec.rb
-- spec/model_spec.rb
-- spec/plugins_spec.rb
-- spec/rcov.opts
+- spec/validations_spec.rb
 - spec/record_spec.rb
+- spec/spec_helper.rb
+- spec/model_spec.rb
 - spec/relations_spec.rb
-- spec/relationships_spec.rb
 - spec/schema_spec.rb
+- spec/rcov.opts
+- spec/plugins_spec.rb
 - spec/spec.opts
-- spec/spec_helper.rb
-- spec/validations_spec.rb
 - lib/sequel_model
-- lib/sequel_model/base.rb
-- lib/sequel_model/caching.rb
-- lib/sequel_model/hooks.rb
-- lib/sequel_model/plugins.rb
+- lib/sequel_model/validations.rb
 - lib/sequel_model/pretty_table.rb
 - lib/sequel_model/record.rb
 - lib/sequel_model/relations.rb
-- lib/sequel_model/relationships.rb
 - lib/sequel_model/schema.rb
-- lib/sequel_model/validations.rb
+- lib/sequel_model/plugins.rb
+- lib/sequel_model/hooks.rb
+- lib/sequel_model/base.rb
+- lib/sequel_model/caching.rb
 - lib/sequel_model.rb
 - CHANGELOG
 has_rdoc: true

data/lib/sequel_model/relationships.rb

@@ -1,224 +0,0 @@
-# = Sequel Relationships
-# 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, :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
-# 
-#
-# 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]
-# it is automatically polymorphic by specifying the has relationship inside the 2User and Company tables to addresses. Addresses themselves don't care. so we have by default polymorphism. 
-# If you need to talk about a 'Company Address' then you can subclass, CompanyAddress < Address and do has :many, :company_addresses
-
-module Sequel
-
-  class Model
-
-    module Relationships
-      class Generator
-        def initialize(model_class, &block)
-          @model_class = model_class
-          instance_eval(&block)
-        end
-
-        def method_missing(method, *args)
-          @model_class.send(method, *args)
-        end
-      end
-    end
-    
-    class << self
-      @@model_relationships = []
-
-      def relationship_exists?(arity,relation)
-        @@model_relationships.detect do |relation|
-          relation[:arity] == arity && 
-          relation[:klass] == relation
-        end
-      end
-
-      # has arity<Symbol>, model<Symbol>
-      # has :one,  :blog, :required => true # blog_id field, cannot be null
-      # 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
-
-        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)
-
-        # Store the relationship
-        @@model_relationships << { 
-          :arity => arity, 
-          :klass => klass, 
-          :options => options 
-        }
-
-        # Define relationship methods
-        after_initialize do
-          define_relationship_method arity, klass, options
-        end
-
-        #unless normalized
-          # :required => true # The relationship must be populated to save
-          # can only be used with normalized => false : 
-        #end
-        # save the relationship
-      end
-      
-      # the proxy methods has_xxx ... , simply pass thru to to has :xxx, ...
-      def has_one(klass, options = {})
-        has :one, klass, options
-      end
-
-      def has_many(klass, options = {})
-        has :many, klass, options
-      end
-
-      def belongs_to(klass, options = {})
-        has :one, klass, options
-      end
-
-      # returns true if exists, false if not
-      def join_table?(first, second)
-        # we still have to test this out      
-        db[join_table(first, second)].table_exists?
-      end
-
-      # TODO: Move this elsewhere? outside relationships?
-      # creates a join table given two table names
-      def create_join_table(first, second)
-        first_key, second_key = "#{first}_id", "#{second}_id"
-        db.create_table join_table(first, second).to_sym do
-          #primary_key [first_key.to_sym, second_key.to_sym]
-          integer first_key, :null => false
-          integer second_key, :null => false
-        end unless join_table?(first, second)
-      end
-
-      def create_join_table!(first, second)
-        db.drop_table join_table(first, second)
-        create_join_table(first, second)
-      end
-
-      def auto_create_join_table!(klass)
-        auto_create_join_table(klass, :force => true)
-      end
-
-      def auto_create_join_table(klass, options = {})
-        first, second = table_name, klass.to_s.pluralize
-        if join_table?(first, second) && options[:force] == true
-          create_join_table!(first, second)
-        else
-          create_join_table(first, second)
-        end
-      end
-
-      # Given two models, it outputs the join table name
-      # which is sorted alphabetically with each table name pluralized
-      # Examples:
-      #   join_table(user, post) #=> :posts_users
-      #   join_table(users, posts) #=> :posts_users
-      def join_table(first, second)
-        first, second = first.to_s.pluralize, second.to_s.pluralize
-        [first, second].sort.join("_").to_sym
-      end
-
-      # relationships do
-      #   ...
-      # end
-      def relationships(&block)
-        Relationships::Generator.new(self, &block)
-      end
-
-      # return true if there are validations stored, false otherwise
-      def has_relationships?
-        model_relationships.length > 0 ? true : false
-      end
-      
-      def model_relationships
-        @@model_relationships
-      end
-
-    end
-
-    # Defines relationship method from the current class to the klass specified
-    def define_relationship_method(arity, relation, options)
-      if arity == :one
-        self.instance_eval "
-          def #{relation}
-            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.dataset.left_outer_join(#{relation}, :id => :#{self.class.table_name.to_s.singularize}_id)
-          end
-        "
-      end
-    end # define_relationship_method
-  end # Model
-end # Sequel

data/spec/relationships_spec.rb

@@ -1,191 +0,0 @@
-require File.join(File.dirname(__FILE__), "spec_helper")
-
-#__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)
-
-      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
-
-end