hyper-model 1.0.alpha1.4 → 1.0.alpha1.5

data/lib/reactive_record/active_record/reactive_record/lookup_tables.rb

@@ -14,15 +14,15 @@ module ReactiveRecord
     end
 
     def waiting_for_save(model)
-      @waiting_for_save[model]
+      @waiting_for_save[model.base_class]
     end
 
     def wait_for_save(model, &block)
-      @waiting_for_save[model] << block
+      @waiting_for_save[model.base_class] << block
     end
 
     def clear_waiting_for_save(model)
-      @waiting_for_save[model] = []
+      @waiting_for_save[model.base_class] = []
     end
 
     def lookup_by_object_id(object_id)
@@ -33,8 +33,8 @@ module ReactiveRecord
       `#{@records_by_object_id}[#{record.object_id}] = #{record}`
     end
 
-    def lookup_by_id(*args) # model and id
-      `#{@records_by_id}[#{args}]` || nil
+    def lookup_by_id(model, id) # model and id
+      `#{@records_by_id}[#{[model.base_class, id]}]` || nil
     end
 
     def set_id_lookup(record)

data/lib/reactive_record/active_record/reactive_record/setters.rb

@@ -43,17 +43,26 @@ module ReactiveRecord
 
     def set_belongs_to(assoc, raw_value)
       set_common(assoc.attribute, raw_value) do |value, attr|
-        if assoc.inverse.collection?
-          update_has_many_through_associations assoc, value
-          update_inverse_collections assoc, value
-        else
-          update_inverse_attribute assoc, value
-        end
-        # itself will just reactively read the value (a model instance)  by doing a .id
-        update_belongs_to attr, value.itself
+        current_value = @attributes[assoc.attribute]
+        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)
+      assoc = orig.inverse
+      attr = assoc.attribute
+      current_value = @attributes[attr]
+      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
@@ -106,9 +115,8 @@ module ReactiveRecord
     end
 
     def change_status_and_notify_helper(attr, changed)
+      return if @being_destroyed
       empty_before = changed_attributes.empty?
-      # TODO: confirm this works:
-      # || data_loading? added so that model.new can be wrapped in a ReactiveRecord.load_data
       if !changed || data_loading?
         changed_attributes.delete(attr)
       elsif !changed_attributes.include?(attr)
@@ -125,70 +133,100 @@ module ReactiveRecord
       )
     end
 
-    def update_inverse_attribute(association, value)
-      # when updating the inverse attribute of a belongs_to that is itself a belongs_to
-      # (i.e. 1-1 relationship) we clear the existing inverse value and then
-      # write the current record to the new value
-      current_value = @attributes[association.attribute]
-      inverse_attr = association.inverse.attribute
-      current_value.attributes[inverse_attr] = nil unless current_value.nil?
-      return if value.nil?
-      value.attributes[inverse_attr] = @ar_instance
-      return if data_loading?
-      Hyperstack::Internal::State::Variable.set(value.backing_record, inverse_attr, @ar_instance)
-    end
-
-    def update_inverse_collections(association, value)
-      # when updating an inverse attribute of a belongs_to that is a has_many (i.e. a collection)
-      # we need to first remove the current associated value (if non-nil), then add the new
-      # value to the collection.  If the inverse collection is not yet initialized we do it here.
-      current_value = @attributes[association.attribute]
-      inverse_attr = association.inverse.attribute
-      if value.nil?
-        current_value.attributes[inverse_attr].delete(@ar_instance) unless current_value.nil?
+    # when updating the inverse attribute of a belongs_to that is itself a belongs_to
+    # (i.e. 1-1 relationship) we clear the existing inverse value and then
+    # write the current record to the new value
+
+    # when updating an inverse attribute of a belongs_to that is a has_many (i.e. a collection)
+    # we need to first remove the current associated value (if non-nil), then add the new
+    # value to the collection.  If the inverse collection is not yet initialized we do it here.
+
+    # the above is split into three methods, because the  inverse of apolymorphic belongs to may
+    # 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, 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.
+        model.attributes[inverse_association.attribute].delete(@ar_instance)
       else
-        value.backing_record.push_onto_collection(@model, association.inverse, @ar_instance)
+        model.attributes[inverse_association.attribute] = nil
+      end
+    end
+
+    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
+        inverse_attr = inverse_association.attribute
+        model.attributes[inverse_attr] = @ar_instance
+        return if data_loading?
+        Hyperstack::Internal::State::Variable.set(model.backing_record, inverse_attr, @ar_instance)
       end
     end
 
     def push_onto_collection(model, association, ar_instance)
       @attributes[association.attribute] ||= Collection.new(model, @ar_instance, association)
-      @attributes[association.attribute] << ar_instance
+      @attributes[association.attribute]._internal_push ar_instance
+    end
+
+    # class Membership < ActiveRecord::Base
+    #   belongs_to :uzer
+    #   belongs_to :memerable, polymorphic: true
+    # end
+    #
+    # class Project < ActiveRecord::Base
+    #   has_many :memberships, as: :memerable, dependent: :destroy
+    #   has_many :uzers, through: :memberships
+    # end
+    #
+    # class Group < ActiveRecord::Base
+    #   has_many :memberships, as: :memerable, dependent: :destroy
+    #   has_many :uzers, through: :memberships
+    # end
+    #
+    # class Uzer < ActiveRecord::Base
+    #   has_many :memberships
+    #   has_many :groups,   through: :memberships, source: :memerable, source_type: 'Group'
+    #   has_many :projects, through: :memberships, source: :memerable, source_type: 'Project'
+    # end
+
+    # membership.uzer = some_new_uzer (i.e. through association is changing)
+    # means membership.some_new_uzer.(groups OR projects) << uzer.memberable (depending on type of memberable)
+    # and we have to remove the current value of the source association (memerable) from the current uzer group or project
+    # 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, 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
+        ta.send method, source_value, value
+        ta.source_associations(source_value).each do |sa|
+          sa.send method, value, source_value
+        end
+      end
     end
 
-    def update_has_many_through_associations(association, value)
-      association.through_associations.each { |ta| update_through_association(ta, value) }
-      association.source_associations.each { |sa| update_source_association(sa, value) }
-    end
+    # def remove_src_assoc(sa, source_value, current_value)
+    #   source_inverse_collection = source_value.attributes[sa.attribute]
+    #   source_inverse_collection.delete(current_value) if source_inverse_collection
+    # end
+    #
+    # def add_src_assoc(sa, source_value, new_value)
+    #   source_value.attributes[sa.attribute] ||= Collection.new(sa.owner_class, source_value, sa)
+    #   source_value.attributes[sa.attribute] << new_value
+    # end
 
-    def update_through_association(ta, new_belongs_to_value)
-      # appointment.doctor = doctor_new_value (i.e. through association is changing)
-      # means appointment.doctor_new_value.patients << appointment.patient
-      # and we have to appointment.doctor_current_value.patients.delete(appointment.patient)
-      source_value = @attributes[ta.source]
-      current_belongs_to_value = @attributes[ta.inverse.attribute]
-      return unless source_value
-      unless current_belongs_to_value.nil? || current_belongs_to_value.attributes[ta.attribute].nil?
-        current_belongs_to_value.attributes[ta.attribute].delete(source_value)
-      end
-      return unless new_belongs_to_value
-      new_belongs_to_value.attributes[ta.attribute] ||= Collection.new(ta.klass, new_belongs_to_value, ta)
-      new_belongs_to_value.attributes[ta.attribute] << source_value
-    end
-
-    def update_source_association(sa, new_source_value)
-      # appointment.patient = patient_value (i.e. source is changing)
-      # means appointment.doctor.patients.delete(appointment.patient)
-      # means appointment.doctor.patients << patient_value
-      belongs_to_value = @attributes[sa.inverse.attribute]
-      current_source_value = @attributes[sa.source]
-      return unless belongs_to_value
-      unless belongs_to_value.attributes[sa.attribute].nil? || current_source_value.nil?
-        belongs_to_value.attributes[sa.attribute].delete(current_source_value)
-      end
-      return unless new_source_value
-      belongs_to_value.attributes[sa.attribute] ||= Collection.new(sa.klass, belongs_to_value, sa)
-      belongs_to_value.attributes[sa.attribute] << new_source_value
-    end
   end
 end

data/lib/reactive_record/broadcast.rb

@@ -20,13 +20,18 @@ module ReactiveRecord
       salt = SecureRandom.hex
       authorization = Hyperstack.authorization(salt, data[:channel], data[:broadcast_id])
       raise 'no server running' unless Hyperstack::Connection.root_path
-      SendPacket.remote(
-        Hyperstack::Connection.root_path,
-        data,
-        operation: operation,
-        salt: salt,
-        authorization: authorization
-      ).tap { |p| raise p.error if p.rejected? }
+      Timeout::timeout(Hyperstack.send_to_server_timeout) do
+        SendPacket.remote(
+          Hyperstack::Connection.root_path,
+          data,
+          operation: operation,
+          salt: salt,
+          authorization: authorization
+        ).tap { |p| raise p.error if p.rejected? }
+      end
+    rescue Timeout::Error
+      puts "\n********* FAILED TO RECEIVE RESPONSE FROM SERVER WITHIN #{Hyperstack.send_to_server_timeout} SECONDS. CHANGES WILL NOT BE SYNCED ************\n"
+      raise 'no server running'
     end unless RUBY_ENGINE == 'opal'
 
     class SendPacket < Hyperstack::ServerOp
@@ -67,7 +72,7 @@ module ReactiveRecord
 
     def self.to_self(record, data = {})
       # simulate incoming packet after a local save
-      operation = if record.new?
+      operation = if record.new_record?
                     :create
                   elsif record.destroyed?
                     :destroy
@@ -177,7 +182,12 @@ module ReactiveRecord
 
         # once we have received all the data from all the channels (applies to create and update only)
         # we yield and process the record
-        yield complete! if @channels == @received
+
+        # pusher fake can send duplicate records which will result in a nil broadcast
+        # so we also check that before yielding
+        if @channels == @received && (broadcast = complete!)
+          yield broadcast
+        end
       end
     end
 

data/lib/reactive_record/interval.rb

@@ -168,12 +168,12 @@ end
 module Kernel
   # (see Browser::Window#after)
   def after(time, &block)
-    `setTimeout(#{block.to_n}, time * 1000)`
+    $window.after(time, &block)
   end
 
   # (see Browser::Window#after!)
   def after!(time, &block)
-    `setTimeout(#{block.to_n}, time * 1000)`
+    $window.after!(time, &block)
   end
 end
 
@@ -187,4 +187,4 @@ class Proc
   def after!(time)
     $window.after!(time, &self)
   end
-end
+end

data/lib/reactive_record/scope_description.rb

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

data/lib/reactive_record/server_data_cache.rb

@@ -280,6 +280,8 @@ module ReactiveRecord
                   if !cache_item.value || cache_item.value.is_a?(Array)
                     # seeing as we just returning representative, no check is needed (its already checked)
                     representative
+                  elsif method == 'model_name'
+                    cache_item.build_new_cache_item(timing(:active_record) { cache_item.value.model_name }, method, method)
                   else
                     begin
                       secured_method = "__secure_remote_access_to_#{[*method].first}"
@@ -449,6 +451,13 @@ keys:
             loaded_collection[0].backing_record.sync_attributes(attrs)
           end
           target.replace loaded_collection
+          # we need to notify any observers of the collection.  collection#replace
+          # will not notify if we are data_loading (which we are) so we will do it
+          # here.  BUT we want the notification to occur after the current event
+          # completes so we wrap it a bulk_update
+          Hyperstack::Internal::State::Mapper.bulk_update do
+            Hyperstack::Internal::State::Variable.set(target, :collection, target.collection)
+          end
         end
 
         if id_value = tree["id"] and id_value.is_a? Array
@@ -486,9 +495,10 @@ keys:
             # we cannot use target.send "#{method}=" here because it might be a server method, which does not have a setter
             # a better fix might be something like target._internal_attribute_hash[method] =  ...
             target.backing_record.set_attr_value(method, value.first) unless method == :id
-          elsif value.is_a? Hash and value[:id] and value[:id].first and association = target.class.reflect_on_association(method)
+          elsif value.is_a?(Hash) && value[:id] && value[:id].first && (association = target.class.reflect_on_association(method))
             # not sure if its necessary to check the id above... is it possible to for the method to be an association but not have an id?
-            new_target = ReactiveRecord::Base.find_by_id(association.klass, value[:id].first)
+            klass = value[:model_name] ? Object.const_get(value[:model_name].first) : association.klass
+            new_target = ReactiveRecord::Base.find_by_id(klass, value[:id].first)
             target.send "#{method}=", new_target
           elsif !(target.class < ActiveRecord::Base)
             new_target = target.send(*method)
@@ -500,7 +510,6 @@ keys:
           load_from_json(value, new_target) if new_target
         end
       rescue Exception => e
-        # debugger
         raise e
       end
     end

data/polymorph-notes.md

@@ -0,0 +1,143 @@
+```ruby
+class Picture < ApplicationRecord
+  belongs_to :imageable, polymorphic: true
+end
+
+class Employee < ApplicationRecord
+  has_many :pictures, as: :imageable
+end
+
+class Product < ApplicationRecord
+  has_many :pictures, as: :imageable
+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
+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
+the belongs_to will be belonging to :imageable instead of :employee or :product.
+
+okay fine
+
+the other way:
+
+the problem is that picture.imageable while loading is pointing to a dummy class (sure call it Imageable)
+so if we say picture.imageable.foo.bar.blat what we get is a dummy value that responds to all methods, and returns itself:
+
+picture.imageable -> imageable123 .foo -> imageable123 .bar -> ... etc.  but it is a dummy value that will cause a fetch of the actual imageable record (or nil).
+
+.imageable should be able to leverage off of server_method.
+
+server_method(:imageable, PolymorphicDummy.new(:imageable))
+
+hmmmm....
+
+really its like doing a picture.imageable.itself (?) (that may work Juuuust fine)
+
+so picture.imageable returns this funky dummy value but does an across the wire request for picture.imageable (which should get imageable_id per a normal relationship) and also get picture.imageable_type.
+
+
+start again....
+
+what happens if we ignore (on the client) the polymorphic: and as:  keys?
+
+belongs_to :imageable
+
+means there is a class Imageable, okay so we make one, and add has_many :pictures to it.
+
+
+and again....
+
+```ruby
+def imageable
+  if imageable_type.loaded? && imageable_id.loaded?
+    const_get(imageable_type).find(imageable_id)
+  else
+    DummyImageable.new(self)
+  end
+end
+```
+
+very close but will not work for cases like this:
+
+```ruby
+  pic = Picture.new
+  employee.pictures << pic
+  pic.imageable # FAIL... (until its been saved)
+  ...
+```
+
+but still it may be as simple as overriding `<<` so that it sets type on imageable.  But we still to have a proper belongs to relationship.
+
+```ruby
+def imageable
+  if we already have the attribute set
+    return the attribute
+  else
+    set attribute to DummyPolyClass.new(self, 'imageable')
+    # DummyPolyClass init will set up a fetch of the actual imageable value
+  end
+end
+
+def imageable=(x)
+  # will it just work ?
+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!
+
+
+### Latest thinking
+
+going from `has_many / has_one as: ...` is easy  its essentially setting the association foreign_key using the name supplied to the as:
+
+The problem is going from the polymorphic belongs_to side.  
+
+We don't know the actual type we are loading which presents two problems.
+
+First we just don't know the type.  So if I say `Picture.find(1).imageable.foo.bar` I really can't do anything with foo and bar.  This is solved by having a DummyPolymorph class, which responds to all missing methods with itself, and on creation sets up a vector to pull it the id, and type of the record being fetched.  This will cause a second fetch to actually get `foo.bar` because we don't know what they are yet.  (Its cool beacuse this is like Type inference actually, and I think we could eventually use a type inference system to get rid of the second fetch!!!)
+
+Second we don't know the inverse of the relationship (since we don't know the type)
+
+We can solve this by  aliasing the inverse relationship (the one with the `as: SOMENAME` option)   to be `has_many #{__hyperstack_polymorphic_inverse_of_#{SOMENAME}` and then defining method(s) against the relationship name.  This way regardless of what the polymorphic relationship points to we know the inverse is `__hyperstack_polymorphic_inverse_of_#{SOMENAME}`.  
+
+If the inverse relationship is a has_many then we define
+```ruby
+def #{RELATIONSHIP_NAME}
+  __hyperstack_polymorphic_inverse_of_#{SOMENAME}
+end
+```
+
+If the inverse relationship is a has_one we have to work a bit harder:
+```ruby
+def #{RELATIONSHIP_NAME}
+  __hyperstack_polymorphic_inverse_of_#{SOMENAME}[0]
+end
+def #{RELATIONSHIP_NAME}=(x)
+  __hyperstack_polymorphic_inverse_of_#{SOMENAME}[0] = x # or perhaps we have to replace the array using the internal method in collection for that purpose.
+end
+```
+
+The remaining problem is that the server side will have no such relationships defined so we need to add the `has_many __hyperstack_polymorphic_inverse_of_#{SOMENAME} as: SOMENAME` server side.