composite_primary_keys 6.0.8 → 7.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e0407c008d66e10820394e98a97bb7a507d0226a
-  data.tar.gz: 25d4c43eb87731e104c3ec486e94a20b9568f0bf
+  metadata.gz: b533cad3bf71d1945db74c8626cac9731a5a6d35
+  data.tar.gz: c117bd2a65a362c69d36f0b2fe4e2495a9811933
 SHA512:
-  metadata.gz: 007219da8c4b82d562742f361516772b7f74d4f97e6d065ef01b526dbb9b6047e18b2445dcf3054070d7ff129da0d7a29f5ff78fc55ef49f22503080fa894a42
-  data.tar.gz: b712e6fb1b0d39c530b6c54c9e6dddd81bcf6552989f95b12160612379aaa27ee671ae6d1fc85a40d698c933ff2fc65eba2777b1e060ac94380f3c7ce6a603cb
+  metadata.gz: a08e6c2dafa9d5570a22ccc4cd12d4b9c598f3b8b463e1719d398408e76a3d05bf15278c620f3dad04939e63964f493f99c5efafa28d6cfab52bc4a06d15a50b
+  data.tar.gz: 114d12d9f174d079a6172ac33748c25110c12f4400274f283f677eab664e2d77a868864b643080e1976fcc8c56e67e08b5fea9807b6eaa71f01d60f02339f549

data/History.rdoc

@@ -1,12 +1,6 @@
-== 6.0.08 (2015-01-24)
+== 7.0.0 (2014-05-26)
 
-* Fix habtm association #delete_records (Uros Jurglic)
-* Support optimistic locking (Toshio Maki)
-* Remove singleton classes on CPK relations (Nicolás Hock Isaza)
-
-== 6.0.7 (2014-10-06)
-
-* Support Rails 4.0.6 (Tom Hughes)
+* Active Record 4.1 support! (Charlie Savage, Tom Hughes, Simon South)
 
 == 6.0.6 (2014-05-26)
 

data/lib/composite_primary_keys.rb

@@ -26,36 +26,37 @@ $:.unshift(File.dirname(__FILE__)) unless
 
 unless defined?(ActiveRecord)
   require 'rubygems'
-  gem 'activerecord', '~>4.0.6'
+  gem 'activerecord', '~>4.1.0'
   require 'active_record'
 end
 
+# AM files we override
+require 'active_model/dirty'
+
 # AR files we override
 require 'active_record/counter_cache'
 require 'active_record/fixtures'
+require 'active_record/model_schema'
 require 'active_record/persistence'
 require 'active_record/relation'
 require 'active_record/sanitization'
 
 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_many_through_association'
 require 'active_record/associations/join_dependency'
 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_model/dirty'
 
 require 'active_record/attribute_methods/dirty'
-require 'active_record/attribute_methods/primary_key'
 require 'active_record/attribute_methods/read'
 require 'active_record/attribute_methods/write'
-require 'active_record/locking/optimistic'
 require 'active_record/nested_attributes'
 
 require 'active_record/connection_adapters/abstract_adapter'
@@ -69,33 +70,32 @@ require 'active_record/validations/uniqueness'
 
 
 # CPK files
+require 'composite_primary_keys/active_model/dirty'
 require 'composite_primary_keys/persistence'
-require 'composite_primary_keys/locking/optimistic'
 require 'composite_primary_keys/active_record_overides'
 require 'composite_primary_keys/base'
 require 'composite_primary_keys/core'
 require 'composite_primary_keys/composite_arrays'
 require 'composite_primary_keys/composite_predicates'
 require 'composite_primary_keys/fixtures'
+require 'composite_primary_keys/model_schema'
 require 'composite_primary_keys/relation'
 require 'composite_primary_keys/sanitization'
 require 'composite_primary_keys/version'
 
 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/has_many_through_association'
 require 'composite_primary_keys/associations/join_dependency'
 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/dirty'
 
 require 'composite_primary_keys/attribute_methods/dirty'
-require 'composite_primary_keys/attribute_methods/primary_key'
 require 'composite_primary_keys/attribute_methods/read'
 require 'composite_primary_keys/attribute_methods/write'
 require 'composite_primary_keys/nested_attributes'
@@ -109,5 +109,3 @@ require 'composite_primary_keys/relation/finder_methods'
 require 'composite_primary_keys/relation/query_methods'
 
 require 'composite_primary_keys/validations/uniqueness'
-
-require 'composite_primary_keys/composite_relation'

data/lib/composite_primary_keys/active_model/dirty.rb

@@ -0,0 +1,14 @@
+module ActiveModel
+  module Dirty
+    def attribute_was(attr)
+      # CPK
+      if self.composite? && attr == "id"
+        self.class.primary_keys.map do |attr|
+          attribute_changed?(attr) ? changed_attributes[attr] : __send__(attr)
+        end
+      else
+        attribute_changed?(attr) ? changed_attributes[attr] : __send__(attr)
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/association_scope.rb

@@ -1,31 +1,18 @@
 module ActiveRecord
   module Associations
     class AssociationScope
-      def add_constraints(scope)
-        tables = construct_tables
+      def add_constraints(scope, owner, assoc_klass, refl, tracker)
+        chain = refl.chain
+        scope_chain = refl.scope_chain
+
+        tables = construct_tables(chain, assoc_klass, refl, tracker)
 
         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
             if reflection.options[:polymorphic]
-              key = reflection.association_primary_key(self.klass)
+              key = reflection.association_primary_key(assoc_klass)
             else
               key = reflection.association_primary_key
             end
@@ -36,39 +23,50 @@ module ActiveRecord
             foreign_key = reflection.active_record_primary_key
           end
 
-          
           if reflection == chain.last
-            # CPK
-            # scope = scope.where(table[key].eq(owner[foreign_key]))
+            # CPK - TODO add back in tracker support
+            #bind_val = bind scope, table.table_name, key.to_s, owner[foreign_key], tracker
+            #scope    = scope.where(table[key].eq(bind_val))
             predicate = cpk_join_predicate(table, key, owner, foreign_key)
             scope = scope.where(predicate)
 
             if reflection.type
-              scope = scope.where(table[reflection.type].eq(owner.class.base_class.name))
+              value    = owner.class.base_class.name
+              bind_val = bind scope, table.table_name, reflection.type.to_s, value, tracker
+              scope    = scope.where(table[reflection.type].eq(bind_val))
             end
           else
             # CPK
-            # constraint = table[key].eq(foreign_table[foreign_key])
+            #constraint = table[key].eq(foreign_table[foreign_key])
             constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
 
             if reflection.type
-              type = chain[i + 1].klass.base_class.name
-              constraint = constraint.and(table[reflection.type].eq(type))
+              value    = chain[i + 1].klass.base_class.name
+              bind_val = bind scope, table.table_name, reflection.type.to_s, value, tracker
+              scope    = scope.where(table[reflection.type].eq(bind_val))
             end
 
             scope = scope.joins(join(foreign_table, constraint))
           end
-          
+
+          is_first_chain = i == 0
+          klass = is_first_chain ? assoc_klass : reflection.klass
+
+          # Exclude the scope of the association itself, because that
+          # was already merged in the #scope method.
           scope_chain[i].each do |scope_chain_item|
-            klass = i == 0 ? self.klass : reflection.klass
-            item  = eval_scope(klass, scope_chain_item)
+            item  = eval_scope(klass, scope_chain_item, owner)
+
+            if scope_chain_item == refl.scope
+              scope.merge! item.except(:where, :includes, :bind)
+            end
 
-            if scope_chain_item == self.reflection.scope
-              scope.merge! item.except(:where, :includes)
+            if is_first_chain
+              scope.includes! item.includes_values
             end
 
-            scope.includes! item.includes_values
             scope.where_values += item.where_values
+            scope.order_values |= item.order_values
           end
         end
 

data/lib/composite_primary_keys/associations/has_and_belongs_to_many_association.rb

@@ -49,8 +49,7 @@ module ActiveRecord
 
           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 }) unless records == :all
-          conds = predicate2.nil?? predicate1 : predicate1.and(predicate2)
-          stmt = relation.where(conds).compile_delete
+          stmt = relation.where(predicate1.and(predicate2)).compile_delete
 
           owner.class.connection.delete stmt.to_sql
         end

data/lib/composite_primary_keys/associations/has_many_association.rb

@@ -3,15 +3,15 @@ module ActiveRecord
     class HasManyAssociation
       def delete_records(records, method)
         if method == :destroy
-          records.each { |r| r.destroy }
+          records.each(&:destroy!)
           update_counter(-records.length) unless inverse_updates_counter_cache?
         else
-          if records == :all
+          if records == :all || !reflection.klass.primary_key
             scope = self.scope
           else
             # CPK
-            # keys  = records.map { |r| r[reflection.association_primary_key] }
-            # scope = scope.where(reflection.association_primary_key => keys)
+            # scope = self.scope.where(reflection.klass.primary_key => records)
+            # scope = self.scope.where(reflection.klass.primary_key => records)
             table = Arel::Table.new(reflection.table_name)
             and_conditions = records.map do |record|
               eq_conditions = Array(reflection.association_primary_key).map do |name|
@@ -31,21 +31,20 @@ module ActiveRecord
           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
-            update_counter(-scope.update_all(updates))
+            update_counter(-scope.update_all(reflection.foreign_key => nil))
           end
         end
       end
 
       def foreign_key_present?
-        # CPK
-        # owner.attribute_present?(reflection.association_primary_key)
-        Array(reflection.association_primary_key).all? {|key| owner.attribute_present?(key)}
+        if reflection.klass.primary_key
+          # CPK
+          #owner.attribute_present?(reflection.association_primary_key)
+          owner.attribute_present?(reflection.association_primary_key)
+          Array(reflection.klass.primary_key).all? {|key| owner.attribute_present?(key)}
+        else
+          false
+        end
       end
     end
   end

data/lib/composite_primary_keys/associations/has_many_through_association.rb

@@ -0,0 +1,88 @@
+module ActiveRecord
+  module Associations
+    class HasManyThroughAssociation
+      def cpk_join_through_predicate(*records)
+        ensure_mutable
+
+        ids = records.map do |record|
+          source_reflection.association_primary_key(reflection.klass).map do |key|
+            record.send(key)
+          end
+        end
+
+        cpk_in_predicate(through_association.scope.klass.arel_table, source_reflection.foreign_key, ids)
+      end
+
+      def delete_records(records, method)
+        ensure_not_nested
+
+        # This is unoptimised; it will load all the target records
+        # even when we just want to delete everything.
+        records = load_target if records == :all
+
+        scope = through_association.scope
+
+        # CPK
+        # scope.where! construct_join_attributes(*records)
+        if source_reflection.klass.composite?
+          scope.where! cpk_join_through_predicate(*records)
+        else
+          scope.where! construct_join_attributes(*records)
+        end
+
+        case method
+          when :destroy
+            if scope.klass.primary_key
+              count = scope.destroy_all.length
+            else
+              scope.to_a.each do |record|
+                record.run_callbacks :destroy
+              end
+
+              arel = scope.arel
+
+              stmt = Arel::DeleteManager.new arel.engine
+              stmt.from scope.klass.arel_table
+              stmt.wheres = arel.constraints
+
+              count = scope.klass.connection.delete(stmt, 'SQL', scope.bind_values)
+            end
+          when :nullify
+            count = scope.update_all(source_reflection.foreign_key => nil)
+          else
+            count = scope.delete_all
+        end
+
+        delete_through_records(records)
+
+        if source_reflection.options[:counter_cache] && method != :destroy
+          counter = source_reflection.counter_cache_column
+          klass.decrement_counter counter, records.map(&:id)
+        end
+
+        if through_reflection.macro == :has_many && update_through_counter?(method)
+          update_counter(-count, through_reflection)
+        end
+
+        update_counter(-count)
+      end
+
+      def through_records_for(record)
+        # CPK
+        #attributes = construct_join_attributes(record)
+        #candidates = Array.wrap(through_association.target)
+        #candidates.find_all { |c| c.attributes.slice(*attributes.keys) == attributes }
+
+        if record.composite?
+          candidates = Array.wrap(through_association.target)
+          candidates.find_all { |c| c.attributes.slice(*source_reflection.association_primary_key) == record.ids_hash }
+        else
+          attributes = construct_join_attributes(record)
+          candidates = Array.wrap(through_association.target)
+          candidates.find_all { |c| c.attributes.slice(*attributes.keys) == attributes }
+        end
+      end
+
+    end
+  end
+end

data/lib/composite_primary_keys/associations/join_dependency.rb

@@ -1,25 +1,33 @@
 module ActiveRecord
   module Associations
     class JoinDependency
-      def instantiate(rows)
-        primary_key = join_base.aliased_primary_key
-        parents = {}
+      def instantiate(result_set, aliases)
+        primary_key = aliases.column_alias(join_root, join_root.primary_key)
+        type_caster = result_set.column_type primary_key
 
-        records = rows.map { |model|
+        seen = Hash.new { |h,parent_klass|
+          h[parent_klass] = Hash.new { |i,parent_id|
+            i[parent_id] = Hash.new { |j,child_klass| j[child_klass] = {} }
+          }
+        }
+
+        model_cache = Hash.new { |h,klass| h[klass] = {} }
+        parents = model_cache[join_root]
+        column_aliases = aliases.column_aliases join_root
+
+        result_set.each { |row_hash|
           # CPK
-          #primary_id = model[primary_key]
-          primary_id = if primary_key.kind_of?(Array)
-            primary_key.map {|key| model[key]}
+          #primary_id = type_caster.type_cast row_hash[primary_key]
+          primary_id = if row_hash[primary_key].kind_of?(Array)
+            row_hash[primary_key].map {|key| type_caster.type_cast key}
           else
-            model[primary_key]
+            type_caster.type_cast row_hash[primary_key]
           end
-          parent = parents[primary_id] ||= join_base.instantiate(model)
-          construct(parent, @associations, join_associations, model)
-          parent
-        }.uniq
+          parent = parents[primary_id] ||= join_root.instantiate(row_hash, column_aliases)
+          construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
+        }
 
-        remove_duplicate_results!(base_klass, records, @associations)
-        records
+        parents.values
       end
 
       protected
@@ -68,4 +76,4 @@ module ActiveRecord
       end
     end
   end
-end
+end

data/lib/composite_primary_keys/associations/join_dependency/join_association.rb

@@ -2,15 +2,15 @@ module ActiveRecord
   module Associations
     class JoinDependency
       class JoinAssociation
-        def build_constraint(reflection, table, key, foreign_table, foreign_key)
+        def build_constraint(klass, table, key, foreign_table, foreign_key)
           # CPK
           # constraint = table[key].eq(foreign_table[foreign_key])
           constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
 
-          if reflection.klass.finder_needs_type_condition?
+          if klass.finder_needs_type_condition?
             constraint = table.create_and([
               constraint,
-              reflection.klass.send(:type_condition, table)
+              klass.send(:type_condition, table)
             ])
           end