composite_primary_keys 7.0.16 → 8.0.0

data/lib/composite_primary_keys/relation/query_methods.rb

@@ -1,41 +1,41 @@
-module CompositePrimaryKeys::ActiveRecord::QueryMethods
-
-  def reverse_sql_order(order_query)
-    # CPK
-    # order_query = ["#{quoted_table_name}.#{quoted_primary_key} ASC"] if order_query.empty?
-
-    # break apart CPKs 
-    order_query = primary_key.map do |key|
-      "#{quoted_table_name}.#{connection.quote_column_name(key)} ASC"
-    end if order_query.empty?
-
-    order_query.map do |o|
-      case o
-      when Arel::Nodes::Ordering
-        o.reverse
-      when String, Symbol
-        o.to_s.split(',').collect do |s|
-          s.strip!
-          s.gsub!(/\sasc\Z/i, ' DESC') || s.gsub!(/\sdesc\Z/i, ' ASC') || s.concat(' DESC')
-        end
-      else
-        o
-      end
-    end.flatten
-  end
-
-
-  def order(*args)    
-    args.map! do |arg|
-      if arg.is_a?(Arel::Nodes::Ordering) && arg.expr.name.is_a?(Array)
-        arg = arg.expr.name.map do |key|
-          cloned_node = arg.clone
-          cloned_node.expr.name = key
-          cloned_node
-        end
-      end
-      arg
-    end if composite?
-    super(*args)
-  end
+module CompositePrimaryKeys::ActiveRecord::QueryMethods
+
+  def reverse_sql_order(order_query)
+    # CPK
+    # order_query = ["#{quoted_table_name}.#{quoted_primary_key} ASC"] if order_query.empty?
+
+    # break apart CPKs 
+    order_query = primary_key.map do |key|
+      "#{quoted_table_name}.#{connection.quote_column_name(key)} ASC"
+    end if order_query.empty?
+
+    order_query.map do |o|
+      case o
+      when Arel::Nodes::Ordering
+        o.reverse
+      when String, Symbol
+        o.to_s.split(',').collect do |s|
+          s.strip!
+          s.gsub!(/\sasc\Z/i, ' DESC') || s.gsub!(/\sdesc\Z/i, ' ASC') || s.concat(' DESC')
+        end
+      else
+        o
+      end
+    end.flatten
+  end
+
+
+  def order(*args)    
+    args.map! do |arg|
+      if arg.is_a?(Arel::Nodes::Ordering) && arg.expr.name.is_a?(Array)
+        arg = arg.expr.name.map do |key|
+          cloned_node = arg.clone
+          cloned_node.expr.name = key
+          cloned_node
+        end
+      end
+      arg
+    end if composite?
+    super(*args)
+  end
 end

data/lib/composite_primary_keys/sanitization.rb

@@ -1,52 +1,52 @@
-module ActiveRecord
-  module Sanitization
-    module ClassMethods
-      protected
-      # Accepts a hash of SQL conditions and replaces those attributes
-      # that correspond to a +composed_of+ relationship with their expanded
-      # aggregate attribute values.
-      # Given:
-      #     class Person < ActiveRecord::Base
-      #       composed_of :address, class_name: "Address",
-      #         mapping: [%w(address_street street), %w(address_city city)]
-      #     end
-      # Then:
-      #     { address: Address.new("813 abc st.", "chicago") }
-      #       # => { address_street: "813 abc st.", address_city: "chicago" }
-      def expand_hash_conditions_for_aggregates(attrs)
-        expanded_attrs = {}
-        attrs.each do |attr, value|
-          if attr.is_a?(CompositePrimaryKeys::CompositeKeys)
-            attr.each_with_index do |key,i|
-              expanded_attrs[key] = value.flatten[i]
-            end
-          elsif aggregation = reflect_on_aggregation(attr.to_sym)
-            mapping = aggregation.mapping
-            mapping.each do |field_attr, aggregate_attr|
-              if mapping.size == 1 && !value.respond_to?(aggregate_attr)
-                expanded_attrs[field_attr] = value
-              else
-                expanded_attrs[field_attr] = value.send(aggregate_attr)
-              end
-            end
-          else
-            expanded_attrs[attr] = value
-          end
-        end
-        expanded_attrs
-      end
-
-      def quoted_id
-        # CPK
-        #quote_value(id, column_for_attribute(self.class.primary_key))
-        if self.composite?
-          [self.class.primary_keys, ids].
-            transpose.
-            map {|attr_name,id| quote_value(id, column_for_attribute(attr_name))}
-        else
-          quote_value(id, column_for_attribute(self.class.primary_key))
-        end
-      end
-    end
-  end
-end
+module ActiveRecord
+  module Sanitization
+    module ClassMethods
+      protected
+      # Accepts a hash of SQL conditions and replaces those attributes
+      # that correspond to a +composed_of+ relationship with their expanded
+      # aggregate attribute values.
+      # Given:
+      #     class Person < ActiveRecord::Base
+      #       composed_of :address, class_name: "Address",
+      #         mapping: [%w(address_street street), %w(address_city city)]
+      #     end
+      # Then:
+      #     { address: Address.new("813 abc st.", "chicago") }
+      #       # => { address_street: "813 abc st.", address_city: "chicago" }
+      def expand_hash_conditions_for_aggregates(attrs)
+        expanded_attrs = {}
+        attrs.each do |attr, value|
+          if attr.is_a?(CompositePrimaryKeys::CompositeKeys)
+            attr.each_with_index do |key,i|
+              expanded_attrs[key] = value.respond_to?(:flatten) ? value.flatten[i] : value
+            end
+          elsif aggregation = reflect_on_aggregation(attr.to_sym)
+            mapping = aggregation.mapping
+            mapping.each do |field_attr, aggregate_attr|
+              if mapping.size == 1 && !value.respond_to?(aggregate_attr)
+                expanded_attrs[field_attr] = value
+              else
+                expanded_attrs[field_attr] = value.send(aggregate_attr)
+              end
+            end
+          else
+            expanded_attrs[attr] = value
+          end
+        end
+        expanded_attrs
+      end
+
+      def quoted_id
+        # CPK
+        #quote_value(id, column_for_attribute(self.class.primary_key))
+        if self.composite?
+          [self.class.primary_keys, ids].
+            transpose.
+            map {|attr_name,id| quote_value(id, column_for_attribute(attr_name))}
+        else
+          quote_value(id, column_for_attribute(self.class.primary_key))
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/validations/uniqueness.rb

@@ -1,38 +1,37 @@
-module ActiveRecord
-  module Validations
-    class UniquenessValidator
-      def validate_each(record, attribute, value)
-        finder_class = find_finder_class_for(record)
-        table = finder_class.arel_table
-        value = map_enum_attribute(finder_class,attribute,value)
-        value = deserialize_attribute(record, attribute, value)
-
-        relation = build_relation(finder_class, table, attribute, value)
-        # CPK
-        # relation = relation.and(table[finder_class.primary_key.to_sym].not_eq(record.id)) if record.persisted?
-        if record.persisted?
-          not_eq_conditions = Array(finder_class.primary_key).zip(Array(record.send(:id))).map do |name, value|
-            table[name.to_sym].not_eq(value)
-          end
-
-          condition = not_eq_conditions.shift
-          not_eq_conditions.each do |not_eq_condition|
-            condition = condition.or(not_eq_condition)
-          end
-          relation = relation.and(condition)
-        end
-
-        relation = scope_relation(record, table, relation)
-        relation = finder_class.unscoped.where(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)
+        table = finder_class.arel_table
+        value = map_enum_attribute(finder_class, attribute, value)
+
+        relation = build_relation(finder_class, table, attribute, value)
+        # CPK
+        # relation = relation.and(table[finder_class.primary_key.to_sym].not_eq(record.id)) if record.persisted?
+        if record.persisted?
+          not_eq_conditions = Array(finder_class.primary_key).zip(Array(record.send(:id))).map do |name, value|
+            table[name.to_sym].not_eq(value)
+          end
+
+          condition = not_eq_conditions.shift
+          not_eq_conditions.each do |not_eq_condition|
+            condition = condition.or(not_eq_condition)
+          end
+          relation = relation.and(condition)
+        end
+        
+        relation = scope_relation(record, table, relation)
+        relation = finder_class.unscoped.where(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

@@ -1,8 +1,8 @@
-module CompositePrimaryKeys
-  module VERSION
-    MAJOR = 7
-    MINOR = 0
-    TINY  = 16
-    STRING = [MAJOR, MINOR, TINY].join('.')
-  end
-end
+module CompositePrimaryKeys
+  module VERSION
+    MAJOR = 8
+    MINOR = 0
+    TINY  = 0
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/tasks/databases/oracle.rake

@@ -1,25 +1,25 @@
-require File.join(PROJECT_ROOT, 'lib', 'composite_primary_keys')
-require File.join(PROJECT_ROOT, 'test', 'connections', 'connection_spec')
-
-namespace :oracle do
-  desc 'Build the Oracle test database'
-  task :build_database => :load_connection do
-    options_str = connection_string
-
-    schema = File.join(PROJECT_ROOT, 'test', 'fixtures', 'db_definitions', 'oracle.sql')
-    sh %( sqlplus #{options_str} < #{schema} )
-  end
-
-  desc 'Drop the Oracle test database'
-  task :drop_database => :load_connection do 
-    options_str = connection_string
-    sh %( sqlplus #{options_str} < #{File.join(SCHEMA_PATH, 'oracle.drop.sql')} )
-  end
-
-  desc 'Rebuild the Oracle test database'
-  task :rebuild_database => [:drop_database, :build_database]
-
-  task :load_connection do
-    require File.join(PROJECT_ROOT, "test", "connections", "native_oracle", "connection")
-  end
-end
+require File.join(PROJECT_ROOT, 'lib', 'composite_primary_keys')
+require File.join(PROJECT_ROOT, 'test', 'connections', 'connection_spec')
+
+namespace :oracle do
+  desc 'Build the Oracle test database'
+  task :build_database => :load_connection do
+    options_str = connection_string
+
+    schema = File.join(PROJECT_ROOT, 'test', 'fixtures', 'db_definitions', 'oracle.sql')
+    sh %( sqlplus #{options_str} < #{schema} )
+  end
+
+  desc 'Drop the Oracle test database'
+  task :drop_database => :load_connection do 
+    options_str = connection_string
+    sh %( sqlplus #{options_str} < #{File.join(SCHEMA_PATH, 'oracle.drop.sql')} )
+  end
+
+  desc 'Rebuild the Oracle test database'
+  task :rebuild_database => [:drop_database, :build_database]
+
+  task :load_connection do
+    require File.join(PROJECT_ROOT, "test", "connections", "native_oracle", "connection")
+  end
+end

data/tasks/databases/sqlserver.rake

@@ -1,40 +1,27 @@
-require File.join(PROJECT_ROOT, 'lib', 'composite_primary_keys')
-require File.join(PROJECT_ROOT, 'test', 'connections', 'connection_spec')
-
-require 'rbconfig'
-if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
-  sql_cmd = "osql"
-else
-  sql_cmd = sqsh
-end
-
-namespace :sqlserver do
-  desc 'Build the SQL Server test database'
-  task :build_database => :load_connection do
-    options_str = connection_string
-
-    schema = File.join(PROJECT_ROOT, 'test', 'fixtures', 'db_definitions',
-                       'sqlserver.sql').gsub(File::SEPARATOR,
-                                             File::ALT_SEPARATOR ||
-                                             File::SEPARATOR)
-    sh %( #{sql_cmd} #{options_str} -i #{schema} )
-  end
-
-  desc 'Drop the SQL Server test database'
-  task :drop_database => :load_connection do
-    options_str = connection_string
-
-    schema = File.join(PROJECT_ROOT, 'test', 'fixtures', 'db_definitions',
-                       'sqlserver.drop.sql').gsub(File::SEPARATOR,
-                                                  File::ALT_SEPARATOR ||
-                                                  File::SEPARATOR)
-    sh %( #{sql_cmd} #{options_str} -i #{schema} )
-  end
-
-  desc 'Rebuild the SQL Server test database'
-  task :rebuild_database => [:drop_database, :build_database]
-
-  task :load_connection do
-    require File.join(PROJECT_ROOT, "test", "connections", "native_sqlserver", "connection")
-  end
-end
+require File.join(PROJECT_ROOT, 'lib', 'composite_primary_keys')
+require File.join(PROJECT_ROOT, 'test', 'connections', 'connection_spec')
+
+namespace :sqlserver do
+  desc 'Build the SQL Server test database'
+  task :build_database => :load_connection do
+    options_str = connection_string
+
+    schema = File.join(PROJECT_ROOT, 'test', 'fixtures', 'db_definitions', 'sqlserver.sql')
+    sh %( sqsh #{options_str} -i #{schema} )
+  end
+
+  desc 'Drop the SQL Server test database'
+  task :drop_database => :load_connection do 
+    options_str = connection_string
+    
+    schema = File.join(PROJECT_ROOT, 'test', 'fixtures', 'db_definitions', 'sqlserver.drop.sql')
+    sh %( sqsh #{options_str} -i #{schema} )
+  end
+
+  desc 'Rebuild the SQL Server test database'
+  task :rebuild_database => [:drop_database, :build_database]
+
+  task :load_connection do
+    require File.join(PROJECT_ROOT, "test", "connections", "native_sqlserver", "connection")
+  end
+end

data/test/abstract_unit.rb

@@ -1,113 +1,113 @@
-PROJECT_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
-
-# To make debugging easier, test within this source tree versus an installed gem
-$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
-require 'composite_primary_keys'
-require 'minitest/autorun'
-require 'active_support/test_case'
-
-# Now load the connection spec
-require File.join(PROJECT_ROOT, "test", "connections", "connection_spec")
-
-spec_name = ENV['ADAPTER'] || 'postgresql'
-spec = CompositePrimaryKeys::ConnectionSpec[spec_name]
-
-# And now connect to the database
-adapter = spec['adapter']
-require File.join(PROJECT_ROOT, "test", "connections", "native_#{spec_name}", "connection")
-
-# Tell active record about the configuration
-ActiveRecord::Base.configurations[:test] = spec
-
-# Tell ActiveRecord where to find models
-ActiveSupport::Dependencies.autoload_paths << File.join(PROJECT_ROOT, 'test', 'fixtures')
-
-I18n.config.enforce_available_locales = true
-
-class ActiveSupport::TestCase
-  include ActiveRecord::TestFixtures
-  
-  self.fixture_path = File.dirname(__FILE__) + "/fixtures/"
-  self.use_instantiated_fixtures = false
-  self.use_transactional_fixtures = true
-
-  def assert_date_from_db(expected, actual, message = nil)
-    # SQL Server doesn't have a separate column type just for dates, 
-    # so the time is in the string and incorrectly formatted
-    if current_adapter?(:SQLServerAdapter)
-      assert_equal expected.strftime("%Y/%m/%d 00:00:00"), actual.strftime("%Y/%m/%d 00:00:00")
-    elsif current_adapter?(:SybaseAdapter)
-      assert_equal expected.to_s, actual.to_date.to_s, message
-    else
-      assert_equal expected.to_s, actual.to_s, message
-    end
-  end
-
-  def assert_queries(num = 1)
-    ActiveRecord::Base.connection.class.class_eval do
-      self.query_count = 0
-      alias_method :execute, :execute_with_query_counting
-    end
-    yield
-  ensure
-    ActiveRecord::Base.connection.class.class_eval do
-      alias_method :execute, :execute_without_query_counting
-    end
-    assert_equal num, ActiveRecord::Base.connection.query_count, "#{ActiveRecord::Base.connection.query_count} instead of #{num} queries were executed."
-  end
-
-  def assert_no_queries(&block)
-    assert_queries(0, &block)
-  end
-  
-  cattr_accessor :classes
-
-  protected
-  
-  def testing_with(&block)
-    classes.keys.each do |key_test|
-      @key_test = key_test
-      @klass_info = classes[@key_test]
-      @klass, @primary_keys = @klass_info[:class], @klass_info[:primary_keys]
-      order = @klass.primary_key.is_a?(String) ? @klass.primary_key : @klass.primary_key.join(',')
-      @first = @klass.order(order).first
-      yield
-    end
-  end
-  
-  def first_id
-    ids = (1..@primary_keys.length).map {|num| 1}
-    composite? ? ids.to_composite_ids : ids.first
-  end
-  
-  def composite?
-    @key_test != :single
-  end  
-
-  # Oracle metadata is in all caps.
-  def with_quoted_identifiers(s)
-    s.gsub(/"(\w+)"/) { |m|
-      if ActiveRecord::Base.configurations[:test]['adapter'] =~ /oracle/i
-        m.upcase
-      else
-        m
-      end
-    }
-  end
-end
-
-def current_adapter?(type)
-  ActiveRecord::ConnectionAdapters.const_defined?(type) &&
-    ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters.const_get(type))
-end
-
-ActiveRecord::Base.connection.class.class_eval do
-  cattr_accessor :query_count
-  alias_method :execute_without_query_counting, :execute
-  def execute_with_query_counting(sql, name = nil)
-    self.query_count += 1
-    execute_without_query_counting(sql, name)
-  end
-end
-
-ActiveRecord::Base.logger = Logger.new(ENV['CPK_LOGFILE'] || STDOUT)
+PROJECT_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+# To make debugging easier, test within this source tree versus an installed gem
+$LOAD_PATH.unshift(File.expand_path('../../lib', __FILE__))
+require 'composite_primary_keys'
+require 'minitest/autorun'
+require 'active_support/test_case'
+
+# Now load the connection spec
+require File.join(PROJECT_ROOT, "test", "connections", "connection_spec")
+
+spec_name = ENV['ADAPTER'] || 'postgresql'
+spec = CompositePrimaryKeys::ConnectionSpec[spec_name]
+
+# And now connect to the database
+adapter = spec['adapter']
+require File.join(PROJECT_ROOT, "test", "connections", "native_#{spec_name}", "connection")
+
+# Tell active record about the configuration
+ActiveRecord::Base.configurations[:test] = spec
+
+# Tell ActiveRecord where to find models
+ActiveSupport::Dependencies.autoload_paths << File.join(PROJECT_ROOT, 'test', 'fixtures')
+
+I18n.config.enforce_available_locales = true
+
+class ActiveSupport::TestCase
+  include ActiveRecord::TestFixtures
+  
+  self.fixture_path = File.dirname(__FILE__) + "/fixtures/"
+  self.use_instantiated_fixtures = false
+  self.use_transactional_fixtures = true
+
+  def assert_date_from_db(expected, actual, message = nil)
+    # SQL Server doesn't have a separate column type just for dates, 
+    # so the time is in the string and incorrectly formatted
+    if current_adapter?(:SQLServerAdapter)
+      assert_equal expected.strftime("%Y/%m/%d 00:00:00"), actual.strftime("%Y/%m/%d 00:00:00")
+    elsif current_adapter?(:SybaseAdapter)
+      assert_equal expected.to_s, actual.to_date.to_s, message
+    else
+      assert_equal expected.to_s, actual.to_s, message
+    end
+  end
+
+  def assert_queries(num = 1)
+    ActiveRecord::Base.connection.class.class_eval do
+      self.query_count = 0
+      alias_method :execute, :execute_with_query_counting
+    end
+    yield
+  ensure
+    ActiveRecord::Base.connection.class.class_eval do
+      alias_method :execute, :execute_without_query_counting
+    end
+    assert_equal num, ActiveRecord::Base.connection.query_count, "#{ActiveRecord::Base.connection.query_count} instead of #{num} queries were executed."
+  end
+
+  def assert_no_queries(&block)
+    assert_queries(0, &block)
+  end
+  
+  cattr_accessor :classes
+
+  protected
+  
+  def testing_with(&block)
+    classes.keys.each do |key_test|
+      @key_test = key_test
+      @klass_info = classes[@key_test]
+      @klass, @primary_keys = @klass_info[:class], @klass_info[:primary_keys]
+      order = @klass.primary_key.is_a?(String) ? @klass.primary_key : @klass.primary_key.join(',')
+      @first = @klass.order(order).first
+      yield
+    end
+  end
+  
+  def first_id
+    ids = (1..@primary_keys.length).map {|num| 1}
+    composite? ? ids.to_composite_ids : ids.first
+  end
+  
+  def composite?
+    @key_test != :single
+  end  
+
+  # Oracle metadata is in all caps.
+  def with_quoted_identifiers(s)
+    s.gsub(/"(\w+)"/) { |m|
+      if ActiveRecord::Base.configurations[:test]['adapter'] =~ /oracle/i
+        m.upcase
+      else
+        m
+      end
+    }
+  end
+end
+
+def current_adapter?(type)
+  ActiveRecord::ConnectionAdapters.const_defined?(type) &&
+    ActiveRecord::Base.connection.instance_of?(ActiveRecord::ConnectionAdapters.const_get(type))
+end
+
+ActiveRecord::Base.connection.class.class_eval do
+  cattr_accessor :query_count
+  alias_method :execute_without_query_counting, :execute
+  def execute_with_query_counting(sql, name = nil)
+    self.query_count += 1
+    execute_without_query_counting(sql, name)
+  end
+end
+
+ActiveRecord::Base.logger = Logger.new(ENV['CPK_LOGFILE'] || STDOUT)