hyper-mesh 0.6.0 → 1.0.0.lap22

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

@@ -1,6 +1,6 @@
 module HyperMesh
   def self.load(&block)
-    ReactiveRecord.load &block
+    ReactiveRecord.load(&block)
   end
 end
 
@@ -69,7 +69,7 @@ module ReactiveRecord
   # 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
+  # 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)
@@ -101,7 +101,9 @@ module ReactiveRecord
 
     if RUBY_ENGINE == 'opal'
 
-      # I DONT THINK WE USE opal-jquery in this module anymore - require 'opal-jquery' if opal_client?
+      # +: 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
 
@@ -145,12 +147,17 @@ module ReactiveRecord
         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")
-          }
+          # 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
@@ -167,10 +174,24 @@ module ReactiveRecord
       after_mount do
         @waiting_on_resources = params.loading
         WhileLoading.add_style_sheet
+        node = dom_node
         %x{
-          var node = #{dom_node};
-          $(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');
+          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
 
@@ -219,7 +240,7 @@ module React
         buffer.dup
       end
 
-      new_element = React.create_element(
+     new_element = React.create_element(
         ReactiveRecord::WhileLoading,
         loading: waiting_on_resources,
         loading_children: loading_children,
@@ -235,8 +256,10 @@ module React
     end
 
   end
+end
 
-  module ::Hyperloop
+if RUBY_ENGINE == 'opal'
+  module Hyperloop
     class Component
       module Mixin
 
@@ -258,56 +281,64 @@ module React
         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{
-            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)
+              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 && while_loading_container.length > 0) {
+                  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
-          %x{
-
-            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
-            }
-            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')
+          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 if RUBY_ENGINE == 'opal'
+  end
 end

data/lib/reactive_record/engine.rb

@@ -3,7 +3,7 @@ module HyperMesh
     isolate_namespace ReactiveRecord
     config.generators do |g|
       g.test_framework      :rspec,        :fixture => false
-      g.fixture_replacement :factory_girl, :dir => 'spec/factories'
+      g.fixture_replacement :factory_bot, :dir => 'spec/factories'
       g.assets false
       g.helper false
     end

data/lib/reactive_record/server_data_cache.rb

@@ -87,6 +87,7 @@ module ReactiveRecord
 
     class ServerDataCache
 
+      # SECURITY - SAFE
       def initialize(acting_user, preloaded_records)
         @acting_user = acting_user
         @cache = []
@@ -96,15 +97,21 @@ module ReactiveRecord
 
       if RUBY_ENGINE != 'opal'
 
+        # SECURITY - UNSAFE
         def [](*vector)
           root = CacheItem.new(@cache, @acting_user, vector[0], @preloaded_records)
           vector[1..-1].inject(root) { |cache_item, method| cache_item.apply_method method if cache_item }
-          vector[0] = vector[0].constantize
-          new_items = @cache.select { | cache_item | cache_item.root == root }
-          @requested_cache_items += new_items
-          new_items.last.value if new_items.last
+          vector[0] = vector[0].constantize # TODO: Security
+          last_value = nil
+          @cache.each do |cache_item|
+            next if cache_item.root != root || @requested_cache_items.include?(cache_item)
+            @requested_cache_items << cache_item
+            last_value = cache_item
+          end
+          last_value
         end
 
+        # SECURITY - SAFE
         def self.[](models, associations, vectors, acting_user)
           ActiveRecord::Base.public_columns_hash
           result = nil
@@ -112,69 +119,78 @@ module ReactiveRecord
             cache = new(acting_user, ReactiveRecord::Base.save_records(models, associations, acting_user, false, false))
             vectors.each { |vector| cache[*vector] }
             result = cache.as_json
-            raise ActiveRecord::Rollback
+            raise ActiveRecord::Rollback, "This Rollback is intentional!"
           end
           result
         end
 
+        # SECURITY - SAFE
         def clear_requests
           @requested_cache_items = []
         end
 
+        # SECURITY - SAFE
         def as_json
-          @requested_cache_items.inject({}) do | hash, cache_item|
+          @requested_cache_items.inject({}) do |hash, cache_item|
             hash.deep_merge! cache_item.as_hash
           end
         end
 
-        def select(&block); @cache.select &block; end
+        # SECURITY - SAFE
+        def select(&block); @cache.select(&block); end
 
-        def detect(&block); @cache.detect &block; end
+        # SECURITY - SAFE
+        def detect(&block); @cache.detect(&block); end
 
+        # SECURITY - SAFE
         def inject(initial, &block); @cache.inject(initial) &block; end
 
         class CacheItem
 
           attr_reader :vector
           attr_reader :absolute_vector
-          attr_reader :record_chain
           attr_reader :root
           attr_reader :acting_user
 
+          # SECURITY - SAFE
           def value
-            @ar_object
+            @value # which is a ActiveRecord object
           end
 
+          # SECURITY - SAFE
           def method
-            vector.last
+            @vector.last
           end
 
+          # SECURITY - UNSAFE
           def self.new(db_cache, acting_user, klass, preloaded_records)
-            klass_constant = klass.constantize
+            klass_constant = klass.constantize # TODO: Security Risk
             if existing = db_cache.detect { |cached_item| cached_item.vector == [klass_constant] }
               return existing
             end
             super
           end
 
+          # SECURITY - UNSAFE
           def initialize(db_cache, acting_user, klass, preloaded_records)
-            klass = klass.constantize
+            klass = klass.constantize # TODO: Security
             @db_cache = db_cache
             @acting_user = acting_user
             @vector = @absolute_vector = [klass]
-            @ar_object = klass
-            @record_chain = []
+            @value = klass
             @parent = nil
             @root = self
             @preloaded_records = preloaded_records
             db_cache << self
           end
 
+          # SECURITY - UNSAFE
           def apply_method_to_cache(method)
-            @db_cache.inject(nil) do | representative, cache_item |
+            @db_cache.inject(nil) do |representative, cache_item|
               if cache_item.vector == vector
-                if @ar_object.class < ActiveRecord::Base and @ar_object.attributes.has_key?(method)
-                  @ar_object.check_permission_with_acting_user(acting_user, :view_permitted?, method)
+                # TODO: Security - this is the wrong check in the wrong place...
+                if @value.class < ActiveRecord::Base and @value.attributes.has_key?(method) # TODO: second check is not needed, its built into  check_permmissions,  check should be does class respond to check_permissions...
+                  @value.check_permission_with_acting_user(@acting_user, :view_permitted?, method)
                 end
                 if method == "*"
                   cache_item.apply_star || representative
@@ -187,14 +203,17 @@ module ReactiveRecord
                 elsif aggregation = cache_item.aggregation?(method)
                   cache_item.build_new_cache_item(aggregation.mapping.collect { |attribute, accessor| cache_item.value[attribute] }, method, method)
                 else
-                  begin
-                    cache_item.build_new_cache_item(cache_item.value.send(*method), method, method)
-                  rescue Exception => e
-                    if cache_item.value and cache_item.value != []
-                      ReactiveRecord::Pry::rescued(e)
-                      raise e, "ReactiveRecord exception caught when applying #{method} to db object #{cache_item.value}: #{e}", e.backtrace
-                    else
-                      representative
+                  if !cache_item.value || cache_item.value.class == Array
+                    representative
+                  else
+                    # TODO: Security.  Protect the send(*method). But its complicated.. method can be an attribute, scope, relationship or actual method.
+                    #                  Each needs some protection logic.
+                    begin
+                      cache_item.build_new_cache_item(cache_item.value.send(*method), method, method)
+                    rescue Exception => e
+                      # ReactiveRecord::Pry::rescued(e)
+                      ::Rails.logger.debug "\033[0;31;1mERROR: HyperModel exception caught when applying #{method} to db object #{cache_item.value}: #{e}\033[0;30;21m"
+                      raise e, "HyperModel fetching records failed, exception caught when applying #{method} to db object #{cache_item.value}: #{e}", e.backtrace
                     end
                   end
                 end
@@ -204,24 +223,26 @@ module ReactiveRecord
             end
           end
 
+          # SECURITY - SAFE
           def aggregation?(method)
-            if method.is_a?(String) && value.class.respond_to?(:reflect_on_aggregation)
-              aggregation = value.class.reflect_on_aggregation(method.to_sym)
-              if aggregation && !(aggregation.klass < ActiveRecord::Base) && value.send(method)
+            if method.is_a?(String) && @value.class.respond_to?(:reflect_on_aggregation)
+              aggregation = @value.class.reflect_on_aggregation(method.to_sym)
+              if aggregation && !(aggregation.klass < ActiveRecord::Base) && @value.send(method)
                 aggregation
               end
             end
           end
 
+          # SECURITY - SAFE
           def apply_star
-            if value && value.length > 0
+            if @value && @value.length > 0
               i = -1
-              value.inject(nil) do | representative, ar_object |
+              @value.inject(nil) do |representative, current_value|
                 i += 1
-                if preloaded_value = @preloaded_records[absolute_vector + ["*#{i}"]]
+                if preloaded_value = @preloaded_records[@absolute_vector + ["*#{i}"]]
                   build_new_cache_item(preloaded_value, "*", "*#{i}")
                 else
-                  build_new_cache_item(ar_object, "*", "*#{i}")
+                  build_new_cache_item(current_value, "*", "*#{i}")
                 end
               end
             else
@@ -229,12 +250,14 @@ module ReactiveRecord
             end
           end
 
-          def build_new_cache_item(new_ar_object, method, absolute_method)
+          # SECURITY - SAFE
+          # TODO replace instance_eval with a method like clone_new_child(....)
+          def build_new_cache_item(new_value, method, absolute_method)
             new_parent = self
             self.clone.instance_eval do
               @vector = @vector + [method]  # don't push it on since you need a new vector!
               @absolute_vector = @absolute_vector + [absolute_method]
-              @ar_object = new_ar_object
+              @value = new_value
               @db_cache << self
               @parent = new_parent
               @root = new_parent.root
@@ -242,6 +265,7 @@ module ReactiveRecord
             end
           end
 
+          # SECURITY - SAFE
           def apply_method(method)
             if method.is_a? Array and method.first == "find_by_id"
               method[0] = "find"
@@ -252,6 +276,7 @@ module ReactiveRecord
             @db_cache.detect { |cached_item| cached_item.vector == new_vector} || apply_method_to_cache(method)
           end
 
+          # SECURITY - SAFE
           def jsonize(method)
             # sadly standard json converts {[:foo, nil] => 123} to {"['foo', nil]": 123}
             # luckily [:foo, nil] does convert correctly
@@ -261,20 +286,20 @@ module ReactiveRecord
 
           def as_hash(children = nil)
             unless children
-              return {} if @ar_object.is_a?(Class) and (@ar_object < ActiveRecord::Base)
-              children = [@ar_object.is_a?(BigDecimal) ? @ar_object.to_f : @ar_object]
+              return {} if @value.is_a?(Class) and (@value < ActiveRecord::Base)
+              children = [@value.is_a?(BigDecimal) ? @value.to_f : @value]
             end
             if @parent
               if method == "*"
-                if @ar_object.is_a? Array  # this happens when a scope is empty there is test case, but
+                if @value.is_a? Array  # this happens when a scope is empty there is test case, but
                   @parent.as_hash({})      # does it work for all edge cases?
                 else
-                  @parent.as_hash({@ar_object.id => children})
+                  @parent.as_hash({@value.id => children})
                 end
-              elsif @ar_object.class < ActiveRecord::Base and children.is_a? Hash
+              elsif @value.class < ActiveRecord::Base and children.is_a? Hash
                 @parent.as_hash({jsonize(method) => children.merge({
-                  :id => (method.is_a?(Array) && method.first == "new") ? [nil] : [@ar_object.id],
-                  @ar_object.class.inheritance_column => [@ar_object[@ar_object.class.inheritance_column]],
+                  :id => (method.is_a?(Array) && method.first == "new") ? [nil] : [@value.id],
+                  @value.class.inheritance_column => [@value[@value.class.inheritance_column]],
                   })})
               elsif method == "*all"
                 @parent.as_hash({jsonize(method) => children.first})
@@ -286,10 +311,40 @@ module ReactiveRecord
             end
           end
 
+          def to_json
+            @value.to_json
+          end
+
         end
 
       end
 
+=begin
+tree is a hash, target is the object that will be filled in with the data hanging off the key.
+first time around target == nil, so for each key, value pair we do this: load_from_json(value, Object.const_get(JSON.parse(key)))
+keys:
+  ':*all':   target.replace tree["*all"].collect { |id| target.proxy_association.klass.find(id) }
+  Example: {'*all': [1, 7, 19, 23]}  target is a collection and will now have 4 records: 1, 7, 19, 23
+
+  'id':  if value is an array then target.id = value.first
+  Example: {'id': [17]} Example the target is a record, and its id is now set to 17
+
+  '*count': target.set_count_state(value.first)  note: set_count_state sets the count of a collection and updates the associated state variable
+  integer-like-string-or-number: target.push_and_update_belongs_to(key)  note: collection will be a has_many association, so we are doing a target << find(key), and updating both ends of the relationship
+  [:new, nnn] do a ReactiveRecord::Base.find_by_object_id(target.base_class, method[1]) and that becomes the new target, with val being passed allow_change
+  [...] and current target is NOT an ActiveRecord Model (??? a collection ???) then send key to target, and that becomes new target
+      but note if value is an array then the scope returned nil, so we destroy the bogus record, and set new target back to nil
+        new_target.destroy and new_target = nil if value.is_a? Array
+  [...] and current target IS AN ActiveRecord Model (not a collection) then target.backing_record.update_attribute([method], target.backing_record.convert(method, value.first))
+  aggregation:
+    target.class.respond_to?(:reflect_on_aggregation) and aggregation = target.class.reflect_on_aggregation(method) and !(aggregation.klass < ActiveRecord::Base)
+      target.send "#{method}=", aggregation.deserialize(value.first)
+  other-string-method-name:
+    if value is a an array then value.first is the new value and we do target.send "{key}=", value.first
+    if value is a hash
+=end
+
+
       def self.load_from_json(tree, target = nil)
         ignore_all = nil
 
@@ -319,7 +374,7 @@ module ReactiveRecord
             if method[0] == "new"
               new_target = ReactiveRecord::Base.find_by_object_id(target.base_class, method[1])
             elsif !(target.class < ActiveRecord::Base)
-              new_target = target.send *method
+              new_target = target.send(*method)
               # value is an array if scope returns nil, so we destroy the bogus record
               new_target.destroy and new_target = nil if value.is_a? Array
             else
@@ -335,7 +390,7 @@ module ReactiveRecord
             new_target = association.klass.find(value[:id].first)
             target.send "#{method}=", new_target
           elsif !(target.class < ActiveRecord::Base)
-            new_target = target.send *method
+            new_target = target.send(*method)
             # value is an array if scope returns nil, so we destroy the bogus record
             new_target.destroy and new_target = nil if value.is_a? Array
           else