composite_primary_keys 0.7.2 → 0.7.3

data/Rakefile

@@ -17,10 +17,6 @@ RELEASE_NAME  = "REL #{PKG_VERSION}"
 RUBY_FORGE_PROJECT = "compositekeys"
 RUBY_FORGE_USER    = "nicwilliams"
 
-PKG_FILES = FileList[
-    "lib/**/*", "test/**/*", "examples/**/*", "doc/**/*", "scripts/**/*", "website/**/*", "[A-Z]*", "install.rb", "CHANGELOG", "README", "Rakefile"
-].exclude(/\bCVS\b|~$/)
-
 
 desc "Default Task"
 task :default => [ :test_mysql ] # UNTESTED =, :test_sqlite, :test_postgresql ]

data/lib/composite_primary_keys/base.rb

@@ -2,18 +2,18 @@ module CompositePrimaryKeys
   module ActiveRecord #:nodoc:
     class CompositeKeyError < StandardError #:nodoc:
     end
-
+    
     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
         base.send(:include, InstanceMethods)
         base.extend(ClassMethods)
       end
-    
+      
       module ClassMethods
         def set_primary_keys(*keys)
           keys = keys.first if keys.first.is_a?(Array)
@@ -35,7 +35,7 @@ module CompositePrimaryKeys
       module InstanceMethods
         def composite?; self.class.composite?; end
       end
-     
+      
       module CompositeInstanceMethods  
         
         # A model instance's primary keys is always available as model.ids
@@ -43,7 +43,7 @@ module CompositePrimaryKeys
         def id
           attr_names = self.class.primary_keys
           CompositeIds.new(
-            attr_names.map {|attr_name| read_attribute(attr_name)}
+                           attr_names.map {|attr_name| read_attribute(attr_name)}
           )
         end
         alias_method :ids, :id
@@ -53,16 +53,16 @@ module CompositePrimaryKeys
         end
         
         def id_before_type_cast #:nodoc:
-            raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::NOT_IMPLEMENTED_YET
+          raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::NOT_IMPLEMENTED_YET
         end
-  
+        
         def quoted_id #:nodoc:
           [self.class.primary_keys, ids].
-            transpose.
-            map {|attr_name,id| quote(id, column_for_attribute(attr_name))}.
-            to_composite_ids
+          transpose.
+          map {|attr_name,id| quote(id, column_for_attribute(attr_name))}.
+          to_composite_ids
         end
-  
+        
         # Sets the primary ID.
         def id=(ids)
           ids = ids.split(ID_SEP) if ids.is_a?(String)
@@ -73,7 +73,7 @@ module CompositePrimaryKeys
           [primary_keys, ids].transpose.each {|key, an_id| write_attribute(key , an_id)}
           id
         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.
@@ -86,7 +86,7 @@ module CompositePrimaryKeys
             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
@@ -103,8 +103,8 @@ module CompositePrimaryKeys
         def method_missing(method_id, *args, &block)
           method_name = method_id.to_s
           if @attributes.include?(method_name) or
-              (md = /\?$/.match(method_name) and
-              @attributes.include?(method_name = md.pre_match))
+           (md = /\?$/.match(method_name) and
+            @attributes.include?(method_name = md.pre_match))
             define_read_methods if self.class.read_methods.empty? && self.class.generate_read_methods
             md ? query_attribute(method_name) : read_attribute(method_name)
           elsif self.class.primary_keys.include? method_name.to_sym
@@ -113,10 +113,10 @@ module CompositePrimaryKeys
             attribute_name, method_type = md.pre_match, md.to_s
             if @attributes.include?(attribute_name)
               case method_type
-                when '='
-                  write_attribute(attribute_name, args.first)
-                when '_before_type_cast'
-                  read_attribute_before_type_cast(attribute_name)
+              when '='
+                write_attribute(attribute_name, args.first)
+              when '_before_type_cast'
+                read_attribute_before_type_cast(attribute_name)
               end
             else
               super
@@ -126,15 +126,15 @@ module CompositePrimaryKeys
           end
         end
         
-      private
+        private
         # The xx_without_callbacks methods are overwritten as that is the end of the alias chain
-      
+        
         # Creates a new record with values matching those of the instance attributes.
         def create_without_callbacks
           unless self.id
             raise CompositeKeyError, "Composite keys do not generated ids from sequences, you must provide id values"
           end
-  
+          
           connection.insert(
             "INSERT INTO #{self.class.table_name} " +
             "(#{quoted_column_names.join(', ')}) " +
@@ -160,97 +160,100 @@ module CompositePrimaryKeys
         # 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_without_callbacks
-          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
+          where_class = [self.class.primary_key, quoted_id].transpose.map do |pair| 
+            "(#{pair[0]} = #{pair[1]})"
+            end.join(" AND ")
+            unless new_record?
+              connection.delete(
+                "DELETE FROM #{self.class.table_name} " +
+                "WHERE #{where_class}",
+                "#{self.class.name} Destroy"
+              )
+            end
+            freeze
           end
-  
-          freeze
+          
         end
-  
-      end
-      
-      module CompositeClassMethods
-        def primary_key; primary_keys; end
-        def primary_key=(keys); primary_keys = keys; end
         
-        def composite?
-          true
-        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(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.
-        # Example:
-        #   Person.exists?(5,7)
-        def exists?(ids)
-          obj = find(ids) rescue false
+        module CompositeClassMethods
+          def primary_key; primary_keys; end
+          def primary_key=(keys); primary_keys = keys; end
+          
+          def composite?
+            true
+          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(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.
+          # Example:
+          #   Person.exists?(5,7)
+          def exists?(ids)
+            obj = find(ids) rescue false
           !obj.nil? and obj.is_a?(self)
-        end
-  
-        # Deletes the record with the given +ids+ without instantiating an object first, e.g. delete(1,2)
-        # 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)
-          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.
-        # Each column that matches to one of the primary keys has its
-        # primary attribute set to true
-        def columns
-          unless @columns
-            @columns = connection.columns(table_name, "#{name} Columns")
-            @columns.each {|column| column.primary = primary_keys.include?(column.name.to_sym)}
+          
+          # Deletes the record with the given +ids+ without instantiating an object first, e.g. delete(1,2)
+          # 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)
+            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
-          @columns
-        end
           
-        ## DEACTIVATED METHODS ##
-        public
-        # Lazy-set the sequence name to the connection's default.  This method
-        # is only ever called once since set_sequence_name overrides it.
+          # Returns an array of column objects for the table associated with this class.
+          # Each column that matches to one of the primary keys has its
+          # primary attribute set to true
+          def columns
+            unless @columns
+              @columns = connection.columns(table_name, "#{name} Columns")
+              @columns.each {|column| column.primary = primary_keys.include?(column.name.to_sym)}
+            end
+            @columns
+          end
+          
+          ## DEACTIVATED METHODS ##
+          public
+          # Lazy-set the sequence name to the connection's default.  This method
+          # is only ever called once since set_sequence_name overrides it.
           def sequence_name #:nodoc:
             raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
           end
-    
+          
           def reset_sequence_name #:nodoc:
             raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
           end
-    
+          
           def set_primary_key(value = nil, &block)
             raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
           end
-       
-        private
+          
+          private
           def find_one(id, options)
             raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
           end
-       
+          
           def find_some(ids, options)
             raise CompositeKeyError, CompositePrimaryKeys::ActiveRecord::Base::INVALID_FOR_COMPOSITE_KEYS
           end
-  
+          
           def find_from_ids(ids, options)
             conditions = " AND (#{sanitize_sql(options[:conditions])})" if options[:conditions]
             # if ids is just a flat list, then its size must = primary_key.length (one id per primary key, in order)
@@ -279,58 +282,58 @@ module CompositePrimaryKeys
             conditions = ids.map do |id_set|
               [primary_keys, id_set].transpose.map do |key, id|
                 "#{table_name}.#{key.to_s}=#{sanitize(id)}"
-              end.join(" AND ")
-            end.join(") OR (")
-            options.update :conditions => "(#{conditions})"
-            
-            result = find_every(options)
-  
-            if result.size == ids.size
-              ids.size == 1 ? result[0] : result
-            else
-              raise RecordNotFound, "Couldn't find all #{name.pluralize} with IDs (#{ids_list})#{conditions}"
+                end.join(" AND ")
+                end.join(") OR (")
+                options.update :conditions => "(#{conditions})"
+                
+                result = find_every(options)
+                
+                if result.size == ids.size
+                  ids.size == 1 ? result[0] : result
+                else
+                  raise RecordNotFound, "Couldn't find all #{name.pluralize} with IDs (#{ids_list})#{conditions}"
+                end
+              end
+              
             end
           end
-
-      end
-    end
-  end
-end
-
-module ActiveRecord
-  ID_SEP = ','
-  ID_SET_SEP = ';'
-
-  class Base
-    # Allows +attr_name+ to be the list of primary_keys, and returns the id
-    # of the object
-    # e.g. @object[@object.class.primary_key] => [1,1]
-    def [](attr_name)
-      if attr_name.is_a?(String) and attr_name != attr_name.split(ID_SEP).first
-        attr_name = attr_name.split(ID_SEP)
-      end
-      attr_name.is_a?(Array) ?
-        attr_name.map {|name| read_attribute(name)} :
-        read_attribute(attr_name)
-    end
-
-    # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+.
-    # (Alias for the protected write_attribute method).
-    def []=(attr_name, value)
-      if attr_name.is_a?(String) and attr_name != attr_name.split(ID_SEP).first
-        attr_name = attr_name.split(ID_SEP)
+        end
       end
-      if attr_name.is_a? Array
-        value = value.split(ID_SEP) if value.is_a? String
-        unless value.length == attr_name.length
-          raise "Number of attr_names and values do not match"
+      
+      module ActiveRecord
+        ID_SEP = ','
+        ID_SET_SEP = ';'
+        
+        class Base
+          # Allows +attr_name+ to be the list of primary_keys, and returns the id
+          # of the object
+          # e.g. @object[@object.class.primary_key] => [1,1]
+          def [](attr_name)
+            if attr_name.is_a?(String) and attr_name != attr_name.split(ID_SEP).first
+              attr_name = attr_name.split(ID_SEP)
+            end
+            attr_name.is_a?(Array) ?
+            attr_name.map {|name| read_attribute(name)} :
+            read_attribute(attr_name)
+          end
+          
+          # Updates the attribute identified by <tt>attr_name</tt> with the specified +value+.
+          # (Alias for the protected write_attribute method).
+          def []=(attr_name, value)
+            if attr_name.is_a?(String) and attr_name != attr_name.split(ID_SEP).first
+              attr_name = attr_name.split(ID_SEP)
+            end
+            if attr_name.is_a? Array
+              value = value.split(ID_SEP) if value.is_a? String
+              unless value.length == attr_name.length
+                raise "Number of attr_names and values do not match"
+              end
+              #breakpoint
+              [attr_name, value].transpose.map {|name,val| write_attribute(name.to_s, val)}
+            else
+              write_attribute(attr_name, value)
+            end
+          end
+          
         end
-        #breakpoint
-        [attr_name, value].transpose.map {|name,val| write_attribute(name.to_s, val)}
-      else
-        write_attribute(attr_name, value)
       end
-    end
-
-  end
-end

data/lib/composite_primary_keys/version.rb

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

data/website/index.html

@@ -33,7 +33,7 @@
     <h1>Composite Primary Keys for Ruby on Rails/ActiveRecords</h1>
     <div id="version" class="clickable" onclick='document.location = "http://rubyforge.org/projects/compositekeys"; return false'>
       Get Version
-      <a href="http://rubyforge.org/projects/compositekeys" class="numbers">0.7.2</a>
+      <a href="http://rubyforge.org/projects/compositekeys" class="numbers">0.7.3</a>
     </div>
     <h2>What</h2>
 
@@ -120,11 +120,11 @@ associations allow for composite foreign keys.</p>
 <span class="keyword">class </span><span class="class">ProductTariff</span> <span class="punct">&lt;</span> <span class="constant">ActiveRecord</span><span class="punct">::</span><span class="constant">Base</span>
   <span class="ident">set_primary_keys</span> <span class="symbol">:product_id</span><span class="punct">,</span> <span class="symbol">:tariff_id</span><span class="punct">,</span> <span class="symbol">:tariff_start_date</span>
   <span class="ident">belongs_to</span> <span class="symbol">:products</span><span class="punct">,</span> <span class="symbol">:foreign_key</span> <span class="punct">=&gt;</span> <span class="symbol">:product_id</span>
-  <span class="ident">belongs_to</span> <span class="symbol">:tariffs</span><span class="punct">,</span>  <span class="symbol">:foreign_keys</span> <span class="punct">=&gt;</span> <span class="punct">[</span><span class="symbol">:tariff_id</span><span class="punct">,</span> <span class="symbol">:tariff_start_date</span><span class="punct">]</span>
+  <span class="ident">belongs_to</span> <span class="symbol">:tariffs</span><span class="punct">,</span>  <span class="symbol">:foreign_key</span> <span class="punct">=&gt;</span> <span class="punct">[</span><span class="symbol">:tariff_id</span><span class="punct">,</span> <span class="symbol">:tariff_start_date</span><span class="punct">]</span>
 <span class="keyword">end</span>
 <span class="keyword">class </span><span class="class">Tariff</span> <span class="punct">&lt;</span> <span class="constant">ActiveRecord</span><span class="punct">::</span><span class="constant">Base</span>
   <span class="ident">set_primary_keys</span> <span class="punct">[</span><span class="symbol">:tariff_id</span><span class="punct">,</span> <span class="symbol">:start_date</span><span class="punct">]</span>
-  <span class="ident">has_many</span> <span class="symbol">:product_tariffs</span><span class="punct">,</span> <span class="symbol">:foreign_keys</span> <span class="punct">=&gt;</span> <span class="punct">[</span><span class="symbol">:tariff_id</span><span class="punct">,</span> <span class="symbol">:tariff_start_date</span><span class="punct">]</span>
+  <span class="ident">has_many</span> <span class="symbol">:product_tariffs</span><span class="punct">,</span> <span class="symbol">:foreign_key</span> <span class="punct">=&gt;</span> <span class="punct">[</span><span class="symbol">:tariff_id</span><span class="punct">,</span> <span class="symbol">:tariff_start_date</span><span class="punct">]</span>
 <span class="keyword">end</span>
 </pre></p>
 
@@ -134,9 +134,9 @@ associations allow for composite foreign keys.</p>
 (called :tariffs) must use a composite foreign key.</p>
 
 
-	<p>The expression can use either the
-:foreign_key or :foreign_keys option to specific the ordered list of table
-columns. If the column names in both tables match, then the :foreign_key(s)
+	<p>The expression must use the :foreign_key option (NOTE, <code>:foreign_keys</code> is not currently supported)
+to specific the ordered list of table
+columns. If the column names in both tables match, then the :foreign_key
 option can be omitted.</p>
 
 
@@ -185,7 +185,7 @@ other stories and things.</p>
 
 	<p>Comments are welcome. Send an email to <a href="mailto:drnicwilliams@gmail.com">Dr Nic Williams</a>.</p>
     <p class="coda">
-      <a href="mailto:drnicwilliams@gmail.com">Dr Nic</a>, 1st September 2006<br>
+      <a href="mailto:drnicwilliams@gmail.com">Dr Nic</a>, 24th October 2006<br>
       Theme extended from <a href="http://rb2js.rubyforge.org/">Paul Battley</a>
     </p>
 </div>

data/website/index.txt

@@ -71,11 +71,11 @@ end
 class ProductTariff < ActiveRecord::Base
   set_primary_keys :product_id, :tariff_id, :tariff_start_date
   belongs_to :products, :foreign_key => :product_id
-  belongs_to :tariffs,  :foreign_keys => [:tariff_id, :tariff_start_date]
+  belongs_to :tariffs,  :foreign_key => [:tariff_id, :tariff_start_date]
 end
 class Tariff < ActiveRecord::Base
   set_primary_keys [:tariff_id, :start_date]
-  has_many :product_tariffs, :foreign_keys => [:tariff_id, :tariff_start_date]
+  has_many :product_tariffs, :foreign_key => [:tariff_id, :tariff_start_date]
 end
 </pre>
 
@@ -83,9 +83,9 @@ The Tariff table has a composite primary key. Hence, the
 <code syntax="ruby">belongs_to</code> association from ProductTariff to Tariff
 (called :tariffs) must use a composite foreign key.
 
-The expression can use either the
-:foreign_key or :foreign_keys option to specific the ordered list of table
-columns. If the column names in both tables match, then the :foreign_key(s)
+The expression must use the :foreign_key option (NOTE, <code>:foreign_keys</code> is not currently supported)
+to specific the ordered list of table
+columns. If the column names in both tables match, then the :foreign_key
 option can be omitted.
 
 Similarly, the <code syntax="ruby">has_many</code> and <code syntax="ruby">has_one</code>

data/website/version-raw.js

@@ -1,3 +1,3 @@
 // Announcement JS file
-var version = "0.7.2";
+var version = "0.7.3";
 MagicAnnouncement.show('compositekeys', version);

data/website/version.js

@@ -1,4 +1,4 @@
 // Version JS file
-var version = "0.7.2";
+var version = "0.7.3";
 
 document.write(" - " + version);

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.8.11
 specification_version: 1
 name: composite_primary_keys
 version: !ruby/object:Gem::Version 
-  version: 0.7.2
-date: 2006-09-27 00:00:00 +02:00
+  version: 0.7.3
+date: 2006-11-09 00:00:00 +01:00
 summary: Support for composite primary keys in ActiveRecords
 require_paths: 
 - lib
@@ -32,16 +32,14 @@ files:
 - install.rb
 - README
 - CHANGELOG
-- lib/composite_primary_keys
 - lib/composite_primary_keys.rb
+- lib/composite_primary_keys
 - 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/reflection.rb
 - lib/composite_primary_keys/associations.rb
-- test/connections
-- test/fixtures
 - test/composite_arrays_test.rb
 - test/hash_tricks.rb
 - test/delete_test.rb
@@ -57,15 +55,12 @@ files:
 - test/attributes_test.rb
 - test/create_test.rb
 - test/santiago_test.rb
-- test/connections/native_mysql
-- test/connections/native_oracle
-- test/connections/native_mysql/connection.rb
-- test/connections/native_oracle/connection.rb
+- test/fixtures
+- test/connections
 - test/fixtures/reference_type.rb
 - test/fixtures/reference_code.rb
 - test/fixtures/reference_types.yml
 - test/fixtures/reference_codes.yml
-- test/fixtures/db_definitions
 - test/fixtures/product.rb
 - test/fixtures/product_tariff.rb
 - test/fixtures/tariff.rb
@@ -82,20 +77,25 @@ files:
 - test/fixtures/articles.yml
 - test/fixtures/users.yml
 - test/fixtures/readings.yml
+- test/fixtures/db_definitions
 - test/fixtures/db_definitions/mysql.drop.sql
 - test/fixtures/db_definitions/mysql.sql
+- test/connections/native_oracle
+- test/connections/native_mysql
+- test/connections/native_oracle/connection.rb
+- test/connections/native_mysql/connection.rb
 - website/index.txt
 - website/template.rhtml
-- website/stylesheets
-- website/javascripts
 - website/index.html
 - website/version.js
 - website/template.js
 - website/version.txt
 - website/version-raw.js
 - website/version-raw.txt
-- website/stylesheets/screen.css
+- website/javascripts
+- website/stylesheets
 - website/javascripts/rounded_corners_lite.inc.js
+- website/stylesheets/screen.css
 - scripts/rubyforge-orig
 - scripts/rubyforge
 - scripts/http-access2-2.0.6.gem