composite_primary_keys 11.3.1 → 12.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9568b1a0261ca52beff062804d3885a795fe4193c9289b140c49c3c36ea199fb
-  data.tar.gz: b458b36aa5e082fc060838953e56eaea26557c4a9570d161c03420ded1a8097e
+  metadata.gz: 540c65209855565625538300ca62ea930ad91494d7a307dbd4db0419a17e576f
+  data.tar.gz: 9bd63c5ffb21a79abb6f4159ddc0245144406e33f1969801f1d9d3176fdf1e2f
 SHA512:
-  metadata.gz: 70cbc4245e31da5701b16dfe7fa109cfe1f395311446537567804b4a378ea6cd2c33d771b00b72e6cd0833a6365b6adcba03a3df4e6564668d298d28f89abbad
-  data.tar.gz: 52df628c9b690b8855f8dbfb52394fca4f07d674aba598b00439cf036138ef73b7975f82c434c185b9c4d4ee4537f70070c27007c2bb5ff81422c513b1a5b96f
+  metadata.gz: 627e469ec7fe07987605b21f156dc042611af0a31282bc711b078479617c5eebeae770f27ec5de3158f686cb7dd4b175b1729dc0116f46e87894d19dc5482292
+  data.tar.gz: 5038fb2ff8282164c9daf3f5b8123d441c3ea50a126222619f12cdaed9118112a7c2f469b90ffb20b482d5e0a1467e3aabf7b5e14e39208a5972ce3b73717633

data/History.rdoc

@@ -1,10 +1,6 @@
-== 11.3.1 (2020-04-01)
-* Fix overriding AbstractReflection for activerecord 5.2.4 (Sergey Semyonov)
-* Fix handling CPK with fields containing comma (Sergey Semyonov)
-* Fixed incorrect SQL condition for joining by CPK (Sergey Semyonov)
-* Update travis.yml file (Sergey Semyonov)
-* Add tests for composite keys with default values (Daniel Wiklund)
-* Fix create record where one or more of the primary keys has a default value (Daniel Wiklund)
+== 12.0.0 (?)
+* Update to ActiveRecord 6.0 (Hiroshi Kajisha, Alexandru Anca, Charlie Savage)
+* Update travis setup (Olle Jonsson)
 
 == 11.2.0 (2019-03-16)
 * When creating new records, honor composite key autoincrementing fields if possible (Antti Pitkänen)
@@ -146,6 +142,20 @@
 == 9.0.0.beta1 (2016-04-16)
 * Rails 5 beta support (Sammy Larbi)
 
+== 8.1.7 (2019-05-04)
+
+Fix key not being an array in subquery on has_many :through (Eric Proulx)
+Convert batches to arrays before continuing loop (Jeremy Mickelson)
+
+== 8.1.6 (2017-05-20)
+
+Query cache with bind params (ttw)
+Fix TestIds#test_set_ids_string. Sqlite's serial and integer are a bit different (Boris Peterbarg)
+Associations with inverse fix (Boris Peterbarg)
+Fix save_has_one_association and add a test for it (Boris Peterbarg)
+Fix save_belongs_to_association override (Boris Peterbarg)
+Extend approach from #344 to fix autosave for has_one associations as well (Cameron Finucane)
+
 == 8.1.5 (2017-01-01)
 
 * Don't nest PK twice when looking up id, fixes #319 (Kerey Roper)

data/README.rdoc

@@ -20,6 +20,7 @@ Every major version of ActiveRecord has included numerous internal changes.  As
 CPK has to be rewritten for each version of ActiveRecord.  To help keep
 things straight, here is the mapping:
 
+    Version 12.x is designed to work with ActiveRecord 6.0.x
     Version 11.x is designed to work with ActiveRecord 5.2.x
     Version 10.x is designed to work with ActiveRecord 5.1.x
     Version  9.x is designed to work with ActiveRecord 5.0.x

data/lib/composite_primary_keys.rb

@@ -26,7 +26,7 @@ $:.unshift(File.dirname(__FILE__)) unless
 
 unless defined?(ActiveRecord)
   require 'rubygems'
-  gem 'activerecord', '~> 5.2.4'
+  gem 'activerecord', '6.0.0.rc1'
   require 'active_record'
 end
 
@@ -59,13 +59,9 @@ require 'active_record/nested_attributes'
 
 require 'active_record/connection_adapters/abstract/database_statements'
 require 'active_record/connection_adapters/abstract_adapter'
-require 'active_record/connection_adapters/abstract_mysql_adapter'
 require 'active_record/connection_adapters/postgresql/database_statements'
 
 require 'active_record/relation/where_clause'
-require 'active_record/relation/predicate_builder/association_query_value'
-
-require 'active_record/validations/uniqueness'
 
 # CPK files
 require 'composite_primary_keys/persistence'
@@ -99,7 +95,6 @@ require 'composite_primary_keys/nested_attributes'
 
 require 'composite_primary_keys/connection_adapters/abstract/database_statements'
 require 'composite_primary_keys/connection_adapters/abstract_adapter'
-require 'composite_primary_keys/connection_adapters/abstract_mysql_adapter'
 require 'composite_primary_keys/connection_adapters/postgresql/database_statements'
 require 'composite_primary_keys/connection_adapters/sqlserver/database_statements'
 

data/lib/composite_primary_keys/arel/to_sql.rb

@@ -1,19 +1,19 @@
 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 << "("
-          collector = visit o.left, collector
-          # CPK
-          collector << ")"
-          collector << " IN ("
-          visit(o.right, collector) << ")"
-        end
-      end
+      # def visit_Arel_Nodes_In o, collector
+      #   if Array === o.right && o.right.empty?
+      #     collector << '1=0'
+      #   else
+      #     # CPK
+      #     collector << "("
+      #     collector = visit o.left, collector
+      #     # CPK
+      #     collector << ")"
+      #     collector << " IN ("
+      #     visit(o.right, collector) << ")"
+      #   end
+      # end
 
       def visit_CompositePrimaryKeys_CompositeKeys o, collector
         values = o.map do |key|

data/lib/composite_primary_keys/associations/association_scope.rb

@@ -11,12 +11,12 @@ module ActiveRecord
         binds += Array(values)
 
         if last_reflection.type
-          binds << owner.class.base_class.name
+          binds << owner.class.polymorphic_name
         end
 
         chain.each_cons(2).each do |reflection, next_reflection|
           if reflection.type
-            binds << next_reflection.klass.base_class.name
+            binds << next_reflection.klass.polymorphic_name
           end
         end
         binds
@@ -38,7 +38,7 @@ module ActiveRecord
         end
 
         if reflection.type
-          polymorphic_type = transform_value(owner.class.base_class.name)
+          polymorphic_type = transform_value(owner.class.polymorphic_name)
           scope = apply_scope(scope, table, reflection.type, polymorphic_type)
         end
 
@@ -58,7 +58,7 @@ module ActiveRecord
         constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
 
         if reflection.type
-          value = transform_value(next_reflection.klass.base_class.name)
+          value = transform_value(next_reflection.klass.polymorphic_name)
           scope = apply_scope(scope, table, reflection.type, value)
         end
 

data/lib/composite_primary_keys/associations/has_many_association.rb

@@ -21,11 +21,12 @@ module ActiveRecord
           scope.delete_all
         else
           # CPK
-          # scope.update_all(reflection.foreign_key => nil)
+          # scope.update_all(nullified_owner_attributes)
           conds = Array(reflection.foreign_key).inject(Hash.new) do |mem, key|
             mem[key] = nil
             mem
           end
+          conds[reflection.type] = nil if reflection.type.present?
           scope.update_all(conds)
         end
       end

data/lib/composite_primary_keys/associations/has_many_through_association.rb

@@ -1,8 +1,6 @@
 module ActiveRecord
   module Associations
     class HasManyThroughAssociation
-
-
       def through_records_for(record)
         # CPK
         # attributes = construct_join_attributes(record)

data/lib/composite_primary_keys/associations/join_dependency.rb

@@ -47,14 +47,14 @@ module ActiveRecord
                          end
 
             parent = parents[parent_key] ||= join_root.instantiate(row_hash, column_aliases, &block)
-            construct(parent, join_root, row_hash, result_set, seen, model_cache, aliases)
+            construct(parent, join_root, row_hash, seen, model_cache)
           }
         end
 
         parents.values
       end
 
-      def construct(ar_parent, parent, row, rs, seen, model_cache, aliases)
+      def construct(ar_parent, parent, row, seen, model_cache)
         return if ar_parent.nil?
 
         parent.children.each do |node|
@@ -63,7 +63,7 @@ module ActiveRecord
             other.loaded!
           elsif ar_parent.association_cached?(node.reflection.name)
             model = ar_parent.association(node.reflection.name).target
-            construct(model, node, row, rs, seen, model_cache, aliases)
+            construct(model, node, row, seen, model_cache)
             next
           end
 
@@ -86,14 +86,15 @@ module ActiveRecord
             next
           end
 
-          model = seen[ar_parent.object_id][node.base_klass][id]
+          model = seen[ar_parent.object_id][node][id]
 
           if model
-            construct(model, node, row, rs, seen, model_cache, aliases)
+            construct(model, node, row, seen, model_cache)
           else
-            model = construct_model(ar_parent, node, row, model_cache, id, aliases)
-            seen[ar_parent.object_id][node.base_klass][id] = model
-            construct(model, node, row, rs, seen, model_cache, aliases)
+            model = construct_model(ar_parent, node, row, model_cache, id)
+
+            seen[ar_parent.object_id][node][id] = model
+            construct(model, node, row, seen, model_cache)
           end
         end
       end

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

@@ -2,42 +2,39 @@ module ActiveRecord
   module Associations
     class Preloader
       class Association
-        def records_for(ids, &block)
-          # CPK
-          #scope.where(association_key_name => ids).load(&block)
-
-          if association_key_name.is_a?(Array)
-            predicate = cpk_in_predicate(klass.arel_table, association_key_name, ids)
-            scope.where(predicate).load(&block)
-          else
-            scope.where(association_key_name => ids).load(&block)
+        def records_for(ids)
+          records = if association_key_name.is_a?(Array)
+                      predicate = cpk_in_predicate(klass.arel_table, association_key_name, ids)
+                      scope.where(predicate)
+                    else
+                      scope.where(association_key_name => ids)
+                    end
+          records.load do |record|
+            # Processing only the first owner
+            # because the record is modified but not an owner
+            owner = owners_by_key[convert_key(record[association_key_name])].first
+            association = owner.association(reflection.name)
+            association.set_inverse_instance(record)
           end
         end
 
         def owners_by_key
-          unless defined?(@owners_by_key)
-            @owners_by_key = owners.each_with_object({}) do |owner, h|
-              # CPK
-              #key = convert_key(owner[owner_key_name])
-              key = if owner_key_name.is_a?(Array)
-                      Array(owner_key_name).map do |key_name|
-                        convert_key(owner[key_name])
-                      end
-                    else
-                      convert_key(owner[owner_key_name])
+          @owners_by_key ||= owners.each_with_object({}) do |owner, result|
+            # CPK
+            # key = convert_key(owner[owner_key_name])
+            key = if owner_key_name.is_a?(Array)
+                    Array(owner_key_name).map do |key_name|
+                      convert_key(owner[key_name])
                     end
-
-              h[key] = owner if key
-            end
+                  else
+                    convert_key(owner[owner_key_name])
+                  end
+            (result[key] ||= []) << owner if key
           end
-          @owners_by_key
         end
 
-        def run(preloader)
-          records = load_records do |record|
-            # CPK
-            #owner = owners_by_key[convert_key(record[association_key_name])]
-
+        def records_by_owner
+          @records_by_owner ||= preloaded_records.each_with_object({}) do |record, result|
             key = if association_key_name.is_a?(Array)
                     Array(record[association_key_name]).map do |key|
                       convert_key(key)
@@ -45,14 +42,9 @@ module ActiveRecord
                   else
                     convert_key(record[association_key_name])
                   end
-
-            owner = owners_by_key[key]
-            association = owner.association(reflection.name)
-            association.set_inverse_instance(record)
-          end
-
-          owners.each do |owner|
-            associate_records_to_owner(owner, records[convert_key(owner[owner_key_name])] || [])
+            owners_by_key[key].each do |owner|
+              (result[owner] ||= []) << record
+            end
           end
         end
       end

data/lib/composite_primary_keys/attribute_methods.rb

@@ -2,8 +2,8 @@ module ActiveRecord
   module AttributeMethods
     def has_attribute?(attr_name)
       # CPK
-      # @attributes.key?(attr_name.to_s)
-      Array(attr_name).all?{|single_attr| @attributes.key?(single_attr.to_s) }
+      # attributes.key?(attr_name)
+      Array(attr_name).all? {|single_attr| attributes.key?(single_attr) }
     end
   end
 end

data/lib/composite_primary_keys/attribute_methods/read.rb

@@ -2,30 +2,27 @@ module ActiveRecord
   module AttributeMethods
     module Read
       def read_attribute(attr_name, &block)
-        name = if self.class.attribute_alias?(attr_name)
-                 # CPK
-                 # self.class.attribute_alias(attr_name).to_s
-                 self.class.attribute_alias(attr_name)
-               else
-                 # CPK
-                 # attr_name.to_s
-                 attr_name
-               end
+        # CPK
+        # name = attr_name.to_s
+        name = attr_name
+        if self.class.attribute_alias?(name)
+          name = self.class.attribute_alias(name)
+        end
 
         primary_key = self.class.primary_key
         # CPK
-        # name = primary_key if name == "id".freeze && primary_key
-        name = primary_key if name == "id".freeze && primary_key && !composite?
+        # name = primary_key if name == "id" && primary_key
+        name = primary_key if name == "id" && primary_key && !composite?
         sync_with_transaction_state if name == primary_key
         _read_attribute(name, &block)
       end
 
-      def _read_attribute(attr_name)
+      def _read_attribute(attr_name, &block) # :nodoc
         # CPK
         if attr_name.kind_of?(Array)
-          attr_name.map {|name| @attributes.fetch_value(name.to_s)}
+          attr_name.map {|name| @attributes.fetch_value(name.to_s, &block)}
         else
-          @attributes.fetch_value(attr_name.to_s) { |n| yield n if block_given? }
+          @attributes.fetch_value(attr_name.to_s, &block)
         end
       end
     end

data/lib/composite_primary_keys/attribute_methods/write.rb

@@ -2,20 +2,17 @@ module ActiveRecord
   module AttributeMethods
     module Write
       def write_attribute(attr_name, value)
-        name = if self.class.attribute_alias?(attr_name)
-                 # CPK
-                 #self.class.attribute_alias(attr_name).to_s
-                 self.class.attribute_alias(attr_name)
-               else
-                 # CPK
-                 # attr_name.to_s
-                 attr_name
-               end
+        # CPK
+        #name = attr_name.to_s
+        name = attr_name
+        if self.class.attribute_alias?(name)
+          name = self.class.attribute_alias(name)
+        end
 
         primary_key = self.class.primary_key
         # CPK
-        # name = primary_key if name == "id".freeze && primary_key
-        name = primary_key if name == "id".freeze && primary_key && !composite?
+        # name = primary_key if name == "id" && primary_key
+        name = primary_key if name == "id" && primary_key && !composite?
         sync_with_transaction_state if name == primary_key
         _write_attribute(name, value)
       end

data/lib/composite_primary_keys/base.rb

@@ -52,7 +52,7 @@ module ActiveRecord
       end
 
       # Don't like this method name, but its modeled after how AR does it
-       def reset_primary_keys #:nodoc:
+      def reset_primary_keys #:nodoc:
         if self == base_class
           # CPK
           self.primary_keys = get_primary_key(base_class.name)
@@ -123,7 +123,7 @@ module ActiveRecord
       end
 
       def to_param
-        persisted? ? to_key.to_composite_keys.to_s : nil
+        persisted? ? to_key.join(CompositePrimaryKeys::ID_SEP) : nil
       end
     end
   end

data/lib/composite_primary_keys/composite_arrays.rb

@@ -1,7 +1,6 @@
 module CompositePrimaryKeys
   ID_SEP     = ','
   ID_SET_SEP = ';'
-  ESCAPE_CHAR = '^'
 
   module ArrayExtension
     def to_composite_keys
@@ -9,27 +8,12 @@ module CompositePrimaryKeys
     end
   end
 
-  # Convert mixed representation of CPKs (by strings or arrays) to normalized
-  # representation (just by arrays).
-  #
-  # `ids` is Array that may contain:
-  # 1. A CPK represented by an array or a string.
-  # 2. An array of CPKs represented by arrays or strings.
-  #
-  # There is an issue. Let `ids` contain an array with several strings. We can't distinguish case 1
-  # from case 2 there in general. E.g. the item can be an array containing appropriate number of strings,
-  # and each string can contain appropriate number of commas. We consider case 2 to win there.
-  def self.normalize(ids, cpk_size)
+  def self.normalize(ids)
     ids.map do |id|
-      if Utils.cpk_as_array?(id, cpk_size) && id.any? { |item| !Utils.cpk_as_string?(item, cpk_size) }
-        # CPK as an array - case 1
-        id
-      elsif id.is_a?(Array)
-        # An array of CPKs - case 2
-        normalize(id, cpk_size)
-      elsif id.is_a?(String)
-        # CPK as a string - case 1
-        CompositeKeys.parse(id)
+      if id.is_a?(Array)
+        normalize(id)
+      elsif id.is_a?(String) && id.index(ID_SEP)
+        id.split(ID_SEP)
       else
         id
       end
@@ -43,7 +27,7 @@ module CompositePrimaryKeys
       when Array
         value.to_composite_keys
       when String
-        value.split(ID_SEP).map { |key| Utils.unescape_string_key(key) }.to_composite_keys
+        self.new(value.split(ID_SEP))
       else
         raise(ArgumentError, "Unsupported type: #{value}")
       end
@@ -59,36 +43,9 @@ module CompositePrimaryKeys
 
     def to_s
       # Doing this makes it easier to parse Base#[](attr_name)
-      map { |key| Utils.escape_string_key(key.to_s) }.join(ID_SEP)
-    end
-  end
-
-  module Utils
-    class << self
-      def escape_string_key(key)
-        key.gsub(Regexp.union(ESCAPE_CHAR, ID_SEP)) do |unsafe|
-          "#{ESCAPE_CHAR}#{unsafe.ord.to_s(16).upcase}"
-        end
-      end
-
-      def unescape_string_key(key)
-        key.gsub(/#{Regexp.escape(ESCAPE_CHAR)}[0-9a-fA-F]{2}/) do |escaped|
-          char = escaped.slice(1, 2).hex.chr
-          (char == ESCAPE_CHAR || char == ID_SEP) ? char : escaped
-        end
-      end
-
-      def cpk_as_array?(value, pk_size)
-        # We don't permit Array to be an element of CPK.
-        value.is_a?(Array) && value.size == pk_size && value.none? { |item| item.is_a?(Array) }
-      end
-
-      def cpk_as_string?(value, pk_size)
-        value.is_a?(String) && value.count(ID_SEP) == pk_size - 1
-      end
+      join(ID_SEP)
     end
   end
-  private_constant :Utils
 end
 
 Array.send(:include, CompositePrimaryKeys::ArrayExtension)