composite_primary_keys 13.0.2 → 13.0.4

data/lib/composite_primary_keys/base.rb

@@ -1,141 +1,137 @@
-module ActiveRecord
-  class CompositeKeyError < StandardError #:nodoc:
-  end
-
-  class Base
-    INVALID_FOR_COMPOSITE_KEYS = 'Not appropriate for composite primary keys'
-    NOT_IMPLEMENTED_YET        = 'Not implemented for composite primary keys yet'
-
-    class << self
-      alias_method :primary_key_without_composite_key_support=, :primary_key=
-      def primary_key=(keys)
-        unless keys.kind_of?(Array)
-          self.primary_key_without_composite_key_support = keys
-          return
-        end
-
-        @primary_keys = keys.map { |k| k.to_s }.to_composite_keys
-
-        class_eval <<-EOV
-          extend  CompositeClassMethods
-          include CompositeInstanceMethods
-        EOV
-      end
-      alias_method :primary_keys=, :primary_key=
-
-      def set_primary_keys(*keys)
-        ActiveSupport::Deprecation.warn(
-            "Calling set_primary_keys is deprecated. Please use `self.primary_keys = keys` instead."
-        )
-
-        keys = keys.first if keys.first.is_a?(Array)
-        if keys.length == 1
-          self.primary_key = keys.first
-        else
-          self.primary_keys = keys
-        end
-      end
-
-      def composite?
-        false
-      end
-    end
-
-    def composite?
-      self.class.composite?
-    end
-
-    module CompositeClassMethods
-      def primary_keys
-        @primary_keys = reset_primary_keys unless defined? @primary_keys
-        @primary_keys
-      end
-
-      # Don't like this method name, but its modeled after how AR does it
-      def reset_primary_keys #:nodoc:
-        if self == base_class
-          # CPK
-          self.primary_keys = get_primary_key(base_class.name)
-        else
-          self.primary_keys = base_class.primary_keys
-        end
-      end
-
-      def primary_key
-        primary_keys
-      end
-
-      def primary_key=(keys)
-        self.primary_keys = keys
-      end
-
-      def composite?
-        true
-      end
-
-      #ids_to_s([[1,2],[7,3]]) -> "(1,2),(7,3)"
-      #ids_to_s([[1,2],[7,3]], ',', ';') -> "1,2;7,3"
-      def ids_to_s(many_ids, id_sep = CompositePrimaryKeys::ID_SEP, list_sep = ',', left_bracket = '(', right_bracket = ')')
-        many_ids.map {|ids| "#{left_bracket}#{CompositePrimaryKeys::CompositeKeys.new(ids)}#{right_bracket}"}.join(list_sep)
-      end
-    end
-
-    module CompositeInstanceMethods
-      # A model instance's primary keys is always available as model.ids
-      # whether you name it the default 'id' or set it to something else.
-      def id
-        attr_names = self.class.primary_keys
-        ::CompositePrimaryKeys::CompositeKeys.new(attr_names.map { |attr_name| read_attribute(attr_name) })
-      end
-      alias_method :ids, :id
-
-      # This is overridden purely for json serialization support. If the model is composite
-      # and one of the keys is id, then we don't want to call the id method, instead we want
-      # to get the id attribute value
-      def read_attribute_for_serialization(attribute)
-        if self.composite? && attribute == 'id'
-          read_attribute(attribute)
-        else
-          send(attribute)
-        end
-      end
-
-      def ids_hash
-        self.class.primary_key.zip(ids).inject(Hash.new) do |hash, (key, value)|
-          hash[key] = value
-          hash
-        end
-      end
-
-      def id_before_type_cast
-        self.class.primary_keys.map do |key|
-          self.read_attribute_before_type_cast(key)
-        end
-      end
-
-      # Sets the primary ID.
-      def id=(ids)
-        ids = CompositePrimaryKeys::CompositeKeys.parse(ids)
-        unless ids.length == self.class.primary_keys.length
-          raise "#{self.class}.id= requires #{self.class.primary_keys.length} ids"
-        end
-        [self.class.primary_keys, ids].transpose.each {|key, an_id| write_attribute(key , an_id)}
-        id
-      end
-
-      def can_change_primary_key_values?
-        false
-      end
-
-      # Returns this record's primary keys values in an Array
-      # if any value is available
-      def to_key
-        ids.to_a if !ids.compact.empty? # XXX Maybe use primary_keys with send instead of ids
-      end
-
-      def to_param
-        persisted? ? to_key.to_composite_keys.to_s : nil
-      end
-    end
-  end
-end
+module ActiveRecord
+  class CompositeKeyError < StandardError #:nodoc:
+  end
+
+  class Base
+    INVALID_FOR_COMPOSITE_KEYS = 'Not appropriate for composite primary keys'
+    NOT_IMPLEMENTED_YET        = 'Not implemented for composite primary keys yet'
+
+    class << self
+      alias_method :primary_key_without_composite_key_support=, :primary_key=
+      def primary_key=(keys)
+        unless keys.kind_of?(Array)
+          self.primary_key_without_composite_key_support = keys
+          return
+        end
+
+        @primary_keys = keys.map { |k| k.to_s }.to_composite_keys
+
+        class_eval <<-EOV
+          extend  CompositeClassMethods
+          include CompositeInstanceMethods
+        EOV
+      end
+      alias_method :primary_keys=, :primary_key=
+
+      def set_primary_keys(*keys)
+        ActiveSupport::Deprecation.warn(
+            "Calling set_primary_keys is deprecated. Please use `self.primary_keys = keys` instead."
+        )
+
+        keys = keys.first if keys.first.is_a?(Array)
+        if keys.length == 1
+          self.primary_key = keys.first
+        else
+          self.primary_keys = keys
+        end
+      end
+
+      def composite?
+        false
+      end
+    end
+
+    def composite?
+      self.class.composite?
+    end
+
+    module CompositeClassMethods
+      def primary_keys
+        @primary_keys = reset_primary_keys unless defined? @primary_keys
+        @primary_keys
+      end
+
+      # Don't like this method name, but its modeled after how AR does it
+      def reset_primary_keys #:nodoc:
+        if self == base_class
+          # CPK
+          self.primary_keys = get_primary_key(base_class.name)
+        else
+          self.primary_keys = base_class.primary_keys
+        end
+      end
+
+      def primary_key
+        primary_keys
+      end
+
+      def primary_key=(keys)
+        self.primary_keys = keys
+      end
+
+      def composite?
+        true
+      end
+
+      #ids_to_s([[1,2],[7,3]]) -> "(1,2),(7,3)"
+      #ids_to_s([[1,2],[7,3]], ',', ';') -> "1,2;7,3"
+      def ids_to_s(many_ids, id_sep = CompositePrimaryKeys::ID_SEP, list_sep = ',', left_bracket = '(', right_bracket = ')')
+        many_ids.map {|ids| "#{left_bracket}#{CompositePrimaryKeys::CompositeKeys.new(ids)}#{right_bracket}"}.join(list_sep)
+      end
+    end
+
+    module CompositeInstanceMethods
+      # A model instance's primary keys is always available as model.ids
+      # whether you name it the default 'id' or set it to something else.
+      def id
+        attr_names = self.class.primary_keys
+        ::CompositePrimaryKeys::CompositeKeys.new(attr_names.map { |attr_name| read_attribute(attr_name) })
+      end
+      alias_method :ids, :id
+
+      # This is overridden purely for json serialization support. If the model is composite
+      # and one of the keys is id, then we don't want to call the id method, instead we want
+      # to get the id attribute value
+      def read_attribute_for_serialization(attribute)
+        if self.composite? && attribute == 'id'
+          read_attribute(attribute)
+        else
+          send(attribute)
+        end
+      end
+
+      def ids_hash
+        self.class.primary_key.zip(ids).inject(Hash.new) do |hash, (key, value)|
+          hash[key] = value
+          hash
+        end
+      end
+
+      def id_before_type_cast
+        self.class.primary_keys.map do |key|
+          self.read_attribute_before_type_cast(key)
+        end
+      end
+
+      # Sets the primary ID.
+      def id=(ids)
+        ids = CompositePrimaryKeys::CompositeKeys.parse(ids)
+        unless ids.length == self.class.primary_keys.length
+          raise "#{self.class}.id= requires #{self.class.primary_keys.length} ids"
+        end
+        [self.class.primary_keys, ids].transpose.each {|key, an_id| write_attribute(key , an_id)}
+        id
+      end
+
+      def can_change_primary_key_values?
+        false
+      end
+
+      # Returns this record's primary keys values in an Array
+      # if any value is available
+      def to_key
+        ids.to_a if !ids.compact.empty? # XXX Maybe use primary_keys with send instead of ids
+      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  = 2
+    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