composite_primary_keys 0.1.4 → 0.3.1

data/Rakefile

@@ -9,7 +9,7 @@ require File.join(File.dirname(__FILE__), 'lib', 'composite_primary_keys', 'vers
 
 PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
 PKG_NAME      = 'composite_primary_keys'
-PKG_VERSION   = CompositePrimayKeys::VERSION::STRING + PKG_BUILD
+PKG_VERSION   = CompositePrimaryKeys::VERSION::STRING + PKG_BUILD
 PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
 
 RELEASE_NAME  = "REL #{PKG_VERSION}"
@@ -24,6 +24,7 @@ PKG_FILES = FileList[
 
 desc "Default Task"
 task :default => [ :test_mysql ] # UNTESTED =, :test_sqlite, :test_postgresql ]
+task :test    => [ :test_mysql ]
 
 # Run the unit tests
 
@@ -38,18 +39,15 @@ end
 SCHEMA_PATH = File.join(File.dirname(__FILE__), *%w(test fixtures db_definitions))
 
 desc 'Build the MySQL test databases'
-task :build_mysql_databases => [:drop_mysql_databases] do 
+task :build_mysql_databases do 
   puts File.join(SCHEMA_PATH, 'mysql.sql')
-  %x( mysqladmin -u root create activerecord_unittest )
-  #%x( mysqladmin  -u root create activerecord_unittest2 )
-  %x( mysql -u root activerecord_unittest < #{File.join(SCHEMA_PATH, 'mysql.sql')} )
-  #%x( mysql -u root activerecord_unittest < #{File.join(SCHEMA_PATH, 'mysql2.sql')} )
+  %x( mysqladmin -u root create "#{PKG_NAME}_unittest" )
+  %x( mysql -u root "#{PKG_NAME}_unittest" < #{File.join(SCHEMA_PATH, 'mysql.sql')} )
 end
 
 desc 'Drop the MySQL test databases'
 task :drop_mysql_databases do 
-  %x( mysqladmin -u root -f drop activerecord_unittest )
-  #%x( mysqladmin -u root -f drop activerecord_unittest2 )
+  %x( mysqladmin -u root -f drop "#{PKG_NAME}_unittest" )
 end
 
 desc 'Rebuild the MySQL test databases'
@@ -57,16 +55,13 @@ task :rebuild_mysql_databases => [:drop_mysql_databases, :build_mysql_databases]
 
 desc 'Build the PostgreSQL test databases'
 task :build_postgresql_databases do 
-  %x( createdb activerecord_unittest )
-  %x( createdb activerecord_unittest2 )
-  %x( psql activerecord_unittest -f #{File.join(SCHEMA_PATH, 'postgresql.sql')} )
-  %x( psql activerecord_unittest2 -f #{File.join(SCHEMA_PATH, 'postgresql2.sql')} )
+  %x( createdb "#{PKG_NAME}_unittest" )
+  %x( psql "#{PKG_NAME}_unittest" -f #{File.join(SCHEMA_PATH, 'postgresql.sql')} )
 end
 
 desc 'Drop the PostgreSQL test databases'
 task :drop_postgresql_databases do 
-  %x( dropdb   activerecord_unittest )
-  %x( dropdb   activerecord_unittest2 )
+  %x( dropdb   "#{PKG_NAME}_unittest" )
 end
 
 desc 'Rebuild the PostgreSQL test databases'
@@ -117,8 +112,8 @@ spec = Gem::Specification.new do |s|
   
   s.author = "Dr Nic Williams"
   s.email = "drnicwilliams@gmail.com"
-  s.homepage = "http://composite_primary_keys.rubyforge.org"
-  s.rubyforge_project = "composite_primary_keys"
+  s.homepage = "http://compositekeys.rubyforge.org"
+  s.rubyforge_project = "compositekeys"
 end
   
 Rake::GemPackageTask.new(spec) do |p|
@@ -154,17 +149,6 @@ end
 
 # Publishing ------------------------------------------------------
 
-desc "Publish the beta gem"
-task :pgem => [:package] do 
-  Rake::SshFilePublisher.new("drnicwilliams@gmail.com", "public_html/gems/gems", "pkg", "#{PKG_FILE_NAME}.gem").upload
-  `ssh drnicwilliams@gmail.com './gemupdate.sh'`
-end
-
-desc "Publish the API documentation"
-task :pdoc => [:rdoc] do 
-  Rake::SshDirPublisher.new("drnicwilliams@gmail.com", "public_html/ar", "doc").upload
-end
-
 desc "Publish the release files to RubyForge."
 task :release => [ :package ] do
   `ruby scripts/rubyforge login`

data/lib/composite_primary_keys.rb

@@ -34,6 +34,7 @@ unless defined?(ActiveRecord)
   end
 end
 
+require 'composite_primary_keys/composite_arrays'
 require 'composite_primary_keys/base'
 
 ActiveRecord::Base.class_eval do

data/lib/composite_primary_keys/base.rb

@@ -3,6 +3,7 @@ module CompositePrimaryKeys
     module Base #:nodoc:
 
       INVALID_FOR_COMPOSITE_KEYS = 'Not appropriate for composite primary keys'
+      NOT_IMPLEMENTED_YET = 'Not implemented for composite primary keys yet'
        
       def self.append_features(base)
         super
@@ -12,8 +13,9 @@ module CompositePrimaryKeys
     
       module ClassMethods
         def set_primary_keys(*keys)
+          keys = keys.first if keys.first.is_a?(Array) or keys.first.is_a?(CompositeKeys)
           cattr_accessor :primary_keys 
-          self.primary_keys = CompositePrimaryKeys::PrimaryKeys.new(keys)
+          self.primary_keys = keys.to_composite_keys
           
           class_eval <<-EOV
             include CompositePrimaryKeys::ActiveRecord::Base::CompositeInstanceMethods
@@ -38,29 +40,22 @@ module CompositePrimaryKeys
         # whether you name it the default 'id' or set it to something else.
         def id
           attr_names = self.class.primary_keys
-          attr_names.map {|attr_name| read_attribute(attr_name)}
+          CompositeIds.new(
+            attr_names.map {|attr_name| read_attribute(attr_name)}
+          )
         end
         alias_method :ids, :id
+        alias_method :to_param, :id
         
-        #id_to_s([1,2]) -> "1,2"
-        #id_to_s([1,2], '-') -> "1-2"
-        def id_to_s(ids, id_sep = CompositePrimaryKeys::ID_SEP)
-          ids.map{|id| self.class.sanitize(id)}.join("#{id_sep}")
-        end
-  
-        # Enables Active Record objects to be used as URL parameters in Action Pack automatically.
-        def to_param
-          id_to_s(ids)
-        end
-  
         def id_before_type_cast #:nodoc:
-          # TODO
-          read_attribute_before_type_cast(self.class.primary_key)
+            raise CompositePrimaryKeys::ActiveRecord::Base::NOT_IMPLEMENTED_YET
         end
   
         def quoted_id #:nodoc:
-          # TODO
-          quote(id, column_for_attribute(self.class.primary_key))
+          [self.class.primary_keys, ids].
+            transpose.
+            map {|attr_name,id| quote(id, column_for_attribute(attr_name))}.
+            to_composite_ids
         end
   
         # Sets the primary ID.
@@ -71,7 +66,33 @@ module CompositePrimaryKeys
           end
           ids.each {|id| write_attribute(self.class.primary_key , id)}
         end
-        
+          
+        # Deletes the record in the database and freezes this instance to reflect that no changes should
+        # be made (since they can't be persisted).
+        def destroy
+          unless new_record?
+            connection.delete <<-end_sql, "#{self.class.name} Destroy"
+              DELETE FROM #{self.class.table_name}
+              WHERE (#{self.class.primary_key}) = (#{quoted_id})
+            end_sql
+          end
+  
+          freeze
+        end
+  
+        # Returns a clone of the record that hasn't been assigned an id yet and
+        # is treated as a new record.  Note that this is a "shallow" clone:
+        # it copies the object's attributes only, not its associations.
+        # The extent of a "deep" clone is application-specific and is therefore
+        # left to the application to implement according to its need.
+        def clone
+          attrs = self.attributes_before_type_cast
+          self.class.primary_keys.each {|key| attrs.delete(key.to_s)}
+          self.class.new do |record|
+            record.send :instance_variable_set, '@attributes', attrs
+          end
+        end
+  
         # Define an attribute reader method.  Cope with nil column.
         def define_read_method(symbol, attr_name, column)
           cast_code = column.type_cast_code('v') if column
@@ -110,6 +131,18 @@ module CompositePrimaryKeys
             super
           end
         end
+        
+      private
+        # Updates the associated record with values matching those of the instance attributes.
+        def update
+          connection.update(
+            "UPDATE #{self.class.table_name} " +
+            "SET #{quoted_comma_pair_list(connection, attributes_with_quotes(false))} " +
+            "WHERE (#{self.class.primary_key}) = (#{id})",
+            "#{self.class.name} Update"
+          )
+          return true
+        end
       end
       
       module CompositeClassMethods
@@ -121,9 +154,9 @@ module CompositePrimaryKeys
         end
        
         #ids_to_s([[1,2],[7,3]]) -> "(1,2),(7,3)"
-        #ids_to_s([[1,2],[7,3]], ',', ';', '', '') -> "1,2;7,3"
-        def ids_to_s(ids, id_sep = CompositePrimaryKeys::ID_SEP, list_sep = ',', left_bracket = '(', right_bracket = ')')
-          "#{left_bracket}#{ids.map{|id| sanitize(id)}.join('#{id_sep}')}#{right_bracket}"
+        #ids_to_s([[1,2],[7,3]], ',', ';') -> "1,2;7,3"
+        def ids_to_s(many_ids, id_sep = CompositePrimaryKeys::ID_SEP, list_sep = ',', left_bracket = '(', right_bracket = ')')
+          many_ids.map {|ids| "#{left_bracket}#{ids}#{right_bracket}"}.join(list_sep)
         end
   
         # Returns true if the given +ids+ represents the primary keys of a record in the database, false otherwise.
@@ -138,13 +171,21 @@ module CompositePrimaryKeys
         # If an array of ids is provided (e.g. delete([1,2], [3,4]), all of them
         # are deleted.
         def delete(*ids)
+          unless ids.is_a?(Array); raise "*ids must be an Array"; end
+          ids = [ids.to_composite_ids] if not ids.first.is_a?(Array)
           delete_all([ "(#{primary_keys}) IN (#{ids_to_s(ids)})" ])
         end
   
         # Destroys the record with the given +ids+ by instantiating the object and calling #destroy (all the callbacks are the triggered).
         # If an array of ids is provided, all of them are destroyed.
         def destroy(*ids)
-          ids.first.is_a?(Array) ? ids.each { |id_set| destroy(id_set) } : find(ids).destroy
+          unless ids.is_a?(Array); raise "*ids must be an Array"; end
+          if ids.first.is_a?(Array)
+            ids = ids.map{|compids| compids.to_composite_ids}
+          else
+            ids = ids.to_composite_ids
+          end
+          ids.first.is_a?(CompositeIds) ? ids.each { |id_set| find(id_set).destroy } : find(ids).destroy
         end
        
         # Returns an array of column objects for the table associated with this class.

data/lib/composite_primary_keys/composite_arrays.rb

@@ -0,0 +1,28 @@
+module CompositePrimaryKeys
+  ID_SEP = ','
+  module ArrayExtension
+    def to_composite_keys
+      CompositeKeys.new(self)
+    end
+    
+    def to_composite_ids
+      CompositeIds.new(self)
+    end
+  end
+  
+  class CompositeArray < Array
+    def to_s
+      join(ID_SEP)
+    end
+  end  
+
+  class CompositeKeys < CompositeArray
+
+  end
+
+  class CompositeIds < CompositeArray
+
+  end
+end
+
+Array.send(:include, CompositePrimaryKeys::ArrayExtension)

data/lib/composite_primary_keys/version.rb

@@ -1,8 +1,8 @@
-module CompositePrimayKeys
+module CompositePrimaryKeys
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 1
-    TINY  = 4
+    MINOR = 3
+    TINY  = 1
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/test/abstract_unit.rb

@@ -1,7 +1,7 @@
 $:.unshift(File.dirname(__FILE__) + '/../lib')
-$:.unshift(File.dirname(__FILE__) + '/../../activesupport/lib')
 
 require 'test/unit'
+require 'hash_tricks'
 require 'active_record'
 require 'active_record/fixtures'
 require 'active_support/binding_of_caller'
@@ -15,7 +15,7 @@ QUOTED_TYPE = ActiveRecord::Base.connection.quote_column_name('type') unless Obj
 class Test::Unit::TestCase #:nodoc:
   self.fixture_path = File.dirname(__FILE__) + "/fixtures/"
   self.use_instantiated_fixtures = false
-  self.use_transactional_fixtures = (ENV['AR_NO_TX_FIXTURES'] != "yes")
+  self.use_transactional_fixtures = true #(ENV['AR_NO_TX_FIXTURES'] != "yes")
 
   def create_fixtures(*table_names, &block)
     Fixtures.create_fixtures(File.dirname(__FILE__) + "/fixtures/", table_names, {}, &block)
@@ -55,7 +55,8 @@ protected
   
   def testing_with(&block)
     classes.keys.each do |@key_test|
-      @klass, @primary_keys = classes[@key_test][:class], classes[@key_test][:primary_keys]
+      @klass_info = classes[@key_test]
+      @klass, @primary_keys = @klass_info[:class], @klass_info[:primary_keys]
       @first = @klass.find_first
       yield
     end

data/test/clone_test.rb

@@ -0,0 +1,35 @@
+require 'abstract_unit'
+require 'fixtures/reference_type'
+require 'fixtures/reference_code'
+
+class CloneTest < Test::Unit::TestCase
+  fixtures :reference_types, :reference_codes
+
+  CLASSES = {
+    :single => {
+      :class => ReferenceType,
+      :primary_keys => [:reference_type_id],
+    },
+    :dual   => { 
+      :class => ReferenceCode,
+      :primary_keys => [:reference_type_id, :reference_code],
+    },
+  }
+  
+  def setup
+    super
+    self.class.classes = CLASSES
+  end
+  
+  def test_truth
+    testing_with do
+      clone = @first.clone
+      assert_equal @first.attributes.block(@klass.primary_key), clone.attributes
+      if composite?
+        @klass.primary_key.each {|key| assert_nil clone[key], "Primary key '#{key}' should be nil"} 
+      else
+        assert_nil clone[@klass.primary_key], "Sole primary key should be nil"
+      end
+    end
+  end
+end

data/test/composite_arrays_test.rb

@@ -0,0 +1,46 @@
+require 'abstract_unit'
+require 'fixtures/reference_type'
+require 'fixtures/reference_code'
+
+class CompositeArraysTest < Test::Unit::TestCase
+
+  def test_new_primary_keys
+    keys = CompositePrimaryKeys::CompositeKeys.new
+    assert_not_nil keys
+    assert_equal '', keys.to_s
+    assert_equal '', "#{keys}"
+  end
+
+  def test_initialize_primary_keys
+    keys = CompositePrimaryKeys::CompositeKeys.new([1,2,3])
+    assert_not_nil keys
+    assert_equal '1,2,3', keys.to_s
+    assert_equal '1,2,3', "#{keys}"
+  end
+  
+  def test_to_composite_keys
+    keys = [1,2,3].to_composite_keys
+    assert_equal CompositePrimaryKeys::CompositeKeys, keys.class
+    assert_equal '1,2,3', keys.to_s
+  end
+
+  def test_new_ids
+    keys = CompositePrimaryKeys::CompositeIds.new
+    assert_not_nil keys
+    assert_equal '', keys.to_s
+    assert_equal '', "#{keys}"
+  end
+
+  def test_initialize_ids
+    keys = CompositePrimaryKeys::CompositeIds.new([1,2,3])
+    assert_not_nil keys
+    assert_equal '1,2,3', keys.to_s
+    assert_equal '1,2,3', "#{keys}"
+  end
+  
+  def test_to_composite_ids
+    keys = [1,2,3].to_composite_ids
+    assert_equal CompositePrimaryKeys::CompositeIds, keys.class
+    assert_equal '1,2,3', keys.to_s
+  end
+end

data/test/delete_test.rb

@@ -0,0 +1,67 @@
+require 'abstract_unit'
+require 'fixtures/reference_type'
+require 'fixtures/reference_code'
+
+class DeleteTest < Test::Unit::TestCase
+  fixtures :reference_types, :reference_codes
+
+  CLASSES = {
+    :single => {
+      :class => ReferenceType,
+      :primary_keys => [:reference_type_id],
+    },
+    :dual   => { 
+      :class => ReferenceCode,
+      :primary_keys => [:reference_type_id, :reference_code],
+    },
+  }
+  
+  def setup
+    super
+    self.class.classes = CLASSES
+  end
+  
+  def test_destroy_one
+    testing_with do
+      #assert @first.destroy
+      assert true
+    end
+  end
+  
+  def test_destroy_one_via_class
+    testing_with do
+      assert @klass.destroy(*@first.id)
+    end
+  end
+  
+  def test_destroy_one_alone_via_class
+    testing_with do
+      assert @klass.destroy(@first.id)
+    end
+  end
+  
+  def test_delete_one
+    testing_with do
+      assert @klass.delete(*@first.id) if composite?
+    end
+  end
+  
+  def test_delete_one_alone
+    testing_with do
+      assert @klass.delete(@first.id)
+    end
+  end
+  
+  def test_delete_many
+    testing_with do
+      to_delete = @klass.find(:all)[0..1]
+      assert_equal 2, to_delete.length
+    end
+  end
+  
+  def test_delete_all
+    testing_with do
+      @klass.delete_all
+    end
+  end
+end

data/test/dummy_test.rb

@@ -3,8 +3,26 @@ require 'fixtures/reference_type'
 require 'fixtures/reference_code'
 
 class DummyTest < Test::Unit::TestCase
+  fixtures :reference_types, :reference_codes
 
+  CLASSES = {
+    :single => {
+      :class => ReferenceType,
+      :primary_keys => [:reference_type_id],
+    },
+    :dual   => { 
+      :class => ReferenceCode,
+      :primary_keys => [:reference_type_id, :reference_code],
+    },
+  }
+  
+  def setup
+    self.class.classes = CLASSES
+  end
+  
   def test_truth
-    assert true
+    testing_with do
+      assert true
+    end
   end
 end

data/test/find_test.rb

@@ -6,7 +6,7 @@ require 'fixtures/reference_code'
 class FindTest < Test::Unit::TestCase
   fixtures :reference_types, :reference_codes
   
-  @@classes = {
+  CLASSES = {
     :single => {
       :class => ReferenceType,
       :primary_keys => [:reference_type_id],
@@ -14,9 +14,14 @@ class FindTest < Test::Unit::TestCase
     :dual   => { 
       :class => ReferenceCode,
       :primary_keys => [:reference_type_id, :reference_code],
-    }
+    },
   }
   
+  def setup
+    super
+    self.class.classes = CLASSES
+  end
+  
   def test_find_first
     testing_with do
       obj = @klass.find_first
@@ -25,18 +30,11 @@ class FindTest < Test::Unit::TestCase
     end
   end
   
-  def test_ids
-    testing_with do
-      assert_equal @first.id, @first.ids if composite?
-    end
-  end
-  
   def test_find
     testing_with do
       found = @klass.find(*first_id) # e.g. find(1,1) or find 1,1
       assert found
       assert_equal @klass, found.class
-      #breakpoint
       assert_equal found, @klass.find(found.id)
       assert_equal found, @klass.find(found.to_param)
     end

data/test/hash_tricks.rb

@@ -0,0 +1,34 @@
+# From:
+# http://www.bigbold.com/snippets/posts/show/2178
+# http://blog.caboo.se/articles/2006/06/11/stupid-hash-tricks
+# 
+# An example utilisation of these methods in a controller is:
+# def some_action
+#    # some script kiddie also passed in :bee, which we don't want tampered with _here_.
+#    @model = Model.create(params.pass(:foo, :bar))
+#  end
+class Hash
+
+  # lets through the keys in the argument
+  # >> {:one => 1, :two => 2, :three => 3}.pass(:one)
+  # => {:one=>1}
+  def pass(*keys)
+    keys = keys.first if keys.first.is_a?(Array)
+    tmp = self.clone
+    tmp.delete_if {|k,v| ! keys.include?(k.to_sym) }
+    tmp.delete_if {|k,v| ! keys.include?(k.to_s) }
+    tmp
+  end
+
+  # blocks the keys in the arguments
+  # >> {:one => 1, :two => 2, :three => 3}.block(:one)
+  # => {:two=>2, :three=>3}
+  def block(*keys)
+    keys = keys.first if keys.first.is_a?(Array)
+    tmp = self.clone
+    tmp.delete_if {|k,v| keys.include?(k.to_sym) }
+    tmp.delete_if {|k,v| keys.include?(k.to_s) }
+    tmp
+  end
+
+end

data/test/ids_test.rb

@@ -0,0 +1,59 @@
+require 'abstract_unit'
+require 'fixtures/reference_type'
+require 'fixtures/reference_code'
+
+class IdsTest < Test::Unit::TestCase
+  fixtures :reference_types, :reference_codes
+  
+  CLASSES = {
+    :single => {
+      :class => ReferenceType,
+      :primary_keys => [:reference_type_id],
+    },
+    :dual   => { 
+      :class => ReferenceCode,
+      :primary_keys => [:reference_type_id, :reference_code],
+    },
+  }
+  
+  def setup
+    super
+    self.class.classes = CLASSES
+  end
+  
+  def test_id
+    testing_with do
+      assert_equal @first.id, @first.ids if composite?
+    end
+  end
+  
+  def test_id_to_s
+    testing_with do
+      assert_equal first_id_str, @first.id.to_s
+      assert_equal first_id_str, "#{@first.id}"
+    end
+  end
+  
+  def test_ids_to_s
+    testing_with do
+      to_test = @klass.find(:all)[0..1].map(&:id)
+      assert_equal '(1,1),(1,2)', @klass.ids_to_s(to_test) if @key_test == :dual
+      assert_equal '1,1;1,2', @klass.ids_to_s(to_test, ',', ';', '', '') if @key_test == :dual
+    end
+  end
+  
+  def test_primary_keys
+    testing_with do
+      if composite?
+        assert_not_nil @klass.primary_keys
+        assert_equal @primary_keys, @klass.primary_keys
+        assert_equal @klass.primary_keys, @klass.primary_key
+      else
+        assert_not_nil @klass.primary_key
+        assert_equal @primary_keys, [@klass.primary_key.to_sym]
+      end
+      assert_equal @primary_keys.join(','), @klass.primary_key.to_s
+      # Need a :primary_keys should be Array with to_s overridden
+    end
+  end
+end

data/test/miscellaneous_test.rb

@@ -3,6 +3,23 @@ require 'fixtures/reference_type'
 require 'fixtures/reference_code'
 
 class MiscellaneousTest < Test::Unit::TestCase
+  fixtures :reference_types, :reference_codes
+  
+  CLASSES = {
+    :single => {
+      :class => ReferenceType,
+      :primary_keys => [:reference_type_id],
+    },
+    :dual   => { 
+      :class => ReferenceCode,
+      :primary_keys => [:reference_type_id, :reference_code],
+    },
+  }
+  
+  def setup
+    super
+    self.class.classes = CLASSES
+  end
 
   def test_composite_class
     testing_with do
@@ -15,19 +32,4 @@ class MiscellaneousTest < Test::Unit::TestCase
       assert_equal composite?, @first.composite?
     end
   end
-  
-  def test_primary_keys
-    testing_with do
-      if composite?
-        assert_not_nil @klass.primary_keys
-        assert_equal @primary_keys, @klass.primary_keys
-        assert_equal @klass.primary_keys, @klass.primary_key
-      else
-        assert_not_nil @klass.primary_key
-        assert_equal @primary_keys, [@klass.primary_key.to_sym]
-      end
-      assert_equal @primary_keys.join(','), @klass.primary_key.to_s
-      # Need a :primary_keys should be Array with to_s overridden
-    end
-  end
 end

data/test/pagination_test.rb

@@ -4,27 +4,32 @@ require 'fixtures/reference_code'
 require 'action_controller/pagination'
 
 class PaginationTest < Test::Unit::TestCase
+  fixtures :reference_types, :reference_codes
   include ActionController::Pagination
   DEFAULT_PAGE_SIZE = 2
-  
-  @@classes = {
+   
+  CLASSES = {
     :single => {
       :class => ReferenceType,
       :primary_keys => [:reference_type_id],
+      :table => :reference_types,
     },
     :dual   => { 
       :class => ReferenceCode,
       :primary_keys => [:reference_type_id, :reference_code],
-    }
+      :table => :reference_codes,
+    },
   }
   
   def setup
+    super
+    self.class.classes = CLASSES
     @params = {}
   end
 
   def test_paginate_all
     testing_with do
-      @object_pages, @objects = paginate :reference_codes, :per_page => DEFAULT_PAGE_SIZE
+      @object_pages, @objects = paginate @klass_info[:table], :per_page => DEFAULT_PAGE_SIZE
       assert_equal 2, @objects.length, "Each page should have #{DEFAULT_PAGE_SIZE} items"
     end
   end

data/test/update_test.rb

@@ -0,0 +1,41 @@
+require 'abstract_unit'
+require 'fixtures/reference_type'
+require 'fixtures/reference_code'
+
+class UpdateTest < Test::Unit::TestCase
+  fixtures :reference_types, :reference_codes
+  
+  CLASSES = {
+    :single => {
+      :class => ReferenceType,
+      :primary_keys => [:reference_type_id],
+      :update => { :description => 'RT Desc' },
+    },
+    :dual   => { 
+      :class => ReferenceCode,
+      :primary_keys => [:reference_type_id, :reference_code],
+      :update => { :description => 'RT Desc' },
+    },
+  }
+  
+  def setup
+    super
+    self.class.classes = CLASSES
+  end
+  
+  def test_setup
+    testing_with do
+      assert_not_nil @klass_info[:update]
+    end
+  end
+  
+  def test_update_attributes
+    testing_with do
+      assert @first.update_attributes(@klass_info[:update])
+      assert @first.reload
+      @klass_info[:update].each_pair do |attr_name, new_value|
+        assert_equal new_value, @first[attr_name], "Attribute #{attr_name} is incorrect"
+      end
+    end
+  end
+end

metadata

@@ -3,14 +3,14 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: composite_primary_keys
 version: !ruby/object:Gem::Version 
-  version: 0.1.4
-date: 2006-07-22 00:00:00 +02:00
+  version: 0.3.1
+date: 2006-07-23 00:00:00 +02:00
 summary: Support for composite primary keys in ActiveRecords
 require_paths: 
 - lib
 email: drnicwilliams@gmail.com
-homepage: http://composite_primary_keys.rubyforge.org
-rubyforge_project: composite_primary_keys
+homepage: http://compositekeys.rubyforge.org
+rubyforge_project: compositekeys
 description: ActiveRecords only support a single primary key, preventing their use on legacy databases where tables have primary keys over 2+ columns. This solution allows an ActiveRecord to be extended to support multiple keys using the class method set_primary_keys.
 autorequire: composite_primary_keys
 default_executable: 
@@ -34,18 +34,23 @@ files:
 - CHANGELOG
 - lib/composite_primary_keys
 - lib/composite_primary_keys.rb
+- lib/composite_primary_keys/fixtures.rb
+- lib/composite_primary_keys/composite_arrays.rb
 - lib/composite_primary_keys/version.rb
 - lib/composite_primary_keys/base.rb
-- lib/composite_primary_keys/fixtures.rb
-- lib/composite_primary_keys/primary_keys.rb
 - test/connections
-- test/abstract_unit.rb
-- test/dummy_test.rb
 - test/fixtures
+- test/composite_arrays_test.rb
+- test/hash_tricks.rb
+- test/delete_test.rb
+- test/ids_test.rb
 - test/find_test.rb
-- test/pagination_test.rb
+- test/update_test.rb
+- test/abstract_unit.rb
 - test/miscellaneous_test.rb
-- test/primary_keys_test.rb
+- test/pagination_test.rb
+- test/dummy_test.rb
+- test/clone_test.rb
 - test/connections/native_mysql
 - test/connections/native_mysql/connection.rb
 - test/fixtures/reference_type.rb

data/lib/composite_primary_keys/primary_keys.rb

@@ -1,10 +0,0 @@
-module CompositePrimaryKeys
-  ID_SEP = ','
-  
-  class PrimaryKeys < Array
-
-    def to_s
-      join(ID_SEP)
-    end
-  end
-end

data/test/primary_keys_test.rb

@@ -1,20 +0,0 @@
-require 'abstract_unit'
-require 'fixtures/reference_type'
-require 'fixtures/reference_code'
-
-class PrimaryKeyTest < Test::Unit::TestCase
-
-  def test_new
-    keys = CompositePrimaryKeys::PrimaryKeys.new
-    assert_not_nil keys
-    assert_equal '', keys.to_s
-    assert_equal '', "#{keys}"
-  end
-
-  def test_initialize
-    keys = CompositePrimaryKeys::PrimaryKeys.new([1,2,3])
-    assert_not_nil keys
-    assert_equal '1,2,3', keys.to_s
-    assert_equal '1,2,3', "#{keys}"
-  end
-end