composite_primary_keys 13.0.3 → 13.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e585b24e33313e3e28cb2930a551379cdd08acee51021a3291f2a31ba63000e6
-  data.tar.gz: f6cd7efcbce731128f39a732cf90623c3b06ce5669c71b79cede3b7cb3f2ec8a
+  metadata.gz: 875a5dc3886b5b887bbcb77bdcb0bfa40ad377e5084fd1bcdf3a71b5c226dbc3
+  data.tar.gz: 9cad15004b91f80917564f623855836217c2ce8e745eb5e6fc47464f10c7cf0c
 SHA512:
-  metadata.gz: ceea9d28fa8d5f910158f1c8ac69ca1d56bca8ab095cab681db4f749f0cae1dc0d9a3ff24009b4a0ffd7afb3f1cb452487e24bacddf48144a280a7e61d459028
-  data.tar.gz: b5ccaaad9807d0a6f82a03be277fea073cc6cfe5dbeb235fbef42ecfd6ca0f321b08367f78e8c8a493614071119399df84c207e3a3cda434f75a9a190980cb5b
+  metadata.gz: f771c6c4266eb770f685c7fc0960c344c10b7666a24240c59b456afa2c4c52c058e530e8e3d1ddfb4575468eb5eaf30a77b141216820eb028d774fc9f9593326
+  data.tar.gz: 33d2e087cdfc10ea336038a5ffabdb5dd878133ba11ed874ee2d6bd7cf5e572f9acf8b3a996bf04b402c161ffe49d2237ae7284266b58e6eed98b53a890ca7e5

data/History.rdoc

@@ -1,3 +1,6 @@
+== 13.0.4
+* Fix previously_new_record? not being set to true after create
+
 == 13.0.3 (2022-01-09)
 * Remove override on ActiveRecord::Base#to_param. That method has moved to Integration
   so no longer works. #541. (Charlie Savage)

data/lib/composite_primary_keys/associations/collection_association.rb

@@ -1,32 +1,32 @@
-module CompositePrimaryKeys
-  module CollectionAssociation
-    def ids_writer(ids)
-      primary_key = reflection.association_primary_key
-      pk_type = klass.type_for_attribute(primary_key)
-      ids = Array(ids).reject(&:blank?)
-      ids.map! { |i| pk_type.cast(i) }
-
-      # CPK-
-      if primary_key.is_a?(Array)
-        predicate = CompositePrimaryKeys::Predicates.cpk_in_predicate(klass.arel_table, reflection.association_primary_key, ids)
-        records = klass.where(predicate).index_by do |r|
-          reflection.association_primary_key.map{ |k| r.send(k) }
-        end.values_at(*ids)
-      else
-        records = klass.where(primary_key => ids).index_by do |r|
-          r.public_send(primary_key)
-        end.values_at(*ids).compact
-      end
-
-      if records.size != ids.size
-        found_ids = records.map { |record| record.public_send(primary_key) }
-        not_found_ids = ids - found_ids
-        klass.all.raise_record_not_found_exception!(ids, records.size, ids.size, primary_key, not_found_ids)
-      else
-        replace(records)
-      end
-    end
-  end
-end
-
+module CompositePrimaryKeys
+  module CollectionAssociation
+    def ids_writer(ids)
+      primary_key = reflection.association_primary_key
+      pk_type = klass.type_for_attribute(primary_key)
+      ids = Array(ids).reject(&:blank?)
+      ids.map! { |i| pk_type.cast(i) }
+
+      # CPK-
+      if primary_key.is_a?(Array)
+        predicate = CompositePrimaryKeys::Predicates.cpk_in_predicate(klass.arel_table, reflection.association_primary_key, ids)
+        records = klass.where(predicate).index_by do |r|
+          reflection.association_primary_key.map{ |k| r.send(k) }
+        end.values_at(*ids)
+      else
+        records = klass.where(primary_key => ids).index_by do |r|
+          r.public_send(primary_key)
+        end.values_at(*ids).compact
+      end
+
+      if records.size != ids.size
+        found_ids = records.map { |record| record.public_send(primary_key) }
+        not_found_ids = ids - found_ids
+        klass.all.raise_record_not_found_exception!(ids, records.size, ids.size, primary_key, not_found_ids)
+      else
+        replace(records)
+      end
+    end
+  end
+end
+
 ActiveRecord::Associations::CollectionAssociation.prepend CompositePrimaryKeys::CollectionAssociation

data/lib/composite_primary_keys/autosave_association.rb

@@ -1,60 +1,60 @@
-module ActiveRecord
-  module AutosaveAssociation
-    def save_has_one_association(reflection)
-      association = association_instance_get(reflection.name)
-      record      = association && association.load_target
-
-      if record && !record.destroyed?
-        autosave = reflection.options[:autosave]
-
-        if autosave && record.marked_for_destruction?
-          record.destroy
-        elsif autosave != false
-          # CPK
-          #key = reflection.options[:primary_key] ? send(reflection.options[:primary_key]) : id
-          key = reflection.options[:primary_key] ? self[reflection.options[:primary_key]] : id
-
-          if (autosave && record.changed_for_autosave?) || new_record? || record_changed?(reflection, record, key)
-            unless reflection.through_reflection
-              record[reflection.foreign_key] = key
-              if inverse_reflection = reflection.inverse_of
-                record.association(inverse_reflection.name).loaded!
-              end
-            end
-
-            saved = record.save(validate: !autosave)
-            raise ActiveRecord::Rollback if !saved && autosave
-            saved
-          end
-        end
-      end
-    end
-
-    def save_belongs_to_association(reflection)
-      association = association_instance_get(reflection.name)
-      return unless association && association.loaded? && !association.stale_target?
-
-      record = association.load_target
-      if record && !record.destroyed?
-        autosave = reflection.options[:autosave]
-
-        if autosave && record.marked_for_destruction?
-          self[reflection.foreign_key] = nil
-          record.destroy
-        elsif autosave != false
-          saved = record.save(validate: !autosave) if record.new_record? || (autosave && record.changed_for_autosave?)
-
-          if association.updated?
-            # CPK
-            # association_id = record.send(reflection.options[:primary_key] || :id)
-            association_id = reflection.options[:primary_key] ? record[reflection.options[:primary_key]] : record.id
-            self[reflection.foreign_key] = association_id
-            association.loaded!
-          end
-
-          saved if autosave
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module AutosaveAssociation
+    def save_has_one_association(reflection)
+      association = association_instance_get(reflection.name)
+      record      = association && association.load_target
+
+      if record && !record.destroyed?
+        autosave = reflection.options[:autosave]
+
+        if autosave && record.marked_for_destruction?
+          record.destroy
+        elsif autosave != false
+          # CPK
+          #key = reflection.options[:primary_key] ? send(reflection.options[:primary_key]) : id
+          key = reflection.options[:primary_key] ? self[reflection.options[:primary_key]] : id
+
+          if (autosave && record.changed_for_autosave?) || new_record? || record_changed?(reflection, record, key)
+            unless reflection.through_reflection
+              record[reflection.foreign_key] = key
+              if inverse_reflection = reflection.inverse_of
+                record.association(inverse_reflection.name).loaded!
+              end
+            end
+
+            saved = record.save(validate: !autosave)
+            raise ActiveRecord::Rollback if !saved && autosave
+            saved
+          end
+        end
+      end
+    end
+
+    def save_belongs_to_association(reflection)
+      association = association_instance_get(reflection.name)
+      return unless association && association.loaded? && !association.stale_target?
+
+      record = association.load_target
+      if record && !record.destroyed?
+        autosave = reflection.options[:autosave]
+
+        if autosave && record.marked_for_destruction?
+          self[reflection.foreign_key] = nil
+          record.destroy
+        elsif autosave != false
+          saved = record.save(validate: !autosave) if record.new_record? || (autosave && record.changed_for_autosave?)
+
+          if association.updated?
+            # CPK
+            # association_id = record.send(reflection.options[:primary_key] || :id)
+            association_id = reflection.options[:primary_key] ? record[reflection.options[:primary_key]] : record.id
+            self[reflection.foreign_key] = association_id
+            association.loaded!
+          end
+
+          saved if autosave
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/composite_arrays.rb

@@ -1,86 +1,86 @@
-module CompositePrimaryKeys
-  ID_SEP     = ','
-  ID_SET_SEP = ';'
-  ESCAPE_CHAR = '^'
-
-  module ArrayExtension
-    def to_composite_keys
-      CompositeKeys.new(self)
-    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 serveral 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)
-    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)
-      else
-        id
-      end
-    end
-  end
-
-  class CompositeKeys < Array
-
-    def self.parse(value)
-      case value
-      when Array
-        value.to_composite_keys
-      when String
-        value.split(ID_SEP).map { |key| Utils.unescape_string_key(key) }.to_composite_keys
-      else
-        raise(ArgumentError, "Unsupported type: #{value}")
-      end
-    end
-
-    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
-    end
-  end
-  private_constant :Utils
-end
-
-Array.send(:include, CompositePrimaryKeys::ArrayExtension)
+module CompositePrimaryKeys
+  ID_SEP     = ','
+  ID_SET_SEP = ';'
+  ESCAPE_CHAR = '^'
+
+  module ArrayExtension
+    def to_composite_keys
+      CompositeKeys.new(self)
+    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 serveral 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)
+    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)
+      else
+        id
+      end
+    end
+  end
+
+  class CompositeKeys < Array
+
+    def self.parse(value)
+      case value
+      when Array
+        value.to_composite_keys
+      when String
+        value.split(ID_SEP).map { |key| Utils.unescape_string_key(key) }.to_composite_keys
+      else
+        raise(ArgumentError, "Unsupported type: #{value}")
+      end
+    end
+
+    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
+    end
+  end
+  private_constant :Utils
+end
+
+Array.send(:include, CompositePrimaryKeys::ArrayExtension)

data/lib/composite_primary_keys/persistence.rb

@@ -73,6 +73,7 @@ module ActiveRecord
       end
 
       @new_record = false
+      @previously_new_record = true
 
       yield(self) if block_given?
 

data/lib/composite_primary_keys/validations/uniqueness.rb

@@ -1,32 +1,32 @@
-module ActiveRecord
-  module Validations
-    class UniquenessValidator
-      def validate_each(record, attribute, value)
-        finder_class = find_finder_class_for(record)
-        value = map_enum_attribute(finder_class, attribute, value)
-
-        relation = build_relation(finder_class, attribute, value)
-        if record.persisted?
-          # CPK
-          if finder_class.primary_key.is_a?(Array)
-            predicate = finder_class.cpk_id_predicate(finder_class.arel_table, finder_class.primary_key, record.id_in_database || record.id)
-            relation = relation.where.not(predicate)
-          elsif finder_class.primary_key
-            relation = relation.where.not(finder_class.primary_key => record.id_in_database)
-          else
-            raise UnknownPrimaryKey.new(finder_class, "Can not validate uniqueness for persisted record without primary key.")
-          end
-        end
-        relation = scope_relation(record, relation)
-        relation = relation.merge(options[:conditions]) if options[:conditions]
-
-        if relation.exists?
-          error_options = options.except(:case_sensitive, :scope, :conditions)
-          error_options[:value] = value
-
-          record.errors.add(attribute, :taken, **error_options)
-        end
-      end
-    end
-  end
+module ActiveRecord
+  module Validations
+    class UniquenessValidator
+      def validate_each(record, attribute, value)
+        finder_class = find_finder_class_for(record)
+        value = map_enum_attribute(finder_class, attribute, value)
+
+        relation = build_relation(finder_class, attribute, value)
+        if record.persisted?
+          # CPK
+          if finder_class.primary_key.is_a?(Array)
+            predicate = finder_class.cpk_id_predicate(finder_class.arel_table, finder_class.primary_key, record.id_in_database || record.id)
+            relation = relation.where.not(predicate)
+          elsif finder_class.primary_key
+            relation = relation.where.not(finder_class.primary_key => record.id_in_database)
+          else
+            raise UnknownPrimaryKey.new(finder_class, "Can not validate uniqueness for persisted record without primary key.")
+          end
+        end
+        relation = scope_relation(record, relation)
+        relation = relation.merge(options[:conditions]) if options[:conditions]
+
+        if relation.exists?
+          error_options = options.except(:case_sensitive, :scope, :conditions)
+          error_options[:value] = value
+
+          record.errors.add(attribute, :taken, **error_options)
+        end
+      end
+    end
+  end
 end

data/lib/composite_primary_keys/version.rb

@@ -2,7 +2,7 @@ module CompositePrimaryKeys
   module VERSION
     MAJOR = 13
     MINOR = 0
-    TINY  = 3
+    TINY  = 4
     STRING = [MAJOR, MINOR, TINY].join('.')
   end
 end

data/test/fixtures/room_assignment.rb

@@ -1,14 +1,14 @@
-class RoomAssignment < ActiveRecord::Base
-  self.primary_keys = :student_id, :dorm_id, :room_id
-  belongs_to :student
-  belongs_to :room, :foreign_key => [:dorm_id, :room_id], :primary_key => [:dorm_id, :room_id]
-  validates_uniqueness_of :student_id
-
-  before_destroy do |record|
-    puts record
-  end
-
-  after_destroy do |record|
-    puts record
-  end
+class RoomAssignment < ActiveRecord::Base
+  self.primary_keys = :student_id, :dorm_id, :room_id
+  belongs_to :student
+  belongs_to :room, :foreign_key => [:dorm_id, :room_id], :primary_key => [:dorm_id, :room_id]
+  validates_uniqueness_of :student_id
+
+  before_destroy do |record|
+    puts record
+  end
+
+  after_destroy do |record|
+    puts record
+  end
 end

data/test/test_composite_arrays.rb

@@ -1,38 +1,38 @@
-require File.expand_path('../abstract_unit', __FILE__)
-
-class CompositeArraysTest < ActiveSupport::TestCase
-
-  def test_new_primary_keys
-    keys = CompositePrimaryKeys::CompositeKeys.new
-    assert_not_nil keys
-    assert_equal '', keys.to_s
-    assert_equal '', "#{keys}"
-  end
-
-  def test_initialize_primary_keys
-    keys = CompositePrimaryKeys::CompositeKeys.new([1,2,3])
-    assert_not_nil keys
-    assert_equal '1,2,3', keys.to_s
-    assert_equal '1,2,3', "#{keys}"
-  end
-
-  def test_to_composite_keys
-    keys = [1,2,3].to_composite_keys
-    assert_equal CompositePrimaryKeys::CompositeKeys, keys.class
-    assert_equal '1,2,3', keys.to_s
-  end
-
-  def test_parse
-    assert_equal ['1', '2'], CompositePrimaryKeys::CompositeKeys.parse('1,2')
-    assert_equal ['The USA', '^Washington, D.C.'],
-                 CompositePrimaryKeys::CompositeKeys.parse('The USA,^5EWashington^2C D.C.')
-    assert_equal ['The USA', '^Washington, D.C.'],
-                 CompositePrimaryKeys::CompositeKeys.parse(['The USA', '^Washington, D.C.'])
-  end
-
-  def test_to_s
-    assert_equal '1,2', CompositePrimaryKeys::CompositeKeys.new([1, 2]).to_s
-    assert_equal 'The USA,^5EWashington^2C D.C.',
-                 CompositePrimaryKeys::CompositeKeys.new(['The USA', '^Washington, D.C.']).to_s
-  end
-end
+require File.expand_path('../abstract_unit', __FILE__)
+
+class CompositeArraysTest < ActiveSupport::TestCase
+
+  def test_new_primary_keys
+    keys = CompositePrimaryKeys::CompositeKeys.new
+    assert_not_nil keys
+    assert_equal '', keys.to_s
+    assert_equal '', "#{keys}"
+  end
+
+  def test_initialize_primary_keys
+    keys = CompositePrimaryKeys::CompositeKeys.new([1,2,3])
+    assert_not_nil keys
+    assert_equal '1,2,3', keys.to_s
+    assert_equal '1,2,3', "#{keys}"
+  end
+
+  def test_to_composite_keys
+    keys = [1,2,3].to_composite_keys
+    assert_equal CompositePrimaryKeys::CompositeKeys, keys.class
+    assert_equal '1,2,3', keys.to_s
+  end
+
+  def test_parse
+    assert_equal ['1', '2'], CompositePrimaryKeys::CompositeKeys.parse('1,2')
+    assert_equal ['The USA', '^Washington, D.C.'],
+                 CompositePrimaryKeys::CompositeKeys.parse('The USA,^5EWashington^2C D.C.')
+    assert_equal ['The USA', '^Washington, D.C.'],
+                 CompositePrimaryKeys::CompositeKeys.parse(['The USA', '^Washington, D.C.'])
+  end
+
+  def test_to_s
+    assert_equal '1,2', CompositePrimaryKeys::CompositeKeys.new([1, 2]).to_s
+    assert_equal 'The USA,^5EWashington^2C D.C.',
+                 CompositePrimaryKeys::CompositeKeys.new(['The USA', '^Washington, D.C.']).to_s
+  end
+end

data/test/test_create.rb

@@ -1,218 +1,219 @@
-require File.expand_path('../abstract_unit', __FILE__)
-
-class TestCreate < ActiveSupport::TestCase
-  fixtures :articles, :students, :dorms, :rooms, :room_assignments, :reference_types, :reference_codes, :streets, :suburbs
-
-  CLASSES = {
-    :single => {
-      :class => ReferenceType,
-      :primary_keys => :reference_type_id,
-      :create => {:reference_type_id => 10, :type_label => 'NEW_TYPE', :abbreviation => 'New Type'}
-    },
-    :dual   => {
-      :class => ReferenceCode,
-      :primary_keys => [:reference_type_id, :reference_code],
-      :create => {:reference_type_id => 1, :reference_code => 20, :code_label => 'NEW_CODE', :abbreviation => 'New Code'}
-    }
-  }
-
-  def setup
-    self.class.classes = CLASSES
-  end
-
-  def test_setup
-    testing_with do
-      assert_not_nil @klass_info[:create]
-    end
-  end
-
-  def test_create
-    testing_with do
-      assert new_obj = @klass.create(@klass_info[:create])
-      assert !new_obj.new_record?
-      assert new_obj.id
-    end
-  end
-
-  def test_create_no_id
-    testing_with do
-      begin
-        @obj = @klass.create(@klass_info[:create].except(@klass.primary_key))
-        @successful = !composite?
-      rescue ActiveRecord::CompositeKeyError
-        @successful = false
-      rescue
-        flunk "Incorrect exception raised: #{$!}, #{$!.class}"
-      end
-      assert_equal composite?, !@successful, "Create should have failed for composites; #{@obj.inspect}"
-    end
-  end
-
-  def test_create_with_array
-    date = Date.new(2027, 01, 27)
-    tariff = Tariff.create!(id: [10, date], amount: 27)
-    refute_nil(tariff)
-    assert_equal([10, date], tariff.id)
-    assert_equal(date, tariff.start_date)
-    assert_equal(27, tariff.amount)
-  end
-
-  def test_create_with_partial_serial
-    attributes = {:location_id => 100}
-
-    # SQLite does not support an autoincrementing field in a composite key
-    if Department.connection.class.name == "ActiveRecord::ConnectionAdapters::SQLite3Adapter"
-      attributes[:id] = 200
-    end
-
-    department = Department.new(attributes)
-    assert_nil(department.attributes[:id])
-
-    department.save!
-    refute_nil(department.attributes["id"])
-    assert_equal(100, department.location_id)
-  end
-
-  def test_create_with_id
-    department = Department.create!(id: [2, 3])
-    assert_equal([2, 3], department.id)
-    assert_equal(2, department.attributes["id"])
-    assert_equal(3, department.attributes["location_id"])
-
-    department.reload
-    assert_equal([2, 3], department.id)
-    assert_equal(2, department.attributes["id"])
-    assert_equal(3, department.attributes["location_id"])
-  end
-
-  def test_create_on_association
-    suburb = Suburb.first
-    suburb.streets.create(:name => "my street")
-    street = Street.find_by_name('my street')
-    assert_equal(suburb.city_id, street.city_id)
-    assert_equal(suburb.suburb_id, street.suburb_id)
-  end
-
-  def test_create_on_association_when_belongs_to_is_single_key
-    rt = ReferenceType.first
-    rt.reference_codes.create(:reference_code => 4321, :code_label => 'foo', :abbreviation => 'bar')
-    rc = ReferenceCode.find_by_reference_code(4321)
-    assert_equal(rc.reference_type_id, rt.reference_type_id)
-  end
-
-  def test_new_habtm
-    restaurant = Restaurant.new(:franchise_id => 101,
-                                :store_id => 201,
-                                :name => "My Store")
-
-    restaurant.suburbs << Suburb.new(:city_id => 24,
-                                     :suburb_id => 25,
-                                     :name => "My Suburb")
-
-    restaurant.save!
-
-    # Test restaurant
-    assert_equal(101, restaurant.franchise_id)
-    assert_equal(201, restaurant.store_id)
-    assert_equal("My Store", restaurant.name)
-    assert_equal(1, restaurant.suburbs.length)
-
-    # Test suburbs
-    suburb = restaurant.suburbs[0]
-    assert_equal(24, suburb.city_id)
-    assert_equal(25, suburb.suburb_id)
-    assert_equal("My Suburb", suburb.name)
-  end
-
-  def test_create_habtm
-    restaurant = Restaurant.create(:franchise_id => 100,
-                                   :store_id => 200,
-                                   :name => "My Store")
-
-    restaurant.suburbs.create(:city_id => 24,
-                              :suburb_id => 25,
-                              :name => "My Suburb")
-
-    # Test restaurant
-    assert_equal(100, restaurant.franchise_id)
-    assert_equal(200, restaurant.store_id)
-    assert_equal("My Store", restaurant.name)
-
-    assert_equal(1, restaurant.suburbs.reload.length)
-
-    # Test suburbs
-    suburb = restaurant.suburbs[0]
-    assert_equal(24, suburb.city_id)
-    assert_equal(25, suburb.suburb_id)
-    assert_equal("My Suburb", suburb.name)
-  end
-
-  def test_has_many_ids_1
-    dorm = dorms(:toyon)
-    room = Room.new(:dorm_id => dorm.id, :room_id => 5)
-    room.save!
-
-    student1 = students(:kelly)
-
-    RoomAssignment.delete_all
-
-    assignment1 = RoomAssignment.new(:student_id => student1.id, :dorm_id => room.dorm_id, :room_id => room.room_id)
-    assignment1.save!
-
-    room.room_assignment_ids = [[assignment1.student_id, assignment1.dorm_id, assignment1.room_id]]
-    room.save!
-
-    assert_equal(1, room.room_assignments.length)
-    assert_equal(assignment1, room.room_assignments.first)
-  end
-
-  def test_has_many_ids_2
-    dorm = dorms(:toyon)
-    room = Room.new(:dorm_id => dorm.id, :room_id => 5)
-    room.save!
-
-    student1 = students(:kelly)
-    student2 = students(:jordan)
-
-    RoomAssignment.delete_all
-
-    assignment1 = RoomAssignment.new(:student_id => student1.id, :dorm_id => room.dorm_id, :room_id => room.room_id)
-    assignment1.save!
-
-    assignment2 = RoomAssignment.new(:student_id => student2.id, :dorm_id => room.dorm_id, :room_id => room.room_id)
-    assignment2.save!
-
-    room.room_assignment_ids = [[assignment1.student_id, assignment1.dorm_id, assignment1.room_id],
-                                [assignment2.student_id, assignment2.dorm_id, assignment2.room_id]]
-    room.save!
-
-    assert_equal(2, room.room_assignments.length)
-    assert_equal(assignment1, room.room_assignments[0])
-    assert_equal(assignment2, room.room_assignments[1])
-  end
-
-  def test_find_or_create_by
-    suburb = Suburb.find_by(:city_id => 3, :suburb_id => 1)
-    assert_nil(suburb)
-
-    suburb = Suburb.find_or_create_by!(:name => 'New Suburb', :city_id => 3, :suburb_id => 1)
-    refute_nil(suburb)
-  end
-
-  def test_cache
-    Suburb.cache do
-      # Suburb does not exist
-      suburb = Suburb.find_by(:city_id => 10, :suburb_id => 10)
-      assert_nil(suburb)
-
-      # Create it
-      suburb = Suburb.create!(:name => 'New Suburb', :city_id => 10, :suburb_id => 10)
-
-      # Should be able to find it
-      suburb = Suburb.find_by(:city_id => 10)
-      refute_nil(suburb)
-      refute_nil(suburb.city_id)
-      refute_nil(suburb.suburb_id)
-    end
-  end
-end
+require File.expand_path('../abstract_unit', __FILE__)
+
+class TestCreate < ActiveSupport::TestCase
+  fixtures :articles, :students, :dorms, :rooms, :room_assignments, :reference_types, :reference_codes, :streets, :suburbs
+
+  CLASSES = {
+    :single => {
+      :class => ReferenceType,
+      :primary_keys => :reference_type_id,
+      :create => {:reference_type_id => 10, :type_label => 'NEW_TYPE', :abbreviation => 'New Type'}
+    },
+    :dual   => {
+      :class => ReferenceCode,
+      :primary_keys => [:reference_type_id, :reference_code],
+      :create => {:reference_type_id => 1, :reference_code => 20, :code_label => 'NEW_CODE', :abbreviation => 'New Code'}
+    }
+  }
+
+  def setup
+    self.class.classes = CLASSES
+  end
+
+  def test_setup
+    testing_with do
+      assert_not_nil @klass_info[:create]
+    end
+  end
+
+  def test_create
+    testing_with do
+      assert new_obj = @klass.create(@klass_info[:create])
+      assert !new_obj.new_record?
+      assert new_obj.id
+      assert new_obj.previously_new_record?
+    end
+  end
+
+  def test_create_no_id
+    testing_with do
+      begin
+        @obj = @klass.create(@klass_info[:create].except(@klass.primary_key))
+        @successful = !composite?
+      rescue ActiveRecord::CompositeKeyError
+        @successful = false
+      rescue
+        flunk "Incorrect exception raised: #{$!}, #{$!.class}"
+      end
+      assert_equal composite?, !@successful, "Create should have failed for composites; #{@obj.inspect}"
+    end
+  end
+
+  def test_create_with_array
+    date = Date.new(2027, 01, 27)
+    tariff = Tariff.create!(id: [10, date], amount: 27)
+    refute_nil(tariff)
+    assert_equal([10, date], tariff.id)
+    assert_equal(date, tariff.start_date)
+    assert_equal(27, tariff.amount)
+  end
+
+  def test_create_with_partial_serial
+    attributes = {:location_id => 100}
+
+    # SQLite does not support an autoincrementing field in a composite key
+    if Department.connection.class.name == "ActiveRecord::ConnectionAdapters::SQLite3Adapter"
+      attributes[:id] = 200
+    end
+
+    department = Department.new(attributes)
+    assert_nil(department.attributes[:id])
+
+    department.save!
+    refute_nil(department.attributes["id"])
+    assert_equal(100, department.location_id)
+  end
+
+  def test_create_with_id
+    department = Department.create!(id: [2, 3])
+    assert_equal([2, 3], department.id)
+    assert_equal(2, department.attributes["id"])
+    assert_equal(3, department.attributes["location_id"])
+
+    department.reload
+    assert_equal([2, 3], department.id)
+    assert_equal(2, department.attributes["id"])
+    assert_equal(3, department.attributes["location_id"])
+  end
+
+  def test_create_on_association
+    suburb = Suburb.first
+    suburb.streets.create(:name => "my street")
+    street = Street.find_by_name('my street')
+    assert_equal(suburb.city_id, street.city_id)
+    assert_equal(suburb.suburb_id, street.suburb_id)
+  end
+
+  def test_create_on_association_when_belongs_to_is_single_key
+    rt = ReferenceType.first
+    rt.reference_codes.create(:reference_code => 4321, :code_label => 'foo', :abbreviation => 'bar')
+    rc = ReferenceCode.find_by_reference_code(4321)
+    assert_equal(rc.reference_type_id, rt.reference_type_id)
+  end
+
+  def test_new_habtm
+    restaurant = Restaurant.new(:franchise_id => 101,
+                                :store_id => 201,
+                                :name => "My Store")
+
+    restaurant.suburbs << Suburb.new(:city_id => 24,
+                                     :suburb_id => 25,
+                                     :name => "My Suburb")
+
+    restaurant.save!
+
+    # Test restaurant
+    assert_equal(101, restaurant.franchise_id)
+    assert_equal(201, restaurant.store_id)
+    assert_equal("My Store", restaurant.name)
+    assert_equal(1, restaurant.suburbs.length)
+
+    # Test suburbs
+    suburb = restaurant.suburbs[0]
+    assert_equal(24, suburb.city_id)
+    assert_equal(25, suburb.suburb_id)
+    assert_equal("My Suburb", suburb.name)
+  end
+
+  def test_create_habtm
+    restaurant = Restaurant.create(:franchise_id => 100,
+                                   :store_id => 200,
+                                   :name => "My Store")
+
+    restaurant.suburbs.create(:city_id => 24,
+                              :suburb_id => 25,
+                              :name => "My Suburb")
+
+    # Test restaurant
+    assert_equal(100, restaurant.franchise_id)
+    assert_equal(200, restaurant.store_id)
+    assert_equal("My Store", restaurant.name)
+
+    assert_equal(1, restaurant.suburbs.reload.length)
+
+    # Test suburbs
+    suburb = restaurant.suburbs[0]
+    assert_equal(24, suburb.city_id)
+    assert_equal(25, suburb.suburb_id)
+    assert_equal("My Suburb", suburb.name)
+  end
+
+  def test_has_many_ids_1
+    dorm = dorms(:toyon)
+    room = Room.new(:dorm_id => dorm.id, :room_id => 5)
+    room.save!
+
+    student1 = students(:kelly)
+
+    RoomAssignment.delete_all
+
+    assignment1 = RoomAssignment.new(:student_id => student1.id, :dorm_id => room.dorm_id, :room_id => room.room_id)
+    assignment1.save!
+
+    room.room_assignment_ids = [[assignment1.student_id, assignment1.dorm_id, assignment1.room_id]]
+    room.save!
+
+    assert_equal(1, room.room_assignments.length)
+    assert_equal(assignment1, room.room_assignments.first)
+  end
+
+  def test_has_many_ids_2
+    dorm = dorms(:toyon)
+    room = Room.new(:dorm_id => dorm.id, :room_id => 5)
+    room.save!
+
+    student1 = students(:kelly)
+    student2 = students(:jordan)
+
+    RoomAssignment.delete_all
+
+    assignment1 = RoomAssignment.new(:student_id => student1.id, :dorm_id => room.dorm_id, :room_id => room.room_id)
+    assignment1.save!
+
+    assignment2 = RoomAssignment.new(:student_id => student2.id, :dorm_id => room.dorm_id, :room_id => room.room_id)
+    assignment2.save!
+
+    room.room_assignment_ids = [[assignment1.student_id, assignment1.dorm_id, assignment1.room_id],
+                                [assignment2.student_id, assignment2.dorm_id, assignment2.room_id]]
+    room.save!
+
+    assert_equal(2, room.room_assignments.length)
+    assert_equal(assignment1, room.room_assignments[0])
+    assert_equal(assignment2, room.room_assignments[1])
+  end
+
+  def test_find_or_create_by
+    suburb = Suburb.find_by(:city_id => 3, :suburb_id => 1)
+    assert_nil(suburb)
+
+    suburb = Suburb.find_or_create_by!(:name => 'New Suburb', :city_id => 3, :suburb_id => 1)
+    refute_nil(suburb)
+  end
+
+  def test_cache
+    Suburb.cache do
+      # Suburb does not exist
+      suburb = Suburb.find_by(:city_id => 10, :suburb_id => 10)
+      assert_nil(suburb)
+
+      # Create it
+      suburb = Suburb.create!(:name => 'New Suburb', :city_id => 10, :suburb_id => 10)
+
+      # Should be able to find it
+      suburb = Suburb.find_by(:city_id => 10)
+      refute_nil(suburb)
+      refute_nil(suburb.city_id)
+      refute_nil(suburb.suburb_id)
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: composite_primary_keys
 version: !ruby/object:Gem::Version
-  version: 13.0.3
+  version: 13.0.4
 platform: ruby
 authors:
 - Charlie Savage
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-01-09 00:00:00.000000000 Z
+date: 2022-12-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -216,7 +216,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.4
+rubygems_version: 3.3.14
 signing_key:
 specification_version: 4
 summary: Composite key support for ActiveRecord