hyper-model 1.0.alpha1.3 → 1.0.alpha1.8

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/operations.rb

@@ -12,6 +12,10 @@ module ReactiveRecord
 
       FORMAT = '0x%x'
 
+      class << self
+        attr_accessor :last_response_sent_at
+      end
+
       def self.serialize_params(hash)
         hash['associations'].each do |assoc|
           assoc['parent_id'] = FORMAT % assoc['parent_id']
@@ -38,6 +42,7 @@ module ReactiveRecord
         response[:saved_models].each do |saved_model|
           saved_model[0] = FORMAT % saved_model[0]
         end if response.is_a?(Hash) && response[:saved_models]
+        response[:sent_at] = Time.now.to_f
         response
       end
 
@@ -45,6 +50,7 @@ module ReactiveRecord
         response[:saved_models].each do |saved_model|
           saved_model[0] = saved_model[0].to_i(16)
         end if response.is_a?(Hash) && response[:saved_models]
+        Base.last_response_sent_at = response.delete(:sent_at)
         response
       end
     end
@@ -93,7 +99,7 @@ module ReactiveRecord
     class Destroy < Base
       param :acting_user, nils: true
       param :model
-      param :id
+      param :id, nils: true
       param :vector
       step do
         ReactiveRecord::Base.destroy_record(

data/lib/reactive_record/active_record/reactive_record/scoped_collection.rb

@@ -9,10 +9,10 @@ module ReactiveRecord
     def set_pre_sync_related_records(related_records, _record = nil)
       @pre_sync_related_records = nil
       ReactiveRecord::Base.catch_db_requests do
-        puts "#{self}.set_pre_sync_related_records filter_records(#{related_records})"
+        # puts "#{self}.set_pre_sync_related_records filter_records(#{related_records})"
 
         @pre_sync_related_records = filter_records(related_records)
-        puts "returns #{@pre_sync_related_records}"
+        # puts "returns #{@pre_sync_related_records}"
         live_scopes.each do |scope|
           scope.set_pre_sync_related_records(@pre_sync_related_records)
         end
@@ -35,9 +35,7 @@ module ReactiveRecord
       if collector?
         update_collector_scope(related_records)
       else
-        puts "#{self}.update_collection calling filter_records(#{related_records})"
         related_records = filter_records(related_records)
-        puts "returns #{related_records}"
         update_filter_scope(@pre_sync_related_records, related_records)
       end
     end
@@ -46,8 +44,7 @@ module ReactiveRecord
       current = Set.new([*@collection])
       (related_records - @pre_sync_related_records).each { |r| current << r }
       (@pre_sync_related_records - related_records).each { |r| current.delete(r) }
-      puts "#{self}.update_collector_scope calling replace(filter_records(#{current}))"
-      replace(filter_records(current).tap { |rr| puts "returns #{rr}" })
+      replace(filter_records(current))
       Set.new([*@collection])
     end
 

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
@@ -85,7 +94,7 @@ module ReactiveRecord
     end
 
     def set_attribute_change_status_and_notify(attr, changed, new_value)
-      if @virgin
+      if @virgin || @being_destroyed
         @attributes[attr] = new_value
       else
         change_status_and_notify_helper(attr, changed) do |had_key, current_value|
@@ -99,7 +108,7 @@ module ReactiveRecord
     end
 
     def set_change_status_and_notify_only(attr, changed)
-      return if @virgin
+      return if @virgin || @being_destroyed
       change_status_and_notify_helper(attr, changed) do
         Hyperstack::Internal::State::Variable.set(self, attr, nil) unless data_loading?
       end
@@ -107,8 +116,6 @@ module ReactiveRecord
 
     def change_status_and_notify_helper(attr, changed)
       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 +132,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/active_record/reactive_record/while_loading.rb

@@ -353,7 +353,7 @@ module ReactiveRecord
 
       end
 
-      def after_mount_and_update
+      def after_mount_and_update(*)
         @waiting_on_resources = @Loading
         node = dom_node
         %x{
@@ -478,6 +478,27 @@ if RUBY_ENGINE == 'opal'
         reactive_record_link_set_while_loading_container_class
       end
 
+      # This is required to support legacy browsers (Internet Explorer 9+)
+      # https://developer.mozilla.org/en-US/docs/Web/API/Element/closest#Polyfill
+      `
+      if (typeof(Element) != 'undefined' && !Element.prototype.matches) {
+        Element.prototype.matches = Element.prototype.msMatchesSelector ||
+                                    Element.prototype.webkitMatchesSelector;
+      }
+
+      if (typeof(Element) != 'undefined' && !Element.prototype.closest) {
+        Element.prototype.closest = function(s) {
+          var el = this;
+
+          do {
+            if (el.matches(s)) return el;
+            el = el.parentElement || el.parentNode;
+          } while (el !== null && el.nodeType === 1);
+          return null;
+        };
+      }
+      `
+
       def reactive_record_link_to_enclosing_while_loading_container
         # Call after any component mounts - attaches the containers loading id to this component
         # Fyi, the while_loading container is responsible for setting its own link to itself

data/lib/reactive_record/broadcast.rb

@@ -6,27 +6,35 @@ module ReactiveRecord
       # before the first broadcast.
       @public_columns_hash ||= ActiveRecord::Base.public_columns_hash
       Hyperstack::InternalPolicy.regulate_broadcast(model) do |data|
+        puts "Broadcast aftercommit hook: #{data}" if Hyperstack::Connection.show_diagnostics
+
         if !Hyperstack.on_server? && Hyperstack::Connection.root_path
-          send_to_server(operation, data) rescue nil # fails if server no longer running so ignore
+          send_to_server(operation, data, model.__synchromesh_update_time) rescue nil # fails if server no longer running so ignore
         else
-          SendPacket.run(data, operation: operation)
+          SendPacket.run(data, operation: operation, updated_at: model.__synchromesh_update_time)
         end
       end
     rescue ActiveRecord::StatementInvalid => e
       raise e unless e.message == "Could not find table 'hyperstack_connections'"
     end unless RUBY_ENGINE == 'opal'
 
-    def self.send_to_server(operation, data)
+    def self.send_to_server(operation, data, updated_at)
       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,
+          updated_at: updated_at,
+          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
@@ -40,6 +48,7 @@ module ReactiveRecord
       param :record
       param :operation
       param :previous_changes
+      param :updated_at
 
       unless RUBY_ENGINE == 'opal'
         validate do
@@ -63,11 +72,11 @@ module ReactiveRecord
           ReactiveRecord::Collection.sync_scopes broadcast.process_previous_changes
         end
       end
-    end
+    end if RUBY_ENGINE == 'opal'
 
     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
@@ -81,7 +90,7 @@ module ReactiveRecord
 
     def record_with_current_values
       ReactiveRecord::Base.load_data do
-        backing_record = @backing_record || klass.find(record[:id]).backing_record
+        backing_record = @backing_record || klass.find(record[klass.primary_key]).backing_record
         if destroyed?
           backing_record.ar_instance
         else
@@ -108,6 +117,10 @@ module ReactiveRecord
       @destroyed
     end
 
+    def local?
+      @is_local
+    end
+
     def klass
       Object.const_get(@klass)
     end
@@ -119,6 +132,7 @@ module ReactiveRecord
     # private
 
     attr_reader :record
+    attr_reader :updated_at
 
     def self.open_channels
       @open_channels ||= Set.new
@@ -128,7 +142,7 @@ module ReactiveRecord
       @in_transit ||= Hash.new { |h, k| h[k] = new(k) }
     end
 
-    def initialize(id)
+    def initialize(id = nil)
       @id = id
       @received = Set.new
       @record = {}
@@ -137,19 +151,15 @@ module ReactiveRecord
 
     def local(operation, record, data)
       @destroyed = operation == :destroy
+      @is_local = true
       @is_new = operation == :create
       @klass = record.class.name
       @record = data
       record.backing_record.destroyed = false
-      @record[:id] = record.id if record.id
+      @record[record.primary_key] = record.id if record.id
       record.backing_record.destroyed = @destroyed
       @backing_record = record.backing_record
       @previous_changes = record.changes
-      # attributes = record.attributes
-      # data.each do |k, v|
-      #   next if klass.reflect_on_association(k) || attributes[k] == v
-      #   @previous_changes[k] = [attributes[k], v]
-      # end
       self
     end
 
@@ -160,10 +170,35 @@ module ReactiveRecord
       @klass ||= params.klass
       @record.merge! params.record
       @previous_changes.merge! params.previous_changes
+      @updated_at = params.updated_at
       ReactiveRecord::Base.when_not_saving(klass) do
-        @backing_record = ReactiveRecord::Base.exists?(klass, params.record[:id])
-        @is_new = params.operation == :create && !@backing_record
-        yield complete! if @channels == @received
+        @backing_record = ReactiveRecord::Base.exists?(klass, params.record[klass.primary_key])
+
+        # first check to see if we already destroyed it and if so exit the block
+        break if @backing_record&.destroyed
+
+        # We ignore whether the record is being created or not, and just check and see if in our
+        # local copy we have ever loaded this id before.  If we have then its not new to us.
+        # BUT if we are destroying a record then it can't be treated as new regardless.
+        # This is because we might be just doing a count on a scope and so no actual records will
+        # exist.  Treating a destroyed record as "new" would cause us to first increment the
+        # scope counter and then decrement for the destroy, resulting in a nop instead of a -1 on
+        # the scope count.
+        @is_new = !@backing_record&.id_loaded? && !@destroyed
+
+        # it is possible that we are recieving data on a record for which we are also waiting
+        # on an an inital data load in which case we have not yet set the loaded id, so we
+        # set if now.
+        @backing_record&.loaded_id = params.record[klass.primary_key]
+
+        # once we have received all the data from all the channels (applies to create and update only)
+        # we yield and process the record
+
+        # 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
 
@@ -208,7 +243,7 @@ module ReactiveRecord
 
     def merge_current_values(br)
       current_values = Hash[*@previous_changes.collect do |attr, values|
-        value = attr == :id ? record[:id] : values.first
+        value = attr == klass.primary_key ? record[klass.primary_key] : values.first
         if br.attributes.key?(attr) &&
            br.attributes[attr] != br.convert(attr, value) &&
            br.attributes[attr] != br.convert(attr, values.last)
@@ -219,7 +254,6 @@ module ReactiveRecord
         end
         [attr, value]
       end.compact.flatten(1)]
-      # TODO: verify - it used to be current_values.merge(br.attributes)
       klass._react_param_conversion(br.attributes.merge(current_values))
     end
   end