composite_primary_keys 8.1.8 → 9.0.0.beta1

data/lib/composite_primary_keys/associations/singular_association.rb

@@ -1,18 +1,14 @@
 module CompositePrimaryKeys
   module SingularAssociation
-    extend ActiveSupport::Concern
-    included do
-      def get_records_with_cpk_support
-        cpk_applies = (target && target.composite?) ||
-          (owner && owner.composite?) ||
-          (options[:primary_key] && options[:primary_key].kind_of?(Array)) || 
-          (options[:foreign_key] && options[:foreign_key].kind_of?(Array))
-        return scope.limit(1).to_a if cpk_applies
-        get_records_without_cpk_support
-      end
-      alias_method_chain :get_records, :cpk_support
+    def get_records
+      cpk_applies = (target && target.composite?) ||
+        (owner && owner.composite?) ||
+        (options[:primary_key] && options[:primary_key].kind_of?(Array)) ||
+        (options[:foreign_key] && options[:foreign_key].kind_of?(Array))
+      return scope.limit(1).to_a if cpk_applies
+      super
     end
   end
 end
 
-ActiveRecord::Associations::SingularAssociation.send(:include, CompositePrimaryKeys::SingularAssociation)
+ActiveRecord::Associations::SingularAssociation.prepend CompositePrimaryKeys::SingularAssociation

data/lib/composite_primary_keys/attribute_methods.rb

@@ -1,9 +1,11 @@
 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) }
+    silence_warnings do
+      def has_attribute?(attr_name)
+        # CPK
+        # @attributes.key?(attr_name.to_s)
+        Array(attr_name).all?{|single_attr| @attributes.key?(single_attr.to_s) }
+      end
     end
   end
 end

data/lib/composite_primary_keys/attribute_methods/primary_key.rb

@@ -1,19 +1,21 @@
 module ActiveRecord
   module AttributeMethods
     module PrimaryKey
-      # Returns the primary key previous value.
-      def id_was
-        sync_with_transaction_state
-        # CPK
-        # attribute_was(self.class.primary_key)
-        if self.composite?
-          self.class.primary_keys.map do |key_attr|
-            attribute_changed?(key_attr) ? changed_attributes[key_attr] : self.ids_hash[key_attr]
+      silence_warnings do
+        # Returns the primary key previous value.
+        def id_was
+          sync_with_transaction_state
+          # CPK
+          # attribute_was(self.class.primary_key)
+          if self.composite?
+            self.class.primary_keys.map do |key_attr|
+              attribute_changed?(key_attr) ? changed_attributes[key_attr] : self.ids_hash[key_attr]
+            end
+          else
+            attribute_was(self.class.primary_key)
           end
-        else
-          attribute_was(self.class.primary_key)
-        end
 
+        end
       end
     end
   end

data/lib/composite_primary_keys/attribute_methods/read.rb

@@ -1,24 +1,25 @@
 module ActiveRecord
   module AttributeMethods
     module Read
-      def read_attribute(attr_name, &block)
-        # CPK
-        if attr_name.kind_of?(Array)
-          _read_attribute(attr_name, &block)
-        else
-          name = attr_name.to_s
+      silence_warnings do
+        def read_attribute(attr_name, &block)
           # CPK
-          name = self.class.primary_key if name == 'id'.freeze && !composite?
-          _read_attribute(name, &block)
+          if attr_name.kind_of?(Array) || attr_name.to_s == 'id'.freeze && @attributes.key?('id')
+            _read_attribute(attr_name, &block)
+          else
+            name = attr_name.to_s
+            name = self.class.primary_key if name == 'id'.freeze
+            _read_attribute(name, &block)
+          end
         end
-      end
 
-      def _read_attribute(attr_name)
-        # CPK
-        if attr_name.kind_of?(Array)
-          attr_name.map {|name| @attributes.fetch_value(name.to_s)}
-        else
-          @attributes.fetch_value(attr_name.to_s) { |n| yield n if block_given? }
+        def _read_attribute(attr_name)
+          # CPK
+          if attr_name.kind_of?(Array)
+            attr_name.map {|name| @attributes.fetch_value(name.to_s)}
+          else
+            @attributes.fetch_value(attr_name.to_s) { |n| yield n if block_given? }
+          end
         end
       end
     end

data/lib/composite_primary_keys/attribute_methods/write.rb

@@ -1,28 +1,30 @@
 module ActiveRecord
   module AttributeMethods
     module Write
-      def write_attribute_with_type_cast(attr_name, value, should_type_cast)
-        # CPK
-        if attr_name.kind_of?(Array)
-          value = [nil]*attr_name.length if value.nil?
-          unless value.length == attr_name.length
-            raise "Number of attr_names #{attr_name.inspect} and values #{value.inspect} do not match"
-          end
-          [attr_name, value].transpose.map {|name,val| write_attribute(name, val)}
-          value
-        else
-          attr_name = attr_name.to_s
+      silence_warnings do
+        def write_attribute_with_type_cast(attr_name, value, should_type_cast)
           # CPK
-          # attr_name = self.class.primary_key if attr_name == 'id' && self.class.primary_key
-          attr_name = self.class.primary_key if attr_name == 'id' && self.class.primary_key && !self.composite?
-
-          if should_type_cast
-            @attributes.write_from_user(attr_name, value)
+          if attr_name.kind_of?(Array)
+            value = [nil]*attr_name.length if value.nil?
+            unless value.length == attr_name.length
+              raise "Number of attr_names #{attr_name.inspect} and values #{value.inspect} do not match"
+            end
+            [attr_name, value].transpose.map {|name,val| write_attribute(name, val)}
+            value
           else
-            @attributes.write_cast_value(attr_name, value)
-          end
+            attr_name = attr_name.to_s
+            # CPK
+            # attr_name = self.class.primary_key if attr_name == 'id' && self.class.primary_key
+            attr_name = self.class.primary_key if attr_name == 'id' && self.class.primary_key && !self.composite?
 
-          value
+            if should_type_cast
+              @attributes.write_from_user(attr_name, value)
+            else
+              @attributes.write_cast_value(attr_name, value)
+            end
+
+            value
+          end
         end
       end
     end

data/lib/composite_primary_keys/attribute_set/builder.rb

@@ -1,19 +1,21 @@
 module ActiveRecord
   class AttributeSet # :nodoc:
     class Builder # :nodoc:
-      def build_from_database(values = {}, additional_types = {})
-        # CPK
-        # if always_initialized && !values.key?(always_initialized)
-        #   values[always_initialized] = nil
-        # end
-        Array(always_initialized).each do |always_initialized_attribute|
-          if always_initialized_attribute && !values.key?(always_initialized_attribute)
-            values[always_initialized_attribute] = nil
+      silence_warnings do
+        def build_from_database(values = {}, additional_types = {})
+          # CPK
+          # if always_initialized && !values.key?(always_initialized)
+          #   values[always_initialized] = nil
+          # end
+          Array(always_initialized).each do |always_initialized_attribute|
+            if always_initialized_attribute && !values.key?(always_initialized_attribute)
+              values[always_initialized_attribute] = nil
+            end
           end
+
+          attributes = LazyAttributeHash.new(types, values, additional_types)
+          AttributeSet.new(attributes)
         end
-        
-        attributes = LazyAttributeHash.new(types, values, additional_types)
-        AttributeSet.new(attributes)
       end
     end
   end

data/lib/composite_primary_keys/base.rb

@@ -21,7 +21,8 @@ module ActiveRecord
         end
       end
 
-      def primary_key_with_composite_key_support=(keys)
+      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
@@ -34,7 +35,6 @@ module ActiveRecord
           include CompositeInstanceMethods
         EOV
       end
-      alias_method_chain :primary_key=, :composite_key_support
       alias_method :primary_keys=, :primary_key=
 
       def set_primary_keys(*keys)
@@ -48,75 +48,11 @@ module ActiveRecord
         else
           self.primary_keys = keys
         end
-     end
+      end
 
       def composite?
         false
       end
-
-      def find_in_batches(options = {})
-        return super unless primary_key.is_a?(Array)
-
-        # Unfortunately .count uses a subquery temp table, which is a big problem when your table is large
-        number_of_rows = count(primary_key.first)
-        batch_size = options[:batch_size] || 100000
-        row_number = 0
-
-        while row_number < number_of_rows
-          end_row_number = row_number + batch_size - 1
-          end_row_number = number_of_rows - 1 if end_row_number > number_of_rows - 1
-
-          # Force the necessary sorting; AR as is will sort a PK table incorrectly
-          start_key = order(*primary_key).
-                         offset(row_number).
-                             first.
-                                 attributes.
-                                     slice(*primary_key)
-
-          end_key =   order(*(primary_key.map { |k| "#{k} ASC" })).
-                         offset(end_row_number).
-                             first.
-                                 attributes.
-                                     slice(*primary_key)
-
-          relation = self
-          lower_bounds = []
-          upper_bounds = []
-
-          # Iterate through the PKs positionally; when we have found a discrepancy between start and end
-          # then we know that's where the boundaries are
-          primary_key.each do |col|
-             if start_key[col] == end_key[col]
-                              relation = relation.where("#{col} = '#{start_key[col]}'")
-                            else
-                                             lower_bounds << [col, start_key[col]]
-                                             upper_bounds << [col, end_key[col]]
-                                           end
-           end
-
-          relation = relation.where(build_batch_case(lower_bounds, '>')) unless lower_bounds.empty?
-          relation = relation.where(build_batch_case(upper_bounds, '<')) unless upper_bounds.empty?
-
-          yield(relation.order(*primary_key))
-
-          row_number = end_row_number + 1
-        end
-      end
-
-      private
-
-      def build_batch_case(bounds, operator)
-        bounds = bounds.dup
-        bound = bounds.shift
-        if bounds.empty?
-          "#{bound[0]} #{operator}= '#{bound[1]}' "
-          else
-          sql_case = "CASE WHEN #{bound[0]} = '#{bound[1]}' THEN "
-          sql_case += build_batch_case(bounds, operator)
-          sql_case += "ELSE #{bound[0]} #{operator} '#{bound[1]}' END "
-          sql_case
-        end
-      end
     end
 
     def composite?
@@ -129,7 +65,7 @@ module ActiveRecord
       end
 
       def primary_key=(keys)
-        primary_keys = keys
+        self.primary_keys = keys
       end
 
       def composite?
@@ -186,7 +122,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 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)
+  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
@@ -38,12 +22,12 @@ module CompositePrimaryKeys
 
   class CompositeKeys < Array
 
-  def self.parse(value)
+    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
+        self.new(value.split(ID_SEP))
       else
         raise(ArgumentError, "Unsupported type: #{value}")
       end
@@ -51,36 +35,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)

data/lib/composite_primary_keys/composite_predicates.rb

@@ -8,23 +8,13 @@ module CompositePrimaryKeys
       end
     end
 
-    def cpk_or_predicate(predicates, group = true)
-      if predicates.length <= 1
-        predicates.first
-      else
-        split_point = predicates.length / 2
-        predicates_first_half = predicates[0...split_point]
-        predicates_second_half = predicates[split_point..-1]
-
-        or_predicate = ::Arel::Nodes::Or.new(cpk_or_predicate(predicates_first_half, false),
-                                             cpk_or_predicate(predicates_second_half, false))
-
-        if group
-          ::Arel::Nodes::Grouping.new(or_predicate)
-        else
-          or_predicate
-        end
+    def cpk_or_predicate(predicates)
+      or_predicate = predicates.map do |predicate|
+        ::Arel::Nodes::Grouping.new(predicate)
+      end.inject do |memo, node|
+        ::Arel::Nodes::Or.new(memo, node)
       end
+      ::Arel::Nodes::Grouping.new(or_predicate)
     end
 
     def cpk_id_predicate(table, keys, values)
@@ -39,6 +29,7 @@ module CompositePrimaryKeys
       key2_fields = Array(key2).map {|key| table2[key]}
 
       eq_predicates = key1_fields.zip(key2_fields).map do |key_field1, key_field2|
+        key_field2 = Arel::Nodes::Quoted.new(key_field2) unless Arel::Attributes::Attribute === key_field2
         key_field1.eq(key_field2)
       end
       cpk_and_predicate(eq_predicates)

data/lib/composite_primary_keys/connection_adapters/abstract_adapter.rb

@@ -1,11 +1,11 @@
-module ActiveRecord
-  module ConnectionAdapters
-    class AbstractAdapter
-      def quote_column_names(name)
-        Array(name).map do |col|
-          quote_column_name(col.to_s)
-        end.to_composite_keys.to_s
-      end
-    end
-  end
+module ActiveRecord
+  module ConnectionAdapters
+    class AbstractAdapter
+      def quote_column_names(name)
+        Array(name).map do |col|
+          quote_column_name(col.to_s)
+        end.join(CompositePrimaryKeys::ID_SEP)
+      end
+    end
+  end
 end