wip

Author: catmando

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

@@ -38,16 +38,19 @@ class AssociationReflection
       attr_reader :macro
       attr_reader :owner_class
       attr_reader :source
+      attr_reader :options
 
       def initialize(owner_class, macro, name, options = {})
         owner_class.reflect_on_all_associations << self
         @owner_class = owner_class
         @macro =       macro
         @options =     options
         unless options[:polymorphic]
-          @klass_name =  options[:class_name] || (collection? && name.camelize.singularize) || name.camelize
+          @klass_name = options[:class_name] || (collection? && name.camelize.singularize) || name.camelize
         end
-        @association_foreign_key = options[:foreign_key] || (macro == :belongs_to && "#{name}_id") || "#{@owner_class.name.underscore}_id"
+        @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]
         @attribute = name
       end
@@ -94,32 +97,41 @@ def inverse(model)
         found
       end
 
-      def inverse_of(model)
+      def inverse_of(model = nil)
         inverse(model)&.attribute
       end
 
-      def find_inverse(model)
-        the_klass = klass || model.class
+      def find_inverse(model)  # private
+        the_klass = klass || model
         return nil unless the_klass
-        klass.reflect_on_all_associations.each do |association|
+        the_klass.reflect_on_all_associations.each do |association|
           next if association.association_foreign_key != @association_foreign_key
-          next if association.klass != @owner_class
+          next unless target_klass_matches(association)
           next if association.attribute == attribute
-          return association if klass == association.owner_class
+          return association if the_klass == association.owner_class
         end
+        return if options[:polymorphic]  # can't dynamically create the polymorphic has_many
         # 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
-          Hyperstack::Component::IsomorphicHelpers.log "**** warning dynamically adding relationship: #{klass}.has_many :#{@owner_class.name.underscore.pluralize}, foreign_key: #{@association_foreign_key}", :warning
-          klass.has_many @owner_class.name.underscore.pluralize, foreign_key: @association_foreign_key
+          Hyperstack::Component::IsomorphicHelpers.log "**** warning dynamically adding relationship: #{the_klass}.has_many :#{@owner_class.name.underscore.pluralize}, foreign_key: #{@association_foreign_key}", :warning
+          the_klass.has_many @owner_class.name.underscore.pluralize, foreign_key: @association_foreign_key
+        elsif options[:as]
+          Hyperstack::Component::IsomorphicHelpers.log "**** warning dynamically adding relationship: #{the_klass}.belongs_to :#{options[:as]}, polymorphic: true", :warning
+          the_klass.belongs_to options[:as], polymorphic: true
         else
-          Hyperstack::Component::IsomorphicHelpers.log "**** warning dynamically adding relationship: #{klass}.belongs_to :#{@owner_class.name.underscore}, foreign_key: #{@association_foreign_key}", :warning
-          klass.belongs_to @owner_class.name.underscore, foreign_key: @association_foreign_key
+          Hyperstack::Component::IsomorphicHelpers.log "**** warning dynamically adding relationship: #{the_klass}.belongs_to :#{@owner_class.name.underscore}, foreign_key: #{@association_foreign_key}", :warning
+          the_klass.belongs_to @owner_class.name.underscore, foreign_key: @association_foreign_key
         end
       end
 
       def klass
-        @klass ||= Object.const_get(@klass_name)
+        @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
       end
 
       def collection?

ruby/hyper-model/lib/reactive_record/scope_description.rb

@@ -93,9 +93,9 @@ def map_joins_path(paths)
         vector = []
         path.split('.').inject(@model) do |model, attribute|
           association = model.reflect_on_association(attribute)
-          inverse_of = association.inverse_of(nil) if association
+          inverse_of = association.inverse_of if association
           raise build_error(path, model, attribute) unless inverse_of
-          vector = [association.inverse_of, *vector]
+          vector = [inverse_of, *vector]
           @joins[association.klass] << vector
           association.klass
         end

ruby/hyper-model/polymorph-notes.md

@@ -12,8 +12,8 @@ class Product < ApplicationRecord
 end
 ```
 
-product/employee.pictures -> works almost as normal has_many as far as Hyperstack client is concerned
-imageable is the "alias" of product/employee.   Its as if there is a class Imageable that is the superclass
+product|employee.pictures -> works almost as normal has_many as far as Hyperstack client is concerned
+imageable is the "alias" of product|employee.   Its as if there is a class Imageable that is the superclass
 of Product and Employee.
 
 so has_many :pictures means the usual thing (i.e. there is a belongs_to relationship on Picture) its just that
@@ -89,3 +89,21 @@ end
 its all about the collection inverse.  The inverse class of the has_many is the class containing the polymorphic belongs to.  But the inverse of a polymorphic belongs to depends on the value. If the value is nil or a DummyPolyClass object then there is no inverse.
 
 I think if inverse takes this into account then `<<` and `=` should just "work" (well almost) and probably everything else will to.
+
+### NOTES on the DummyPolyClass...
+
+it needs to respond to reflect_on_all_associations, but just return an empty array.  This way when we search for matching inverse attribute we won't find it.
+
+### Status
+
+added model to inverse, inverse_of, find_inverse
+
+if the relationship is a collection then we will always know the inverse.
+
+The only time we might no know the inverse is if its NOT a collection (i.e. belongs_to)
+
+So only places that are applying inverse to an association that is NOT a collection do we have to pass the model in.
+
+All inverse_of method calls have been checked and updated
+
+that leaves inverse which is only used in SETTERS hurray!