composite_primary_keys 8.1.8 → 9.0.0.beta1

data/lib/composite_primary_keys/connection_adapters/postgresql_adapter.rb

@@ -1,17 +1,48 @@
 module ActiveRecord
   module ConnectionAdapters
-    module PostgreSQL
-      module Quoting
-        def quote_column_name(name)
+    class PostgreSQLAdapter
+      def insert_sql(sql, name = nil, pk = nil, id_value = nil, sequence_name = nil)
+        unless pk
+          # Extract the table from the insert sql. Yuck.
+          table_ref = extract_table_ref_from_insert_sql(sql)
+          pk = primary_key(table_ref) if table_ref
+        end
+
+        if pk && use_insert_returning?
           # CPK
-          # PGconn.quote_ident(name.to_s)
-          if name.is_a?(Array)
-            name.map do |column|
-              PGconn.quote_ident(column.to_s)
-            end.join(', ')
-          else
-            PGconn.quote_ident(name.to_s)
-          end
+          # select_value("#{sql} RETURNING #{quote_column_names(pk)}")
+          select_value("#{sql} RETURNING #{quote_column_names(pk)}")
+        elsif pk
+          super
+          last_insert_id_value(sequence_name || default_sequence_name(table_ref, pk))
+        else
+          super
+        end
+      end
+      alias :create :insert
+
+      def sql_for_insert(sql, pk, id_value, sequence_name, binds)
+        unless pk
+          # Extract the table from the insert sql. Yuck.
+          table_ref = extract_table_ref_from_insert_sql(sql)
+          pk = primary_key(table_ref) if table_ref
+        end
+
+        if pk && use_insert_returning?
+          # CPK
+          # sql = "#{sql} RETURNING #{quote_column_names(pk)}"
+          sql = "#{sql} RETURNING #{quote_column_names(pk)}"
+        end
+
+        [sql, binds]
+      end
+
+      # Returns a single value if query returns a single element
+      # otherwise returns an array corresponding to the composite keys
+      def last_inserted_id(result)
+        row = result && result.rows.first
+        if Array === row
+          row.size == 1 ? row[0] : row
         end
       end
     end

data/lib/composite_primary_keys/core.rb

@@ -1,60 +1,61 @@
 module ActiveRecord
   module Core
-    def initialize_dup(other) # :nodoc:
-      @attributes = @attributes.dup
-      # CPK
-      # @attributes.reset(self.class.primary_key)
-      Array(self.class.primary_key).each {|key| @attributes.reset(key)}
+    silence_warnings do
+      def initialize_dup(other) # :nodoc:
+        @attributes = @attributes.dup
+        # CPK
+        # @attributes.reset(self.class.primary_key)
+        Array(self.class.primary_key).each {|key| @attributes.reset(key)}
 
-      run_callbacks(:initialize) unless _initialize_callbacks.empty?
+        run_callbacks(:initialize) unless _initialize_callbacks.empty?
 
-      @aggregation_cache = {}
-      @association_cache = {}
+        @aggregation_cache = {}
+        @association_cache = {}
 
-      @new_record  = true
-      @destroyed   = false
+        @new_record  = true
+        @destroyed   = false
 
-      super
+        super
+      end
     end
 
     module ClassMethods
-      def find(*ids) # :nodoc:
-        # We don't have cache keys for this stuff yet
-        return super unless ids.length == 1
-        # Allow symbols to super to maintain compatibility for deprecated finders until Rails 5
-        return super if ids.first.kind_of?(Symbol)
-        return super if block_given? ||
-          primary_key.nil? ||
-          default_scopes.any? ||
-          current_scope ||
-          columns_hash.include?(inheritance_column) ||
-          ids.first.kind_of?(Array)
-
-        # CPK
-        return super if self.composite?
-
-        id  = ids.first
-        if ActiveRecord::Base === id
-          id = id.id
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            You are passing an instance of ActiveRecord::Base to `find`.
-            Please pass the id of the object by calling `.id`
-          MSG
-        end
-        key = primary_key
-
-        s = find_by_statement_cache[key] || find_by_statement_cache.synchronize {
-          find_by_statement_cache[key] ||= StatementCache.create(connection) { |params|
+      silence_warnings do
+        def find(*ids) # :nodoc:
+          # We don't have cache keys for this stuff yet
+          return super unless ids.length == 1
+          return super if block_given? ||
+                          primary_key.nil? ||
+                          scope_attributes? ||
+                          columns_hash.include?(inheritance_column) ||
+                          ids.first.kind_of?(Array)
+          # CPK
+          return super if self.composite?
+
+          id  = ids.first
+          if ActiveRecord::Base === id
+            id = id.id
+            ActiveSupport::Deprecation.warn(<<-MSG.squish)
+              You are passing an instance of ActiveRecord::Base to `find`.
+              Please pass the id of the object by calling `.id`
+            MSG
+          end
+
+          key = primary_key
+
+          statement = cached_find_by_statement(key) { |params|
             where(key => params.bind).limit(1)
           }
-        }
-        record = s.execute([id], self, connection).first
-        unless record
-          raise RecordNotFound, "Couldn't find #{name} with '#{primary_key}'=#{id}"
+          record = statement.execute([id], self, connection).first
+          unless record
+            raise RecordNotFound.new("Couldn't find #{name} with '#{primary_key}'=#{id}",
+                                     name, primary_key, id)
+          end
+          record
+        rescue RangeError
+          raise RecordNotFound.new("Couldn't find #{name} with an out of range value for '#{primary_key}'",
+                                   name, primary_key)
         end
-        record
-      rescue RangeError
-        raise RecordNotFound, "Couldn't find #{name} with an out of range value for '#{primary_key}'"
       end
     end
   end

data/lib/composite_primary_keys/dirty.rb

@@ -1,19 +1,19 @@
-module ActiveModel
-  module Dirty
-    def can_change_primary_key?
-      true
-    end
-
-    def primary_key_changed?
-      !!changed.detect { |key| ids_hash.keys.include?(key.to_s) }
-    end
-
-    def primary_key_was
-      ids_hash.keys.inject(Hash.new) do |result, attribute_name|
-        result[attribute_name] = attribute_was(attribute_name.to_s)
-        result
-      end
-    end
-    alias_method :ids_hash_was, :primary_key_was
-  end
-end
+module ActiveModel
+  module Dirty
+    def can_change_primary_key?
+      true
+    end
+
+    def primary_key_changed?
+      !!changed.detect { |key| ids_hash.keys.include?(key.to_s) }
+    end
+
+    def primary_key_was
+      ids_hash.keys.inject(Hash.new) do |result, attribute_name|
+        result[attribute_name] = attribute_was(attribute_name.to_s)
+        result
+      end
+    end
+    alias_method :ids_hash_was, :primary_key_was
+  end
+end

data/lib/composite_primary_keys/fixtures.rb

@@ -1,25 +1,27 @@
 module ActiveRecord
   class Fixture
-    def find
-      if model_class
-        # CPK
-        # model_class.unscoped do
-        #   model_class.find(fixture[model_class.primary_key])
-        # end
-        model_class.unscoped do
-          ids = self.ids(model_class.primary_key)
-          model_class.find(ids)
+    silence_warnings do
+      def find
+        if model_class
+          # CPK
+          # model_class.unscoped do
+          #   model_class.find(fixture[model_class.primary_key])
+          # end
+          model_class.unscoped do
+            ids = self.ids(model_class.primary_key)
+            model_class.find(ids)
+          end
+        else
+          raise FixtureClassNotFound, "No class attached to find."
         end
-      else
-        raise FixtureClassNotFound, "No class attached to find."
       end
-    end
 
-    def ids(key)
-      if key.is_a? Array
-        key.map {|a_key| fixture[a_key.to_s] }
-      else
-        fixture[key]
+      def ids(key)
+        if key.is_a? Array
+          key.map {|a_key| fixture[a_key.to_s] }
+        else
+          fixture[key]
+        end
       end
     end
   end

data/lib/composite_primary_keys/locking/optimistic.rb

@@ -1,54 +1,58 @@
-  module ActiveRecord
-    module Locking
-      module Optimistic
-        private
-          def _update_record(attribute_names = @attributes.keys) #:nodoc:
-            return super unless locking_enabled?
-            return 0 if attribute_names.empty?
-
-            lock_col = self.class.locking_column
-            previous_lock_value = send(lock_col).to_i
-            increment_lock
-
-            attribute_names += [lock_col]
-            attribute_names.uniq!
-
-            begin
-              relation = self.class.unscoped
-
-              if self.composite?
-                affected_rows = relation.where(
-                    relation.cpk_id_predicate(relation.table, self.class.primary_key, id_was)
-                ).where(
-                    lock_col => previous_lock_value
-                ).update_all(
-                    Hash[attributes_for_update(attribute_names).map do |name|
-                           [name, _read_attribute(name)]
-                         end]
-                )
-              else
-                affected_rows = relation.where(
-                    self.class.primary_key => id,
-                    lock_col => previous_lock_value,
-                ).update_all(
-                    Hash[attributes_for_update(attribute_names).map do |name|
+module ActiveRecord
+  module Locking
+    module Optimistic
+
+      private
+
+      silence_warnings do
+        def _update_record(attribute_names = @attributes.keys) #:nodoc:
+          return super unless locking_enabled?
+          return 0 if attribute_names.empty?
+
+          lock_col = self.class.locking_column
+          previous_lock_value = send(lock_col).to_i
+          increment_lock
+
+          attribute_names += [lock_col]
+          attribute_names.uniq!
+
+          begin
+            relation = self.class.unscoped
+
+            if self.composite?
+              affected_rows = relation.where(
+                  relation.cpk_id_predicate(relation.table, self.class.primary_key, id_was)
+              ).where(
+                  lock_col => previous_lock_value
+              ).update_all(
+                  Hash[attributes_for_update(attribute_names).map do |name|
                          [name, _read_attribute(name)]
                        end]
-                )
-              end
+              )
+            else
+              affected_rows = relation.where(
+                  self.class.primary_key => id,
+                  lock_col => previous_lock_value,
+              ).update_all(
+                  Hash[attributes_for_update(attribute_names).map do |name|
+                       [name, _read_attribute(name)]
+                     end]
+              )
+            end
 
-              unless affected_rows == 1
-                raise ActiveRecord::StaleObjectError.new(self, "update")
-              end
+            unless affected_rows == 1
+              raise ActiveRecord::StaleObjectError.new(self, "update")
+            end
 
-              affected_rows
+            affected_rows
 
-            # If something went wrong, revert the version.
-            rescue Exception
-              send(lock_col + '=', previous_lock_value)
-              raise
+          # If something went wrong, revert the version.
+          rescue Exception
+            send(lock_col + '=', previous_lock_value)
+            raise
           end
         end
+      end
     end
   end
 end

data/lib/composite_primary_keys/nested_attributes.rb

@@ -8,70 +8,81 @@ module ActiveRecord
       end
     end
 
-    def assign_nested_attributes_for_collection_association(association_name, attributes_collection)
-      options = self.nested_attributes_options[association_name]
+    silence_warnings do
+      def assign_nested_attributes_for_collection_association(association_name, attributes_collection)
+        options = self.nested_attributes_options[association_name]
 
-      unless attributes_collection.is_a?(Hash) || attributes_collection.is_a?(Array)
-        raise ArgumentError, "Hash or Array expected, got #{attributes_collection.class.name} (#{attributes_collection.inspect})"
-      end
+        if attributes_collection.respond_to?(:permitted?)
+          attributes_collection = attributes_collection.to_h
+        end
 
-      check_record_limit!(options[:limit], attributes_collection)
+        unless attributes_collection.is_a?(Hash) || attributes_collection.is_a?(Array)
+          raise ArgumentError, "Hash or Array expected, got #{attributes_collection.class.name} (#{attributes_collection.inspect})"
+        end
 
-      if attributes_collection.is_a? Hash
-        keys = attributes_collection.keys
-        attributes_collection = if keys.include?('id') || keys.include?(:id)
-                                  [attributes_collection]
-                                else
-                                  attributes_collection.values
-                                end
-      end
+        check_record_limit!(options[:limit], attributes_collection)
 
-      association = association(association_name)
+        if attributes_collection.is_a? Hash
+          keys = attributes_collection.keys
+          attributes_collection = if keys.include?('id') || keys.include?(:id)
+                                    [attributes_collection]
+                                  else
+                                    attributes_collection.values
+                                  end
+        end
 
-      existing_records = if association.loaded?
-                           association.target
-                         # CPK
-                         elsif association.reflection.klass.composite?
-                           attributes_collection.map do |attribute_collection|
-                             attribute_ids = attribute_collection['id'] || attribute_collection[:id]
-                             if attribute_ids
-                               ids = CompositePrimaryKeys::CompositeKeys.parse(attribute_ids)
-                               eq_predicates = association.klass.primary_key.zip(ids).map do |primary_key, value|
-                                 association.klass.arel_table[primary_key].eq(value)
+        association = association(association_name)
+
+        existing_records = if association.loaded?
+                             association.target
+                           # CPK
+                           elsif association.reflection.klass.composite?
+                             attributes_collection.map do |attribute_collection|
+                               attribute_ids = attribute_collection['id'] || attribute_collection[:id]
+                               if attribute_ids
+                                 ids = CompositePrimaryKeys::CompositeKeys.parse(attribute_ids)
+                                 eq_predicates = Class.new.extend(CompositePrimaryKeys::Predicates).cpk_id_predicate(association.klass.arel_table, association.klass.primary_key, ids)
+                                 association.scope.where(eq_predicates).to_a
+                               else
+                                 []
                                end
-                               association.scope.where(*eq_predicates).to_a
-                             else
-                               []
-                             end
-                           end.flatten.compact
-                         else
-                           attribute_ids = attributes_collection.map {|a| a['id'] || a[:id] }.compact
-                           attribute_ids.empty? ? [] : association.scope.where(association.klass.primary_key => attribute_ids)
-                         end
+                             end.flatten.compact
+                           else
+                             attribute_ids = attributes_collection.map {|a| a['id'] || a[:id] }.compact
+                             attribute_ids.empty? ? [] : association.scope.where(association.klass.primary_key => attribute_ids)
+                           end
 
-      attributes_collection.each do |attributes|
-        attributes = attributes.with_indifferent_access
-        if attributes['id'].blank?
-          unless reject_new_record?(association_name, attributes)
-            association.build(attributes.except(*UNASSIGNABLE_KEYS))
+        attributes_collection.each do |attributes|
+          if attributes.respond_to?(:permitted?)
+            attributes = attributes.to_h
           end
-        elsif existing_record = cpk_detect_record(attributes['id'], existing_records)
-          unless call_reject_if(association_name, attributes)
-            # Make sure we are operating on the actual object which is in the association's
-            # proxy_target array (either by finding it, or adding it if not found)
-            # Take into account that the proxy_target may have changed due to callbacks
-            target_record = cpk_detect_record(attributes['id'], association.target)
-
-            if target_record
-              existing_record = target_record
-            else
-              association.add_to_target(existing_record, :skip_callbacks)
+          attributes = attributes.with_indifferent_access
+          if attributes['id'].blank?
+            unless reject_new_record?(association_name, attributes)
+              new_record = association.build(attributes.except(*UNASSIGNABLE_KEYS))
+              public_send("#{self.attributes.keys.first}_will_change!") # TODO CPK: Note: Is this a bug in Rails? We need to somehow set the parent model as changed even when changes are only adding new records to an association. This is not the way to do it, but I am not sure how it should be done.
+              new_record
             end
+          elsif existing_record = cpk_detect_record(attributes['id'], existing_records)
+            unless call_reject_if(association_name, attributes)
+              # Make sure we are operating on the actual object which is in the association's
+              # proxy_target array (either by finding it, or adding it if not found)
+              # Take into account that the proxy_target may have changed due to callbacks
+              target_record = cpk_detect_record(attributes['id'], association.target)
 
-            assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
+              if target_record
+                existing_record = target_record
+              else
+                association.add_to_target(existing_record, :skip_callbacks)
+              end
+
+              result_from_assign = assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy])
+              public_send("#{self.attributes.keys.first}_will_change!") # TODO CPK: Note: Is this a bug in Rails? We need to somehow set the parent model as changed even when changes are only adding new records to an association. This is not the way to do it, but I am not sure how it should be done.
+              result_from_assign
+            end
+          else
+            raise_nested_attributes_record_not_found!(association_name, attributes['id'])
           end
-        else
-          raise_nested_attributes_record_not_found!(association_name, attributes['id'])
         end
       end
     end