wip - all non has-many-through specs passing

Author: catmando

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

@@ -40,6 +40,7 @@ class AssociationReflection
       attr_reader :source
       attr_reader :source_type
       attr_reader :options
+      attr_reader :polymorphic_type_attribute
 
       def initialize(owner_class, macro, name, options = {})
         owner_class.reflect_on_all_associations << self
@@ -59,6 +60,7 @@ def initialize(owner_class, macro, name, options = {})
           @source = options[:source] || @klass_name.underscore
           @source_type = options[:source_type] || @klass_name
         end
+        @polymorphic_type_attribute = "#{name}_type" if options[:polymorphic]
         @attribute = name
         @through_associations = Hash.new { |_h, k| [] unless k }
       end
@@ -136,9 +138,7 @@ def source_associations(model)
         source_belongs_to_association.through_associations(model)
       end
 
-      def polymorphic?
-        !@klass_name
-      end
+      alias :polymorphic? polymorphic_type_attribute
 
       def inverse(model = nil)
         return @inverse if @inverse

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

@@ -377,32 +377,53 @@ def _react_param_conversion(param, opt = nil)
 
             associations = reflect_on_all_associations
 
+            already_processed_keys = Set.new
+            old_param = param.dup
+
             param = param.collect do |key, value|
-              assoc = associations.detect do |association|
-                association.association_foreign_key == key
+              next if already_processed_keys.include? key
+
+              model_name = model_id = nil
+
+              assoc = associations.detect do |poly_assoc|
+                if key == poly_assoc.polymorphic_type_attribute
+                  model_name = value
+                  already_processed_keys << poly_assoc.association_foreign_key
+                elsif key == poly_assoc.association_foreign_key
+                  model_id = value
+                  already_processed_keys << poly_assoc.polymorphic_type_attribute
+                end
               end
 
               if assoc
                 if !value
                   [assoc.attribute, [nil]]
                 elsif assoc.polymorphic?
-                  model_name = param.detect { |k, *| k == "#{assoc.attribute}_type" }&.last
-                  model_name ||= target.send("#{assoc.attribute}_type")
+                  model_id ||= param.detect { |k, *| k == assoc.association_foreign_key }&.last
+                  model_id ||= target.send(assoc.attribute)&.id
+                  if model_id.nil?
+                    raise "Error in #{self.name}._react_param_conversion. \n"\
+                          "Could not determine the id of #{assoc.attribute} of #{target.inspect}.\n"\
+                          "It was not provided in the conversion data, "\
+                          "and it is unknown on the client"
+                  end
+                  model_name ||= param.detect { |k, *| k == assoc.polymorphic_type_attribute }&.last
+                  model_name ||= target.send(assoc.polymorphic_type_attribute)
                   unless Object.const_defined?(model_name)
                     raise "Error in #{self.name}._react_param_conversion. \n"\
                           "Could not determine the type of #{assoc.attribute} of #{target.inspect}.\n"\
                           "It was not provided in the conversion data, "\
                           "and it is unknown on the client"
                   end
-                  [assoc.attribute, { id: [value], model_name: [model_name] }]
+
+                  [assoc.attribute, { id: [model_id], model_name: [model_name] }]
                 else
                   [assoc.attribute, { id: [value]}]
                 end
               else
                 [key, [value]]
               end
-            end
-            # TODO: verify wrapping with load_data was added so broadcasting works in 1.0.0.lap28
+            end.compact
             ReactiveRecord::Base.load_data do
               ReactiveRecord::ServerDataCache.load_from_json(Hash[param], target)
             end

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

@@ -2,7 +2,7 @@
 require 'test_components'
 require 'rspec-steps'
 
-describe "polymorphic relationships", js: true, skip: true do
+describe "polymorphic relationships", js: true do
 
   before(:all) do
     require 'pusher'
@@ -173,12 +173,13 @@ def self.build_tables
     def compare_to_server(model, expression, expected_result, load=true)
       server_side = eval("#{model.class}.find(#{model.id}).#{expression}")
       expect(server_side).to eq(expected_result)
+      be_expected_result = expected_result.is_a?(Array) ? contain_exactly(*expected_result) : eq(expected_result)
       if load
         expect_promise("Hyperstack::Model.load { #{model.class}.find(#{model.id}).#{expression} }")
-        .to contain_exactly(*expected_result)
+        .to be_expected_result
       else
         wait_for_ajax
-        expect_evaluate_ruby("#{model.class}.find(#{model.id}).#{expression}").to contain_exactly(*expected_result)
+        expect_evaluate_ruby("#{model.class}.find(#{model.id}).#{expression}").to be_expected_result
       end
     end
 
@@ -216,6 +217,7 @@ def compare_to_server(model, expression, expected_result, load=true)
     it 'create server side with broadcast update' do
       compare_to_server @imageable1, 'pictures.collect(&:name)', ['picture11', 'picture12']
       Picture.create(name: 'picture15', imageable: @imageable1)
+      wait_for_ajax
       compare_to_server @imageable1, 'pictures.collect(&:name)', ['picture11', 'picture12', 'picture15'], false
     end
 
@@ -234,27 +236,25 @@ def compare_to_server(model, expression, expected_result, load=true)
 
     it 'changing belongs to relationship on client' do
       # not working yet
-      # compare_to_server @picture11, 'imageable.name',        'imageable1'
-      # compare_to_server @picture21, 'imageable.name',        'imageable2'
       compare_to_server @imageable1, 'pictures.collect(&:name)', ['picture11', 'picture12']
       compare_to_server @imageable2, 'pictures.collect(&:name)', ['picture21', 'picture22']
-
-      evaluate_ruby do
+      evaluate_promise do
         p = Picture.find(1)
         p.imageable = Product.find(1)
         p.save
       end
-      binding.pry
+      wait_for_ajax
       compare_to_server @imageable1, 'pictures.collect(&:name)', ['picture12'], false
       compare_to_server @imageable2, 'pictures.collect(&:name)', ['picture11', 'picture21', 'picture22'], false
     end
 
     it 'changing belongs to relationship on server' do
+      # compare_to_server @picture11, 'imageable.name',        'imageable1'  # here for debug assist
+      # compare_to_server @picture11, 'imageable.ss',          '123'          # here for debug assist
+
       # just debugging here... when id doesn't change we don't realize that data is changing
       compare_to_server @imageable1, 'pictures.collect(&:name)', ['picture11', 'picture12']
       compare_to_server @imageable2, 'pictures.collect(&:name)', ['picture21', 'picture22']
-
-      wait_for_ajax
       p = Picture.find_by_name('picture11')
       p.imageable = @imageable2
       p.save