hyper-mesh 0.5.3 → 0.5.4

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

@@ -86,12 +86,12 @@ module ReactiveRecord
       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)
+        value.backing_record.push_onto_collection(@model, association.inverse, @ar_instance)
       end
     end
 
-    def push_onto_collection(association, ar_instance)
-      attributes[association.attribute] ||= Collection.new(@model, @ar_instance, association)
+    def push_onto_collection(model, association, ar_instance)
+      attributes[association.attribute] ||= Collection.new(model, @ar_instance, association)
       attributes[association.attribute] << ar_instance
     end
 

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

@@ -83,12 +83,12 @@ module ReactiveRecord
       @while_loading_counter = 0
     end
 
-    def get_next_while_loading_counter
+    def self.get_next_while_loading_counter
       @while_loading_counter += 1
     end
 
-    def preload_css(css)
-      @css_to_preload << css << "\n"
+    def self.preload_css(css)
+      @css_to_preload += "#{css}\n"
     end
 
     def self.has_observers?
@@ -103,14 +103,14 @@ module ReactiveRecord
 
       # I DONT THINK WE USE opal-jquery in this module anymore - require 'opal-jquery' if opal_client?
 
-      include React::Component
+      include Hyperloop::Component::Mixin
 
       param :loading
       param :loaded_children
       param :loading_children
       param :element_type
       param :element_props
-      param :display, default: ""
+      param :display, default: ''
 
       class << self
 
@@ -158,35 +158,37 @@ module ReactiveRecord
       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"+
+          ".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 = loading
+        @waiting_on_resources = params.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');
+          $(node).children(':nth-child(-1n+'+#{params.loaded_children.count}+')').addClass('reactive_record_show_when_loaded');
+          $(node).children(':nth-child(1n+'+#{params.loaded_children.count+1}+')').addClass('reactive_record_show_while_loading');
         }
       end
 
       after_update do
-        @waiting_on_resources = loading
+        @waiting_on_resources = params.loading
       end
 
       def render
-        props = element_props.dup
+        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(element_type, props) { loaded_children + loading_children }
+        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
@@ -204,22 +206,28 @@ module React
       loaded_children = []
       loaded_children = block.call.dup if block
 
-      loading_children = [display]
+      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
-        buffer << result.to_s if result.is_a? String
+        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 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
+
+      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
@@ -228,77 +236,78 @@ module React
 
   end
 
-  module Component
+  module ::Hyperloop
+    class Component
+      module Mixin
 
-    alias_method :original_component_did_mount, :component_did_mount
+        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
+        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
+        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 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)
+        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');
+        end
 
-          } else if (!$(node).hasClass('reactive_record_is_loaded')) {
+        def reactive_record_link_set_while_loading_container_class
+          %x{
 
-            if (!$(node).attr('data-reactive_record_while_loading_container_id')) {
-              $(node).removeClass('reactive_record_is_loading');
-              $(node).addClass('reactive_record_is_loaded');
+            var node = #{dom_node};
+            var wl = #{!self.is_a?(ReactiveRecord::WhileLoading)}
+            if (#{!self.is_a?(ReactiveRecord::WhileLoading)} && $(node).is('[data-reactive_record_while_loading_container_id]')) {
+              return
             }
-            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')
+            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
     end
-
   end if RUBY_ENGINE == 'opal'
-
 end

data/lib/reactive_record/broadcast.rb

@@ -0,0 +1,183 @@
+module ReactiveRecord
+  class Broadcast
+
+    def self.after_commit(operation, model)
+      Hyperloop::InternalPolicy.regulate_broadcast(model) do |data|
+        if !Hyperloop.on_server? && Hyperloop::Connection.root_path
+          send_to_server(operation, data)
+        else
+          SendPacket.run(data, operation: operation)
+        end
+      end
+    rescue ActiveRecord::StatementInvalid => e
+      raise e unless e.message == "Could not find table 'hyperloop_connections'"
+    end unless RUBY_ENGINE == 'opal'
+
+    def self.send_to_server(operation, data)
+      salt = SecureRandom.hex
+      authorization = Hyperloop.authorization(salt, data[:channel], data[:broadcast_id])
+      raise 'no server running' unless Hyperloop::Connection.root_path
+      SendPacket.remote(
+        Hyperloop::Connection.root_path,
+        data,
+        operation: operation,
+        salt: salt,
+        authorization: authorization
+      )
+    end unless RUBY_ENGINE == 'opal'
+
+    class SendPacket < Hyperloop::ServerOp
+      param authorization: nil, nils: true
+      param salt: nil
+      param :operation
+      param :broadcast_id
+      param :channel
+      param :channels
+      param :klass
+      param :record
+      param :operation
+      param :previous_changes
+
+      unless RUBY_ENGINE == 'opal'
+        validate do
+          params.authorization.nil? ||
+          Hyperloop.authorization(
+            params.salt, params.channel, params.broadcast_id
+          ) == params.authorization
+        end
+        dispatch_to { params.channel }
+      end
+    end
+
+    SendPacket.on_dispatch do |params|
+      in_transit[params.broadcast_id].receive(params) do |broadcast|
+        if params.operation == :destroy
+          ReactiveRecord::Collection.sync_scopes broadcast
+        else
+          ReactiveRecord::Base.when_not_saving(broadcast.klass) do
+            ReactiveRecord::Collection.sync_scopes broadcast
+          end
+        end
+      end
+    end
+
+    def self.to_self(record, data = {})
+      # simulate incoming packet after a local save
+      operation = if record.new?
+                    :create
+                  elsif record.destroyed?
+                    :destroy
+                  else
+                    :change
+                  end
+      dummy_broadcast = new.local(operation, record, data)
+      record.backing_record.sync! data unless operation == :destroy
+      ReactiveRecord::Collection.sync_scopes dummy_broadcast
+    end
+
+    def record_with_current_values
+      ReactiveRecord::Base.load_data do
+        backing_record = @backing_record || klass.find(record[:id]).backing_record
+        if destroyed?
+          backing_record.ar_instance
+        else
+          merge_current_values(backing_record)
+        end
+      end
+    end
+
+    def record_with_new_values
+      klass._react_param_conversion(record).tap do |ar_instance|
+        if destroyed?
+          ar_instance.backing_record.destroy_associations
+        elsif new?
+          ar_instance.backing_record.initialize_collections
+        end
+      end
+    end
+
+    def new?
+      @is_new
+    end
+
+    def destroyed?
+      @destroyed
+    end
+
+    def klass
+      Object.const_get(@klass)
+    end
+
+    def to_s
+      "klass: #{klass} record: #{record} new?: #{new?} destroyed?: #{destroyed?}"
+    end
+
+    # private
+
+    attr_reader :record
+
+    def self.open_channels
+      @open_channels ||= Set.new
+    end
+
+    def self.in_transit
+      @in_transit ||= Hash.new { |h, k| h[k] = new(k) }
+    end
+
+    def initialize(id)
+      @id = id
+      @received = Set.new
+      @record = {}
+      @previous_changes = {}
+    end
+
+    def local(operation, record, data)
+      @destroyed = operation == :destroy
+      @is_new = operation == :create
+      @klass = record.class.name
+      @record = data
+      record.backing_record.destroyed = false
+      @record.merge!(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
+      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
+    end
+
+    def complete!
+      self.class.in_transit.delete @id
+    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)}"
+          return nil
+        end
+        [attr, value]
+      end.compact.flatten].merge(br.attributes)
+      klass._react_param_conversion(current_values)
+    end
+  end
+end