hyper-model 0.6.0 → 0.99.0

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

@@ -0,0 +1,107 @@
+module ReactiveRecord
+  # redefine if you want to process errors (i.e. logging, rollbar, etc)
+  def self.on_fetch_error(e, params); end
+
+  # associations: {parent_id: record.object_id, attribute: attribute, child_id: assoc_record.object_id}
+  # models: {id: record.object_id, model: record.model.model_name.to_s, attributes: changed_attributes}
+
+  module Operations
+    # to make debug easier we convert all the object_id strings to be hex representation
+    class Base < Hyperloop::ControllerOp
+      param :acting_user, nils: true
+
+      FORMAT = '0x%x'
+
+      def self.serialize_params(hash)
+        hash['associations'].each do |assoc|
+          assoc['parent_id'] = FORMAT % assoc['parent_id']
+          assoc['child_id'] = FORMAT % assoc['child_id']
+        end if hash['associations']
+        hash['models'].each do |assoc|
+          assoc['id'] = FORMAT % assoc[:id]
+        end if hash['models']
+        hash
+      end
+
+      def self.deserialize_params(hash)
+        hash['associations'].each do |assoc|
+          assoc['parent_id'] = assoc['parent_id'].to_i(16)
+          assoc['child_id'] = assoc['child_id'].to_i(16)
+        end if hash['associations']
+        hash['models'].each do |assoc|
+          assoc['id'] = assoc['id'].to_i(16)
+        end if hash['models']
+        hash
+      end
+
+      def self.serialize_response(response)
+        response[:saved_models].each do |saved_model|
+          saved_model[0] = FORMAT % saved_model[0]
+        end if response.is_a?(Hash) && response[:saved_models]
+        response
+      end
+
+      def self.deserialize_response(response)
+        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]
+        response
+      end
+    end
+    # fetch queued up records from the server
+    # subclass of ControllerOp so we can pass the controller
+    # along to on_error
+    class Fetch < Base
+      param :acting_user, nils: true
+      param models: []
+      param associations: []
+      param :pending_fetches
+      step do
+        ReactiveRecord::ServerDataCache[
+          params.models.map(&:with_indifferent_access),
+          params.associations.map(&:with_indifferent_access),
+          params.pending_fetches,
+          params.acting_user
+        ]
+      end
+      failed do |e|
+        # AccessViolations are already sent to on_error
+        Hyperloop.on_error(e, :fetch_error, params.to_h) unless e.is_a? Hyperloop::AccessViolation
+        raise e
+      end
+    end
+
+    class Save < Base
+      param :acting_user, nils: true
+      param models: []
+      param associations: []
+      param :save, type: :boolean
+      param :validate, type: :boolean
+
+      step do
+        ReactiveRecord::Base.save_records(
+          params.models.map(&:with_indifferent_access),
+          params.associations.map(&:with_indifferent_access),
+          params.acting_user,
+          params.validate,
+          params.save
+        )
+      end
+    end
+
+    class Destroy < Base
+      param :acting_user, nils: true
+      param :model
+      param :id
+      param :vector
+      step do
+        ReactiveRecord::Base.destroy_record(
+          params.model,
+          params.id,
+          params.vector,
+          params.acting_user
+        )
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module ReactiveRecord
+  # The base collection class works with relationships
+  # method overrides for scoped collections
+  module ScopedCollection
+    [:filter?, :collector?, :joins_with?, :related_records_for].each do |method|
+      define_method(method) { |*args| @scope_description.send method, *args }
+    end
+
+    def set_pre_sync_related_records(related_records, _record = nil)
+      @pre_sync_related_records = nil
+      ReactiveRecord::Base.catch_db_requests do
+        @pre_sync_related_records = filter_records(related_records)
+        live_scopes.each do |scope|
+          scope.set_pre_sync_related_records(@pre_sync_related_records)
+        end
+      end if filter?
+    end
+
+    def sync_scopes(related_records, record, filtering = true)
+      filtering =
+        @pre_sync_related_records && filtering &&
+        ReactiveRecord::Base.catch_db_requests do
+          related_records = update_collection(related_records)
+        end
+      reload_from_db if !filtering && joins_with?(record)
+      live_scopes.each { |scope| scope.sync_scopes(related_records, record, filtering) }
+    ensure
+      @pre_sync_related_records = nil
+    end
+
+    def update_collection(related_records)
+      if collector?
+        update_collector_scope(related_records)
+      else
+        related_records = filter_records(related_records)
+        update_filter_scope(@pre_sync_related_records, related_records)
+      end
+    end
+
+    def update_collector_scope(related_records)
+      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) }
+      replace(filter_records(current))
+      Set.new([*@collection])
+    end
+
+    def update_filter_scope(before, after)
+      if (collection || !@count.nil?) && before != after
+        if collection
+          (after - before).each { |r| push r }
+          (before - after).each { |r| delete r }
+        else
+          @count += (after - before).count
+          @count -= (before - after).count
+          notify_of_change self # TODO: remove self .... and retest
+        end
+      end
+      after
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module ReactiveRecord
+  # The base collection class works with relationships
+  # method overrides for the unscoped collection
+  module UnscopedCollection
+    def set_pre_sync_related_records(related_records, _record = nil)
+      @pre_sync_related_records = related_records
+      live_scopes.each { |scope| scope.set_pre_sync_related_records(@pre_sync_related_records) }
+    end
+
+    def sync_scopes(related_records, record, filtering = true)
+      live_scopes.each { |scope| scope.sync_scopes(related_records, record, filtering) }
+    ensure
+      @pre_sync_related_records = nil
+    end
+  end
+end

data/lib/reactive_record/active_record/reactive_record/while_loading.rb

@@ -0,0 +1,343 @@
+module HyperMesh
+  def self.load(&block)
+    ReactiveRecord.load(&block)
+  end
+end
+
+module ReactiveRecord
+
+  # will repeatedly execute the block until it is loaded
+  # immediately returns a promise that will resolve once the block is loaded
+
+  def self.load(&block)
+    promise = Promise.new
+    @load_stack ||= []
+    @load_stack << @loads_pending
+    @loads_pending = nil
+    result = block.call.itself
+    if @loads_pending
+      @blocks_to_load ||= []
+      @blocks_to_load << [Base.current_fetch_id, promise, block]
+    else
+      promise.resolve result
+    end
+    @loads_pending = @load_stack.pop
+    promise
+  rescue Exception => e
+    React::IsomorphicHelpers.log "ReactiveRecord.load exception raised during initial load: #{e}", :error
+  end
+
+  def self.loads_pending!
+    @loads_pending = true
+  end
+
+  def self.check_loads_pending
+    if @loads_pending
+      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.current_fetch_id
+        ReactiveRecord::WhileLoading.quiet!
+        false
+      end
+    end
+  end
+
+  def self.run_blocks_to_load(fetch_id, failure = nil)
+    if @blocks_to_load
+      blocks_to_load_now = @blocks_to_load.select { |data| data.first == fetch_id }
+      @blocks_to_load = @blocks_to_load.reject { |data| data.first == fetch_id }
+      @load_stack ||= []
+      blocks_to_load_now.each do |data|
+        id, promise, block = data
+        @load_stack << @loads_pending
+        @loads_pending = nil
+        result = block.call(failure)
+        if check_loads_pending && !failure
+          @blocks_to_load << [Base.current_fetch_id, promise, block]
+        else
+          promise.resolve result
+        end
+        @loads_pending = @load_stack.pop
+      end
+    end
+  rescue Exception => e
+    React::IsomorphicHelpers.log "ReactiveRecord.load exception raised during retry: #{e}", :error
+  end
+
+
+  # Adds while_loading feature to React
+  # to use attach a .while_loading handler to any element for example
+  # div { "displayed if everything is loaded" }.while_loading { "displayed while I'm loading" }
+  # the contents of the div will be switched (using javascript classes) depending on the state of contents of the first block
+
+  # To notify React that something is loading use React::WhileLoading.loading!
+  # once everything is loaded then do React::WhileLoading.loaded_at message (typically a time stamp just for debug purposes)
+
+  class WhileLoading
+
+    include React::IsomorphicHelpers
+
+    before_first_mount do
+      @css_to_preload = ""
+      @while_loading_counter = 0
+    end
+
+    def self.get_next_while_loading_counter
+      @while_loading_counter += 1
+    end
+
+    def self.preload_css(css)
+      @css_to_preload += "#{css}\n"
+    end
+
+    def self.has_observers?
+      React::State.has_observers?(self, :loaded_at)
+    end
+
+    prerender_footer do
+      "<style>\n#{@css_to_preload}\n</style>".tap { @css_to_preload = ""}
+    end
+
+    if RUBY_ENGINE == 'opal'
+
+      # +: I DONT THINK WE USE opal-jquery in this module anymore - require 'opal-jquery' if opal_client?
+      # -: You think wrong. add_style_sheet uses the jQuery $, after_mount too, others too
+      # -: I removed those references. Now you think right.
+
+      include Hyperloop::Component::Mixin
+
+      param :loading
+      param :loaded_children
+      param :loading_children
+      param :element_type
+      param :element_props
+      param :display, default: ''
+
+      class << self
+
+        def loading?
+          @is_loading
+        end
+
+        def loading!
+          React::RenderingContext.waiting_on_resources = true
+          React::State.get_state(self, :loaded_at)
+          # this was moved to where the fetch is actually pushed on to the fetch array in isomorphic base
+          # React::State.set_state(self, :quiet, false)
+          @is_loading = true
+        end
+
+        def loaded_at(loaded_at)
+          React::State.set_state(self, :loaded_at, loaded_at)
+          @is_loading = false
+        end
+
+        def quiet?
+          React::State.get_state(self, :quiet)
+        end
+
+        def page_loaded?
+          React::State.get_state(self, :page_loaded)
+        end
+
+        def quiet!
+          React::State.set_state(self, :quiet, true)
+          after(1) { React::State.set_state(self, :page_loaded, true) } unless on_opal_server? or @page_loaded
+          @page_loaded = true
+        end
+
+        def add_style_sheet
+          # directly assigning the code to the variable triggers a opal 0.10.5 compiler bug.
+          unless @style_sheet_added
+            %x{
+              var style_el = document.createElement("style");
+              style_el.setAttribute("type", "text/css");
+              style_el.innerHTML = ".reactive_record_is_loading > .reactive_record_show_when_loaded { display: none; }\n" +
+                                   ".reactive_record_is_loaded > .reactive_record_show_while_loading { display: none; }";
+              document.head.append(style_el);
+            }
+            @style_sheet_added = true
+          end
+        end
+
+      end
+
+      before_mount do
+        @uniq_id = WhileLoading.get_next_while_loading_counter
+        WhileLoading.preload_css(
+          ".reactive_record_while_loading_container_#{@uniq_id} > :nth-child(1n+#{params.loaded_children.count+1}) {\n"+
+          "  display: none;\n"+
+          "}\n"
+        )
+      end
+
+      after_mount do
+        @waiting_on_resources = params.loading
+        WhileLoading.add_style_sheet
+        node = dom_node
+        %x{
+          var nodes = node.querySelectorAll(':nth-child(-1n+'+#{params.loaded_children.count}+')');
+          nodes.forEach(
+            function(current_node, current_index, list_obj) {
+              if (current_node.className.indexOf('reactive_record_show_when_loaded') === -1) {
+                current_node.className = current_node.className + ' reactive_record_show_when_loaded';
+              }
+            }
+          );
+          nodes = node.querySelectorAll(':nth-child(1n+'+#{params.loaded_children.count+1}+')');
+          nodes.forEach(
+            function(current_node, current_index, list_obj) {
+              if (current_node.className.indexOf('reactive_record_show_while_loading') === -1) {
+                current_node.className = current_node.className + ' reactive_record_show_while_loading';
+              }
+            }
+          );
+        }
+      end
+
+      after_update do
+        @waiting_on_resources = params.loading
+      end
+
+      def render
+        props = params.element_props.dup
+        classes = [props[:class], props[:className], "reactive_record_while_loading_container_#{@uniq_id}"].compact.join(" ")
+        props.merge!({
+          "data-reactive_record_while_loading_container_id" => @uniq_id,
+          "data-reactive_record_enclosing_while_loading_container_id" => @uniq_id,
+          class: classes
+        })
+        React.create_element(params.element_type[0], props) do
+          params.loaded_children + params.loading_children
+        end.tap { |e| e.waiting_on_resources = params.loading }
+      end
+
+    end
+
+  end
+
+end
+
+module React
+
+  class Element
+
+    def while_loading(display = "", &loading_display_block)
+      loaded_children = []
+      loaded_children = block.call.dup if block
+      if display.respond_to? :as_node
+        display = display.as_node
+        loading_display_block = lambda { display.render }
+      elsif !loading_display_block
+        loading_display_block = lambda { display }
+      end
+      loading_children = RenderingContext.build do |buffer|
+        result = loading_display_block.call
+        result = result.to_s if result.try :acts_as_string?
+        result.span.tap { |e| e.waiting_on_resources = RenderingContext.waiting_on_resources } if result.is_a? String
+        buffer.dup
+      end
+
+     new_element = React.create_element(
+        ReactiveRecord::WhileLoading,
+        loading: waiting_on_resources,
+        loading_children: loading_children,
+        loaded_children: loaded_children,
+        element_type: [type],
+        element_props: properties)
+
+      RenderingContext.replace(self, new_element)
+    end
+
+    def hide_while_loading
+      while_loading
+    end
+
+  end
+end
+
+if RUBY_ENGINE == 'opal'
+  module Hyperloop
+    class Component
+      module Mixin
+
+        alias_method :original_component_did_mount, :component_did_mount
+
+        def component_did_mount(*args)
+          original_component_did_mount(*args)
+          reactive_record_link_to_enclosing_while_loading_container
+          reactive_record_link_set_while_loading_container_class
+        end
+
+        alias_method :original_component_did_update, :component_did_update
+
+        def component_did_update(*args)
+          original_component_did_update(*args)
+          reactive_record_link_set_while_loading_container_class
+        end
+
+        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
+          node = dom_node
+          %x{
+              if (typeof node === "undefined" || node === null) return;
+              var node_wl_attr = node.getAttribute('data-reactive_record_enclosing_while_loading_container_id');
+              if (node_wl_attr === null || node_wl_attr === "") {
+                var while_loading_container = node.closest('[data-reactive_record_while_loading_container_id]');
+                if (while_loading_container !== null) {
+                  var container_id = while_loading_container.getAttribute('data-reactive_record_while_loading_container_id');
+                  node.setAttribute('data-reactive_record_enclosing_while_loading_container_id', container_id);
+                }
+              }
+            }
+        end
+
+        def reactive_record_link_set_while_loading_container_class
+          node = dom_node
+          loading = (waiting_on_resources ? `true` : `false`)
+          %x{
+              if (typeof node === "undefined" || node === null) return;
+              var while_loading_container_id = node.getAttribute('data-reactive_record_while_loading_container_id');
+              if (#{!self.is_a?(ReactiveRecord::WhileLoading)} && while_loading_container_id !== null && while_loading_container_id !== "") {
+                return;
+              }
+              var enc_while_loading_container_id = node.getAttribute('data-reactive_record_enclosing_while_loading_container_id');
+              if (enc_while_loading_container_id !== null && enc_while_loading_container_id !== "") {
+                var while_loading_container = document.body.querySelector('[data-reactive_record_while_loading_container_id="'+enc_while_loading_container_id+'"]');
+                if (loading) {
+                  node.className = node.className.replace(/reactive_record_is_loaded/g, '').replace(/  /g, ' ');
+                  if (node.className.indexOf('reactive_record_is_loading') === -1) {
+                    node.className = node.className + ' reactive_record_is_loading';
+                  }
+                  if (while_loading_container !== null) {
+                    while_loading_container.className = while_loading_container.className.replace(/reactive_record_is_loaded/g, '').replace(/  /g, ' ');
+                    if (while_loading_container.className.indexOf('reactive_record_is_loading') === -1) {
+                      while_loading_container.className = while_loading_container.className + ' reactive_record_is_loading';
+                    }
+                  }
+                } else if (node.className.indexOf('reactive_record_is_loaded') === -1) {
+                  if (while_loading_container_id === null || while_loading_container_id === "") {
+                    node.className = node.className.replace(/reactive_record_is_loading/g, '').replace(/  /g, ' ');
+                    if (node.className.indexOf('reactive_record_is_loaded') === -1) {
+                      node.className = node.className + ' reactive_record_is_loaded';
+                    }
+                  }
+                  if (while_loading_container.className.indexOf('reactive_record_is_loaded') === -1) {
+                    var loading_children = while_loading_container.querySelectorAll('[data-reactive_record_enclosing_while_loading_container_id="'+enc_while_loading_container_id+'"].reactive_record_is_loading');
+                    if (loading_children.length === 0) {
+                      while_loading_container.className = while_loading_container.className.replace(/reactive_record_is_loading/g, '').replace(/  /g, ' ');
+                      if (while_loading_container.className.indexOf('reactive_record_is_loaded') === -1) {
+                        while_loading_container.className = while_loading_container.className + ' reactive_record_is_loaded';
+                      }
+                    }
+                  }
+                }
+              }
+            }
+        end
+      end
+    end
+  end
+end