composite_primary_keys 3.1.7 → 3.1.8

data/History.txt

@@ -1,10 +1,11 @@
-== 3.1.7 2011-05-19
+== 3.1.8 2011-05-26
+* Fix calling clear on a HABTM associate (David Rueck)
+
+== 3.1.7 2011-05-26
 * Support regular AR models having one or many composite models (Jacques Fuentes)
 * Minor test cleanup
 * Make version requirements more explicit
 * Remove Arel extensions used for calculations
-* Fix test that included wrong error constant
-
 
 == 3.1.6 2011-04-03
 * Updated belongs_to association to be a bit more flexible with non-CPK
@@ -13,14 +14,12 @@
 * Fix write issue when one of they keys in a composite key is
   called id (Tom Hughes)
 
-
 == 3.1.5 2011-03-24
 * Fix simple calculation methods
 * Fix instantiation of cpk records via associations.
 * Fix Relation#delete
 * Fix Relation#destroy
 
-
 == 3.1.4 2011-03-06
 * Support ActiveRecord 3.0.5 (interpolate_sql was removed and
   replaced by interpolate_and_sanitize_sql)

data/lib/composite_primary_keys.rb

@@ -25,7 +25,7 @@ $:.unshift(File.dirname(__FILE__)) unless
   $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
 unless defined?(ActiveRecord)
-  gem 'arel', '~> 2.0.0'
+  require 'rubygems'
   gem 'activerecord', '>= 3.0.5', '~> 3.0.0'
   require 'active_record'
 end

data/lib/composite_primary_keys/associations/association.rb

@@ -0,0 +1,23 @@
+module ActiveRecord
+  module Associations
+    class Association
+      def creation_attributes
+        attributes = {}
+
+        if reflection.macro.in?([:has_one, :has_many]) && !options[:through]
+          # CPK
+          # attributes[reflection.foreign_key] = owner[reflection.active_record_primary_key]
+          Array(reflection.foreign_key).zip(Array(reflection.active_record_primary_key)).each do |key1, key2|
+            attributes[key1] = owner[key2]
+          end
+
+          if reflection.options[:as]
+            attributes[reflection.type] = owner.class.base_class.name
+          end
+        end
+
+        attributes
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/association_scope.rb

@@ -0,0 +1,67 @@
+module ActiveRecord
+  module Associations
+    class AssociationScope
+      def add_constraints(scope)
+        tables = construct_tables
+
+        chain.each_with_index do |reflection, i|
+          table, foreign_table = tables.shift, tables.first
+
+          if reflection.source_macro == :has_and_belongs_to_many
+            join_table = tables.shift
+
+            # CPK
+            # scope = scope.joins(join(
+            #  join_table,
+            #  table[reflection.active_record_primary_key].
+            #    eq(join_table[reflection.association_foreign_key])
+            #))
+            predicate = cpk_join_predicate(table, reflection.association_primary_key,
+                                           join_table, reflection.association_foreign_key)
+            scope = scope.joins(join(join_table, predicate))
+
+            table, foreign_table = join_table, tables.first
+          end
+
+          if reflection.source_macro == :belongs_to
+            key         = reflection.association_primary_key
+            foreign_key = reflection.foreign_key
+          else
+            key         = reflection.foreign_key
+            foreign_key = reflection.active_record_primary_key
+          end
+
+          if reflection == chain.last
+            # CPK
+            # scope = scope.where(table[key].eq(owner[foreign_key]))
+            predicate = cpk_join_predicate(table, key, owner, foreign_key)
+            scope = scope.where(predicate)
+
+            conditions[i].each do |condition|
+              if options[:through] && condition.is_a?(Hash)
+                condition = { table.name => condition }
+              end
+
+              scope = scope.where(interpolate(condition))
+            end
+          else
+            # CPK
+            # constraint = table[key].eq(foreign_table[foreign_key])
+            constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
+            scope = scope.where(predicate)
+
+            join       = join(foreign_table, constraint)
+
+            scope = scope.joins(join)
+
+            unless conditions[i].empty?
+              scope = scope.where(sanitize(conditions[i], table))
+            end
+          end
+        end
+
+        scope
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/has_and_belongs_to_many_association.rb

@@ -88,6 +88,56 @@ module ActiveRecord
 
         return true
       end
-    end
+
+      # CPK
+      #def delete_records(records)
+      #  if sql = @reflection.options[:delete_sql]
+      #    records.each { |record| @owner.connection.delete(interpolate_and_sanitize_sql(sql, record)) }
+      #  else
+      #    relation = Arel::Table.new(@reflection.options[:join_table])
+      #    relation.where(relation[@reflection.primary_key_name].eq(@owner.id).
+      #      and(relation[@reflection.association_foreign_key].in(records.map { |x| x.id }.compact))
+      #    ).delete
+      #  end
+      #end
+
+      # CPK
+      def delete_records(records)
+        if sql = @reflection.options[:delete_sql]
+          records.each { |record| @owner.connection.delete(interpolate_and_sanitize_sql(sql, record)) }
+        else
+          relation = Arel::Table.new(@reflection.options[:join_table])
+
+          if @reflection.cpk_primary_key 
+            owner_conditions = []
+            @reflection.cpk_primary_key.each_with_index do |column,i|
+              owner_conditions << relation[column.to_sym].eq(@owner.id[i])
+            end
+            owner_conditions_arel = owner_conditions.inject { |conds, cond| conds.and(cond) }
+          else
+            owner_conditions_arel = relation[@reflection.primary_key_name].eq(@owner.id)
+          end
+
+          if @reflection.association_foreign_key.kind_of?(Array)
+            association_conditions = []
+            records.each do |rec|
+              record_conditions = []
+              @reflection.association_foreign_key.each_with_index do |column,i|
+                record_conditions << relation[column.to_sym].eq(rec.id[i])
+              end
+              association_conditions << record_conditions.inject { |conds, cond| conds.and(cond) }
+            end
+            association_conditions_arel = association_conditions.inject { |conds, cond| conds.or(cond) }
+          else
+            association_conditions_arel = relation[@reflection.association_foreign_key].in(records.map { |x| x.id }.compact)
+          end
+          
+          all_conditions_arel = owner_conditions_arel.and(association_conditions_arel)
+          
+          relation.where(all_conditions_arel).delete
+        end
+      end
+
+    end    
   end
-end
+end

data/lib/composite_primary_keys/associations/join_dependency/join_association.rb

@@ -0,0 +1,22 @@
+module ActiveRecord
+  module Associations
+    class JoinDependency
+      class JoinAssociation
+        def build_constraint(reflection, table, key, foreign_table, foreign_key)
+          # CPK
+          # constraint = table[key].eq(foreign_table[foreign_key])
+          constraint = cpk_join_predicate(table, key, foreign_table, foreign_key)
+
+          if reflection.klass.finder_needs_type_condition?
+            constraint = table.create_and([
+              constraint,
+              reflection.klass.send(:type_condition, table)
+            ])
+          end
+
+          constraint
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/join_dependency/join_part.rb

@@ -0,0 +1,39 @@
+module ActiveRecord
+  module Associations
+    class JoinDependency
+      class JoinPart
+        def aliased_primary_key
+          # CPK
+          # "#{aliased_prefix}_r0"
+
+          active_record.composite? ?
+            primary_key.inject([]) {|aliased_keys, key| aliased_keys << "#{ aliased_prefix }_r#{aliased_keys.length}"} :
+            "#{ aliased_prefix }_r0"
+        end
+
+        def record_id(row)
+          # CPK
+          # row[aliased_primary_key]
+          active_record.composite? ?
+            aliased_primary_key.map {|key| row[key]}.to_composite_keys :
+            row[aliased_primary_key]
+        end
+
+        def column_names_with_alias
+          unless @column_names_with_alias
+            @column_names_with_alias = []
+
+            # CPK
+            #([primary_key] + (column_names - [primary_key])).each_with_index do |column_name, i|
+            keys = active_record.composite? ? primary_key.map(&:to_s) : [primary_key]
+
+            (keys + (column_names - keys)).each_with_index do |column_name, i|
+              @column_names_with_alias << [column_name, "#{aliased_prefix}_r#{i}"]
+            end
+          end
+          @column_names_with_alias
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/preloader/association.rb

@@ -0,0 +1,61 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class Association
+        def records_for(ids)
+          # CPK
+          # scoped.where(association_key.in(ids))
+          predicate = cpk_in_predicate(table, reflection.foreign_key, ids)
+          scoped.where(predicate)
+        end
+        
+        def associated_records_by_owner
+          # CPK
+          # owner_keys = owners.map { |owner| owner[owner_key_name] }.compact.uniq
+          owner_keys = owners.map do |owner|
+            Array(owner_key_name).map do |owner_key|
+              owner[owner_key]
+            end
+          end.compact.uniq
+
+          if klass.nil? || owner_keys.empty?
+            records = []
+          else
+            # Some databases impose a limit on the number of ids in a list (in Oracle it's 1000)
+            # Make several smaller queries if necessary or make one query if the adapter supports it
+            sliced  = owner_keys.each_slice(model.connection.in_clause_length || owner_keys.size)
+            records = sliced.map { |slice| records_for(slice) }.flatten
+          end
+
+          # Each record may have multiple owners, and vice-versa
+          records_by_owner = Hash[owners.map { |owner| [owner, []] }]
+          records.each do |record|
+            # CPK
+            # owner_key = record[association_key_name].to_s
+            owner_key = Array(association_key_name).map do |key_name|
+              record[key_name]
+            end.join(CompositePrimaryKeys::ID_SEP)
+
+            owners_by_key[owner_key].each do |owner|
+              records_by_owner[owner] << record
+            end
+          end
+          records_by_owner
+        end
+
+        def owners_by_key
+          @owners_by_key ||= owners.group_by do |owner|
+            # CPK
+            # key = owner[owner_key_name]
+            key = Array(owner_key_name).map do |key_name|
+              owner[key_name]
+            end
+            # CPK
+            # key && key.to_s
+            key && key.join(CompositePrimaryKeys::ID_SEP)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/preloader/belongs_to.rb

@@ -0,0 +1,13 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class BelongsTo
+        def records_for(ids)
+          # CPK
+          predicate = cpk_in_predicate(table, association_key_name, ids)
+          scoped.where(predicate)
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/associations/preloader/has_and_belongs_to_many.rb

@@ -0,0 +1,46 @@
+module ActiveRecord
+  module Associations
+    class Preloader
+      class HasAndBelongsToMany
+        def records_for(ids)
+          # CPK
+          #scope = super
+          predicate = cpk_in_predicate(join_table, reflection.foreign_key, ids)
+          scope = scoped.where(predicate)
+
+          klass.connection.select_all(scope.arel.to_sql, 'SQL', scope.bind_values)
+        end
+
+        def join
+          # CPK
+          #condition = table[reflection.association_primary_key].eq(
+           # join_table[reflection.association_foreign_key])
+          condition = cpk_join_predicate(table, reflection.association_primary_key,
+                                         join_table, reflection.association_foreign_key)
+
+          table.create_join(join_table, table.create_on(condition))
+        end
+
+        def association_key_alias(field)
+          "ar_association_key_name_#{field.to_s}"
+        end
+
+        def join_select
+          # CPK
+          # association_key.as(Arel.sql(association_key_name))
+          Array(reflection.foreign_key).map do |key|
+            join_table[key].as(Arel.sql(association_key_alias(key)))
+          end
+        end
+
+        def association_key_name
+          # CPK
+          # 'ar_association_key_name'
+          Array(reflection.foreign_key).map do |key|
+            association_key_alias(key)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/attribute_methods/primary_key.rb

@@ -0,0 +1,19 @@
+module ActiveRecord
+  module AttributeMethods #:nodoc:
+    module PrimaryKey
+      def to_key
+        # CPK
+        #key = send(self.class.primary_key)
+        #[key] if key
+
+        primary_key = self.class.primary_key
+        if primary_key.is_a?(Array)
+          primary_key.collect{|k| send(k)}
+        else
+          key = send(primary_key)
+          [key] if key
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/attribute_methods/read.rb

@@ -0,0 +1,88 @@
+module CompositePrimaryKeys
+  module ActiveRecord
+    module AttributeMethods
+      module Read
+        def self.included(base)
+          base.send(:extend, ClassMethods)
+          alias [] read_attribute
+        end
+
+        module ClassMethods
+          def define_read_method(method_name, attr_name, column)
+            cast_code = column.type_cast_code('v')
+            # CPK - this is a really horrid hack, needed to get
+            # right class namespace :(
+            if cast_code.match(/^ActiveRecord/)
+              cast_code = "::#{cast_code}"
+            end
+
+            access_code = "(v=@attributes['#{attr_name}']) && #{cast_code}"
+
+            # CPK
+            # unless attr_name.to_s == self.primary_key.to_s
+            #   access_code.insert(0, "missing_attribute('#{attr_name}', caller) unless @attributes.has_key?('#{attr_name}'); ")
+            # end
+            unless self.primary_keys.include?(attr_name.to_sym)
+              access_code = access_code.insert(0, "missing_attribute('#{attr_name}', caller) unless @attributes.has_key?('#{attr_name}'); ")
+            end
+
+            if cache_attribute?(attr_name)
+              access_code = "@attributes_cache['#{attr_name}'] ||= (#{access_code})"
+            end
+
+            # Where possible, generate the method by evalling a string, as this will result in
+            # faster accesses because it avoids the block eval and then string eval incurred
+            # by the second branch.
+            #
+            # The second, slower, branch is necessary to support instances where the database
+            # returns columns with extra stuff in (like 'my_column(omg)').
+            if method_name =~ ActiveModel::AttributeMethods::COMPILABLE_REGEXP
+              generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__
+                def _#{method_name}
+                  #{access_code}
+                end
+
+                alias #{method_name} _#{method_name}
+              STR
+            else
+              generated_attribute_methods.module_eval do
+                define_method("_#{method_name}") { eval(access_code) }
+                alias_method(method_name, "_#{method_name}")
+              end
+            end
+          end
+        end
+
+        def read_attribute(attr_name)
+          # CPK
+          if attr_name.kind_of?(Array)
+            attr_name.map {|name| read_attribute(name)}.to_composite_keys
+          elsif respond_to? "_#{attr_name}"
+            send "_#{attr_name}" if @attributes.has_key?(attr_name.to_s)
+          else
+            _read_attribute attr_name
+          end
+        end
+        
+        def _read_attribute(attr_name)
+          attr_name = attr_name.to_s
+          # CPK
+          # attr_name = self.class.primary_key if attr_name == 'id'
+          attr_name = self.class.primary_key if (attr_name == 'id' and !self.composite?)
+          value = @attributes[attr_name]
+          unless value.nil?
+            if column = column_for_attribute(attr_name)
+              if unserializable_attribute?(attr_name, column)
+                unserialize_attribute(attr_name)
+              else
+                column.type_cast(value)
+              end
+            else
+              value
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/attribute_methods/write.rb

@@ -0,0 +1,40 @@
+module CompositePrimaryKeys
+  module ActiveRecord
+    module AttributeMethods
+      module Write
+        def self.included(base)
+          alias []= write_attribute
+          alias_method :raw_write_attribute, :write_attribute
+        end
+
+        def write_attribute(attr_name, value)
+          if attr_name.kind_of?(Array)
+            unless value.length == attr_name.length
+              raise "Number of attr_names and values do not match"
+            end
+            [attr_name, value].transpose.map {|name,val| _write_attribute(name, val)}
+            value
+          else
+            _write_attribute(attr_name, value)
+          end
+        end
+        
+        def _write_attribute(attr_name, value)
+          attr_name = attr_name.to_s
+          # CPK
+          # attr_name = self.class.primary_key if attr_name == 'id'
+          attr_name = self.class.primary_key if (attr_name == 'id' and !self.composite?)
+          @attributes_cache.delete(attr_name)
+          if (column = column_for_attribute(attr_name)) && column.number?
+            @attributes[attr_name] = convert_number_column_value(value)
+          else
+            @attributes[attr_name] = value
+          end
+        end
+
+
+
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/composite_predicates.rb

@@ -0,0 +1,44 @@
+module CompositePrimaryKeys
+  module Predicates
+    def cpk_or_predicate(predicates)
+      result = predicates.shift
+      predicates.each do |predicate|
+        result = result.or(predicate)
+      end
+      result
+    end
+
+    def cpk_id_predicate(table, keys, values)
+      eq_predicates = keys.zip(values).map do |key, value|
+        table[key].eq(value)
+      end
+      Arel::Nodes::And.new(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]}
+
+      predicates = key1_fields.zip(key2_fields).map do |key_field1, key_field2|
+        key_field1.eq(key_field2)
+      end
+      Arel::Nodes::And.new(predicates)
+    end
+
+    def cpk_in_predicate(table, primary_keys, ids)
+      and_predicates = ids.map do |id_set|
+        eq_predicates = Array(primary_keys).zip(id_set).map do |primary_key, value|
+          table[primary_key].eq(value)
+        end
+        Arel::Nodes::And.new(eq_predicates)
+      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::Relation.send(:include, CompositePrimaryKeys::Predicates)

data/lib/composite_primary_keys/named_scope.rb

@@ -0,0 +1,29 @@
+module CompositePrimaryKeys
+  module ActiveRecord
+    module NamedScope
+      module ClassMethods
+        def scoped(options = nil)
+          result = if options
+            scoped.apply_finder_options(options)
+          else
+            if current_scope
+              current_scope.clone
+            else
+              scope = relation.clone
+              scope.default_scoped = true
+              scope
+            end
+          end
+
+          # CPK
+          class << result
+            include CompositePrimaryKeys::ActiveRecord::FinderMethods
+            include CompositePrimaryKeys::ActiveRecord::QueryMethods
+            include CompositePrimaryKeys::ActiveRecord::Relation
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/relation/finder_methods.rb

@@ -0,0 +1,119 @@
+module CompositePrimaryKeys
+  module ActiveRecord
+    module FinderMethods
+      def construct_limited_ids_condition(relation)
+        orders = relation.order_values
+        # CPK
+        # values = @klass.connection.distinct("#{@klass.connection.quote_table_name table_name}.#{primary_key}", orders)
+        keys = @klass.primary_keys.map do |key|
+          "#{@klass.connection.quote_table_name @klass.table_name}.#{key}"
+        end
+        values = @klass.connection.distinct(keys.join(', '), orders)
+
+        relation = relation.dup
+
+        ids_array = relation.select(values).collect {|row| row[primary_key]}
+        # CPK
+        # ids_array.empty? ? raise(ThrowResult) : table[primary_key].in(ids_array)
+
+        # OR together each and expression (key=value and key=value) that matches an id set
+        # since we only need to match 0 or more records
+        or_expressions = ids_array.map do |id_set|
+          # AND together "key=value" exprssios to match each id set
+          and_expressions = [self.primary_keys, id_set].transpose.map do |key, id|
+            table[key].eq(id)
+          end
+          Arel::Nodes::And.new(and_expressions)
+        end
+
+        first = or_expressions.shift
+        Arel::Nodes::Grouping.new(or_expressions.inject(first) do |memo, expr|
+            Arel::Nodes::Or.new(memo, expr)
+        end)
+      end
+
+      def exists?(id = nil)
+        # ID can be:
+        #   Array - ['department_id = ? and location_id = ?', 1, 1]
+        #   Array -> [1,2]
+        #   CompositeKeys -> [1,2]
+
+        id = id.id if ::ActiveRecord::Base === id
+
+        join_dependency = construct_join_dependency_for_association_find
+        relation = construct_relation_for_association_find(join_dependency)
+        relation = relation.except(:select).select("1").limit(1)
+
+        # CPK
+        #case id
+        #when Array, Hash
+        #  relation = relation.where(id)
+        #else
+        #  relation = relation.where(table[primary_key].eq(id)) if id
+        #end
+
+        case id
+        when CompositePrimaryKeys::CompositeKeys
+          relation = relation.where(cpk_id_predicate(table, primary_key, id))
+        when Array
+          if !id.first.kind_of?(String)
+            return self.exists?(id.to_composite_keys)
+          else
+            relation = relation.where(id)
+          end
+        when Hash
+          relation = relation.where(id)
+        else
+          raise(ArgumentError, "Unsupported id sent to exists?")
+        end
+        connection.select_value(relation.to_sql) ? true : false
+      end
+
+      def find_with_ids(*ids, &block)
+        return to_a.find { |*block_args| yield(*block_args) } if block_given?
+
+        # Supports:
+        #   find('1,2')             ->  ['1,2']
+        #   find(1,2)               ->  [1,2]
+        #   find([1,2])             -> [['1,2']]
+        #   find([1,2], [3,4])      -> [[1,2],[3,4]]
+        #
+        # Does *not* support:
+        #   find('1,2', '3,4')      ->  ['1,2','3,4']
+
+        # Normalize incoming data.  Note the last arg can be nil.  Happens
+        # when find is called with nil options like the reload method does.
+        ids.compact!
+        ids = [ids] unless ids.first.kind_of?(Array)
+
+        results = ids.map do |cpk_ids|
+          cpk_ids = if cpk_ids.length == 1
+            cpk_ids.first.split(CompositePrimaryKeys::ID_SEP).to_composite_keys
+          else
+            cpk_ids.to_composite_keys
+          end
+
+          unless cpk_ids.length == @klass.primary_keys.length
+            raise "#{cpk_ids.inspect}: Incorrect number of primary keys for #{@klass.name}: #{@klass.primary_keys.inspect}"
+          end
+
+          new_relation = clone
+          [@klass.primary_keys, cpk_ids].transpose.map do |key, id|
+            new_relation = new_relation.where(key => id)
+          end
+
+          records = new_relation.to_a
+
+          if records.empty?
+            conditions = new_relation.arel.where_sql
+            raise(::ActiveRecord::RecordNotFound,
+                  "Couldn't find #{@klass.name} with ID=#{cpk_ids} #{conditions}")
+          end
+          records
+        end.flatten
+
+        ids.length == 1 ? results.first : results
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/relation/query_methods.rb

@@ -0,0 +1,24 @@
+module CompositePrimaryKeys
+  module ActiveRecord
+    module QueryMethods
+      def reverse_order
+        order_clause = arel.order_clauses
+
+        # CPK
+        # order = order_clause.empty? ?
+        #  "#{table_name}.#{primary_key} DESC" :
+        #  reverse_sql_order(order_clause).join(', ')
+
+        order = unless order_clause.empty?
+          reverse_sql_order(order_clause).join(', ')
+        else
+          klass.primary_key.map do |key|
+            "#{table_name}.#{key} DESC"
+          end.join(", ")
+        end
+
+        except(:order).order(Arel.sql(order))
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/version.rb

@@ -2,7 +2,7 @@ module CompositePrimaryKeys
   module VERSION #:nodoc:
     MAJOR = 3
     MINOR = 1
-    TINY  = 7
+    TINY  = 8
     STRING = [MAJOR, MINOR, TINY].join('.')
   end
 end

data/test/abstract_unit.rb

@@ -1,21 +1,20 @@
 dir = File.dirname(__FILE__)
 PROJECT_ROOT = File.expand_path(File.join(dir, '..'))
 
-adapter = ENV["ADAPTER"] || 'postgresql'
+adapter = ENV["ADAPTER"] || "postgresql"
 
-require 'pp'
-require 'test/unit'
-require 'hash_tricks'
-require 'rubygems'
+require "pp"
+require "test/unit"
+require "hash_tricks"
 
 # To make debugging easier, test within this source tree versus an installed gem
 #require 'composite_primary_keys'
 require File.join(PROJECT_ROOT, "lib", "composite_primary_keys")
 
-require 'active_record/fixtures'
-require File.join(PROJECT_ROOT, 'test', 'connections', 'connection_spec')
+require File.join(PROJECT_ROOT, "test", "connections", "connection_spec")
 require File.join(PROJECT_ROOT, "test", "connections", "native_#{adapter}", "connection")
 
+
 # Tell ActiveRecord where to find models
 ActiveSupport::Dependencies.autoload_paths << File.join(PROJECT_ROOT, 'test', 'fixtures')
 

data/test/connections/native_mysql/connection.rb

@@ -7,7 +7,7 @@ def connection_string
   options['u'] = SPEC['username']  if SPEC['username']
   options['p'] = SPEC['password']  if SPEC['password']
   options['S'] = SPEC['sock']      if SPEC['sock']
-  options.map { |key, value| "-#{key}#{value}" }.join(" ")
+  options.map { |key, value| "-#{key} #{value}" }.join(" ")
 end
 
   # Adapter config setup in locals/database_connections.rb

data/test/test_associations.rb

@@ -160,7 +160,15 @@ class TestAssociations < ActiveSupport::TestCase
     assert_equal 2, @restaurant.suburbs.size
   end
 
-  def test_has_one_with_primary_key
+  def test_habtm_clear
+    @restaurant = Restaurant.find([1,1])
+    assert_equal 2, @restaurant.suburbs.size
+    @restaurant.suburbs.clear
+    @restaurant = Restaurant.find([1,1])
+    assert_equal 0, @restaurant.suburbs.size
+  end
+
+  def test_has_many_with_primary_key
     @membership = Membership.find([1, 1])
     assert_equal 2, @membership.reading.id
   end
@@ -235,4 +243,4 @@ class TestAssociations < ActiveSupport::TestCase
     assert_equal(1, memberships.length)
     assert_equal([1,1], memberships[0].id)
   end
-end
+end

data/test/test_create.rb

@@ -38,7 +38,7 @@ class TestCreate < ActiveSupport::TestCase
       begin
         @obj = @klass.create(@klass_info[:create].block(@klass.primary_key))
         @successful = !composite?
-      rescue ActiveRecord::CompositeKeyError
+      rescue CompositePrimaryKeys::ActiveRecord::CompositeKeyError
         @successful = false
       rescue
         flunk "Incorrect exception raised: #{$!}, #{$!.class}"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: composite_primary_keys
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 19
   prerelease: 
   segments: 
   - 3
   - 1
-  - 7
-  version: 3.1.7
+  - 8
+  version: 3.1.8
 platform: ruby
 authors: 
 - Dr Nic Williams
@@ -16,30 +16,22 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-19 00:00:00 Z
+date: 2011-05-26 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: arel
+  name: activerecord
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
-        hash: 15
+        hash: 7
         segments: 
-        - 2
+        - 3
         - 0
         - 0
-        version: 2.0.0
-  type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: activerecord
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
+        version: 3.0.0
     - - ">="
       - !ruby/object:Gem::Version 
         hash: 13
@@ -48,20 +40,12 @@ dependencies:
         - 0
         - 5
         version: 3.0.5
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 7
-        segments: 
-        - 3
-        - 0
-        - 0
-        version: 3.0.0
   type: :runtime
-  version_requirements: *id002
+  version_requirements: *id001
 - !ruby/object:Gem::Dependency 
   name: rspec
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -71,7 +55,7 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id003
+  version_requirements: *id002
 description: Composite key support for ActiveRecord 3
 email: 
 - drnicwilliams@gmail.com
@@ -89,17 +73,28 @@ files:
 - init.rb
 - install.rb
 - loader.rb
+- lib/composite_primary_keys/associations/association.rb
 - lib/composite_primary_keys/associations/association_proxy.rb
+- lib/composite_primary_keys/associations/association_scope.rb
 - lib/composite_primary_keys/associations/has_and_belongs_to_many_association.rb
 - lib/composite_primary_keys/associations/has_many_association.rb
 - lib/composite_primary_keys/associations/has_one_association.rb
+- lib/composite_primary_keys/associations/join_dependency/join_association.rb
+- lib/composite_primary_keys/associations/join_dependency/join_part.rb
+- lib/composite_primary_keys/associations/preloader/association.rb
+- lib/composite_primary_keys/associations/preloader/belongs_to.rb
+- lib/composite_primary_keys/associations/preloader/has_and_belongs_to_many.rb
 - lib/composite_primary_keys/associations/through_association_scope.rb
 - lib/composite_primary_keys/associations.rb
 - lib/composite_primary_keys/association_preload.rb
+- lib/composite_primary_keys/attribute_methods/primary_key.rb
+- lib/composite_primary_keys/attribute_methods/read.rb
+- lib/composite_primary_keys/attribute_methods/write.rb
 - lib/composite_primary_keys/attribute_methods.rb
 - lib/composite_primary_keys/base.rb
 - lib/composite_primary_keys/calculations.rb
 - lib/composite_primary_keys/composite_arrays.rb
+- lib/composite_primary_keys/composite_predicates.rb
 - lib/composite_primary_keys/connection_adapters/abstract_adapter.rb
 - lib/composite_primary_keys/connection_adapters/ibm_db_adapter.rb
 - lib/composite_primary_keys/connection_adapters/oracle_adapter.rb
@@ -108,11 +103,14 @@ files:
 - lib/composite_primary_keys/connection_adapters/sqlite3_adapter.rb
 - lib/composite_primary_keys/finder_methods.rb
 - lib/composite_primary_keys/fixtures.rb
+- lib/composite_primary_keys/named_scope.rb
 - lib/composite_primary_keys/persistence.rb
 - lib/composite_primary_keys/primary_key.rb
 - lib/composite_primary_keys/query_methods.rb
 - lib/composite_primary_keys/read.rb
 - lib/composite_primary_keys/reflection.rb
+- lib/composite_primary_keys/relation/finder_methods.rb
+- lib/composite_primary_keys/relation/query_methods.rb
 - lib/composite_primary_keys/relation.rb
 - lib/composite_primary_keys/validations/uniqueness.rb
 - lib/composite_primary_keys/version.rb