wip - has-many-through completely broken head back to previous commit perhaps

Author: catmando

ruby/hyper-model/lib/reactive_record/active_record/reactive_record/collection.rb

@@ -414,18 +414,20 @@ def set_belongs_to(child)
 
     def update_child(item)
       backing_record = item.backing_record
-      if backing_record && @owner && @association && !@association.through_association? && item.attributes[@association.inverse_of] != @owner
+      if backing_record && @owner && @association && item.attributes[@association.inverse_of] != @owner #&& [email protected]_association?
         inverse_of = @association.inverse_of
         current_association_value = item.attributes[inverse_of]
         backing_record.virgin = false unless backing_record.data_loading?
-        backing_record.update_belongs_to(inverse_of, @owner)
-        unless current_association_value.nil?  # might be a dummy value which responds to nil
-          current_association = @association.inverse.inverse(current_association_value)
-          current_association_attribute = current_association.attribute
-          if current_association.collection? && current_association_value.attributes[current_association_attribute]
-            current_association.attributes[current_association_attribute].delete(item)
-          end
-        end
+        #backing_record.update_belongs_to(inverse_of, @owner)
+        backing_record.set_belongs_to_via_has_many(@association, @owner)
+        # following is handled by update_belongs_to and is redundant
+        # unless current_association_value.nil?  # might be a dummy value which responds to nil
+        #   current_association = @association.inverse.inverse(current_association_value)
+        #   current_association_attribute = current_association.attribute
+        #   if current_association.collection? && current_association_value.attributes[current_association_attribute]
+        #     current_association.attributes[current_association_attribute].delete(item)
+        #   end
+        # end
         @owner.backing_record.sync_has_many(@association.attribute)
       end
     end

ruby/hyper-model/lib/reactive_record/active_record/reactive_record/setters.rb

@@ -45,14 +45,28 @@ def set_has_many(assoc, raw_value)
     def set_belongs_to(assoc, raw_value)
       set_common(assoc.attribute, raw_value) do |value, attr|
         current_value = @attributes[assoc.attribute]
-        update_has_many_through_associations assoc, current_value, :remove_member
-        update_has_many_through_associations assoc, value, :add_member
-        remove_current_inverse_attribute     assoc, current_value
-        add_new_inverse_attribute            assoc, value
+        update_has_many_through_associations assoc, nil, current_value, :remove_member
+        update_has_many_through_associations assoc, nil, value, :add_member
+        remove_current_inverse_attribute     assoc, nil, current_value
+        add_new_inverse_attribute            assoc, nil, value
         update_belongs_to                    attr,  value.itself
       end
     end
 
+    def set_belongs_to_via_has_many(orig, value)
+      puts "set_belongs_to_via_has_many(#{orig.inspect}, #{value.inspect})"
+      assoc = orig.inverse
+      attr = assoc.attribute
+      current_value = @attributes[attr]
+      puts "set_belongs_to_via_has_many(#{orig.attribute}, #{attr}, #{current_value.inspect}, #{value.inspect})"
+
+      update_has_many_through_associations assoc, orig, current_value, :remove_member
+      update_has_many_through_associations assoc, orig, value, :add_member
+      remove_current_inverse_attribute     assoc, orig, current_value
+      add_new_inverse_attribute            assoc, orig, value
+      update_belongs_to                    attr,  value.itself
+    end
+
     def sync_has_many(attr)
       set_change_status_and_notify_only attr, @attributes[attr] != @synced_attributes[attr]
     end
@@ -136,9 +150,10 @@ def change_status_and_notify_helper(attr, changed)
     # change from has_one to has_many.  So we first deal with the current value, then
     # update the new value which uses the push_onto_collection helper
 
-    def remove_current_inverse_attribute(association, model)
+    def remove_current_inverse_attribute(association, orig, model)
       return if model.nil?
       inverse_association = association.inverse(model)
+      return if inverse_association == orig
       if inverse_association.collection?
         # note we don't have to check if the collection exists, since it must
         # exist as at this ar_instance is already part of it.
@@ -148,9 +163,10 @@ def remove_current_inverse_attribute(association, model)
       end
     end
 
-    def add_new_inverse_attribute(association, model)
+    def add_new_inverse_attribute(association, orig, model)
       return if model.nil?
       inverse_association = association.inverse(model)
+      return if inverse_association == orig
       if inverse_association.collection?
         model.backing_record.push_onto_collection(@model, inverse_association, @ar_instance)
       else
@@ -193,9 +209,10 @@ def push_onto_collection(model, association, ar_instance)
     # and we have to then find any inverse has_many_through association (i.e. group or projects.uzers) and delete the
     # current value from those collections and push the new value on
 
-    def update_has_many_through_associations(assoc, value, method)
+    def update_has_many_through_associations(assoc, orig, value, method)
       return if value.nil?
       assoc.through_associations(value).each do |ta|
+        next if orig == ta
         source_value = @attributes[ta.source]
         # skip if source value is nil or if type of the association does not match type of source
         next unless source_value.class.to_s == ta.source_type

ruby/hyper-model/spec/batch7/poly_assoc_spec.rb

@@ -273,8 +273,8 @@ def compare_to_server(model, expression, expected_result, load=true)
       @uzer2 = Uzer.create(name: 'uzer2', uzer_data: 'uzer data2')
       @uzer3 = Uzer.create(name: 'uzer3', uzer_data: 'uzer data3')
       @group1 = Group.create(name: 'group1', group_data: 'group data1')
-      @group1 = Group.create(name: 'group2', group_data: 'group data2')
-      @group1 = Group.create(name: 'group3', group_data: 'group data3')
+      @group2 = Group.create(name: 'group2', group_data: 'group data2')
+      @group3 = Group.create(name: 'group3', group_data: 'group data3')
       @project1 = Project.create(name: 'project1', project_data: 'project data1')
       @project2 = Project.create(name: 'project2', project_data: 'project data2')
       @project3 = Project.create(name: 'project3', project_data: 'project data3')
@@ -303,10 +303,13 @@ def compare_to_server(model, expression, expected_result, load=true)
       evaluate_promise do
         uzer = Uzer.find(1)
         group = Group.find(1)
-        uzer.groups << group # client side
-        group.save # needed for client side semantics
+        project = Membership.new(uzer: uzer, memerable: group)
+        #uzer.groups << group # client side
+        #group.save # needed for client side semantics
+        project.save
       end
       binding.pry
+      @group1.reload
       compare_to_server @group1, 'uzers.collect(&:id)', [@uzer1.id] # server side
     end