composite_primary_keys 8.1.0 → 8.1.1

data/lib/composite_primary_keys/composite_arrays.rb

@@ -1,43 +1,43 @@
-module CompositePrimaryKeys
-  ID_SEP     = ','
-  ID_SET_SEP = ';'
-
-  module ArrayExtension
-    def to_composite_keys
-      CompositeKeys.new(self)
-    end
-  end
-
-  def self.normalize(ids)
-    ids.map do |id|
-      if id.is_a?(Array)
-        normalize(id)
-      elsif id.is_a?(String) && id.index(ID_SEP)
-        id.split(ID_SEP)
-      else
-        id
-      end
-    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
+
+  def self.normalize(ids)
+    ids.map do |id|
+      if id.is_a?(Array)
+        normalize(id)
+      elsif id.is_a?(String) && id.index(ID_SEP)
+        id.split(ID_SEP)
+      else
+        id
+      end
+    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/connection_adapters/abstract/connection_specification_changes.rb

@@ -9,7 +9,7 @@ module ActiveRecord
       end
     end
 
-    def self.establish_connection(spec = ENV["DATABASE_URL"])
+    def self.establish_connection(spec = nil)
       spec     ||= ActiveRecord::ConnectionHandling::DEFAULT_ENV.call.to_sym
       resolver =   ConnectionAdapters::ConnectionSpecification::Resolver.new configurations
       spec     =   resolver.spec(spec)
@@ -64,8 +64,7 @@ module ActiveRecord
         connection_handler.clear_active_connections!
       end
 
-      delegate :clear_reloadable_connections!,
-        :clear_all_connections!,:verify_active_connections!, :to => :connection_handler
+      delegate :clear_reloadable_connections!, :clear_all_connections!, :to => :connection_handler
     end
   end
 end

data/lib/composite_primary_keys/core.rb

@@ -1,61 +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)}
-
-      run_callbacks(:initialize) unless _initialize_callbacks.empty?
-
-      @aggregation_cache = {}
-      @association_cache = {}
-
-      @new_record  = true
-      @destroyed   = false
-
-      super
-    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|
-            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}"
-        end
-        record
-      rescue RangeError
-        raise RecordNotFound, "Couldn't find #{name} with an out of range value for '#{primary_key}'"
-      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
+
+    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|
+            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}"
+        end
+        record
+      rescue RangeError
+        raise RecordNotFound, "Couldn't find #{name} with an out of range value for '#{primary_key}'"
+      end
+    end
+  end
 end

data/lib/composite_primary_keys/persistence.rb

@@ -1,57 +1,57 @@
-module ActiveRecord
-  module Persistence
-    def relation_for_destroy
-      # CPK
-      if self.composite?
-        relation = self.class.unscoped
-
-        Array(self.class.primary_key).each_with_index do |key, index|
-          column     = self.class.columns_hash[key]
-          substitute = self.class.connection.substitute_at(column, index)
-          relation = relation.where(self.class.arel_table[key].eq(substitute))
-          relation.bind_values += [[column, self[key]]]
-        end
-
-        relation
-      else
-        pk         = self.class.primary_key
-        column     = self.class.columns_hash[pk]
-        substitute = self.class.connection.substitute_at(column, 0)
-
-        relation = self.class.unscoped.where(
-          self.class.arel_table[pk].eq(substitute))
-
-        relation.bind_values = [[column, id]]
-        relation
-      end
-    end
-
-    def touch(*names)
-      raise ActiveRecordError, "cannot touch on a new record object" unless persisted?
-
-      attributes = timestamp_attributes_for_update_in_model
-      attributes.concat(names)
-
-      unless attributes.empty?
-        current_time = current_time_from_proper_timezone
-        changes = {}
-
-        attributes.each do |column|
-          column = column.to_s
-          changes[column] = write_attribute(column, current_time)
-        end
-
-        changes[self.class.locking_column] = increment_lock if locking_enabled?
-
-        clear_attribute_changes(changes.keys)
-        primary_key = self.class.primary_key
-        # CPK
-        #self.class.unscoped.where(primary_key => self[primary_key]).update_all(changes) == 1
-        primary_key_predicate = self.class.unscoped.cpk_id_predicate(self.class.arel_table, Array(primary_key), Array(id))
-        self.class.unscoped.where(primary_key_predicate).update_all(changes) == 1
-      else
-        true
-      end
-    end
-  end
+module ActiveRecord
+  module Persistence
+    def relation_for_destroy
+      # CPK
+      if self.composite?
+        relation = self.class.unscoped
+
+        Array(self.class.primary_key).each_with_index do |key, index|
+          column     = self.class.columns_hash[key]
+          substitute = self.class.connection.substitute_at(column, index)
+          relation = relation.where(self.class.arel_table[key].eq(substitute))
+          relation.bind_values += [[column, self[key]]]
+        end
+
+        relation
+      else
+        pk         = self.class.primary_key
+        column     = self.class.columns_hash[pk]
+        substitute = self.class.connection.substitute_at(column, 0)
+
+        relation = self.class.unscoped.where(
+          self.class.arel_table[pk].eq(substitute))
+
+        relation.bind_values = [[column, id]]
+        relation
+      end
+    end
+
+    def touch(*names)
+      raise ActiveRecordError, "cannot touch on a new record object" unless persisted?
+
+      attributes = timestamp_attributes_for_update_in_model
+      attributes.concat(names)
+
+      unless attributes.empty?
+        current_time = current_time_from_proper_timezone
+        changes = {}
+
+        attributes.each do |column|
+          column = column.to_s
+          changes[column] = write_attribute(column, current_time)
+        end
+
+        changes[self.class.locking_column] = increment_lock if locking_enabled?
+
+        clear_attribute_changes(changes.keys)
+        primary_key = self.class.primary_key
+        # CPK
+        #self.class.unscoped.where(primary_key => self[primary_key]).update_all(changes) == 1
+        primary_key_predicate = self.class.unscoped.cpk_id_predicate(self.class.arel_table, Array(primary_key), Array(id))
+        self.class.unscoped.where(primary_key_predicate).update_all(changes) == 1
+      else
+        true
+      end
+    end
+  end
 end

data/lib/composite_primary_keys/relation.rb

@@ -1,68 +1,68 @@
-module ActiveRecord
-  class Relation
-    alias :initialize_without_cpk :initialize
-    def initialize(klass, table, values = {})
-      initialize_without_cpk(klass, table, values)
-      add_cpk_support if klass && klass.composite?
-    end
-
-    alias :initialize_copy_without_cpk :initialize_copy
-    def initialize_copy(other)
-      initialize_copy_without_cpk(other)
-      add_cpk_support if klass.composite?
-    end
-
-    def add_cpk_support
-      extend CompositePrimaryKeys::CompositeRelation
-    end
-
-    # CPK adds this so that it finds the Equality nodes beneath the And node:
-    # equalities = where_values.grep(Arel::Nodes::Equality).find_all { |node|
-    #  node.left.relation.name == table_name
-    # }
-    alias :where_values_hash_without_cpk :where_values_hash
-    def where_values_hash(relation_table_name = table_name)
-      nodes_from_and = where_values.grep(Arel::Nodes::And).map {|and_node| and_node.children.grep(Arel::Nodes::Equality) }.flatten
-
-      equalities = (nodes_from_and + where_values.grep(Arel::Nodes::Equality)).find_all { |node|
-        node.left.relation.name == relation_table_name
-      }
-
-      binds = Hash[bind_values.find_all(&:first).map { |column, v| [column.name, v] }]
-      
-      Hash[equalities.map { |where|
-        name = where.left.name
-        [name, binds.fetch(name.to_s) {
-          case where.right
-          when Array then where.right.map(&:val)
-          else
-            where.right.val
-          end
-        }]
-      }]
-    end
-
-    def _update_record(values, id, id_was)
-      substitutes, binds = substitute_values values
-
-      # CPK
-      um = if self.composite?
-        relation = @klass.unscoped.where(cpk_id_predicate(@klass.arel_table, @klass.primary_key, id_was || id))
-        relation.arel.compile_update(substitutes, @klass.primary_key)
-      else
-        scope = @klass.unscoped
-
-        if @klass.finder_needs_type_condition?
-          scope.unscope!(where: @klass.inheritance_column)
-        end
-        
-        scope.where(@klass.arel_table[@klass.primary_key].eq(id_was || id)).arel.compile_update(substitutes, @klass.primary_key)
-      end
-
-      @klass.connection.update(
-        um,
-        'SQL',
-        binds)
-    end
-  end
-end
+module ActiveRecord
+  class Relation
+    alias :initialize_without_cpk :initialize
+    def initialize(klass, table, values = {})
+      initialize_without_cpk(klass, table, values)
+      add_cpk_support if klass && klass.composite?
+    end
+
+    alias :initialize_copy_without_cpk :initialize_copy
+    def initialize_copy(other)
+      initialize_copy_without_cpk(other)
+      add_cpk_support if klass.composite?
+    end
+
+    def add_cpk_support
+      extend CompositePrimaryKeys::CompositeRelation
+    end
+
+    # CPK adds this so that it finds the Equality nodes beneath the And node:
+    # equalities = where_values.grep(Arel::Nodes::Equality).find_all { |node|
+    #  node.left.relation.name == table_name
+    # }
+    alias :where_values_hash_without_cpk :where_values_hash
+    def where_values_hash(relation_table_name = table_name)
+      nodes_from_and = where_values.grep(Arel::Nodes::And).map {|and_node| and_node.children.grep(Arel::Nodes::Equality) }.flatten
+
+      equalities = (nodes_from_and + where_values.grep(Arel::Nodes::Equality)).find_all { |node|
+        node.left.relation.name == relation_table_name
+      }
+
+      binds = Hash[bind_values.find_all(&:first).map { |column, v| [column.name, v] }]
+      
+      Hash[equalities.map { |where|
+        name = where.left.name
+        [name, binds.fetch(name.to_s) {
+          case where.right
+          when Array then where.right.map(&:val)
+          else
+            where.right.val
+          end
+        }]
+      }]
+    end
+
+    def _update_record(values, id, id_was)
+      substitutes, binds = substitute_values values
+
+      # CPK
+      um = if self.composite?
+        relation = @klass.unscoped.where(cpk_id_predicate(@klass.arel_table, @klass.primary_key, id_was || id))
+        relation.arel.compile_update(substitutes, @klass.primary_key)
+      else
+        scope = @klass.unscoped
+
+        if @klass.finder_needs_type_condition?
+          scope.unscope!(where: @klass.inheritance_column)
+        end
+        
+        scope.where(@klass.arel_table[@klass.primary_key].eq(id_was || id)).arel.compile_update(substitutes, @klass.primary_key)
+      end
+
+      @klass.connection.update(
+        um,
+        'SQL',
+        binds)
+    end
+  end
+end