composite_primary_keys 3.1.11 → 4.0.0.beta1

data/History.txt

@@ -1,11 +1,6 @@
-== 3.1.11 2012-05-20
-Fix AssociationReflection#derive_primary_key for belongs_to relationships (Heinrich Lee Yu).
-
-== 3.1.10 2011-07-08
-* Bugfix for belongs_to with includes (John Ash)
-* Improved tests for calling clear on a habtm association, which involved (David Rueck)
-* Fixed bug that resulted in unrelated records being deleted when calling (David Rueck)
-* Output deprecation warnings about extra columns in join table CPK-aware (David Rueck)
+== 4.0.0.beta1 2011-06-09
+* ActiveRecord 3.1 compatibility.  This required a significant rewrite due to
+  all the changes in AR 3.1 versus 3.0.
 
 == 3.1.9 2011-06-04
 * Improve HABTM association tests (David Rueck)
@@ -19,6 +14,7 @@ Fix AssociationReflection#derive_primary_key for belongs_to relationships (Heinr
 * Minor test cleanup (Charlie Savage)
 * Make version requirements more explicit (Charlie Savage)
 * Remove Arel extensions used for calculations (Charlie Savage)
+* Fix test that included wrong error constant
 
 == 3.1.6 2011-04-03
 * Updated belongs_to association to be a bit more flexible with non-CPK (Charlie Savage)
@@ -27,12 +23,14 @@ Fix AssociationReflection#derive_primary_key for belongs_to relationships (Heinr
 * Fix write issue when one of they keys in a composite key is
   called id (Tom Hughes)
 
+
 == 3.1.5 2011-03-24
 * Fix simple calculation methods (Charlie Savage)
 * Fix instantiation of cpk records via associations  (Charlie Savage)
 * Fix Relation#delete (Charlie Savage)
 * Fix Relation#destroy (Charlie Savage)
 
+
 == 3.1.4 2011-03-06
 * Support ActiveRecord 3.0.5 - interpolate_sql was removed and
   replaced by interpolate_and_sanitize_sql (Charlie Savage)

data/lib/composite_primary_keys.rb

@@ -26,50 +26,67 @@ $:.unshift(File.dirname(__FILE__)) unless
 
 unless defined?(ActiveRecord)
   require 'rubygems'
-  gem 'activerecord', '>= 3.0.5', '~> 3.0.0'
+  gem 'activerecord', '=3.1.0.rc1'
   require 'active_record'
 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'
+# AR files we override
+require 'active_record/fixtures'
+require 'active_record/persistence'
+require 'active_record/relation'
+
+require 'active_record/associations/association'
+require 'active_record/associations/association_scope'
 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 'active_record/persistence'
+require 'active_record/associations/join_dependency/join_part'
+require 'active_record/associations/join_dependency/join_association'
+require 'active_record/associations/preloader/association'
+require 'active_record/associations/preloader/belongs_to'
+require 'active_record/associations/preloader/has_and_belongs_to_many'
+
+require 'active_record/attribute_methods/dirty'
+require 'active_record/attribute_methods/read'
+require 'active_record/attribute_methods/write'
+
+require 'active_record/connection_adapters/abstract_adapter'
+require 'active_record/connection_adapters/postgresql_adapter'
+
+require 'active_record/relation/calculations'
+require 'active_record/relation/finder_methods'
 require 'active_record/relation/query_methods'
-require 'active_record/attribute_methods/primary_key'
-require 'active_record/fixtures'
 
+require 'active_record/validations/uniqueness'
+
+
+# CPK files
+require 'composite_primary_keys/base'
 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/composite_predicates'
+require 'composite_primary_keys/fixtures'
 require 'composite_primary_keys/persistence'
-require 'composite_primary_keys/reflection'
 require 'composite_primary_keys/relation'
-require 'composite_primary_keys/read'
-require 'composite_primary_keys/write'
-require 'composite_primary_keys/finder_methods'
-require 'composite_primary_keys/base'
-require 'composite_primary_keys/calculations'
-require 'composite_primary_keys/validations/uniqueness'
-require 'composite_primary_keys/query_methods'
-require 'composite_primary_keys/primary_key'
-require 'composite_primary_keys/fixtures'
+require 'composite_primary_keys/version'
 
-Dir[File.dirname(__FILE__) + '/composite_primary_keys/connection_adapters/*.rb'].each do |adapter|
-  begin
-    require adapter.gsub('.rb','')
-  rescue MissingSourceFile
-  end
-end
+require 'composite_primary_keys/associations/association'
+require 'composite_primary_keys/associations/association_scope'
+require 'composite_primary_keys/associations/has_and_belongs_to_many_association'
+require 'composite_primary_keys/associations/has_many_association'
+require 'composite_primary_keys/associations/join_dependency/join_part'
+require 'composite_primary_keys/associations/join_dependency/join_association'
+require 'composite_primary_keys/associations/preloader/association'
+require 'composite_primary_keys/associations/preloader/belongs_to'
+require 'composite_primary_keys/associations/preloader/has_and_belongs_to_many'
+
+require 'composite_primary_keys/attribute_methods/dirty'
+require 'composite_primary_keys/attribute_methods/read'
+require 'composite_primary_keys/attribute_methods/write'
+
+require 'composite_primary_keys/connection_adapters/abstract_adapter'
+require 'composite_primary_keys/connection_adapters/postgresql_adapter'
+
+require 'composite_primary_keys/relation/calculations'
+require 'composite_primary_keys/relation/finder_methods'
+require 'composite_primary_keys/relation/query_methods'
+
+require 'composite_primary_keys/validations/uniqueness'

data/lib/composite_primary_keys/associations/association.rb

@@ -0,0 +1,23 @@
+module ActiveRecord
+  module Associations
+    class Association
+      def creation_attributes
+        attributes = {}
+
+        if reflection.macro.in?([:has_one, :has_many]) && !options[:through]
+          # CPK
+          # attributes[reflection.foreign_key] = owner[reflection.active_record_primary_key]
+          Array(reflection.foreign_key).zip(Array(reflection.active_record_primary_key)).each do |key1, key2|
+            attributes[key1] = owner[key2]
+          end
+
+          if reflection.options[:as]
+            attributes[reflection.type] = owner.class.base_class.name
+          end
+        end
+
+        attributes
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/association_scope.rb

@@ -0,0 +1,67 @@
+module ActiveRecord
+  module Associations
+    class AssociationScope
+      def add_constraints(scope)
+        tables = construct_tables
+
+        chain.each_with_index do |reflection, i|
+          table, foreign_table = tables.shift, tables.first
+
+          if reflection.source_macro == :has_and_belongs_to_many
+            join_table = tables.shift
+
+            # CPK
+            # scope = scope.joins(join(
+            #  join_table,
+            #  table[reflection.active_record_primary_key].
+            #    eq(join_table[reflection.association_foreign_key])
+            #))
+            predicate = cpk_join_predicate(table, reflection.association_primary_key,
+                                           join_table, reflection.association_foreign_key)
+            scope = scope.joins(join(join_table, predicate))
+
+            table, foreign_table = join_table, tables.first
+          end
+
+          if reflection.source_macro == :belongs_to
+            key         = reflection.association_primary_key
+            foreign_key = reflection.foreign_key
+          else
+            key         = reflection.foreign_key
+            foreign_key = reflection.active_record_primary_key
+          end
+
+          if reflection == chain.last
+            # CPK
+            # scope = scope.where(table[key].eq(owner[foreign_key]))
+            predicate = cpk_join_predicate(table, key, owner, foreign_key)
+            scope = scope.where(predicate)
+
+            conditions[i].each do |condition|
+              if options[:through] && condition.is_a?(Hash)
+                condition = { table.name => condition }
+              end
+
+              scope = scope.where(interpolate(condition))
+            end
+          else
+            # CPK
+            # constraint = table[key].eq(foreign_table[foreign_key])
+            constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
+            scope = scope.where(predicate)
+
+            join       = join(foreign_table, constraint)
+
+            scope = scope.joins(join)
+
+            unless conditions[i].empty?
+              scope = scope.where(sanitize(conditions[i], table))
+            end
+          end
+        end
+
+        scope
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/has_and_belongs_to_many_association.rb

@@ -1,143 +1,53 @@
 module ActiveRecord
   module Associations
     class HasAndBelongsToManyAssociation
-      def construct_sql
-        if @reflection.options[:finder_sql]
-          @finder_sql = interpolate_and_sanitize_sql(@reflection.options[:finder_sql])
+      def insert_record(record, validate = true)
+        return if record.new_record? && !record.save(:validate => validate)
+
+        if options[:insert_sql]
+          owner.connection.insert(interpolate(options[:insert_sql], record))
         else
           # CPK
-          # @finder_sql = "#{@owner.connection.quote_table_name @reflection.options[:join_table]}.#{@reflection.primary_key_name} = #{owner_quoted_id} "
-          @finder_sql = full_columns_equals(@reflection.options[:join_table], @reflection.cpk_primary_key, owner_quoted_id)
-          @finder_sql << " AND (#{conditions})" if conditions
-        end
-
-        join_condition = if composite?
-          conditions = Array.new
-          primary_keys.length.times do |i|
-            conditions << "#{@reflection.quoted_table_name}.#{@reflection.klass.primary_key[i]} = #{@owner.connection.quote_table_name @reflection.options[:join_table]}.#{@reflection.association_foreign_key[i]}"
+          #stmt = join_table.compile_insert(
+          #  join_table[reflection.foreign_key]             => owner.id,
+          #  join_table[reflection.association_foreign_key] => record.id
+          #)
+          join_values = Hash.new
+          Array(reflection.foreign_key).zip(Array(owner.id)) do |name, value|
+            attribute = join_table[name]
+            join_values[attribute] = value
           end
-          conditions.join(' AND ')
-        else
-          "#{@reflection.quoted_table_name}.#{@reflection.klass.primary_key} = #{@owner.connection.quote_table_name @reflection.options[:join_table]}.#{@reflection.association_foreign_key}"
-        end
-        #@join_sql = "INNER JOIN #{@owner.connection.quote_table_name @reflection.options[:join_table]} ON #{@reflection.quoted_table_name}.#{@reflection.klass.primary_key} = #{@owner.connection.quote_table_name @reflection.options[:join_table]}.#{@reflection.association_foreign_key}"
-        @join_sql = "INNER JOIN #{@owner.connection.quote_table_name @reflection.options[:join_table]} ON (#{join_condition})"
 
-        construct_counter_sql
-      end
-      
-      def insert_record(record, force = true, validate = true)
-        unless record.persisted?
-          if force
-            record.save!
-          else
-            return false unless record.save(:validate => validate)
+          Array(reflection.association_foreign_key).zip(Array(record.id)) do |name, value|
+            attribute = join_table[name]
+            join_values[attribute] = value
           end
-        end
-
-        if @reflection.options[:insert_sql]
-          @owner.connection.insert(interpolate_and_sanitize_sql(@reflection.options[:insert_sql], record))
-        else
-          relation   = Arel::Table.new(@reflection.options[:join_table])
-          timestamps = record_timestamp_columns(record)
-          timezone   = record.send(:current_time_from_proper_timezone) if timestamps.any?
 
-          # CPK
-          #attributes = Hash[columns.map do |column|
-          #  name = column.name
-          #  value = case name.to_s
-          #    when @reflection.primary_key_name.to_s
-          #      @owner.id
-          #    when @reflection.association_foreign_key.to_s
-          #      record.id
-          #    when *timestamps
-          #      timezone
-          #    else
-          #      @owner.send(:quote_value, record[name], column) if record.has_attribute?(name)
-          #  end
-          #  [relation[name], value] unless value.nil?
-          #end]
-
-          # CPK
-          owner_foreign_keys = @reflection.cpk_primary_key.map{|key| key.to_s}
-          association_foreign_keys = Array(@reflection.association_foreign_key).map{|key| key.to_s}
+          stmt = join_table.compile_insert(join_values)
 
-          attributes = Hash[columns.map do |column|
-            name = column.name.to_s
-            value = case
-              when owner_foreign_keys.include?(name)
-                index = owner_foreign_keys.index(name)
-                primary_keys = Array(@owner.class.primary_key)
-                primary_key = primary_keys[index]
-                @owner[primary_key]
-              when association_foreign_keys.include?(name)
-                index = association_foreign_keys.index(name)
-                primary_keys = Array(@reflection.klass.primary_key)
-                primary_key = primary_keys[index]
-                record[primary_key]
-              when timestamps.include?(name)
-                timezone
-              else
-                @owner.send(:quote_value, record[name], column) if record.has_attribute?(name)
-            end
-            [relation[name], value] unless value.nil?
-          end]
-
-          relation.insert(attributes)
+          owner.connection.insert stmt.to_sql
         end
 
-        return true
+        record
       end
 
-      # CPK
-      #def delete_records(records)
-      #  if sql = @reflection.options[:delete_sql]
-      #    records.each { |record| @owner.connection.delete(interpolate_and_sanitize_sql(sql, record)) }
-      #  else
-      #    relation = Arel::Table.new(@reflection.options[:join_table])
-      #    relation.where(relation[@reflection.primary_key_name].eq(@owner.id).
-      #      and(relation[@reflection.association_foreign_key].in(records.map { |x| x.id }.compact))
-      #    ).delete
-      #  end
-      #end
-
-      # CPK
-      def delete_records(records)
-        if sql = @reflection.options[:delete_sql]
-          records.each { |record| @owner.connection.delete(interpolate_and_sanitize_sql(sql, record)) }
+      def delete_records(records, method)
+        if sql = options[:delete_sql]
+          records.each { |record| owner.connection.delete(interpolate(sql, record)) }
         else
-          relation = Arel::Table.new(@reflection.options[:join_table])
+          relation = join_table
+          # CPK
+          # stmt = relation.where(relation[reflection.foreign_key].eq(owner.id).
+          #  and(relation[reflection.association_foreign_key].in(records.map { |x| x.id }.compact))
+          #).compile_delete
 
-          if @reflection.cpk_primary_key.size > 1 
-            owner_conditions = []
-            @reflection.cpk_primary_key.each_with_index do |column,i|
-              owner_conditions << relation[column.to_sym].eq(@owner.id[i])
-            end
-            owner_conditions_arel = owner_conditions.inject { |conds, cond| conds.and(cond) }
-          else
-            owner_conditions_arel = relation[@reflection.primary_key_name].eq(@owner.id)
-          end
+          predicate1 = cpk_id_predicate(relation, Array(reflection.foreign_key), Array(owner.id))
+          predicate2 = cpk_in_predicate(relation, Array(reflection.association_foreign_key), records.map { |x| x.id })
+          stmt = relation.where(predicate1.and(predicate2)).compile_delete
 
-          if @reflection.association_foreign_key.kind_of?(Array)
-            association_conditions = []
-            records.each do |rec|
-              record_conditions = []
-              @reflection.association_foreign_key.each_with_index do |column,i|
-                record_conditions << relation[column.to_sym].eq(rec.id[i])
-              end
-              association_conditions << record_conditions.inject { |conds, cond| conds.and(cond) }
-            end
-            association_conditions_arel = association_conditions.inject { |conds, cond| conds.or(cond) }
-          else
-            association_conditions_arel = relation[@reflection.association_foreign_key].in(records.map { |x| x.id }.compact)
-          end
-          
-          all_conditions_arel = owner_conditions_arel.and(association_conditions_arel)
-          
-          relation.where(all_conditions_arel).delete
+          owner.connection.delete stmt.to_sql
         end
       end
-
     end    
   end
 end

data/lib/composite_primary_keys/associations/has_many_association.rb

@@ -1,79 +1,40 @@
 module ActiveRecord
   module Associations
     class HasManyAssociation
-      def construct_sql
-        case
-          when @reflection.options[:finder_sql]
-            @finder_sql = interpolate_and_sanitize_sql(@reflection.options[:finder_sql])
-
-          when @reflection.options[:as]
-            @finder_sql =
-              "#{@reflection.quoted_table_name}.#{@reflection.options[:as]}_id = #{owner_quoted_id} AND " +
-              "#{@reflection.quoted_table_name}.#{@reflection.options[:as]}_type = #{@owner.class.quote_value(@owner.class.base_class.name.to_s)}"
-            @finder_sql << " AND (#{conditions})" if conditions
-
-          else
-            # CPK
-            # @finder_sql = "#{@reflection.quoted_table_name}.#{@reflection.primary_key_name} = #{owner_quoted_id}"
-            @finder_sql = full_columns_equals(@reflection.table_name, @reflection.cpk_primary_key, owner_quoted_id)
-            @finder_sql << " AND (#{conditions})" if conditions
-        end
-
-        construct_counter_sql
-      end
-
-      def owner_quoted_id
-        if (keys = @reflection.options[:primary_key])
-          keys.is_a?(Array) ? keys.collect {|k| quote_value(@owner.send(k)) } : quote_value(@owner.send(keys))
+      def delete_records(records, method)
+        if method == :destroy
+          records.each { |r| r.destroy }
+          update_counter(-records.length) unless inverse_updates_counter_cache?
         else
-          @owner.quoted_id
-        end
-      end
-
-      def delete_records(records)
-        case @reflection.options[:dependent]
-          when :destroy
-            records.each { |r| r.destroy }
-          when :delete_all
-            @reflection.klass.delete(records.map { |record| record.id })
-          else
-            relation = Arel::Table.new(@reflection.table_name)
-            # CPK
-            #relation.where(relation[@reflection.primary_key_name].eq(@owner.id).
-            #    and(relation[@reflection.klass.primary_key].in(records.map { |r| r.id }))
-            #).update(relation[@reflection.primary_key_name] => nil)
-
-            id_predicate = nil
-            owner_key_values = @reflection.cpk_primary_key.zip([@owner.id].flatten)
-            owner_key_values.each do |key, value|
-              eq = relation[key].eq(value)
-              id_predicate = id_predicate ? id_predicate.and(eq) : eq
+          # CPK
+          # keys  = records.map { |r| r[reflection.association_primary_key] }
+          # scope = scoped.where(reflection.association_primary_key => keys)
+          table = Arel::Table.new(reflection.table_name)
+          and_conditions = records.map do |record|
+            eq_conditions = Array(reflection.association_primary_key).map do |name|
+              table[name].eq(record[name])
             end
+            Arel::Nodes::And.new(eq_conditions)
+          end
 
-            record_predicates = nil
-            records.each do |record|
-              keys = [@reflection.klass.primary_key].flatten
-              values = [record.id].flatten
-
-              record_predicate = nil
-              keys.zip(values).each do |key, value|
-                eq = relation[key].eq(value)
-                record_predicate = record_predicate ? record_predicate.and(eq) : eq
-              end
-              record_predicates = record_predicates ? record_predicates.or(record_predicate) : record_predicate
-            end
+          condition = and_conditions.shift
+          and_conditions.each do |and_condition|
+            condition = condition.or(and_condition)
+          end
 
-            relation = relation.where(id_predicate.and(record_predicates))
+          scope = scoped.where(condition)
 
-            nullify_relation = Arel::Table.new(@reflection.table_name)
-            nullify = @reflection.cpk_primary_key.inject(Hash.new) do |hash, key|
-              hash[nullify_relation[key]] = nil
+          if method == :delete_all
+            update_counter(-scope.delete_all)
+          else
+            # CPK
+            # update_counter(-scope.update_all(reflection.foreign_key => nil))
+            updates = Array(reflection.foreign_key).inject(Hash.new) do |hash, name|
+              hash[name] = nil
               hash
             end
-
-            relation.update(nullify)
-
-            @owner.class.update_counters(@owner.id, cached_counter_attribute_name => -records.size) if has_cached_counter?
+            update_counter(-scope.update_all(updates))
+          end
         end
       end
     end