hyper-mesh 0.4.0

data/lib/reactive_record/active_record/reactive_record/reactive_set_relationship_helpers.rb

@@ -0,0 +1,189 @@
+module ReactiveRecord
+  # methods to update aggregrations and relations, called from reactive_set!
+  class Base
+    def update_aggregate(attribute, value)
+      # if attribute is an aggregate then
+      # match and update all fields in the aggregate from value and return true
+      # otherwise return false
+      aggregation = @model.reflect_on_aggregation(attribute)
+      return false unless aggregation && (aggregation.klass < ActiveRecord::Base)
+      if value
+        value_attributes = value.backing_record.attributes
+        update_mapped_attributes(aggregation) { |attr| value_attributes[attr] }
+      else
+        update_mapped_attributes(aggregation) { nil }
+      end
+      true
+    end
+
+    def update_mapped_attributes(aggregation)
+      # insure the aggregate attr is initialized, clear the virt flag, the caller
+      # will yield each of the matching attribute values
+      attr = aggregation.attribute
+      attributes[attr] ||= aggregation.klass.new if new?
+      aggregate_record = attributes[attr]
+      raise 'uninitialized aggregate attribute - should never happen' unless aggregate_record
+      aggregate_backing_record = aggregate_record.backing_record
+      aggregate_backing_record.virgin = false
+      aggregation.mapped_attributes.each do |mapped_attribute|
+        aggregate_backing_record.update_attribute(mapped_attribute, yield(mapped_attribute))
+      end
+    end
+
+    def update_relationships(attr, value)
+      # update the inverse relationship, and any through relationships
+      # return either the value, or in the case of updating a collection
+      # return the new collection after value is overwritten into it.
+      association = @model.reflect_on_association(attr)
+      return value unless association
+      if association.collection?
+        overwrite_has_many_collection(association, value)
+      else
+        update_belongs_to_association(association, value)
+        value
+      end
+    end
+
+    def overwrite_has_many_collection(association, value)
+      # 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.new(association.klass, @ar_instance, association).tap do |collection|
+        collection.replace(value || [])
+      end
+    end
+
+    def update_belongs_to_association(association, value)
+      # either update update the inverse has_many collection or individual belongs_to
+      # inverse values
+      if association.inverse.collection?
+        update_has_many_through_associations(association, value)
+        update_inverse_collections(association, value)
+      else
+        update_inverse_attribute(association, value)
+      end
+    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(association.inverse, @ar_instance)
+      end
+    end
+
+    def push_onto_collection(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
+
+    # def reactive_set!(attribute, value)
+    #   @virgin = false unless data_loading?
+    #   unless @destroyed or (!(attributes[attribute].is_a? DummyValue) and attributes.has_key?(attribute) and attributes[attribute] == value)
+    #     if association = @model.reflect_on_association(attribute)
+    #       if association.collection?
+    #         collection = Collection.new(association.klass, @ar_instance, association)
+    #         collection.replace(value || [])
+    #         value = collection
+    #       else
+    #         inverse_of = association.inverse_of
+    #         inverse_association = association.klass.reflect_on_association(inverse_of)
+    #         if inverse_association.collection?
+    #           if value.nil?
+    #             attributes[attribute].attributes[inverse_of].delete(@ar_instance) unless attributes[attribute].nil?
+    #           elsif value.attributes[inverse_of]
+    #             value.attributes[inverse_of] << @ar_instance
+    #           else
+    #             value.attributes[inverse_of] = Collection.new(@model, value, inverse_association)
+    #             # value.attributes[inverse_of].replace [@ar_instance]
+    #             # why was the above not just the below???? fixed 10/28/2016
+    #             value.attributes[inverse_of] << @ar_instance
+    #           end
+    #         elsif !value.nil?
+    #           attributes[attribute].attributes[inverse_of] = nil unless attributes[attribute].nil?
+    #           value.attributes[inverse_of] = @ar_instance
+    #           React::State.set_state(value.backing_record, inverse_of, @ar_instance) unless data_loading?
+    #         elsif attributes[attribute]
+    #           attributes[attribute].attributes[inverse_of] = nil
+    #         end
+    #       end
+    #     elsif aggregation = @model.reflect_on_aggregation(attribute) and (aggregation.klass < ActiveRecord::Base)
+    #
+    #       if new?
+    #         attributes[attribute] ||= aggregation.klass.new
+    #       elsif !attributes[attribute]
+    #         raise "uninitialized aggregate attribute - should never happen"
+    #       end
+    #
+    #       aggregate_record = attributes[attribute].backing_record
+    #       aggregate_record.virgin = false
+    #
+    #       if value
+    #         value_attributes = value.backing_record.attributes
+    #         aggregation.mapped_attributes.each { |mapped_attribute| aggregate_record.update_attribute(mapped_attribute, value_attributes[mapped_attribute])}
+    #       else
+    #         aggregation.mapped_attributes.each { |mapped_attribute| aggregate_record.update_attribute(mapped_attribute, nil) }
+    #       end
+    #
+    #       return attributes[attribute]
+    #
+    #     end
+    #     update_attribute(attribute, value)
+    #   end
+    #   value
+    # 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/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,299 @@
+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
+    if @loads_pending
+      @blocks_to_load ||= []
+      @blocks_to_load << [Base.last_fetch_at, promise, block]
+    else
+      promise.resolve result
+    end
+    @loads_pending = @load_stack.pop
+    promise
+  rescue Exception => e
+    debugger
+    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.last_fetch_at
+        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 and !failure
+          @blocks_to_load << [Base.last_fetch_at, 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 jQuery.show/hide) 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 get_next_while_loading_counter
+      @while_loading_counter += 1
+    end
+
+    def 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?
+
+      include React::Component
+
+      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)
+          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
+          @style_sheet ||= %x{
+            $('<style type="text/css">'+
+              '  .reactive_record_is_loading > .reactive_record_show_when_loaded { display: none; }'+
+              '  .reactive_record_is_loaded > .reactive_record_show_while_loading { display: none; }'+
+              '</style>').appendTo("head")
+          }
+        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+#{loaded_children.count+1}) {\n"+
+          "  display: none;\n"+
+          "}\n"
+        )
+      end
+
+      after_mount do
+        @waiting_on_resources = loading
+        WhileLoading.add_style_sheet
+        %x{
+          var node = #{dom_node};
+          $(node).children(':nth-child(-1n+'+#{loaded_children.count}+')').addClass('reactive_record_show_when_loaded');
+          $(node).children(':nth-child(1n+'+#{loaded_children.count+1}+')').addClass('reactive_record_show_while_loading');
+        }
+      end
+
+      after_update do
+        @waiting_on_resources = loading
+      end
+
+      def render
+        props = 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(element_type, props) { loaded_children + loading_children }
+      end
+
+    end
+
+  end
+
+end
+
+module React
+
+  class Element
+
+    def while_loading(display = "", &loading_display_block)
+
+      loaded_children = []
+      loaded_children = block.call.dup if block
+
+      loading_children = [display]
+      loading_children = RenderingContext.build do |buffer|
+        result = loading_display_block.call
+        buffer << result.to_s if result.is_a? String
+        buffer.dup
+      end if loading_display_block
+      RenderingContext.replace(
+        self,
+        React.create_element(
+          ReactiveRecord::WhileLoading,
+          loading: waiting_on_resources,
+          loading_children: loading_children,
+          loaded_children: loaded_children,
+          element_type: type,
+          element_props: properties)
+        )
+    end
+
+    def hide_while_loading
+      while_loading
+    end
+
+  end
+
+  module Component
+
+    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
+
+      %x{
+        var node = #{dom_node};
+        if (!$(node).is('[data-reactive_record_enclosing_while_loading_container_id]')) {
+          var while_loading_container = $(node).closest('[data-reactive_record_while_loading_container_id]')
+          if (while_loading_container.length > 0) {
+            var container_id = $(while_loading_container).attr('data-reactive_record_while_loading_container_id')
+            $(node).attr('data-reactive_record_enclosing_while_loading_container_id', container_id)
+          }
+        }
+      }
+
+    end
+
+    def reactive_record_link_set_while_loading_container_class
+
+      %x{
+
+        var node = #{dom_node};
+        var while_loading_container_id = $(node).attr('data-reactive_record_enclosing_while_loading_container_id');
+        if (while_loading_container_id) {
+          var while_loading_container = $('[data-reactive_record_while_loading_container_id='+while_loading_container_id+']');
+          var loading = (#{waiting_on_resources} == true);
+          if (loading) {
+            $(node).addClass('reactive_record_is_loading');
+            $(node).removeClass('reactive_record_is_loaded');
+            $(while_loading_container).addClass('reactive_record_is_loading');
+            $(while_loading_container).removeClass('reactive_record_is_loaded');
+
+          } else if (!$(node).hasClass('reactive_record_is_loaded')) {
+
+            if (!$(node).attr('data-reactive_record_while_loading_container_id')) {
+              $(node).removeClass('reactive_record_is_loading');
+              $(node).addClass('reactive_record_is_loaded');
+            }
+            if (!$(while_loading_container).hasClass('reactive_record_is_loaded')) {
+              var loading_children = $(while_loading_container).
+                find('[data-reactive_record_enclosing_while_loading_container_id='+while_loading_container_id+'].reactive_record_is_loading')
+              if (loading_children.length == 0) {
+                $(while_loading_container).removeClass('reactive_record_is_loading')
+                $(while_loading_container).addClass('reactive_record_is_loaded')
+              }
+            }
+
+          }
+
+        }
+      }
+
+    end
+
+  end if RUBY_ENGINE == 'opal'
+
+end