composite_primary_keys 7.0.16 → 8.0.0

data/lib/composite_primary_keys/composite_arrays.rb

@@ -1,30 +1,30 @@
-module CompositePrimaryKeys
-  ID_SEP     = ','
-  ID_SET_SEP = ';'
-
-  module ArrayExtension
-    def to_composite_keys
-      CompositeKeys.new(self)
-    end
-  end
-
-  class CompositeKeys < Array
-    def self.parse(value)
-      case value
-      when Array
-        value.to_composite_keys
-      when String
-        self.new(value.split(ID_SEP))
-      else
-        raise(ArgumentError, "Unsupported type: #{value}")
-      end
-    end
-
-    def to_s
-      # Doing this makes it easier to parse Base#[](attr_name)
-      join(ID_SEP)
-    end
-  end
-end
-
-Array.send(:include, CompositePrimaryKeys::ArrayExtension)
+module CompositePrimaryKeys
+  ID_SEP     = ','
+  ID_SET_SEP = ';'
+
+  module ArrayExtension
+    def to_composite_keys
+      CompositeKeys.new(self)
+    end
+  end
+
+  class CompositeKeys < Array
+    def self.parse(value)
+      case value
+      when Array
+        value.to_composite_keys
+      when String
+        self.new(value.split(ID_SEP))
+      else
+        raise(ArgumentError, "Unsupported type: #{value}")
+      end
+    end
+
+    def to_s
+      # Doing this makes it easier to parse Base#[](attr_name)
+      join(ID_SEP)
+    end
+  end
+end
+
+Array.send(:include, CompositePrimaryKeys::ArrayExtension)

data/lib/composite_primary_keys/composite_predicates.rb

@@ -1,51 +1,51 @@
-module CompositePrimaryKeys
-  module Predicates
-    def cpk_and_predicate(predicates)
-      if predicates.length == 1
-        predicates.first
-      else
-        Arel::Nodes::And.new(predicates)
-      end
-    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)
-      eq_predicates = keys.zip(values).map do |key, value|
-        table[key].eq(value)
-      end
-      cpk_and_predicate(eq_predicates)
-    end
-
-    def cpk_join_predicate(table1, key1, table2, key2)
-      key1_fields = Array(key1).map {|key| table1[key]}
-      key2_fields = Array(key2).map {|key| table2[key]}
-
-      eq_predicates = key1_fields.zip(key2_fields).map do |key_field1, key_field2|
-        key_field1.eq(key_field2)
-      end
-      cpk_and_predicate(eq_predicates)
-    end
-
-    def cpk_in_predicate(table, primary_keys, ids)
-      and_predicates = ids.map do |id|
-        cpk_id_predicate(table, primary_keys, id)
-      end
-      cpk_or_predicate(and_predicates)
-    end
-  end
-end
-
-ActiveRecord::Associations::AssociationScope.send(:include, CompositePrimaryKeys::Predicates)
-ActiveRecord::Associations::JoinDependency::JoinAssociation.send(:include, CompositePrimaryKeys::Predicates)
-ActiveRecord::Associations::Preloader::Association.send(:include, CompositePrimaryKeys::Predicates)
-ActiveRecord::Associations::HasManyThroughAssociation.send(:include, CompositePrimaryKeys::Predicates)
-ActiveRecord::Relation.send(:include, CompositePrimaryKeys::Predicates)
+module CompositePrimaryKeys
+  module Predicates
+    def cpk_and_predicate(predicates)
+      if predicates.length == 1
+        predicates.first
+      else
+        Arel::Nodes::And.new(predicates)
+      end
+    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)
+      eq_predicates = keys.zip(values).map do |key, value|
+        table[key].eq(value)
+      end
+      cpk_and_predicate(eq_predicates)
+    end
+
+    def cpk_join_predicate(table1, key1, table2, key2)
+      key1_fields = Array(key1).map {|key| table1[key]}
+      key2_fields = Array(key2).map {|key| table2[key]}
+
+      eq_predicates = key1_fields.zip(key2_fields).map do |key_field1, key_field2|
+        key_field1.eq(key_field2)
+      end
+      cpk_and_predicate(eq_predicates)
+    end
+
+    def cpk_in_predicate(table, primary_keys, ids)
+      and_predicates = ids.map do |id|
+        cpk_id_predicate(table, primary_keys, id)
+      end
+      cpk_or_predicate(and_predicates)
+    end
+  end
+end
+
+ActiveRecord::Associations::AssociationScope.send(:include, CompositePrimaryKeys::Predicates)
+ActiveRecord::Associations::JoinDependency::JoinAssociation.send(:include, CompositePrimaryKeys::Predicates)
+ActiveRecord::Associations::Preloader::Association.send(:include, CompositePrimaryKeys::Predicates)
+ActiveRecord::Associations::HasManyThroughAssociation.send(:include, CompositePrimaryKeys::Predicates)
+ActiveRecord::Relation.send(:include, CompositePrimaryKeys::Predicates)
 ActiveRecord::PredicateBuilder.send(:extend, CompositePrimaryKeys::Predicates)

data/lib/composite_primary_keys/composite_relation.rb

@@ -1,48 +1,48 @@
-module CompositePrimaryKeys
-  module CompositeRelation
-    include CompositePrimaryKeys::ActiveRecord::Batches
-    include CompositePrimaryKeys::ActiveRecord::Calculations
-    include CompositePrimaryKeys::ActiveRecord::FinderMethods
-    include CompositePrimaryKeys::ActiveRecord::QueryMethods
-
-    def delete(id_or_array)
-      # CPK
-      if self.composite?
-        id_or_array = if id_or_array.is_a?(CompositePrimaryKeys::CompositeKeys)
-                        [id_or_array]
-                      else
-                        Array(id_or_array)
-                      end
-
-        id_or_array.each do |id|
-          # Is the passed in id actually a record?
-          id = id.kind_of?(::ActiveRecord::Base) ? id.id : id
-          where(cpk_id_predicate(table, self.primary_key, id)).delete_all
-        end
-      else
-        where(primary_key => id_or_array).delete_all
-      end
-    end
-
-    def destroy(id_or_array)
-      # Without CPK:
-      #if id.is_a?(Array)
-      #  id.map { |one_id| destroy(one_id) }
-      #else
-      #  find(id).destroy
-      #end
-
-      id_or_array = if id_or_array.kind_of?(CompositePrimaryKeys::CompositeKeys)
-        [id_or_array]
-      else
-        Array(id_or_array)
-      end
-
-      id_or_array.each do |id|
-        where(cpk_id_predicate(table, self.primary_key, id)).each do |record|
-          record.destroy
-        end
-      end
-    end
-  end
-end
+module CompositePrimaryKeys
+  module CompositeRelation
+    include CompositePrimaryKeys::ActiveRecord::Batches
+    include CompositePrimaryKeys::ActiveRecord::Calculations
+    include CompositePrimaryKeys::ActiveRecord::FinderMethods
+    include CompositePrimaryKeys::ActiveRecord::QueryMethods
+
+    def delete(id_or_array)
+      # CPK
+      if self.composite?
+        id_or_array = if id_or_array.is_a?(CompositePrimaryKeys::CompositeKeys)
+                        [id_or_array]
+                      else
+                        Array(id_or_array)
+                      end
+
+        id_or_array.each do |id|
+          # Is the passed in id actually a record?
+          id = id.kind_of?(::ActiveRecord::Base) ? id.id : id
+          where(cpk_id_predicate(table, self.primary_key, id)).delete_all
+        end
+      else
+        where(primary_key => id_or_array).delete_all
+      end
+    end
+
+    def destroy(id_or_array)
+      # Without CPK:
+      #if id.is_a?(Array)
+      #  id.map { |one_id| destroy(one_id) }
+      #else
+      #  find(id).destroy
+      #end
+
+      id_or_array = if id_or_array.kind_of?(CompositePrimaryKeys::CompositeKeys)
+        [id_or_array]
+      else
+        Array(id_or_array)
+      end
+
+      id_or_array.each do |id|
+        where(cpk_id_predicate(table, self.primary_key, id)).each do |record|
+          record.destroy
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/connection_adapters/abstract/connection_specification_changes.rb

@@ -4,9 +4,6 @@ module ActiveRecord
       if (adapter.to_s =~ /postgresql/) or (adapter.to_s =~ /postgis/)
         require "composite_primary_keys/connection_adapters/postgresql_adapter.rb"
       end
-      if (adapter.to_s =~ /sqlserver/)
-        require "composite_primary_keys/connection_adapters/sqlserver_adapter.rb"
-      end
     end
 
     def self.establish_connection(spec = ENV["DATABASE_URL"])
@@ -64,7 +61,8 @@ module ActiveRecord
         connection_handler.clear_active_connections!
       end
 
-      delegate :clear_reloadable_connections!, :clear_all_connections!, :to => :connection_handler
+      delegate :clear_reloadable_connections!,
+        :clear_all_connections!,:verify_active_connections!, :to => :connection_handler
     end
   end
 end

data/lib/composite_primary_keys/connection_adapters/postgresql_adapter.rb

@@ -1,60 +1,46 @@
-module ActiveRecord
-  module ConnectionAdapters
-    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
-          # CPK
-          # select_value("#{sql} RETURNING #{quote_column_name(pk)}")
-          select_value("#{sql} RETURNING #{quote_column_names(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
-
-        # CPK
-        # sql = "#{sql} RETURNING #{quote_column_name(pk)}" if pk
-        sql = "#{sql} RETURNING #{quote_column_names(pk)}" if pk
-
-        [sql, binds]
-      end
-
-      # Returns a single value if query returns a single element
-      # otherwise returns an array coresponding 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
-
-      module Quoting
-        def quote_column_name(name) #:nodoc:
-          # 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
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module ConnectionAdapters
+    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
+          # CPK
+          # select_value("#{sql} RETURNING #{quote_column_name(pk)}")
+          select_value("#{sql} RETURNING #{quote_column_names(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
+
+        # CPK
+        # sql = "#{sql} RETURNING #{quote_column_name(pk)}" if pk
+        sql = "#{sql} RETURNING #{quote_column_names(pk)}" if pk
+
+        [sql, binds]
+      end
+
+      # Returns a single value if query returns a single element
+      # otherwise returns an array coresponding 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
+  end
+end

data/lib/composite_primary_keys/core.rb

@@ -1,47 +1,69 @@
-module ActiveRecord
-  module Core
-    def init_internals
-      pk = self.class.primary_key
-
-      # CPK
-      #@attributes[pk] = nil unless @attributes.key?(pk)
-      unless self.composite?
-        @attributes[pk] = nil unless @attributes.key?(pk)
-      end
-
-      @aggregation_cache        = {}
-      @association_cache        = {}
-      @attributes_cache         = {}
-      @readonly                 = false
-      @destroyed                = false
-      @marked_for_destruction   = false
-      @destroyed_by_association = nil
-      @new_record               = true
-      @txn                      = nil
-      @_start_transaction_state = {}
-      @transaction_state        = nil
-      @reflects_state           = [false]
-    end
-
-    def initialize_dup(other) # :nodoc:
-      cloned_attributes = other.clone_attributes(:read_attribute_before_type_cast)
-      self.class.initialize_attributes(cloned_attributes, :serialized => false)
-
-      @attributes = cloned_attributes
-
-      # CPK
-      #@attributes[self.class.primary_key] = nil
-      Array(self.class.primary_key).each {|key| @attributes[key] = nil}
-
-      run_callbacks(:initialize) unless _initialize_callbacks.empty?
-
-      @aggregation_cache = {}
-      @association_cache = {}
-      @attributes_cache  = {}
-
-      @new_record  = true
-
-      super
-    end
-  end
-end
+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)}
+
+      run_callbacks(:initialize) unless _initialize_callbacks.empty?
+
+      @aggregation_cache = {}
+      @association_cache = {}
+
+      @new_record  = true
+      @destroyed   = false
+
+      super
+    end
+    
+    
+  end
+end
+
+
+module CompositePrimaryKeys
+  module ActiveRecordCoreConcernIncludedExtension
+    extend ActiveSupport::Concern
+
+    included do
+      def self.find(*ids)
+        if composite?
+          super(cpk_parse_ids(ids))
+        else
+          super
+        end
+      end
+      
+      private
+      def self.cpk_parse_ids(ids)
+        result = []
+        ids.each do |id|
+          if id.is_a?(String)
+            if id.index(",")
+              result << [id.split(",")]
+            else
+              result << [id]
+            end
+          elsif id.is_a?(Array) && id.count > 1 && id.first.to_s.index(",")
+            result << id.map{|subid| subid.split(",")}
+          else
+            result << [id]
+          end
+        end
+        
+        copy_to_find_depth, depth = result.dup, -1
+
+        until copy_to_find_depth == result.flatten
+          depth += 1
+          copy_to_find_depth = copy_to_find_depth.flatten(1)
+        end
+        
+        result = result.flatten(depth)
+        return result
+      end
+    end
+  end
+end
+  
+ActiveRecord::Base.send(:include, CompositePrimaryKeys::ActiveRecordCoreConcernIncludedExtension)