wip - some specs passing

catmando · catmando · commit 30cb36683d5d · 2019-02-21T15:46:47.000-05:00
diff --git a/.travis.yml b/.travis.yml
@@ -54,52 +54,52 @@ _deploy_gem: &_deploy_gem
 
 jobs:
   include:
-    - <<: *_test_gem
-      env: COMPONENT=hyper-i18n        RUBY_VERSION=2.5.1
-    - <<: *_test_gem
-      env: COMPONENT=hyper-trace       RUBY_VERSION=2.5.1
-    - <<: *_test_gem
-      env: COMPONENT=hyper-state       RUBY_VERSION=2.5.1
-    - <<: *_test_gem
-      env: COMPONENT=hyper-component   RUBY_VERSION=2.5.1
+    # - <<: *_test_gem
+    #   env: COMPONENT=hyper-i18n        RUBY_VERSION=2.5.1
+    # - <<: *_test_gem
+    #   env: COMPONENT=hyper-trace       RUBY_VERSION=2.5.1
+    # - <<: *_test_gem
+    #   env: COMPONENT=hyper-state       RUBY_VERSION=2.5.1
+    # - <<: *_test_gem
+    #   env: COMPONENT=hyper-component   RUBY_VERSION=2.5.1
     - <<: *_test_gem
       env: COMPONENT=hyper-model       RUBY_VERSION=2.5.1 TASK=part1
     - <<: *_test_gem
       env: COMPONENT=hyper-model       RUBY_VERSION=2.5.1 TASK=part2
     - <<: *_test_gem
       env: COMPONENT=hyper-model       RUBY_VERSION=2.5.1 TASK=part3
-    - <<: *_test_gem
-      env: COMPONENT=hyper-operation   RUBY_VERSION=2.5.1
-    - <<: *_test_gem
-      env: COMPONENT=hyper-router      RUBY_VERSION=2.5.1
-    - <<: *_test_gem
-      env: COMPONENT=hyper-spec        RUBY_VERSION=2.5.1
-    - <<: *_test_gem
-      env: COMPONENT=hyper-store       RUBY_VERSION=2.5.1
-    - <<: *_test_gem
-      env: COMPONENT=rails-hyperstack  RUBY_VERSION=2.5.1
-    - <<: *_test_gem
-      env: COMPONENT=hyperstack-config RUBY_VERSION=2.5.1
-
-    - <<: *_deploy_gem
-      env: COMPONENT=hyper-i18n
-    - <<: *_deploy_gem
-      env: COMPONENT=hyper-trace
-    - <<: *_deploy_gem
-      env: COMPONENT=hyper-state
-    - <<: *_deploy_gem
-      env: COMPONENT=hyper-component
-    - <<: *_deploy_gem
-      env: COMPONENT=hyper-model
-    - <<: *_deploy_gem
-      env: COMPONENT=hyper-operation
-    - <<: *_deploy_gem
-      env: COMPONENT=hyper-router
-    - <<: *_deploy_gem
-      env: COMPONENT=hyper-spec
-    - <<: *_deploy_gem
-      env: COMPONENT=hyper-store
-    - <<: *_deploy_gem
-      env: COMPONENT=rails-hyperstack
-    - <<: *_deploy_gem
-      env: COMPONENT=hyperstack-config
+    # - <<: *_test_gem
+    #   env: COMPONENT=hyper-operation   RUBY_VERSION=2.5.1
+    # - <<: *_test_gem
+    #   env: COMPONENT=hyper-router      RUBY_VERSION=2.5.1
+    # - <<: *_test_gem
+    #   env: COMPONENT=hyper-spec        RUBY_VERSION=2.5.1
+    # - <<: *_test_gem
+    #   env: COMPONENT=hyper-store       RUBY_VERSION=2.5.1
+    # - <<: *_test_gem
+    #   env: COMPONENT=rails-hyperstack  RUBY_VERSION=2.5.1
+    # - <<: *_test_gem
+    #   env: COMPONENT=hyperstack-config RUBY_VERSION=2.5.1
+    #
+    # - <<: *_deploy_gem
+    #   env: COMPONENT=hyper-i18n
+    # - <<: *_deploy_gem
+    #   env: COMPONENT=hyper-trace
+    # - <<: *_deploy_gem
+    #   env: COMPONENT=hyper-state
+    # - <<: *_deploy_gem
+    #   env: COMPONENT=hyper-component
+    # - <<: *_deploy_gem
+    #   env: COMPONENT=hyper-model
+    # - <<: *_deploy_gem
+    #   env: COMPONENT=hyper-operation
+    # - <<: *_deploy_gem
+    #   env: COMPONENT=hyper-router
+    # - <<: *_deploy_gem
+    #   env: COMPONENT=hyper-spec
+    # - <<: *_deploy_gem
+    #   env: COMPONENT=hyper-store
+    # - <<: *_deploy_gem
+    #   env: COMPONENT=rails-hyperstack
+    # - <<: *_deploy_gem
+    #   env: COMPONENT=hyperstack-config
diff --git a/ruby/hyper-model/lib/hyper-model.rb b/ruby/hyper-model/lib/hyper-model.rb
@@ -20,6 +20,7 @@
   require "reactive_record/active_record/reactive_record/isomorphic_base"
   require 'reactive_record/active_record/reactive_record/dummy_value'
   require 'reactive_record/active_record/reactive_record/column_types'
+  require 'reactive_record/active_record/reactive_record/dummy_polymorph'
   require "reactive_record/active_record/aggregations"
   require "reactive_record/active_record/associations"
   require "reactive_record/active_record/reactive_record/backing_record_inspector"
diff --git a/ruby/hyper-model/lib/reactive_record/active_record/associations.rb b/ruby/hyper-model/lib/reactive_record/active_record/associations.rb
@@ -38,6 +38,7 @@ class AssociationReflection
       attr_reader :macro
       attr_reader :owner_class
       attr_reader :source
+      attr_reader :source_type
       attr_reader :options
 
       def initialize(owner_class, macro, name, options = {})
@@ -49,10 +50,26 @@ def initialize(owner_class, macro, name, options = {})
           @klass_name = options[:class_name] || (collection? && name.camelize.singularize) || name.camelize
         end
         @association_foreign_key =
-          options[:foreign_key] || (macro == :belongs_to && "#{name}_id") ||
-          (options[:as] && "#{options[:as]}_id") || "#{@owner_class.name.underscore}_id"
-        @source = options[:source] || @klass_name.underscore if options[:through]
+          options[:foreign_key] ||
+          (macro == :belongs_to && "#{name}_id") ||
+          (options[:as] && "#{options[:as]}_id") ||
+          (options[:polymorphic] && "#{name}_id") ||
+          "#{@owner_class.name.underscore}_id"
+        if options[:through]
+          @source = options[:source] || @klass_name.underscore
+          @source_type = options[:source_type] || @klass_name
+        end
         @attribute = name
+        @through_associations = Hash.new { |_h, k| [] unless k }
+        @source_associations =  Hash.new { |_h, k| [] unless k }
+      end
+
+      def collection?
+        @macro == :has_many
+      end
+
+      def singular?
+        @macro != :has_many
       end
 
       def through_association
@@ -67,21 +84,23 @@ def through_association
 
       alias through_association? through_association
 
-      def through_associations
+      def through_associations(model)
         # find all associations that use the inverse association as the through association
         # that is find all associations that are using this association in a through relationship
-        @through_associations ||= klass.reflect_on_all_associations.select do |assoc|
-          assoc.through_association && assoc.inverse == self
+        the_klass = klass(model)
+        @through_associations[the_klass] ||= the_klass.reflect_on_all_associations.select do |assoc|
+          assoc.through_association && assoc.inverse(nil) == self
         end
       end
 
-      def source_associations
+      def source_associations(model)
         # find all associations that use this association as the source
-        # that is final all associations that are using this association as the source in a
+        # that is find all associations that are using this association as the source in a
         # through relationship
-        @source_associations ||= owner_class.reflect_on_all_associations.collect do |sibling|
-          sibling.klass.reflect_on_all_associations.select do |assoc|
-            assoc.source == attribute
+        the_klass = klass(model)
+        @source_associations[the_klass] ||= owner_class.reflect_on_all_associations.collect do |sibling|
+          sibling.klass(model).reflect_on_all_associations.select do |assoc|
+            assoc.source == attribute && assoc.source_type == the_klass.name
           end
         end.flatten
       end
@@ -92,25 +111,25 @@ def polymorphic?
 
       def inverse(model)
         return @inverse if @inverse
-        found = through_association ? through_association.inverse(model) : find_inverse(model)
+        ta = through_association(model)
+        found = ta ? ta.inverse(model) : find_inverse(model)
         @inverse = found unless polymorphic?
         found
       end
 
       def inverse_of(model = nil)
-        inverse(model)&.attribute
+        inverse(model).attribute
       end
 
       def find_inverse(model)  # private
-        the_klass = klass || model
-        return nil unless the_klass
+        the_klass = klass(model)
         the_klass.reflect_on_all_associations.each do |association|
           next if association.association_foreign_key != @association_foreign_key
-          next unless target_klass_matches(association)
           next if association.attribute == attribute
           return association if the_klass == association.owner_class
         end
-        return if options[:polymorphic]  # can't dynamically create the polymorphic has_many
+        debugger if options[:polymorphic]
+        raise "could not find inverse of polymorphic belongs_to: #{model.inspect} #{self.inspect}" if options[:polymorphic]
         # instead of raising an error go ahead and create the inverse relationship if it does not exist.
         # https://github.com/hyperstack-org/hyperstack/issues/89
         if macro == :belongs_to
@@ -125,22 +144,17 @@ def find_inverse(model)  # private
         end
       end
 
-      def klass
+      def klass(model = nil)
         @klass ||= Object.const_get(@klass_name) if @klass_name
-      end
-
-      def target_klass_matches?(inverse_association)
-        return inverse_association.options[:as] if options[:polymorphic]
-        @owner_class == inverse_association.klass
+        raise "model is not correct class" if @klass && model && model.class != @klass
+        debugger unless @klass || model
+        raise "no model supplied for polymorphic relationship" unless @klass || model
+        @klass || model.class
       end
 
       def collection?
         [:has_many].include? @macro
       end
-
     end
-
   end
-
-
 end
diff --git a/ruby/hyper-model/lib/reactive_record/active_record/class_methods.rb b/ruby/hyper-model/lib/reactive_record/active_record/class_methods.rb
@@ -383,10 +383,20 @@ def _react_param_conversion(param, opt = nil)
               end
 
               if assoc
-                if value
-                  [assoc.attribute, { id: [value] }]
-                else
+                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")
+                  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] }]
+                else
+                  [assoc.attribute, { id: [value]}]
                 end
               else
                 [key, [value]]
diff --git a/ruby/hyper-model/lib/reactive_record/active_record/reactive_record/base.rb b/ruby/hyper-model/lib/reactive_record/active_record/reactive_record/base.rb
@@ -115,6 +115,9 @@ def self.new_from_vector(model, aggregate_owner, *vector)
       # this is the equivilent of find but for associations and aggregations
       # because we are not fetching a specific attribute yet, there is NO communication with the
       # server.  That only happens during find.
+
+      return DummyPolymorph.new(vector) unless model
+
       model = model.base_class
 
       # do we already have a record with this vector?  If so return it, otherwise make a new one.
diff --git a/ruby/hyper-model/lib/reactive_record/active_record/reactive_record/collection.rb b/ruby/hyper-model/lib/reactive_record/active_record/reactive_record/collection.rb
@@ -416,11 +416,15 @@ def update_child(item)
       backing_record = item.backing_record
       if backing_record && @owner && @association && !@association.through_association? && item.attributes[@association.inverse_of] != @owner
         inverse_of = @association.inverse_of
-        current_association = item.attributes[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)
-        if current_association && current_association.attributes[@association.attribute]
-          current_association.attributes[@association.attribute].delete(item)
+        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
diff --git a/ruby/hyper-model/lib/reactive_record/active_record/reactive_record/dummy_polymorph.rb b/ruby/hyper-model/lib/reactive_record/active_record/reactive_record/dummy_polymorph.rb
@@ -0,0 +1,22 @@
+module ReactiveRecord
+  class DummyPolymorph
+    def initialize(vector)
+      @vector = vector
+      puts "VECTOR: #{@vector.inspect}"
+      Base.load_from_db(nil, *vector, 'id')
+      Base.load_from_db(nil, *vector, 'model_name')
+    end
+
+    def nil?
+      true
+    end
+
+    def method_missing(*)
+      self
+    end
+
+    def self.reflect_on_all_associations(*)
+      []
+    end
+  end
+end
diff --git a/ruby/hyper-model/lib/reactive_record/active_record/reactive_record/getters.rb b/ruby/hyper-model/lib/reactive_record/active_record/reactive_record/getters.rb
@@ -5,8 +5,12 @@ module Getters
     def get_belongs_to(assoc, reload = nil)
       getter_common(assoc.attribute, reload) do |has_key, attr|
         return if new?
-        value = Base.fetch_from_db([@model, [:find, id], attr, @model.primary_key]) if id.present?
-        value = find_association(assoc, value)
+        if id.present?
+          value = Base.fetch_from_db([@model, [:find, id], attr, @model.primary_key])
+          klass = Base.fetch_from_db([@model, [:find, id], attr, 'class', 'name'])
+          klass &&= Object.const_get(klass)
+        end
+        value = find_association(assoc, value, klass)
         sync_ignore_dummy attr, value, has_key
       end&.cast_to_current_sti_type
     end
@@ -102,13 +106,16 @@ def getter_common(attribute, reload)
       end.tap { |value| Hyperstack::Internal::State::Variable.get(self, attribute) unless data_loading? }
     end
 
-    def find_association(association, id)
-      inverse_of = association.inverse_of
+    def find_association(association, id, klass)
       instance = if id
-        find(association.klass, association.klass.primary_key => id)
+        find(klass, klass.primary_key => id)
+      elsif association.polymorphic?
+        new_from_vector(nil, nil, *vector, association.attribute)
       else
         new_from_vector(association.klass, nil, *vector, association.attribute)
       end
+      return instance if instance.is_a? DummyPolymorph
+      inverse_of = association.inverse_of(instance)
       instance_backing_record_attributes = instance.attributes
       inverse_association = association.klass.reflect_on_association(inverse_of)
       if inverse_association.collection?
diff --git a/ruby/hyper-model/lib/reactive_record/active_record/reactive_record/isomorphic_base.rb b/ruby/hyper-model/lib/reactive_record/active_record/reactive_record/isomorphic_base.rb
@@ -223,7 +223,7 @@ def self.gather_records(records_to_process, force, record_being_saved)
               if association.collection?
                 # following line changed from .all to .collection on 10/28
                 [*value.collection, *value.unsaved_children].each do |assoc|
-                  add_new_association.call(record, attribute, assoc.backing_record) if assoc.changed?(association.inverse_of) or assoc.new?
+                  add_new_association.call(record, attribute, assoc.backing_record) if assoc.changed?(association.inverse_of(assoc)) or assoc.new?
                 end
               elsif record.new? || record.changed?(attribute) || (record == record_being_saved && force)
                 if value.nil?
diff --git a/ruby/hyper-model/lib/reactive_record/active_record/reactive_record/setters.rb b/ruby/hyper-model/lib/reactive_record/active_record/reactive_record/setters.rb
diff --git a/ruby/hyper-model/lib/reactive_record/server_data_cache.rb b/ruby/hyper-model/lib/reactive_record/server_data_cache.rb
diff --git a/ruby/hyper-model/spec/batch7/poly_assoc_spec.rb b/ruby/hyper-model/spec/batch7/poly_assoc_spec.rb
