composite_primary_keys 5.0.12 → 5.0.13

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NTVjMmVhMjcyMDljMDU3NWRjZTNhMzEyOTlhMDZhYTg1MTk0NDUxYg==
+  data.tar.gz: !binary |-
+    MDIxYzNmNjc2ZWZiMDdjZThjYTM2YzQ3MjVjODJiYjBmYzcwYzYxOQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    YjI2NjIwOWUzZGQyNDY3NTZhZTBiNjNjOWZlOTA5NDUyZTE2MWY4Y2UwNDAz
+    ZWZlMWEwMmZjNDQ4ODc2OTI2YTk1YmIxMDU2YjY2MTlkOThhMTFlODdmNTE1
+    MjRkNzhjMDA1YjRmZDZhODFkOTQ5MzhmM2U5ZTU2MzlhMWZlYWI=
+  data.tar.gz: !binary |-
+    NWZhZDQ3ZjhmNmNiZmFhZTI2YmZiYWJjNTE0OTA0ZWQxZjA3MzAzZTY2NzIz
+    OTU0YjA2NDAxZmY3MWQ4ZTAwMjgwZDdhMWNjZjk0OGViYzdmNjRjZjk4MGZj
+    NDEyMGFhMGNiNmZlZjY2YTJjMmVjMmQ1ZjI0MzgxOTcxYjE5ZDI=

data/History.rdoc

@@ -1,3 +1,8 @@
+== 5.0.13 2013-04-27
+* Batch query improvements (Jordan Byron)
+* Support nested attributes (aiasfina and Charlie Savage)
+* ActiveRecord 4.0 support in ar_4.0.x branch
+
 == 5.0.12 2013-01-21
 * Fix HasManyAssociation foreign_key_present? method to work with non CPK assocations (Charlie Savage)
 

data/lib/composite_primary_keys.rb

@@ -53,6 +53,7 @@ require 'active_model/dirty'
 require 'active_record/attribute_methods/dirty'
 require 'active_record/attribute_methods/read'
 require 'active_record/attribute_methods/write'
+require 'active_record/nested_attributes'
 
 require 'active_record/connection_adapters/abstract_adapter'
 
@@ -91,6 +92,7 @@ require 'composite_primary_keys/dirty'
 require 'composite_primary_keys/attribute_methods/dirty'
 require 'composite_primary_keys/attribute_methods/read'
 require 'composite_primary_keys/attribute_methods/write'
+require 'composite_primary_keys/nested_attributes'
 
 require 'composite_primary_keys/connection_adapters/abstract_adapter'
 require 'composite_primary_keys/connection_adapters/abstract/connection_specification_changes'

data/lib/composite_primary_keys/base.rb

@@ -127,9 +127,8 @@ module ActiveRecord
 
       # Sets the primary ID.
       def id=(ids)
-        ids = ids.split(CompositePrimaryKeys::ID_SEP) if ids.is_a?(String)
-        ids.flatten!
-        unless ids.is_a?(Array) and ids.length == self.class.primary_keys.length
+        ids = CompositePrimaryKeys::CompositeKeys.parse(ids)
+        unless ids.length == self.class.primary_keys.length
           raise "#{self.class}.id= requires #{self.class.primary_keys.length} ids"
         end
         [self.class.primary_keys, ids].transpose.each {|key, an_id| write_attribute(key , an_id)}

data/lib/composite_primary_keys/composite_arrays.rb

@@ -9,6 +9,17 @@ module CompositePrimaryKeys
   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)

data/lib/composite_primary_keys/nested_attributes.rb

@@ -0,0 +1,78 @@
+module ActiveRecord
+  module NestedAttributes
+    def assign_nested_attributes_for_collection_association(association_name, attributes_collection, assignment_opts = {})
+      options = self.nested_attributes_options[association_name]
+
+      unless attributes_collection.is_a?(Hash) || attributes_collection.is_a?(Array)
+        raise ArgumentError, "Hash or Array expected, got #{attributes_collection.class.name} (#{attributes_collection.inspect})"
+      end
+
+      if options[:limit] && attributes_collection.size > options[:limit]
+        raise TooManyRecords, "Maximum #{options[:limit]} records are allowed. Got #{attributes_collection.size} records instead."
+      end
+
+      if attributes_collection.is_a? Hash
+        keys = attributes_collection.keys
+        attributes_collection = if keys.include?('id') || keys.include?(:id)
+                                  Array.wrap(attributes_collection)
+                                else
+                                  attributes_collection.values
+                                end
+      end
+
+      association = association(association_name)
+
+      existing_records = if association.loaded?
+                           association.target
+                         # CPK
+                         elsif association.reflection.klass.composite?
+                           attributes_collection.map do |attribute_collection|
+                             attribute_ids = attribute_collection['id'] || attribute_collection[:id]
+                             if attribute_ids
+                               ids = CompositePrimaryKeys::CompositeKeys.parse(attribute_ids)
+                               eq_predicates = association.klass.primary_key.zip(ids).map do |primary_key, value|
+                                 association.klass.arel_table[primary_key].eq(value)
+                               end
+                               association.scoped.where(*eq_predicates).to_a
+                             else
+                               []
+                             end
+                           end.flatten.compact
+                         else
+                           attribute_ids = attributes_collection.map {|a| a['id'] || a[:id] }.compact
+                           attribute_ids.empty? ? [] : association.scoped.where(association.klass.primary_key => attribute_ids)
+                         end
+
+      attributes_collection.each do |attributes|
+        attributes = attributes.with_indifferent_access
+
+        if attributes['id'].blank?
+          unless reject_new_record?(association_name, attributes)
+            association.build(attributes.except(*unassignable_keys(assignment_opts)), assignment_opts)
+          end
+        elsif existing_record = existing_records.detect { |record| record.id.to_s == attributes['id'].to_s }
+          unless association.loaded? || call_reject_if(association_name, attributes)
+            # Make sure we are operating on the actual object which is in the association's
+            # proxy_target array (either by finding it, or adding it if not found)
+            target_record = association.target.detect { |record| record == existing_record }
+
+            if target_record
+              existing_record = target_record
+            else
+              association.add_to_target(existing_record)
+            end
+
+          end
+
+          if !call_reject_if(association_name, attributes)
+            assign_to_or_mark_for_destruction(existing_record, attributes, options[:allow_destroy], assignment_opts)
+          end
+        elsif assignment_opts[:without_protection]
+          association.build(attributes.except(*unassignable_keys(assignment_opts)), assignment_opts)
+        else
+          raise_nested_attributes_record_not_found(association_name, attributes['id'])
+        end
+      end
+    end
+  end
+end

data/lib/composite_primary_keys/relation/batches.rb

@@ -5,7 +5,7 @@ module CompositePrimaryKeys
         relation = self
 
         unless arel.orders.blank? && arel.taken.blank?
-          ActiveRecord::Base.logger.warn("Scoped order and limit are ignored, it's forced to be batch order and batch size")
+          ::ActiveRecord::Base.logger.warn("Scoped order and limit are ignored, it's forced to be batch order and batch size")
         end
 
         if (finder_options = options.except(:start, :batch_size)).present?
@@ -21,11 +21,10 @@ module CompositePrimaryKeys
         relation = relation.reorder(batch_order).limit(batch_size)
 
         # CPK
-        #records = relation.where(table[primary_key].gteq(start)).all
-        self.primary_key.each do |key|
-          relation = relation.where(table[key].gteq(start))
-        end
-        records = relation.all
+        # records = relation.where(table[primary_key].gteq(start)).all
+        records = self.primary_key.reduce(relation) do |rel, key|
+          rel.where(table[key].gteq(start))
+        end.all
 
         while records.any?
           records_size = records.size
@@ -37,12 +36,23 @@ module CompositePrimaryKeys
 
           if primary_key_offset
             # CPK
-            #records = relation.where(table[primary_key].gt(primary_key_offset)).to_a
-            self.primary_key.each do |key|
-              relation = relation.where(table[key].gt(primary_key_offset))
-            end
-            records = relation.to_a
+            # Lexicographically select records
+            #
+            query = prefixes(primary_key.zip(primary_key_offset)).map do |kvs|
+              and_clause = kvs.each_with_index.map do |(k, v), i|
+                # Use > for the last key in the and clause
+                # otherwise use =
+                if i == kvs.length - 1
+                  table[k].gt(v)
+                else
+                  table[k].eq(v)
+                end
+              end.reduce(:and)
+
+              Arel::Nodes::Grouping.new(and_clause)
+            end.reduce(:or)
 
+            records = relation.where(query)
           else
             raise "Primary key not included in the custom select clause"
           end
@@ -51,6 +61,13 @@ module CompositePrimaryKeys
 
       private
 
+      # Helper method to collect prefixes of an array:
+      # prefixes([:a, :b, :c]) => [[:a], [:a, :b], [:a, :b, :c]]
+      #
+      def prefixes(ary)
+        ary.length.times.reduce([]) { |results, i| results << ary[0..i] }
+      end
+
       def batch_order
         # CPK
         #"#{quoted_table_name}.#{quoted_primary_key} ASC"
@@ -60,4 +77,4 @@ module CompositePrimaryKeys
       end
     end
   end
-end
+end

data/lib/composite_primary_keys/version.rb

@@ -2,7 +2,7 @@ module CompositePrimaryKeys
   module VERSION
     MAJOR = 5
     MINOR = 0
-    TINY  = 12
+    TINY  = 13
     STRING = [MAJOR, MINOR, TINY].join('.')
   end
 end

data/test/connections/databases.yml

@@ -5,7 +5,6 @@
 mysql:
   adapter: mysql2
   username: root
-  password: root
   database: composite_primary_keys_unittest
 
 sqlite3:

data/test/fixtures/departments.yml

@@ -5,3 +5,11 @@ accounting:
 engineering:
   department_id: 2
   location_id: 1
+
+human_resources:
+  department_id: 3
+  location_id: 2
+
+offsite_accounting:
+  department_id: 1
+  location_id: 2

data/test/fixtures/room_assignments.yml

@@ -6,4 +6,19 @@ jacksons_room:
 bobs_room:
     student_id: 2
     dorm_id: 1
-    room_id: 1
+    room_id: 1
+
+kellys_room:
+    student_id: 3
+    dorm_id: 1
+    room_id: 2
+
+jordans_room:
+    student_id: 4
+    dorm_id: 1
+    room_id: 2
+
+brads_room:
+    student_id: 5
+    dorm_id: 1
+    room_id: 3

data/test/fixtures/rooms.yml

@@ -4,4 +4,9 @@ branner_room_1:
 
 branner_room_2:
   dorm_id: 1
-  room_id: 2
+  room_id: 2
+
+branner_room_3:
+  dorm_id: 1
+  room_id: 3
+

data/test/fixtures/students.yml

@@ -2,4 +2,14 @@ jackson:
   id: 1
 
 bob:
-  id: 2
+  id: 2
+
+kelly:
+  id: 3
+
+jordan:
+  id: 4
+
+brad:
+  id: 5
+

data/test/test_associations.rb

@@ -4,7 +4,7 @@ class TestAssociations < ActiveSupport::TestCase
   fixtures :articles, :products, :tariffs, :product_tariffs, :suburbs, :streets, :restaurants,
            :dorms, :rooms, :room_attributes, :room_attribute_assignments, :students, :room_assignments, :users, :readings,
            :departments, :employees, :memberships, :membership_statuses
-  
+
   def test_products
     assert_not_nil products(:first_product).product_tariffs
     assert_equal 2, products(:first_product).product_tariffs.length
@@ -131,7 +131,7 @@ class TestAssociations < ActiveSupport::TestCase
 
   def test_has_many_through_when_through_association_is_composite
     dorm = Dorm.find(:first)
-    assert_equal(2, dorm.rooms.length)
+    assert_equal(3, dorm.rooms.length)
     assert_equal(1, dorm.rooms.first.room_attributes.length)
     assert_equal('type', dorm.rooms.first.room_attributes.first.name)
   end
@@ -213,9 +213,10 @@ class TestAssociations < ActiveSupport::TestCase
   def test_has_many_with_composite_key
     # In this case a regular model (Dorm) has_many composite models (Rooms)
     dorm = dorms(:branner)
-    assert_equal(2, dorm.rooms.length)
+    assert_equal(3, dorm.rooms.length)
     assert_equal(1, dorm.rooms[0].room_id)
     assert_equal(2, dorm.rooms[1].room_id)
+    assert_equal(3, dorm.rooms[2].room_id)
   end
 
   def test_joins_has_many_with_primary_key

data/test/test_find.rb

@@ -46,6 +46,22 @@ class TestFind < ActiveSupport::TestCase
     assert_equal(['The Netherlands', 'Amsterdam'], capitol.id)
   end
 
+  def test_find_each
+    room_assignments = []
+    RoomAssignment.find_each(:batch_size => 2) do |assignment|
+      room_assignments << assignment
+    end
+
+    assert_equal(RoomAssignment.count, room_assignments.uniq.length)
+  end
+
+  def test_find_each_with_scope
+    scoped_departments = Department.where("department_id <> 3")
+    scoped_departments.find_each(:batch_size => 2) do |department|
+      assert department.id != 3
+    end
+  end
+
   def test_not_found
     error = assert_raise(::ActiveRecord::RecordNotFound) do
       ReferenceCode.find(['999', '999'])
@@ -76,9 +92,9 @@ class TestFind < ActiveSupport::TestCase
     assert_equal([1,1], suburb.id)
   end
 
-  def test_find_in_batchs
-    departments = Department.find_in_batches do |batch|
-      assert_equal(2, batch.size)
+  def test_find_in_batches
+    Department.find_in_batches do |batch|
+      assert_equal(Department.count, batch.size)
     end
   end
-end
+end

data/test/test_nested_attributes.rb

@@ -2,15 +2,13 @@ require File.expand_path('../abstract_unit', __FILE__)
 
 # Testing the find action on composite ActiveRecords with two primary keys
 class TestNestedAttributes < ActiveSupport::TestCase
-  fixtures :reference_types
-
-  def setup
-    @reference_type = ReferenceType.first
-  end
+  fixtures :reference_types, :reference_codes
 
   def test_nested_atttribute_create
     code_id = 1001
-    @reference_type.update_attribute :reference_codes_attributes, [{
+
+    reference_type = reference_types(:name_prefix)
+    reference_type.update_attribute :reference_codes_attributes, [{
       :reference_code => code_id,
       :code_label => 'XX',
       :abbreviation => 'Xx'
@@ -20,14 +18,17 @@ class TestNestedAttributes < ActiveSupport::TestCase
 
   def test_nested_atttribute_update
     code_id = 1002
-    @reference_type.update_attribute :reference_codes_attributes, [{
+
+    reference_type = reference_types(:name_prefix)
+    reference_type.update_attribute :reference_codes_attributes, [{
       :reference_code => code_id,
       :code_label => 'XX',
       :abbreviation => 'Xx'
     }]
+
     reference_code = ReferenceCode.find_by_reference_code(code_id)
-    cpk = CompositePrimaryKeys::CompositeKeys[@reference_type.reference_type_id, code_id]
-    @reference_type.update_attribute :reference_codes_attributes, [{
+    cpk = CompositePrimaryKeys::CompositeKeys[reference_type.reference_type_id, code_id]
+    reference_type.update_attribute :reference_codes_attributes, [{
       :id => cpk,
       :code_label => 'AAA',
       :abbreviation => 'Aaa'
@@ -36,4 +37,30 @@ class TestNestedAttributes < ActiveSupport::TestCase
     assert_kind_of(ReferenceCode, reference_code)
     assert_equal(reference_code.code_label, 'AAA')
   end
+
+  def test_nested_atttribute_update_2
+    reference_type = reference_types(:gender)
+    reference_code = reference_codes(:gender_male)
+
+    reference_type.update_attributes(:reference_codes_attributes => [{:id => reference_code.id,
+                                                                      :code_label => 'XX',
+                                                                      :abbreviation => 'Xx'}])
+
+    reference_code.reload
+    assert_equal(reference_code.code_label, 'XX')
+    assert_equal(reference_code.abbreviation, 'Xx')
+  end
+
+  def test_nested_atttribute_update_3
+    reference_type = reference_types(:gender)
+    reference_code = reference_codes(:gender_male)
+
+    reference_type.update_attributes(:reference_codes_attributes => [{:id => reference_code.id.to_s,
+                                                                      :code_label => 'XX',
+                                                                      :abbreviation => 'Xx'}])
+
+    reference_code.reload
+    assert_equal(reference_code.code_label, 'XX')
+    assert_equal(reference_code.abbreviation, 'Xx')
+  end
 end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: composite_primary_keys
 version: !ruby/object:Gem::Version
-  version: 5.0.12
-  prerelease: 
+  version: 5.0.13
 platform: ruby
 authors:
 - Dr Nic Williams
@@ -10,12 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-21 00:00:00.000000000 Z
+date: 2013-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -26,7 +24,6 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
@@ -69,6 +66,7 @@ files:
 - lib/composite_primary_keys/counter_cache.rb
 - lib/composite_primary_keys/dirty.rb
 - lib/composite_primary_keys/fixtures.rb
+- lib/composite_primary_keys/nested_attributes.rb
 - lib/composite_primary_keys/persistence.rb
 - lib/composite_primary_keys/relation/batches.rb
 - lib/composite_primary_keys/relation/calculations.rb
@@ -195,27 +193,26 @@ files:
 - test/test_validations.rb
 homepage: https://github.com/drnic/composite_primary_keys
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: 1.8.7
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: compositekeys
-rubygems_version: 1.8.24
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Composite key support for ActiveRecord
 test_files:
 - test/abstract_unit.rb