hyper-mesh 1.0.0.lap27 → 1.0.0.lap28

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

@@ -0,0 +1,54 @@
+module ReactiveRecord
+  module LookupTables
+    def initialize_lookup_tables
+      @records = Hash.new { |hash, key| hash[key] = [] }
+      @records_by_id = `{}`
+      @records_by_vector = `{}`
+      @records_by_object_id = `{}`
+      @class_scopes = Hash.new { |hash, key| hash[key] = {} }
+      @waiting_for_save = Hash.new { |hash, key| hash[key] = [] }
+    end
+
+    def class_scopes(model)
+      @class_scopes[model.base_class]
+    end
+
+    def waiting_for_save(model)
+      @waiting_for_save[model]
+    end
+
+    def wait_for_save(model, &block)
+      @waiting_for_save[model] << block
+    end
+
+    def clear_waiting_for_save(model)
+      @waiting_for_save[model] = []
+    end
+
+    def lookup_by_object_id(object_id)
+      `#{@records_by_object_id}[#{object_id}]`.ar_instance
+    end
+
+    def set_object_id_lookup(record)
+      `#{@records_by_object_id}[#{record.object_id}] = #{record}`
+    end
+
+    def lookup_by_id(*args) # model and id
+      `#{@records_by_id}[#{args}]` || nil
+    end
+
+    def set_id_lookup(record)
+      `#{@records_by_id}[#{[record.model, record.id]}] = #{record}`
+    end
+
+    def lookup_by_vector(vector)
+      `#{@records_by_vector}[#{vector}]` || nil
+    end
+
+    def set_vector_lookup(record, vector)
+      record.vector = vector
+      `delete #{@records_by_vector}[#{record.vector}]`
+      `#{@records_by_vector}[#{vector}] = record`
+    end
+  end
+end

data/lib/reactive_record/active_record/reactive_record/operations.rb

@@ -74,6 +74,7 @@ module ReactiveRecord
       param :acting_user, nils: true
       param models: []
       param associations: []
+      param :save, type: :boolean
       param :validate, type: :boolean
 
       step do
@@ -82,7 +83,7 @@ module ReactiveRecord
           params.associations.map(&:with_indifferent_access),
           params.acting_user,
           params.validate,
-          true
+          params.save
         )
       end
     end

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

@@ -53,7 +53,7 @@ module ReactiveRecord
         else
           @count += (after - before).count
           @count -= (before - after).count
-          notify_of_change self  # TODO remove self .... and retest
+          notify_of_change self # TODO: remove self .... and retest
         end
       end
       after

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

@@ -0,0 +1,194 @@
+module ReactiveRecord
+  module Setters
+    def set_attr_value(attr, raw_value)
+      set_common(attr, raw_value) { |value| update_simple_attribute(attr, value) }
+    end
+
+    def set_ar_aggregate(aggr, raw_value)
+      set_common(aggr.attribute, raw_value) do |value, attr|
+        @attributes[attr] ||= aggr.klass.new if new?
+        abr = @attributes[attr].backing_record
+        abr.virgin = false
+        map = value.attributes if value
+        aggr.mapped_attributes.each do |mapped_attr|
+          abr.update_aggregate_attribute mapped_attr, map && map[mapped_attr]
+        end
+        return @attributes[attr]
+      end
+    end
+
+    def set_non_ar_aggregate(aggregation, raw_value)
+      set_common(aggregation.attribute, raw_value) do |value, attr|
+        if data_loading?
+          @synced_attributes[attr] = aggregation.deserialize(aggregation.serialize(value))
+        else
+          changed = !@synced_attributes.key?(attr) || @synced_attributes[attr] != value
+        end
+        set_attribute_change_status_and_notify attr, changed, value
+      end
+    end
+
+    def set_has_many(assoc, raw_value)
+      set_common(assoc.attribute, raw_value) do |value, attr|
+        # create a new collection to hold value, shove it in, and return the new collection
+        # the replace method will take care of updating the inverse belongs_to links as
+        # the collection is overwritten
+        collection = Collection.new(assoc.klass, @ar_instance, assoc)
+        collection.replace(value || [])
+        @synced_attributes[attr] = value if data_loading?
+        set_attribute_change_status_and_notify attr, value != @synced_attributes[attr], collection
+        return collection
+      end
+    end
+
+    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
+      end
+    end
+
+    def sync_has_many(attr)
+      set_change_status_and_notify_only attr, @attributes[attr] != @synced_attributes[attr]
+    end
+
+    def update_simple_attribute(attr, value)
+      if data_loading?
+        @synced_attributes[attr] = value
+      else
+        changed = !@synced_attributes.key?(attr) || @synced_attributes[attr] != value
+      end
+      set_attribute_change_status_and_notify attr, changed, value
+    end
+
+    alias update_belongs_to update_simple_attribute
+    alias update_aggregate_attribute update_simple_attribute
+
+    private
+
+    def set_common(attr, value)
+      value = convert(attr, value)
+      @virgin = false unless data_loading?
+      if !@destroyed && (
+           !@attributes.key?(attr) ||
+           @attributes[attr].is_a?(Base::DummyValue) ||
+           @attributes[attr] != value)
+        yield value, attr
+      end
+      value
+    end
+
+    def set_attribute_change_status_and_notify(attr, changed, new_value)
+      if @virgin
+        @attributes[attr] = new_value
+      else
+        change_status_and_notify_helper(attr, changed) do |had_key, current_value|
+          @attributes[attr] = new_value
+          if !data_loading? ||
+             (on_opal_client? && had_key && current_value.loaded? && current_value != new_value)
+            React::State.set_state(self, attr, new_value, data_loading?)
+          end
+        end
+      end
+    end
+
+    def set_change_status_and_notify_only(attr, changed)
+      return if @virgin
+      change_status_and_notify_helper(attr, changed) do
+        React::State.set_state(self, attr, nil) unless data_loading?
+      end
+    end
+
+    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)
+        changed_attributes << attr
+      end
+      yield @attributes.key?(attr), @attributes[attr]
+      return unless empty_before != changed_attributes.empty?
+      if on_opal_client? && !data_loading?
+        React::State.set_state(self, '!CHANGED!', !changed_attributes.empty?, true)
+      end
+      return unless aggregate_owner
+      aggregate_owner.set_change_status_and_notify_only(
+        attr, !@attributes[attr].backing_record.changed_attributes.empty?
+      )
+    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?
+      React::State.set_state(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?
+      else
+        value.backing_record.push_onto_collection(@model, association.inverse, @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
+    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 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

@@ -17,7 +17,7 @@ module ReactiveRecord
     result = block.call.itself
     if @loads_pending
       @blocks_to_load ||= []
-      @blocks_to_load << [Base.last_fetch_at, promise, block]
+      @blocks_to_load << [Base.current_fetch_id, promise, block]
     else
       promise.resolve result
     end
@@ -36,7 +36,7 @@ module ReactiveRecord
       if Base.pending_fetches.count > 0
         true
       else  # this happens when for example loading foo.x results in somebody looking at foo.y while foo.y is still being loaded
-        ReactiveRecord::WhileLoading.loaded_at Base.last_fetch_at
+        ReactiveRecord::WhileLoading.loaded_at Base.current_fetch_id
         ReactiveRecord::WhileLoading.quiet!
         false
       end
@@ -53,8 +53,8 @@ module ReactiveRecord
         @load_stack << @loads_pending
         @loads_pending = nil
         result = block.call(failure)
-        if check_loads_pending and !failure
-          @blocks_to_load << [Base.last_fetch_at, promise, block]
+        if check_loads_pending && !failure
+          @blocks_to_load << [Base.current_fetch_id, promise, block]
         else
           promise.resolve result
         end
@@ -297,7 +297,6 @@ if RUBY_ENGINE == 'opal'
         def reactive_record_link_set_while_loading_container_class
           node = dom_node
           loading = (waiting_on_resources ? `true` : `false`)
-          #puts "******* reactive_record_link_set_while_loading_container_class #{self} #{node} #{loading}"
           %x{
               if (typeof node === "undefined" || node === null) return;
               var while_loading_container_id = node.getAttribute('data-reactive_record_while_loading_container_id');

data/lib/reactive_record/active_record_error.rb

@@ -0,0 +1,4 @@
+module ActiveRecord
+  class ActiveRecordError < StandardError
+  end
+end

data/lib/reactive_record/broadcast.rb

@@ -23,7 +23,7 @@ module ReactiveRecord
         operation: operation,
         salt: salt,
         authorization: authorization
-      )
+      ).tap { |p| raise p.error if p.rejected? }
     end unless RUBY_ENGINE == 'opal'
 
     class SendPacket < Hyperloop::ServerOp
@@ -54,9 +54,7 @@ module ReactiveRecord
         if params.operation == :destroy
           ReactiveRecord::Collection.sync_scopes broadcast
         else
-          ReactiveRecord::Base.when_not_saving(broadcast.klass) do
-            ReactiveRecord::Collection.sync_scopes broadcast
-          end
+          ReactiveRecord::Collection.sync_scopes broadcast.process_previous_changes
         end
       end
     end
@@ -137,47 +135,86 @@ module ReactiveRecord
       @klass = record.class.name
       @record = data
       record.backing_record.destroyed = false
-      @record.merge!(id: record.id) if record.id
+      @record[:id] = record.id if record.id
       record.backing_record.destroyed = @destroyed
       @backing_record = record.backing_record
-      attributes = record.backing_record.attributes
-      data.each do |k, v|
-        next if klass.reflect_on_association(k) || attributes[k] == v
-        @previous_changes[k] = [attributes[k], v]
-      end
+      @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
 
     def receive(params)
       @destroyed = params.operation == :destroy
-      @is_new = params.operation == :create
       @channels ||= Hyperloop::IncomingBroadcast.open_channels.intersection params.channels
-      #raise 'synchromesh security violation' unless @channels.include? params.channels
       @received << params.channel
       @klass ||= params.klass
       @record.merge! params.record
       @previous_changes.merge! params.previous_changes
-      @backing_record = ReactiveRecord::Base.exists?(klass, params.record[:id])
-      yield complete! if @channels == @received
+      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
+      end
     end
 
     def complete!
       self.class.in_transit.delete @id
     end
 
+    def value_changed?(attr, value)
+      attrs = @backing_record.synced_attributes
+      return true if attr == @backing_record.primary_key
+      return attrs[attr] != @backing_record.convert(attr, value) if attrs.key?(attr)
+
+      assoc = klass.reflect_on_association_by_foreign_key attr
+
+      return value unless assoc
+      child = attrs[assoc.attribute]
+      return value != child.id if child
+      value
+    end
+
+    def integrity_check
+      @previous_changes.each do |attr, value|
+        next if @record.key?(attr) && @record[attr] == value.last
+        React::IsomorphicHelpers.log "Broadcast contained change to #{attr} -> #{value.last} "\
+                                     "without corresponding value in attributes (#{@record}).\n",
+                                     :error
+        raise "Broadcast Integrity Error"
+      end
+    end
+
+    def process_previous_changes
+      return self unless @backing_record
+      integrity_check
+      return self if destroyed?
+      @record.dup.each do |attr, value|
+        next if value_changed?(attr, value)
+        @record.delete(attr)
+        @previous_changes.delete(attr)
+      end
+      self
+    end
+
     def merge_current_values(br)
       current_values = Hash[*@previous_changes.collect do |attr, values|
         value = attr == :id ? record[:id] : values.first
         if br.attributes.key?(attr) &&
            br.attributes[attr] != br.convert(attr, value) &&
            br.attributes[attr] != br.convert(attr, values.last)
-          puts "warning #{attr} has changed locally - will force a reload.\n"\
-               "local value: #{br.attributes[attr]} remote value: #{br.convert(attr, value)}->#{br.convert(attr, values.last)}"
+          React::IsomorphicHelpers.log "warning #{attr} has changed locally - will force a reload.\n"\
+               "local value: #{br.attributes[attr]} remote value: #{br.convert(attr, value)}->#{br.convert(attr, values.last)}",
+               :warning
           return nil
         end
         [attr, value]
-      end.compact.flatten].merge(br.attributes)
-      klass._react_param_conversion(current_values)
+      end.compact.flatten]
+      # TODO: verify - it used to be current_values.merge(br.attributes)
+      klass._react_param_conversion(br.attributes.merge(current_values))
     end
   end
 end

data/lib/reactive_record/permissions.rb

@@ -88,10 +88,11 @@ class ActiveRecord::Base
     alias belongs_to_without_reactive_record_add_is_method belongs_to
 
     def belongs_to(attr_name, scope = nil, options = {})
-      define_method "#{attr_name}_is?".to_sym do |model|
-        send(options[:foreign_key] || "#{attr_name}_id") == model.id
+      belongs_to_without_reactive_record_add_is_method(attr_name, scope, options).tap do
+        define_method "#{attr_name}_is?".to_sym do |model|
+          self.class.reflections[attr_name].foreign_key == model.id
+        end
       end
-      belongs_to_without_reactive_record_add_is_method(attr_name, scope, options)
     end
   end
 
@@ -103,7 +104,7 @@ class ActiveRecord::Base
       self.acting_user = old
       self
     else
-      raise ReactiveRecord::AccessViolation, "for #{permission}(#{args})"
+      raise Hyperloop::AccessViolation, "for #{permission}(#{args})"
     end
   end