hyper-mesh 1.0.0.lap27 → 1.0.0.lap28

data/lib/reactive_record/scope_description.rb

@@ -18,7 +18,7 @@ module ReactiveRecord
     attr_reader :name
 
     def self.find(target_model, name)
-      name = name.gsub(/!$/,'')
+      name = name.gsub(/!$/, '')
       target_model.send "_#{name}_synchromesh_scope_description_"
     rescue
       nil
@@ -34,13 +34,22 @@ module ReactiveRecord
 
     def joins_with?(record)
       @joins.detect do |klass, vector|
-        vector.any? && (klass == :all || record.class == klass || record.class < klass)
+        # added klass < record.class to handle STI case... should check to see if this could ever
+        # cause a problem.   Probably not a problem.
+        next unless vector.any?
+        (klass == :all || record.class == klass || record.class < klass || klass < record.class)
       end
     end
 
+    def get_joins(klass)
+      joins = @joins[klass] if @joins.key? klass
+      joins ||= @joins[klass.base_class] if @joins.key?(klass.base_class)
+      joins || @joins[:all]
+    end
+
     def related_records_for(record)
       ReactiveRecord::Base.catch_db_requests([]) do
-        (@joins[record.class.base_class] || @joins[:all]).collect do |vector|
+        get_joins(record.class).collect do |vector|
           crawl(record, *vector)
         end.flatten.compact
       end
@@ -52,8 +61,6 @@ module ReactiveRecord
       else
         Set.new(related_records.select { |r| r.instance_exec(*args, &@filter_proc) })
       end
-    rescue Exception => e
-      raise "Client side scope #{@model}.#{@name} raised error: #{e.message}"
     end
 
     # private methods
@@ -70,7 +77,8 @@ module ReactiveRecord
       if !@filter_proc || joins_list == []
         @joins = { all: [] }
       elsif joins_list.nil?
-        @joins = { @model => [[]], all: [] }
+        klass = @model < ActiveRecord::Base ? @model.base_class : @model
+        @joins = { klass => [[]], all: [] }
       elsif joins_list == :all
         @joins = { all: [[]] }
       else

data/lib/reactive_record/server_data_cache.rb

@@ -1,5 +1,11 @@
+require 'set'
 module ReactiveRecord
 
+  # requested cache items I think is there just so prerendering with multiple components works.
+  # because we have to dump the cache after each component render (during prererender) but
+  # we want to keep the larger cache alive (is this important???) we keep track of what got added
+  # to the cache during this cycle
+
   # the point is to collect up a all records needed, with whatever attributes were required + primary key, and inheritance column
   # or get all scope arrays, with the record ids
 
@@ -84,17 +90,26 @@ module ReactiveRecord
   # [Todo, [find, 119], owner, todos, active, *all]
   # -> [[Todo, [find, 119], owner, todos, active, *all], [119, 123], 119, 12]
 
-
     class ServerDataCache
 
-      # SECURITY - SAFE
       def initialize(acting_user, preloaded_records)
         @acting_user = acting_user
         @cache = []
-        @requested_cache_items = []
+        @cache_reps = {}
+        @requested_cache_items = Set.new
         @preloaded_records = preloaded_records
       end
 
+      attr_reader :cache
+      attr_reader :cache_reps
+      attr_reader :requested_cache_items
+
+      def add_item_to_cache(item)
+        cache << item
+        cache_reps[item.vector] = item
+        requested_cache_items << item
+      end
+
       if RUBY_ENGINE != 'opal'
 
         def self.get_model(str)
@@ -112,52 +127,69 @@ module ReactiveRecord
           str.constantize
         end
 
-        # SECURITY - NOW SAFE
         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] = ServerDataCache.get_model(vector[0])
-          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
+          timing('building cache_items') do
+            root = CacheItem.new(self, @acting_user, vector[0], @preloaded_records)
+            vector[1..-1].inject(root) { |cache_item, method| cache_item.apply_method method if cache_item }
+          end
+        end
+
+        def start_timing(&block)
+          ServerDataCache.start_timing(&block)
+        end
+
+        def timing(tag, &block)
+          ServerDataCache.timing(tag, &block)
+        end
+
+        def self.start_timing(&block)
+          @timings = Hash.new { |h, k| h[k] = 0 }
+          start_time = Time.now
+          yield.tap do
+            ::Rails.logger.debug "********* Total Time #{total = Time.now - start_time} ***********************"
+            sum = 0
+            @timings.sort_by(&:last).reverse.each do |tag, time|
+              ::Rails.logger.debug "            #{tag}: #{time} (#{(time/total*100).to_i})%"
+              sum += time
+            end
+            ::Rails.logger.debug "********* Other Time ***********************"
           end
-          last_value
         end
 
-        # SECURITY - SAFE
+        def self.timing(tag, &block)
+          start_time = Time.now
+          tag = tag.to_sym
+          yield.tap { @timings[tag] += (Time.now - start_time) if @timings }
+        end
+
         def self.[](models, associations, vectors, acting_user)
-          ActiveRecord::Base.public_columns_hash
-          result = nil
-          ActiveRecord::Base.transaction do
-            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, "This Rollback is intentional!"
+          start_timing do
+            timing(:public_columns_hash) { ActiveRecord::Base.public_columns_hash }
+            result = nil
+            ActiveRecord::Base.transaction do
+              cache = new(acting_user, timing(:save_records) { ReactiveRecord::Base.save_records(models, associations, acting_user, false, false) })
+              timing(:process_vectors) { vectors.each { |vector| cache[*vector] } }
+              timing(:as_json) { result = cache.as_json }
+              raise ActiveRecord::Rollback, "This Rollback is intentional!"
+            end
+            result
           end
-          result
         end
 
-        # SECURITY - SAFE
         def clear_requests
-          @requested_cache_items = []
+          @requested_cache_items = Set.new
         end
 
-        # SECURITY - SAFE
         def as_json
           @requested_cache_items.inject({}) do |hash, cache_item|
             hash.deep_merge! cache_item.as_hash
           end
         end
 
-        # SECURITY - SAFE
         def select(&block); @cache.select(&block); end
 
-        # SECURITY - SAFE
         def detect(&block); @cache.detect(&block); end
 
-        # SECURITY - SAFE
         def inject(initial, &block); @cache.inject(initial) &block; end
 
         class CacheItem
@@ -167,28 +199,23 @@ module ReactiveRecord
           attr_reader :root
           attr_reader :acting_user
 
-          # SECURITY - SAFE
           def value
             @value # which is a ActiveRecord object
           end
 
-          # SECURITY - SAFE
           def method
             @vector.last
           end
 
-          # SECURITY - NOW SAFE
           def self.new(db_cache, acting_user, klass, preloaded_records)
-            klass_constant = ServerDataCache.get_model(klass)
-            if existing = db_cache.detect { |cached_item| cached_item.vector == [klass_constant] }
+            klass = ServerDataCache.get_model(klass)
+            if existing = ServerDataCache.timing(:root_lookup) { db_cache.cache.detect { |cached_item| cached_item.vector == [klass] } }
               return existing
             end
             super
           end
 
-          # SECURITY - NOW SAFE
           def initialize(db_cache, acting_user, klass, preloaded_records)
-            klass = ServerDataCache.get_model(klass)
             @db_cache = db_cache
             @acting_user = acting_user
             @vector = @absolute_vector = [klass]
@@ -196,21 +223,30 @@ module ReactiveRecord
             @parent = nil
             @root = self
             @preloaded_records = preloaded_records
-            db_cache << self
+            @db_cache.add_item_to_cache self
+          end
+
+          def start_timing(&block)
+            ServerDataCache.class.start_timing(&block)
+          end
+
+          def timing(tag, &block)
+            ServerDataCache.timing(tag, &block)
           end
 
-          # SECURITY - UNSAFE
           def apply_method_to_cache(method)
-            @db_cache.inject(nil) do |representative, cache_item|
+            @db_cache.cache.inject(nil) do |representative, cache_item|
               if cache_item.vector == vector
                 if method == "*"
                   # apply_star does the security check if value is present
                   cache_item.apply_star || representative
                 elsif method == "*all"
                   # if we secure the collection then we assume its okay to read the ids
-                  cache_item.build_new_cache_item(cache_item.value.__secure_collection_check(@acting_user).collect { |record| record.id }, method, method)
+                  secured_value = cache_item.value.__secure_collection_check(@acting_user)
+                  cache_item.build_new_cache_item(timing(:active_record) { secured_value.collect { |record| record.id } }, method, method)
                 elsif method == "*count"
-                  cache_item.build_new_cache_item(cache_item.value.__secure_collection_check(@acting_user).count, method, method)
+                  secured_value = cache_item.value.__secure_collection_check(@acting_user)
+                  cache_item.build_new_cache_item(timing(:active_record) { cache_item.value.__secure_collection_check(@acting_user).count }, method, method)
                 elsif preloaded_value = @preloaded_records[cache_item.absolute_vector + [method]]
                   # no security check needed since we already evaluated this
                   cache_item.build_new_cache_item(preloaded_value, method, method)
@@ -224,11 +260,13 @@ module ReactiveRecord
                   else
                     begin
                       secured_method = "__secure_remote_access_to_#{[*method].first}"
-                      if cache_item.value.class < ActiveRecord::Base and cache_item.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...
+
+                      # order is important.  This check must be first since scopes can have same name as attributes!
+                      if cache_item.value.respond_to? secured_method
+                        cache_item.build_new_cache_item(timing(:active_record) { cache_item.value.send(secured_method, cache_item.value, @acting_user, *([*method][1..-1])) }, method, method)
+                      elsif (cache_item.value.class < ActiveRecord::Base) && cache_item.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...
                         cache_item.value.check_permission_with_acting_user(@acting_user, :view_permitted?, method)
-                        cache_item.build_new_cache_item(cache_item.value.send(*method), method, method)
-                      elsif cache_item.value.respond_to? secured_method
-                        cache_item.build_new_cache_item(cache_item.value.send(secured_method, @acting_user, *([*method][1..-1])), method, method)
+                        cache_item.build_new_cache_item(timing(:active_record) { cache_item.value.send(*method) }, method, method)
                       else
                         raise "method missing"
                       end
@@ -245,7 +283,6 @@ 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)
@@ -255,7 +292,6 @@ module ReactiveRecord
             end
           end
 
-          # SECURITY - NOW SAFE
           def apply_star
             if @value && @value.__secure_collection_check(@acting_user) && @value.length > 0
               i = -1
@@ -272,7 +308,6 @@ module ReactiveRecord
             end
           end
 
-          # 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
@@ -280,26 +315,23 @@ module ReactiveRecord
               @vector = @vector + [method]  # don't push it on since you need a new vector!
               @absolute_vector = @absolute_vector + [absolute_method]
               @value = new_value
-              @db_cache << self
+              @db_cache.add_item_to_cache self
               @parent = new_parent
               @root = new_parent.root
               self
             end
           end
 
-          # SECURITY - SAFE
           def apply_method(method)
-            
             if method.is_a? Array and method.first == "find_by_id"
               method[0] = "find"
             elsif method.is_a? String and method =~ /^\*[0-9]+$/
               method = "*"
             end
             new_vector = vector + [method]
-            @db_cache.detect { |cached_item| cached_item.vector == new_vector} || apply_method_to_cache(method)
+            timing('apply_method lookup') { @db_cache.cache_reps[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
@@ -307,30 +339,39 @@ module ReactiveRecord
             method.is_a?(Array) ? method.to_json : method
           end
 
+          def merge_inheritance_column(children)
+            if @value.attributes.key? @value.class.inheritance_column
+              children[@value.class.inheritance_column] = [@value[@value.class.inheritance_column]]
+            end
+            children
+          end
+
           def as_hash(children = nil)
             unless children
-              return {} if @value.is_a?(Class) and (@value < ActiveRecord::Base)
+              return {} if @value.is_a?(Class) && (@value < ActiveRecord::Base)
               children = [@value.is_a?(BigDecimal) ? @value.to_f : @value]
             end
             if @parent
               if method == "*"
                 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?
+                  @parent.as_hash({})  # does it work for all edge cases?
                 else
                   @parent.as_hash({@value.id => children})
                 end
-              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] : [@value.id],
-                  @value.class.inheritance_column => [@value[@value.class.inheritance_column]],
-                  })})
-              elsif method == "*all"
-                @parent.as_hash({jsonize(method) => children.first})
+              elsif (@value.class < ActiveRecord::Base) && children.is_a?(Hash)
+                id = method.is_a?(Array) && method.first == "new" ? [nil] : [@value.id]
+                # c = children.merge(id: id)
+                # if @value.attributes.key? @value.class.inheritance_column
+                #   c[@value.class.inheritance_column] = [@value[@value.class.inheritance_column]]
+                # end
+                @parent.as_hash(jsonize(method) => merge_inheritance_column(children.merge(id: id)))
+              elsif method == '*all'
+                @parent.as_hash('*all' => children.first)
               else
-                @parent.as_hash({jsonize(method) => children})
+                @parent.as_hash(jsonize(method) => children)
               end
             else
-              {method.name => children}
+              { method.name => children }
             end
           end
 
@@ -369,7 +410,6 @@ keys:
 
 
       def self.load_from_json(tree, target = nil)
-        ignore_all = nil
 
         # have to process *all before any other items
         # we leave the "*all" key in just for debugging purposes, and then skip it below
@@ -384,6 +424,7 @@ keys:
         tree.each do |method, value|
           method = JSON.parse(method) rescue method
           new_target = nil
+
           if method == "*all"
             next # its already been processed above
           elsif !target
@@ -395,19 +436,24 @@ keys:
             #target << (new_target = target.proxy_association.klass.find(method))
           elsif method.is_a? Array
             if method[0] == "new"
-              new_target = ReactiveRecord::Base.find_by_object_id(target.base_class, method[1])
+              new_target = ReactiveRecord::Base.lookup_by_object_id(method[1])
             elsif !(target.class < ActiveRecord::Base)
               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
-              target.backing_record.update_attribute([method], target.backing_record.convert(method, value.first))
+              target.backing_record.update_simple_attribute([method], target.backing_record.convert(method, value.first))
             end
-          elsif 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)
+          elsif target.class.respond_to?(:reflect_on_aggregation) &&
+                (aggregation = target.class.reflect_on_aggregation(method)) &&
+                !(aggregation.klass < ActiveRecord::Base)
+            value = [aggregation.deserialize(value.first)] unless value.first.is_a?(aggregation.klass)
+
+            target.send "#{method}=", value.first
           elsif value.is_a? Array
-            target.send "#{method}=", value.first unless method == "id" # we handle ids first so things sync nicely
+            # we cannot use target.send "#{method}=" here because it might be a server method, which does not have a setter
+            # a better fix might be something like target._internal_attribute_hash[method] =  ...
+            target.backing_record.set_attr_value(method, value.first) unless method == :id
           elsif value.is_a? Hash and value[:id] and value[:id].first and association = target.class.reflect_on_association(method)
             # not sure if its necessary to check the id above... is it possible to for the method to be an association but not have an id?
             new_target = association.klass.find(value[:id].first)
@@ -421,6 +467,9 @@ keys:
           end
           load_from_json(value, new_target) if new_target
         end
+      rescue Exception => e
+        # debugger
+        raise e
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: hyper-mesh
 version: !ruby/object:Gem::Version
-  version: 1.0.0.lap27
+  version: 1.0.0.lap28
 platform: ruby
 authors:
 - Mitch VanDuyn
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-03-07 00:00:00.000000000 Z
+date: 2018-05-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -31,28 +31,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.0.lap27
+        version: 1.0.0.lap28
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.0.lap27
+        version: 1.0.0.lap28
 - !ruby/object:Gem::Dependency
   name: hyper-operation
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.0.lap27
+        version: 1.0.0.lap28
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.0.lap27
+        version: 1.0.0.lap28
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -129,14 +129,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.0.lap27
+        version: 1.0.0.lap28
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.0.lap27
+        version: 1.0.0.lap28
 - !ruby/object:Gem::Dependency
   name: hyper-trace
   requirement: !ruby/object:Gem::Requirement
@@ -570,9 +570,7 @@ description: HyperMesh is the base for HyperModel. HyperModel gives your HyperCo
 email:
 - mitch@catprint.com
 - jan@kursator.com
-executables:
-- console
-- setup
+executables: []
 extensions: []
 extra_rdoc_files: []
 files:
@@ -598,6 +596,7 @@ files:
 - lib/hyper-mesh.rb
 - lib/hypermesh/version.rb
 - lib/kernel/itself.rb
+- lib/object/tap.rb
 - lib/opal/equality_patches.rb
 - lib/opal/parse_patch.rb
 - lib/opal/set_patches.rb
@@ -606,6 +605,7 @@ files:
 - lib/reactive_record/active_record/base.rb
 - lib/reactive_record/active_record/class_methods.rb
 - lib/reactive_record/active_record/error.rb
+- lib/reactive_record/active_record/errors.rb
 - lib/reactive_record/active_record/instance_methods.rb
 - lib/reactive_record/active_record/public_columns_hash.rb
 - lib/reactive_record/active_record/reactive_record/backing_record_inspector.rb
@@ -613,12 +613,15 @@ files:
 - lib/reactive_record/active_record/reactive_record/collection.rb
 - lib/reactive_record/active_record/reactive_record/column_types.rb
 - lib/reactive_record/active_record/reactive_record/dummy_value.rb
+- lib/reactive_record/active_record/reactive_record/getters.rb
 - lib/reactive_record/active_record/reactive_record/isomorphic_base.rb
+- lib/reactive_record/active_record/reactive_record/lookup_tables.rb
 - lib/reactive_record/active_record/reactive_record/operations.rb
-- lib/reactive_record/active_record/reactive_record/reactive_set_relationship_helpers.rb
 - lib/reactive_record/active_record/reactive_record/scoped_collection.rb
+- lib/reactive_record/active_record/reactive_record/setters.rb
 - lib/reactive_record/active_record/reactive_record/unscoped_collection.rb
 - lib/reactive_record/active_record/reactive_record/while_loading.rb
+- lib/reactive_record/active_record_error.rb
 - lib/reactive_record/broadcast.rb
 - lib/reactive_record/engine.rb
 - lib/reactive_record/interval.rb
@@ -653,7 +656,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: React based CRUD access and Synchronization of active record models across