composite_primary_keys 8.1.1 → 8.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ac219a8f2d8b68052ff1719a9ac2b9f115a20c6e
-  data.tar.gz: 7d2524dcb34b125090e65d428ec9c86458df5c22
+  metadata.gz: ce98265078e9df3388a619400153228e3d060120
+  data.tar.gz: 02bfe6e56836f6a5c6f6e73ca8bcc1af3502a729
 SHA512:
-  metadata.gz: b586736b9fa329e675e7809ac949fd91949627f48935208119fae5a32a56f7c0d1dbf93395403eee246ede367c9d4fa9fa575c25bf54b2ff5f9825539af96c11
-  data.tar.gz: ba237055b960bd8c68dbf602d8a9c6b2e3419938c4d8ddc4884caf6cd61f7098b4bd95eeb008e33613a21f30029dc7f2d703dc60d2635f1409e867e951c8c688
+  metadata.gz: 47e1b2d9385bdc3222d316989aad9c876d218cc985cbf4a11cfa66cf4de0fe67a466891242b8f2b38af96e1a0e2a6d34da7176ff2ca55b5445c2c43c94a46fe5
+  data.tar.gz: e7c96de2cb63e3512f511b9d46a81df2154fe05d4ed7547d65ea101e691f90f484df3f9d8da3aaa269ba5a0054ebac48e92738064d51e5d1e39fb41df9189f69

data/History.rdoc

@@ -1,3 +1,7 @@
+== 8.1.2 (2015-12-13)
+
+* Fix failing tests
+
 == 8.1.1 (2015-08-04)
 
 * Updates to make Travis CI green (Laust Rud Jacobsen)
@@ -8,7 +12,6 @@
 * Remove call to verify_active_connections! which was removed from AR 4.1 (Steve Pletcher)
 * Aligned the establish connection paramater handling to be similar to latest version of rails (Harish Shetty)
 
-
 == 8.1.0 (2014-03-23)
 
 * ActiveRecord 4.2.1 support (Charlie Savage)

data/lib/composite_primary_keys.rb

@@ -30,6 +30,9 @@ unless defined?(ActiveRecord)
   require 'active_record'
 end
 
+# Arel files we override
+require 'arel/visitors/to_sql'
+
 # AR files we override
 require 'active_record/counter_cache'
 require 'active_record/fixtures'
@@ -68,13 +71,14 @@ require 'active_record/relation/query_methods'
 require 'active_record/validations/uniqueness'
 
 # CPK files
+require 'composite_primary_keys/arel/visitors/to_sql'
+
 require 'composite_primary_keys/persistence'
 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/attribute_set/builder'

data/lib/composite_primary_keys/arel/visitors/to_sql.rb

@@ -0,0 +1,24 @@
+module Arel
+  module Visitors
+    class ToSql
+      def visit_Arel_Nodes_In o, collector
+        if Array === o.right && o.right.empty?
+          collector << '1=0'
+        else
+          # CPK
+          # collector = visit o.left, collector
+          if o.left.name.is_a?(Array)
+            collector << "("
+            collector = visit(o.left, collector)
+            collector << ")"
+          else
+            collector = visit o.left, collector
+          end
+
+          collector << " IN ("
+          visit(o.right, collector) << ")"
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/association_scope.rb

@@ -1,72 +1,46 @@
 module ActiveRecord
   module Associations
     class AssociationScope
-      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)
+      def next_chain_scope(scope, table, reflection, tracker, assoc_klass, foreign_table, next_reflection)
+        join_keys = reflection.join_keys(assoc_klass)
+        key = join_keys.key
+        foreign_key = join_keys.foreign_key
 
-        chain.each_with_index do |reflection, i|
-          table, foreign_table = tables.shift, tables.first
+        # CPK
+        # constraint = table[key].eq(foreign_table[foreign_key])
+        constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
 
-          join_keys = reflection.join_keys(assoc_klass)
-          key = join_keys.key
-          foreign_key = join_keys.foreign_key
-          
-          if reflection == chain.last
-            # CPK - TODO add back in tracker support
-            if key.kind_of?(Array) || foreign_key.kind_of?(Array)
-              predicate = cpk_join_predicate(table, key, owner, foreign_key)
-              scope = scope.where(predicate)
-            else
-              bind_val = bind scope, table.table_name, key.to_s, owner[foreign_key], tracker
-              scope    = scope.where(table[key].eq(bind_val))
-            end
-            
-            
-            if reflection.type
-              value    = owner.class.base_class.name
-              bind_val = bind scope, table.table_name, reflection.type, value, tracker
-              scope    = scope.where(table[reflection.type].eq(bind_val))
-            end
-          else
-            # CPK
-            #constraint = table[key].eq(foreign_table[foreign_key])
-            constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
-
-            if reflection.type
-              value    = chain[i + 1].klass.base_class.name
-              bind_val = bind scope, table.table_name, reflection.type, 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
+        if reflection.type
+          value    = next_reflection.klass.base_class.name
+          bind_val = bind scope, table.table_name, reflection.type, value, tracker
+          scope    = scope.where(table[reflection.type].eq(bind_val))
+        end
 
-          # Exclude the scope of the association itself, because that
-          # was already merged in the #scope method.
-          scope_chain[i].each do |scope_chain_item|
-            item  = eval_scope(klass, scope_chain_item, owner)
+        scope.joins(join(foreign_table, constraint))
+      end
 
-            if scope_chain_item == refl.scope
-              scope.merge! item.except(:where, :includes, :bind)
-            end
+      def last_chain_scope(scope, table, reflection, owner, tracker, assoc_klass)
+        join_keys = reflection.join_keys(assoc_klass)
+        key = join_keys.key
+        foreign_key = join_keys.foreign_key
+
+        if key.kind_of?(Array) || foreign_key.kind_of?(Array)
+          predicate = cpk_join_predicate(table, key, owner, foreign_key)
+          scope = scope.where(predicate)
+        else
+          bind_val = bind scope, table.table_name, key.to_s, owner[foreign_key], tracker
+          scope    = scope.where(table[key].eq(bind_val))
+        end
 
-            if is_first_chain
-              scope.includes! item.includes_values
-            end
+        if reflection.type
+          value    = owner.class.base_class.name
+          bind_val = bind scope, table.table_name, reflection.type, value, tracker
 
-            scope.where_values += item.where_values
-            scope.bind_values  += item.bind_values
-            scope.order_values |= item.order_values
-          end
+          scope.where(table[reflection.type].eq(bind_val))
+        else
+          scope
         end
-
-        scope
       end
     end
   end

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

@@ -1,22 +1,22 @@
-module ActiveRecord
-  module Associations
-    class JoinDependency
-      class JoinAssociation
-        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 klass.finder_needs_type_condition?
-            constraint = table.create_and([
-              constraint,
-              klass.send(:type_condition, table)
-            ])
-          end
-
-          constraint
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Associations
+    class JoinDependency
+      class JoinAssociation
+        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 klass.finder_needs_type_condition?
+            constraint = table.create_and([
+              constraint,
+              klass.send(:type_condition, table)
+            ])
+          end
+
+          constraint
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/preloader/association.rb

@@ -54,13 +54,19 @@ module ActiveRecord
             records_for(slice)
           }
 
+          # CPK
+          # @preloaded_records.map { |record|
+          #   key = record[association_key_name]
+          #   key = key.to_s if key_conversion_required?
+          #
+          #   [record, key]
+          # }
           @preloaded_records.map { |record|
-            # CPK
-            #[record, record[association_key_name]]
-            owner_key = Array(association_key_name).map do |key_name|
+            key = Array(association_key_name).map do |key_name|
               record[key_name]
             end.join(CompositePrimaryKeys::ID_SEP)
-            [record, owner_key]
+
+            [record, key]
           }
         end
 
@@ -69,7 +75,7 @@ module ActiveRecord
                                owners.group_by do |owner|
                                  # CPK
                                  # owner[owner_key_name].to_s
-                                 key = Array(owner_key_name).map do |key_name|
+                                 Array(owner_key_name).map do |key_name|
                                    owner[key_name]
                                  end.join(CompositePrimaryKeys::ID_SEP)
                                end
@@ -77,7 +83,7 @@ module ActiveRecord
                                owners.group_by do |owner|
                                  # CPK
                                  # owner[owner_key_name]
-                                 key = Array(owner_key_name).map do |key_name|
+                                 Array(owner_key_name).map do |key_name|
                                    owner[key_name]
                                  end.join(CompositePrimaryKeys::ID_SEP)
                                end

data/lib/composite_primary_keys/associations/preloader/belongs_to.rb

@@ -1,19 +1,19 @@
-module ActiveRecord
-  module Associations
-    class Preloader
-      class BelongsTo
-        def query_scope(ids)
-          # CPK
-          # scope.where(association_key.in(ids))
-
-          if association_key_name.is_a?(Array)
-            predicate = cpk_in_predicate(table, association_key_name, ids)
-            scope.where(predicate)
-          else
-            scope.where(association_key.in(ids))
-          end
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Associations
+    class Preloader
+      class BelongsTo
+        def query_scope(ids)
+          # CPK
+          # scope.where(association_key.in(ids))
+
+          if association_key_name.is_a?(Array)
+            predicate = cpk_in_predicate(table, association_key_name, ids)
+            scope.where(predicate)
+          else
+            scope.where(association_key.in(ids))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/attribute_methods/primary_key.rb

@@ -5,8 +5,7 @@ module ActiveRecord
       def id_was
         sync_with_transaction_state
         # CPK
-        #attribute_was(self.class.primary_key)
-
+        # attribute_was(self.class.primary_key)
         if self.composite?
           self.class.primary_keys.map do |key_attr|
             attribute_changed?(key_attr) ? changed_attributes[key_attr] : self.ids_hash[key_attr]

data/lib/composite_primary_keys/attribute_methods/read.rb

@@ -7,7 +7,7 @@ module ActiveRecord
           _read_attribute(attr_name, &block)
         else
           name = attr_name.to_s
-          name = self.class.primary_key if name == 'id'
+          name = self.class.primary_key if name == 'id'.freeze
           _read_attribute(name, &block)
         end
       end
@@ -22,4 +22,4 @@ module ActiveRecord
       end
     end
   end
-end
+end

data/lib/composite_primary_keys/attribute_methods/write.rb

@@ -19,7 +19,7 @@ module ActiveRecord
           if should_type_cast
             @attributes.write_from_user(attr_name, value)
           else
-            @attributes.write_from_database(attr_name, value)
+            @attributes.write_cast_value(attr_name, value)
           end
 
           value

data/lib/composite_primary_keys/composite_predicates.rb

@@ -1,51 +1,56 @@
-module CompositePrimaryKeys
-  module Predicates
-    def cpk_and_predicate(predicates)
-      if predicates.length == 1
-        predicates.first
-      else
-        Arel::Nodes::And.new(predicates)
-      end
-    end
-
-    def cpk_or_predicate(predicates)
-      or_predicate = predicates.map do |predicate|
-        ::Arel::Nodes::Grouping.new(predicate)
-      end.inject do |memo, node|
-        ::Arel::Nodes::Or.new(memo, node)
-      end
-      ::Arel::Nodes::Grouping.new(or_predicate)
-    end
-
-    def cpk_id_predicate(table, keys, values)
-      eq_predicates = keys.zip(values).map do |key, value|
-        table[key].eq(value)
-      end
-      cpk_and_predicate(eq_predicates)
-    end
-
-    def cpk_join_predicate(table1, key1, table2, key2)
-      key1_fields = Array(key1).map {|key| table1[key]}
-      key2_fields = Array(key2).map {|key| table2[key]}
-
-      eq_predicates = key1_fields.zip(key2_fields).map do |key_field1, key_field2|
-        key_field1.eq(key_field2)
-      end
-      cpk_and_predicate(eq_predicates)
-    end
-
-    def cpk_in_predicate(table, primary_keys, ids)
-      and_predicates = ids.map do |id|
-        cpk_id_predicate(table, primary_keys, id)
-      end
-      cpk_or_predicate(and_predicates)
-    end
-  end
-end
-
-ActiveRecord::Associations::AssociationScope.send(:include, CompositePrimaryKeys::Predicates)
-ActiveRecord::Associations::JoinDependency::JoinAssociation.send(:include, CompositePrimaryKeys::Predicates)
-ActiveRecord::Associations::Preloader::Association.send(:include, CompositePrimaryKeys::Predicates)
-ActiveRecord::Associations::HasManyThroughAssociation.send(:include, CompositePrimaryKeys::Predicates)
-ActiveRecord::Relation.send(:include, CompositePrimaryKeys::Predicates)
+module CompositePrimaryKeys
+  module Predicates
+    def cpk_and_predicate(predicates)
+      if predicates.length == 1
+        predicates.first
+      else
+        Arel::Nodes::And.new(predicates)
+      end
+    end
+
+    def cpk_or_predicate(predicates)
+      if predicates.length <= 1
+        predicates.first
+      else
+        predicates_copy = predicates.dup
+        predicate = predicates_copy.shift
+
+        or_predicate = predicates_copy.inject(predicate) do |mem, predicate|
+          ::Arel::Nodes::Or.new(mem, predicate)
+        end
+        ::Arel::Nodes::Grouping.new(or_predicate)
+      end
+    end
+
+    def cpk_id_predicate(table, keys, values)
+      eq_predicates = keys.zip(values).map do |key, value|
+        table[key].eq(value)
+      end
+      cpk_and_predicate(eq_predicates)
+    end
+
+    def cpk_join_predicate(table1, key1, table2, key2)
+      key1_fields = Array(key1).map {|key| table1[key]}
+      key2_fields = Array(key2).map {|key| table2[key]}
+
+      eq_predicates = key1_fields.zip(key2_fields).map do |key_field1, key_field2|
+        key_field1.eq(key_field2)
+      end
+      cpk_and_predicate(eq_predicates)
+    end
+
+    def cpk_in_predicate(table, primary_keys, ids)
+      and_predicates = ids.map do |id|
+        cpk_id_predicate(table, primary_keys, id)
+      end
+      cpk_or_predicate(and_predicates)
+    end
+  end
+end
+
+ActiveRecord::Associations::AssociationScope.send(:include, CompositePrimaryKeys::Predicates)
+ActiveRecord::Associations::JoinDependency::JoinAssociation.send(:include, CompositePrimaryKeys::Predicates)
+ActiveRecord::Associations::Preloader::Association.send(:include, CompositePrimaryKeys::Predicates)
+ActiveRecord::Associations::HasManyThroughAssociation.send(:include, CompositePrimaryKeys::Predicates)
+ActiveRecord::Relation.send(:include, CompositePrimaryKeys::Predicates)
 ActiveRecord::PredicateBuilder.send(:extend, CompositePrimaryKeys::Predicates)