composite_primary_keys 2.3.5.1 → 3.0.0.b2

data/History.txt

@@ -1,3 +1,29 @@
+== 3.0.1.b 2010-12-06
+
+* Port to Rails 3.0 and Ruby 1.9.2
+
+* Backwards compatability issues
+  + You can no longer define a composite primary key with a single field.  If you
+    try, your model will just default to a standard active record model.  Removing
+    this corner case simplified the code.
+  + Removed CompositePrimaryKeys::CompositeKeys.  This was done so that the #to_s
+    method on composite ids, such as [1,2], returns "[1, 2]".  This in turns
+    reduces the amount of core Rails code that needs to be overridden.
+  + Setting attribute values by string is no longer supported. For example, this
+    no longer works:
+      my_record[[:main_id, :secondary_id]] = '1,2'
+    Instead, do  this:
+      my_record[[:main_id, :secondary_id]] = [1,2]
+    Once again, this was done to reduce the amount of overridden Rails code
+  + At the moment, complex finds with nested arrays do not work.  For example
+    find([[1,2], [3,4]))
+  + Count methods no longer work.  For example, Tariff.count(:include => :product_tariffs)
+    in the TestAssociations#test_count test returns an error.  This is because Rails 3.0
+    uses Arel to perform such calculations, and its not obvious (at least to me) how to
+    hook into this new mechanism to support tables with composite keys.
+  + The TestPolymorphic#test_polymorphic_has_many_through is currently failing, but this
+    looks like an ActiveRecord 3.0 bug to me.
+
 == 2.3.5.1 2010-02-13
 
 * Resolved "warning: already initialized constant HasManyThroughCantAssociateThroughHasManyReflection" [Titi Ala'ilima]

data/README.txt

@@ -36,6 +36,6 @@ http://groups.google.com/compositekeys
 
 == Author
 
-Written by Dr Nic Williams, drnicwilliams@gmail
+Written by Dr Nic Williams, drnicwilliams@gmail.
 Contributions by many!
 

data/Rakefile

@@ -5,61 +5,51 @@ require 'rake/testtask'
 require 'rake/rdoctask'
 require 'rake/packagetask'
 require 'rake/gempackagetask'
-require 'rake/contrib/rubyforgepublisher'
-require 'fileutils'
-require 'hoe'
-include FileUtils
-require File.join(File.dirname(__FILE__), 'lib', 'composite_primary_keys', 'version')
 
-AUTHOR = "Dr Nic Williams"
-EMAIL = "drnicwilliams@gmail.com"
-DESCRIPTION = "Composite key support for ActiveRecords"
-GEM_NAME = "composite_primary_keys" # what ppl will type to install your gem
-if File.exists?("~/.rubyforge/user-config.yml")
-  # TODO this should prob go in a local/ file
-  config = YAML.load(File.read(File.expand_path("~/.rubyforge/user-config.yml")))
-  RUBYFORGE_USERNAME = config["username"]
-end
-RUBYFORGE_PROJECT = "compositekeys"
-HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+# Set global variable so other tasks can access them
+PROJECT_ROOT = File.expand_path(".")
+GEM_NAME = 'composite_primary_keys'
 
-REV = nil #File.read(".svn/entries")[/committed-rev="(\d+)"/, 1] rescue nil
-VERS = ENV['VERSION'] || (CompositePrimaryKeys::VERSION::STRING + (REV ? ".#{REV}" : ""))
-CLEAN.include ['**/.*.sw?', '*.gem', '.config','debug.log','*.db','logfile','log/**/*','**/.DS_Store', '.project']
-RDOC_OPTS = ['--quiet', '--title', "newgem documentation",
-    "--opname", "index.html",
-    "--line-numbers",
-    "--main", "README",
-    "--inline-source"]
+# Read the current version
+require File.join(File.dirname(__FILE__), 'lib', 'composite_primary_keys', 'version')
 
-class Hoe
-  def extra_deps
-    @extra_deps.reject { |x| Array(x).first == 'hoe' }
-  end
+# Setup Gem Specs
+spec = Gem::Specification.new do |s|
+  s.name        = GEM_NAME
+  s.version     = CompositePrimaryKeys::VERSION::STRING
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Dr Nic Williams", "Charlie Savage"]
+  s.email       = ["drnicwilliams@gmail.com"]
+  s.homepage    = "http://github.com/cfis/composite_primary_keys"
+  s.summary     = "Composite key support for ActiveRecord"
+  s.rubyforge_project = 'compositekeys'
+  s.description = "Composite key support for ActiveRecord 3"
+  s.files        = FileList['Rakefile',
+                            '*.txt',
+                            '*.rb',
+                            'lib/**/*',
+                            'local/**/*',
+                            'scripts/**/*',
+                            'tasks/**/*',
+                            'test/**/*'].to_a
+  s.require_path = 'lib'
+  s.test_files = Dir.glob("test/**")
+
+  s.date = Time.new
+  s.has_rdoc = true
+
+  # Dependencies
+  s.required_ruby_version = '>= 1.8.7'
+  s.add_dependency('activerecord', '>= 3.0.1')
+  s.add_development_dependency "rspec"
 end
 
-# Generate all the Rake tasks
-# Run 'rake -T' to see list of generated tasks (from gem root directory)
-hoe = Hoe.new(GEM_NAME, VERS) do |p|
-  p.author = AUTHOR
-  p.description = DESCRIPTION
-  p.email = EMAIL
-  p.summary = DESCRIPTION
-  p.url = HOMEPATH
-  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
-  p.test_globs = ["test/**/test*.rb"]
-  p.clean_globs |= CLEAN  #An array of file patterns to delete on clean.
-
-  # == Optional
-  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
-  p.extra_deps = [['activerecord', '>= 2.3.5']]  #An array of rubygem dependencies.
-  #p.spec_extras    - A hash of extra values to set in the gemspec.
+# Rake task to build the default package
+Rake::GemPackageTask.new(spec) do |pkg|
+  pkg.need_tar = true
 end
 
-CHANGES = hoe.paragraphs_of('History.txt', 0..1).join("\n\n")
-PATH    = RUBYFORGE_PROJECT
-hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
-
-PROJECT_ROOT = File.expand_path(".")
-
-require 'loader'
+# Load task files
+Dir.glob('tasks/**/*.rake').each do |rake_file|
+  load File.join(File.dirname(__FILE__), rake_file)
+end

data/lib/composite_primary_keys.rb

@@ -29,27 +29,39 @@ unless defined?(ActiveRecord)
     require 'active_record'  
   rescue LoadError
     require 'rubygems'
-    require_gem 'activerecord'
+    gem 'active_record'
   end
 end
 
 require 'active_record/associations.rb'
+require 'active_record/associations/association_proxy.rb'
+require 'active_record/associations/association_collection'
+require 'active_record/associations/association_proxy'
+require 'active_record/associations/belongs_to_association'
+require 'active_record/associations/belongs_to_polymorphic_association'
+require 'active_record/associations/has_and_belongs_to_many_association'
+require 'active_record/associations/has_many_association'
+require 'active_record/associations/has_one_association'
+require 'active_record/associations/has_one_through_association'
+require 'active_record/associations/through_association_scope'
 
 require 'composite_primary_keys/fixtures'
 require 'composite_primary_keys/composite_arrays'
 require 'composite_primary_keys/associations'
+require 'composite_primary_keys/associations/association_proxy'
+require 'composite_primary_keys/associations/has_one_association'
+require 'composite_primary_keys/associations/has_many_association'
+require 'composite_primary_keys/associations/has_and_belongs_to_many_association'
+require 'composite_primary_keys/associations/through_association_scope'
 require 'composite_primary_keys/association_preload'
 require 'composite_primary_keys/reflection'
+require 'composite_primary_keys/relation'
+require 'composite_primary_keys/read'
+require 'composite_primary_keys/finder_methods'
 require 'composite_primary_keys/base'
 require 'composite_primary_keys/calculations'
-require 'composite_primary_keys/migration'
-require 'composite_primary_keys/attribute_methods'
 require 'composite_primary_keys/validations/uniqueness'
 
-ActiveRecord::Base.class_eval do
-  include CompositePrimaryKeys::ActiveRecord::Base
-end
-
 Dir[File.dirname(__FILE__) + '/composite_primary_keys/connection_adapters/*.rb'].each do |adapter|
   begin
     require adapter.gsub('.rb','')

data/lib/composite_primary_keys/association_preload.rb

@@ -10,101 +10,60 @@ module CompositePrimaryKeys
       module ClassMethods
         def preload_has_and_belongs_to_many_association(records, reflection, preload_options={})
           table_name = reflection.klass.quoted_table_name
-          id_to_record_map, ids = construct_id_map_for_composite(records)
+          id_to_record_map, ids = construct_id_map(records)
           records.each {|record| record.send(reflection.name).loaded}
           options = reflection.options
 
           if composite?
-            primary_key = reflection.primary_key_name.to_s.split(CompositePrimaryKeys::ID_SEP)
             where = (primary_key * ids.size).in_groups_of(primary_key.size).map do |keys|
               "(" + keys.map{|key| "t0.#{connection.quote_column_name(key)} = ?"}.join(" AND ") + ")"
             end.join(" OR ")
 
             conditions = [where, ids].flatten
             joins = "INNER JOIN #{connection.quote_table_name options[:join_table]} t0 ON #{full_composite_join_clause(reflection, reflection.klass.table_name, reflection.klass.primary_key, 't0', reflection.association_foreign_key)}"
-            parent_primary_keys = reflection.primary_key_name.to_s.split(CompositePrimaryKeys::ID_SEP).map{|k| "t0.#{connection.quote_column_name(k)}"}
-            parent_record_id = connection.concat(*parent_primary_keys.zip(["','"] * (parent_primary_keys.size - 1)).flatten.compact)
+            parent_primary_keys = reflection.cpk_primary_key.map{|k| "t0.#{connection.quote_column_name(k)}"}
+            concat_arr = parent_primary_keys.zip(["'#{CompositePrimaryKeys::ID_SEP}'"] * (parent_primary_keys.size - 1)).flatten.compact
+            parent_record_id = connection.concat(*concat_arr)
           else
-            conditions = ["t0.#{connection.quote_column_name(reflection.primary_key_name)}  IN (?)", ids]
-            joins = "INNER JOIN #{connection.quote_table_name options[:join_table]} t0 ON #{reflection.klass.quoted_table_name}.#{connection.quote_column_name(reflection.klass.primary_key)} = t0.#{connection.quote_column_name(reflection.association_foreign_key)})"
+            conditions = "t0.#{reflection.primary_key_name} #{in_or_equals_for_ids(ids)}"
+            conditions << append_conditions(reflection, preload_options)
+            conditions = [conditions, ids]
+            joins = "INNER JOIN #{connection.quote_table_name options[:join_table]} t0 ON #{reflection.klass.quoted_table_name}.#{reflection.klass.primary_key} = t0.#{reflection.association_foreign_key}"
             parent_record_id = reflection.primary_key_name
-          end
-
-          conditions.first << append_conditions(reflection, preload_options)
-
-          associated_records = reflection.klass.find(:all,
-            :conditions => conditions,
-            :include    => options[:include],
-            :joins      => joins,
-            :select     => "#{options[:select] || table_name+'.*'}, #{parent_record_id} as parent_record_id_",
-            :order      => options[:order])
-
-          set_association_collection_records(id_to_record_map, reflection.name, associated_records, 'parent_record_id_')
-        end
+         end
 
-        def preload_has_many_association(records, reflection, preload_options={})
-          id_to_record_map, ids = construct_id_map_for_composite(records)
-          records.each {|record| record.send(reflection.name).loaded}
-          options = reflection.options
+        associated_records = reflection.klass.unscoped.where(conditions).
+            includes(options[:include]).
+            joins(joins).
+            select("#{options[:select] || table_name+'.*'}, #{parent_record_id} as the_parent_record_id").
+            order(options[:order]).to_a
 
-          if options[:through]
-            through_records = preload_through_records(records, reflection, options[:through])
-            through_reflection = reflections[options[:through]]
-            through_primary_key = through_reflection.primary_key_name
-
-            unless through_records.empty?
-              source = reflection.source_reflection.name
-              #add conditions from reflection!
-              through_records.first.class.preload_associations(through_records, source, reflection.options)
-              through_records.each do |through_record|
-                key = through_primary_key.to_s.split(CompositePrimaryKeys::ID_SEP).map{|k| through_record.send(k)}.join(CompositePrimaryKeys::ID_SEP)
-                add_preloaded_records_to_collection(id_to_record_map[key], reflection.name, through_record.send(source))
-              end
-            end
-          else
-            associated_records = find_associated_records(ids, reflection, preload_options)
-            set_association_collection_records(id_to_record_map, reflection.name, associated_records, reflection.primary_key_name.to_s.split(CompositePrimaryKeys::ID_SEP))
-          end
-        end
-
-        def preload_through_records(records, reflection, through_association)
-          through_reflection = reflections[through_association]
-          through_primary_key = through_reflection.primary_key_name
-
-          if reflection.options[:source_type]
-            interface = reflection.source_reflection.options[:foreign_type]
-            preload_options = {:conditions => ["#{connection.quote_column_name interface} = ?", reflection.options[:source_type]]}
-
-            records.compact!
-            records.first.class.preload_associations(records, through_association, preload_options)
-
-            # Dont cache the association - we would only be caching a subset
-            through_records = []
-            records.each do |record|
-              proxy = record.send(through_association)
-
-              if proxy.respond_to?(:target)
-                through_records << proxy.target
-                proxy.reset
-              else # this is a has_one :through reflection
-                through_records << proxy if proxy
-              end
-            end
-            through_records.flatten!
-          else
-            records.first.class.preload_associations(records, through_association)
-            through_records = records.map {|record| record.send(through_association)}.flatten
-          end
-
-          through_records.compact!
-          through_records
+          set_association_collection_records(id_to_record_map, reflection.name, associated_records, 'the_parent_record_id')
         end
 
         def preload_belongs_to_association(records, reflection, preload_options={})
+          return if records.first.send("loaded_#{reflection.name}?")
           options = reflection.options
-          primary_key_name = reflection.primary_key_name.to_s.split(CompositePrimaryKeys::ID_SEP)
-
+          
+          ids = Array.new
+          
           if options[:polymorphic]
+            # CPK
+            #polymorph_type = options[:foreign_type]
+            #klasses_and_ids = {}
+
+            # Construct a mapping from klass to a list of ids to load and a mapping of those ids back to their parent_records
+            #records.each do |record|
+            #  if klass = record.send(polymorph_type)
+            #    klass_id = record.send(primary_key_name)
+            #    if klass_id
+            #      id_map = klasses_and_ids[klass] ||= {}
+            #      id_list_for_klass_id = (id_map[klass_id.to_s] ||= [])
+            #      id_list_for_klass_id << record
+            #    end
+            #  end
+            #end
+            #klasses_and_ids = klasses_and_ids.to_a
             raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
           else
             # I need to keep the original ids for each record (as opposed to the stringified) so
@@ -114,128 +73,74 @@ module CompositePrimaryKeys
             id_map = {}
 
             records.each do |record|
-              key = primary_key_name.map{|k| record.send(k)}
-              key_as_string = key.join(CompositePrimaryKeys::ID_SEP)
+              keys = record[reflection.cpk_primary_key]
+              ids << keys
 
-              if key_as_string
-                mapped_records = (id_map[key_as_string] ||= {:id => key, :records => []})
-                mapped_records[:records] << record
-              end
+              mapped_records = (id_map[keys.to_s] ||= [])
+              mapped_records << record
             end
 
-
             klasses_and_ids = [[reflection.klass.name, id_map]]
           end
 
           klasses_and_ids.each do |klass_and_id|
             klass_name, id_map = *klass_and_id
+            next if id_map.empty?
             klass = klass_name.constantize
-            table_name = klass.quoted_table_name
-            connection = reflection.active_record.connection
 
-            if composite?
-              primary_key = klass.primary_key.to_s.split(CompositePrimaryKeys::ID_SEP)
-              ids = id_map.keys.uniq.map {|id| id_map[id][:id]}
+            table_name = klass.quoted_table_name
+            primary_key = [reflection.options[:primary_key] || klass.primary_key].flatten
 
-              where = (primary_key * ids.size).in_groups_of(primary_key.size).map do |keys|
-                 "(" + keys.map{|key| "#{table_name}.#{connection.quote_column_name(key)} = ?"}.join(" AND ") + ")"
-              end.join(" OR ")
+            # CPK
+            conditions = id_map.map do |key, value|
+              "(" +
+              primary_key.map do |key|
+                "#{table_name}.#{connection.quote_column_name(key)} = ?"
+              end.join(' AND ') + ")"
+            end.join(' OR ')
 
-              conditions = [where, ids].flatten
-            else
-              conditions = ["#{table_name}.#{connection.quote_column_name(primary_key)} IN (?)", id_map.keys.uniq]
-            end
+            conditions << append_conditions(reflection, preload_options)
 
-            conditions.first << append_conditions(reflection, preload_options)
+            conditions = [conditions] + ids.uniq.flatten
 
-            associated_records = klass.find(:all,
-              :conditions => conditions,
-              :include    => options[:include],
-              :select     => options[:select],
-              :joins      => options[:joins],
-              :order      => options[:order])
+            associated_records = klass.unscoped.where(conditions).apply_finder_options(options.slice(:include, :select, :joins, :order)).to_a
 
             set_association_single_records(id_map, reflection.name, associated_records, primary_key)
           end
         end
-
-        def set_association_collection_records(id_to_record_map, reflection_name, associated_records, key)
-          associated_records.each do |associated_record|
-            associated_record_key = associated_record[key]
-            associated_record_key = associated_record_key.is_a?(Array) ? associated_record_key.join(CompositePrimaryKeys::ID_SEP) : associated_record_key.to_s
-            mapped_records = id_to_record_map[associated_record_key]
-            add_preloaded_records_to_collection(mapped_records, reflection_name, associated_record)
-          end
-        end
-
-        def set_association_single_records(id_to_record_map, reflection_name, associated_records, key)
-          seen_keys = {}
-          associated_records.each do |associated_record|
-            associated_record_key = associated_record[key]
-            associated_record_key = associated_record_key.is_a?(Array) ? associated_record_key.join(CompositePrimaryKeys::ID_SEP) : associated_record_key.to_s
-
-            #this is a has_one or belongs_to: there should only be one record.
-            #Unfortunately we can't (in portable way) ask the database for 'all records where foo_id in (x,y,z), but please
-            # only one row per distinct foo_id' so this where we enforce that
-            next if seen_keys[associated_record_key]
-            seen_keys[associated_record_key] = true
-            mapped_records = id_to_record_map[associated_record_key][:records]
-            mapped_records.each do |mapped_record|
-              mapped_record.send("set_#{reflection_name}_target", associated_record)
-            end
-          end
-        end
-
+        
         def find_associated_records(ids, reflection, preload_options)
           options = reflection.options
           table_name = reflection.klass.quoted_table_name
 
           if interface = reflection.options[:as]
-            raise AssociationNotSupported, "Polymorphic joins not supported for composite keys"
+            conditions = "#{reflection.klass.quoted_table_name}.#{connection.quote_column_name "#{interface}_id"} #{in_or_equals_for_ids(ids)} and #{reflection.klass.quoted_table_name}.#{connection.quote_column_name "#{interface}_type"} = '#{self.base_class.sti_name}'"
           else
-            connection = reflection.active_record.connection
-            foreign_key = reflection.primary_key_name
-            conditions = ["#{table_name}.#{connection.quote_column_name(foreign_key)} IN (?)", ids]
-            
-            if composite?
-              foreign_keys = foreign_key.to_s.split(CompositePrimaryKeys::ID_SEP)
-            
-              where = (foreign_keys * ids.size).in_groups_of(foreign_keys.size).map do |keys|
-                "(" + keys.map{|key| "#{table_name}.#{connection.quote_column_name(key)} = ?"}.join(" AND ") + ")"
-              end.join(" OR ")
-
-              conditions = [where, ids].flatten
-            end
+            foreign_key = reflection.cpk_primary_key
+
+            where = (foreign_key * ids.size).in_groups_of(foreign_key.size).map do |keys|
+              "(" + keys.map{|key| "#{reflection.klass.quoted_table_name}.#{connection.quote_column_name(key)} = ?"}.join(" AND ") + ")"
+            end.join(" OR ")
+
+            conditions = [where, ids].flatten
           end
 
-          conditions.first << append_conditions(reflection, preload_options)
+          conditions[0] << append_conditions(reflection, preload_options)
 
-          reflection.klass.find(:all,
-            :select     => (preload_options[:select] || options[:select] || "#{table_name}.*"),
-            :include    => preload_options[:include] || options[:include],
+          find_options = {
+            :select => preload_options[:select] || options[:select] || "#{table_name}.*",
+            :include => preload_options[:include] || options[:include],
+            # CPK
+            # :conditions => [conditions, ids],
             :conditions => conditions,
-            :joins      => options[:joins],
-            :group      => preload_options[:group] || options[:group],
-            :order      => preload_options[:order] || options[:order])
-        end        
-        
-        # Given a collection of ActiveRecord objects, constructs a Hash which maps
-        # the objects' IDs to the relevant objects. Returns a 2-tuple
-        # <tt>(id_to_record_map, ids)</tt> where +id_to_record_map+ is the Hash,
-        # and +ids+ is an Array of record IDs.
-        def construct_id_map_for_composite(records)
-          id_to_record_map = {}
-          ids = []
-          records.each do |record|
-            primary_key ||= record.class.primary_key
-            ids << record.id
-            mapped_records = (id_to_record_map[record.id.to_s] ||= [])
-            mapped_records << record
-          end
-          ids.uniq!
-          return id_to_record_map, ids
+            :joins => options[:joins],
+            :group => preload_options[:group] || options[:group],
+            :order => preload_options[:order] || options[:order]
+          }
+
+          reflection.klass.unscoped.apply_finder_options(find_options).to_a
         end
-        
+
         def full_composite_join_clause(reflection, table1, full_keys1, table2, full_keys2)
           connection = reflection.active_record.connection
           full_keys1 = full_keys1.split(CompositePrimaryKeys::ID_SEP) if full_keys1.is_a?(String)
@@ -250,4 +155,4 @@ module CompositePrimaryKeys
       end
     end
   end
-end
+end