reactive-record 0.7.22 → 0.7.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8ac17cb9431cfb70da2b36ad364d6f6daddabfad
-  data.tar.gz: 1ce72b88c991bcd5bd7b2b643a64c10b0da1173b
+  metadata.gz: 764bdacfc7a0653116882702f4d5ed982cd12cd1
+  data.tar.gz: 7b481038117f876a4a002fe6314ed0bbb407cf3f
 SHA512:
-  metadata.gz: 4f030a78f2bfb6be443e26f00a3782f33730abbfea6fcdf9897fde842436e14f113cd7c2d152ed2280536ef245e67ec91629c97080f1fbb4e6a882b8a00baabc
-  data.tar.gz: 8ced444a4e20aeabba7536f3acddfee6aad92c195f9ffbee484955e53ba0714b08b8f6b53c35d71f28694cc32a65d49d6076581b283fc9fd2fcd68f385d754f6
+  metadata.gz: a545ede62898bf66cc953aa86b05ff559dd9b4f2f356aa9c93efbed79697b2da6ceb6cec8167889d2dc9d822ead2cd8e195b2971d8b7c1cea69731be87574c5d
+  data.tar.gz: b4a4136d8ae962647c427d49f239a593d2404da3195e49ff69b637c8bfeae57f11914946d2a687d431bada263624d1574989b3d54b0e929ba20ef4a71d869931

data/app/controllers/reactive_record/reactive_record_controller.rb

@@ -5,16 +5,32 @@ module ReactiveRecord
   class ReactiveRecordController < ::ApplicationController
 
     def fetch
-      render :json => ReactiveRecord::ServerDataCache[params[:pending_fetches], acting_user]
+      render :json => ReactiveRecord::ServerDataCache[
+        (params[:models] || []).map(&:with_indifferent_access),
+        (params[:associations] || []).map(&:with_indifferent_access),
+        params[:pending_fetches],
+        acting_user
+      ]
     end
 
 
     def save
-      render :json => ReactiveRecord::Base.save_records(params[:models], params[:associations], acting_user, params[:validate])
+      render :json => ReactiveRecord::Base.save_records(
+        (params[:models] || []).map(&:with_indifferent_access),
+        (params[:associations] || []).map(&:with_indifferent_access),
+        acting_user,
+        params[:validate],
+        true
+      )
     end
 
     def destroy
-      render :json => ReactiveRecord::Base.destroy_record(params[:model], params[:id], params[:vector], acting_user)
+      render :json => ReactiveRecord::Base.destroy_record(
+        params[:model],
+        params[:id],
+        params[:vector],
+        acting_user
+      )
     end
 
   end

data/lib/reactive_record/active_record/aggregations.rb

@@ -19,10 +19,16 @@ module ActiveRecord
       attr_reader :klass_name
       attr_reader :attribute
       attr_reader :mapped_attributes
+      attr_reader :constructor
+
+      def construct(args)
+
+      end
 
       def initialize(owner_class, macro, name, options = {})
         owner_class.reflect_on_all_aggregations << self
         @owner_class = owner_class
+        @constructor = options[:constructor] || :new
         @klass_name =  options[:class_name] || name.camelize
         @attribute =   name
         if options[:mapping].respond_to? :collect
@@ -37,6 +43,24 @@ module ActiveRecord
         @klass ||= Object.const_get(@klass_name)
       end
 
+      def serialize(object)
+        if object.nil?
+          object # return dummy value if that is what we got
+        else
+          @mapped_attributes.collect { |attr| object.send(attr) }
+        end
+      end
+
+      def deserialize(array)
+        if array.nil?
+          array # return dummy value if that is what we got
+        elsif @constructor.respond_to?(:call)
+          @constructor.call(*array)
+        else
+          klass.send(@constructor, *array)
+        end
+      end
+
     end
 
   end

data/lib/reactive_record/active_record/class_methods.rb

@@ -79,6 +79,27 @@ module ActiveRecord
       ReactiveRecord::Base.class_scopes(self)[:all] = collection
     end
 
+    # def server_methods(*methods)
+    #   methods.each do |method|
+    #     define_method(method) do |*args|
+    #       if args.count == 0
+    #         @backing_record.reactive_get!(method, :initialize)
+    #       else
+    #         @backing_record.reactive_get!([[method]+args], :initialize)
+    #       end
+    #     end
+    #     define_method("#{method}!") do |*args|
+    #       if args.count == 0
+    #         @backing_record.reactive_get!(method, :force)
+    #       else
+    #         @backing_record.reactive_get!([[method]+args], :force)
+    #       end
+    #     end
+    #   end
+    # end
+    #
+    # alias_method :server_method, :server_methods
+
     [:belongs_to, :has_many, :has_one].each do |macro|
       define_method(macro) do |*args| # is this a bug in opal?  saying name, scope=nil, opts={} does not work!
         name = args.first
@@ -106,11 +127,11 @@ module ActiveRecord
 
     def _react_param_conversion(param, opt = nil)
       # defines how react will convert incoming json to this ActiveRecord model
-      times = {start: Time.now.to_f, json_start: 0, json_end: 0, db_load_start: 0, db_load_end: 0}
+      #TIMING times = {start: Time.now.to_f, json_start: 0, json_end: 0, db_load_start: 0, db_load_end: 0}
       param_is_native = !param.respond_to?(:is_a?) rescue true
-      times[:json_start] = Time.now.to_f
+      #TIMING times[:json_start] = Time.now.to_f
       param = JSON.from_object param if param_is_native
-      times[:json_end] = Time.now.to_f
+      #TIMING times[:json_end] = Time.now.to_f
       result = if param.is_a? self
         param
       elsif param.is_a? Hash
@@ -123,16 +144,16 @@ module ActiveRecord
           else
             target = new
           end
-          times[:db_load_start] = Time.now.to_f
+          #TIMING times[:db_load_start] = Time.now.to_f
           ReactiveRecord::Base.load_from_json(Hash[param.collect { |key, value| [key, [value]] }], target)
-          times[:db_load_end] = Time.now.to_f
+          #TIMING times[:db_load_end] = Time.now.to_f
           target
         end
       else
         nil
       end
-      times[:end] = Time.now.to_f
-      #puts "times - total: #{'%.04f' % (times[:end]-times[:start])}, native conversion: #{'%.04f' % (times[:json_end]-times[:json_start])}, loading: #{'%.04f' % (times[:db_load_end]-times[:db_load_start])}"
+      #TIMING times[:end] = Time.now.to_f
+      #TIMING puts "times - total: #{'%.04f' % (times[:end]-times[:start])}, native conversion: #{'%.04f' % (times[:json_end]-times[:json_start])}, loading: #{'%.04f' % (times[:db_load_end]-times[:db_load_start])}"
       result
     end
 

data/lib/reactive_record/active_record/instance_methods.rb

@@ -9,6 +9,7 @@ module ActiveRecord
     end
 
     def initialize(hash = {})
+
       if hash.is_a? ReactiveRecord::Base
         @backing_record = hash
       else
@@ -63,15 +64,19 @@ module ActiveRecord
     end
 
     def method_missing(name, *args, &block)
+      if name =~ /\!$/
+        name = name.gsub(/\!$/,"")
+        force_update = true
+      end
       if name =~ /_changed\?$/
         @backing_record.changed?(name.gsub(/_changed\?$/,""))
       elsif args.count == 1 && name =~ /=$/ && !block
         attribute_name = name.gsub(/=$/,"")
         @backing_record.reactive_set!(attribute_name, args[0])
       elsif args.count == 0 && !block
-        @backing_record.reactive_get!(name)
+        @backing_record.reactive_get!(name, force_update)
       elsif !block
-        @backing_record.reactive_get!([[name]+args])
+        @backing_record.reactive_get!([[name]+args], force_update)
       else
         super
       end

data/lib/reactive_record/active_record/reactive_record/base.rb

@@ -33,6 +33,8 @@ module ReactiveRecord
     attr_accessor :aggregate_owner
     attr_accessor :aggregate_attribute
     attr_accessor :destroyed
+    attr_accessor :updated_during
+    attr_accessor :synced_attributes
 
     # While data is being loaded from the server certain internal behaviors need to change
     # for example records all record changes are synced as they happen.
@@ -89,6 +91,10 @@ module ReactiveRecord
       record.ar_instance ||= infer_type_from_hash(model, record.attributes).new(record)
     end
 
+    def self.find_by_object_id(model, object_id)
+      @records[model].detect { |record| record.object_id == object_id }.ar_instance
+    end
+
     def self.new_from_vector(model, aggregate_owner, *vector)
       # this is the equivilent of find but for associations and aggregations
       # because we are not fetching a specific attribute yet, there is NO communication with the
@@ -121,6 +127,7 @@ module ReactiveRecord
       @synced_attributes = {}
       @attributes = {}
       @changed_attributes = []
+      @virgin = true
       records[model] << self
     end
 
@@ -148,6 +155,7 @@ module ReactiveRecord
         @ar_instance.instance_variable_set(:@backing_record, existing_record)
         existing_record.attributes.merge!(attributes) { |key, v1, v2| v1 }
       end
+      value
     end
 
     def attributes
@@ -155,10 +163,12 @@ module ReactiveRecord
       @attributes
     end
 
-    def reactive_get!(attribute)
+    def reactive_get!(attribute, reload = nil)
+      @virgin = false unless data_loading?
       unless @destroyed
         if @attributes.has_key? attribute
           attributes[attribute].notify if @attributes[attribute].is_a? DummyValue
+          apply_method(attribute) if reload
         else
           apply_method(attribute)
         end
@@ -168,6 +178,7 @@ module ReactiveRecord
     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?
@@ -194,10 +205,12 @@ module ReactiveRecord
               attributes[attribute].attributes[inverse_of] = nil
             end
           end
-        elsif aggregation = @model.reflect_on_aggregation(attribute)
+        elsif aggregation = @model.reflect_on_aggregation(attribute) and (aggregation.klass < ActiveRecord::Base)
 
-          unless attributes[attribute]
-            raise "unitialized aggregate attribute - should never happen"
+          if new?
+            attributes[attribute] ||= aggregation.klass.new
+          elsif !attributes[attribute]
+            raise "uninitialized aggregate attribute - should never happen"
           end
 
           aggregate_record = attributes[attribute].backing_record
@@ -219,6 +232,17 @@ module ReactiveRecord
 
     def update_attribute(attribute, *args)
       value = args[0]
+      if args.count != 0 and data_loading?
+        if aggregation = model.reflect_on_aggregation(attribute) and !(aggregation.klass < ActiveRecord::Base)
+          @synced_attributes[attribute] = aggregation.deserialize(aggregation.serialize(value))
+        else
+          @synced_attributes[attribute] = value
+        end
+      end
+      if @virgin
+        attributes[attribute] = value if args.count != 0
+        return
+      end
       changed = if args.count == 0
         if association = @model.reflect_on_association(attribute) and association.collection?
           attributes[attribute] != @synced_attributes[attribute]
@@ -236,10 +260,16 @@ module ReactiveRecord
       elsif !changed_attributes.include?(attribute)
         changed_attributes << attribute
       end
+      current_value = attributes[attribute]
       attributes[attribute] = value if args.count != 0
-      React::State.set_state(self, attribute, value) unless data_loading?
+      if !data_loading?
+        React::State.set_state(self, attribute, value)
+      elsif on_opal_client? and current_value.loaded? and current_value != value  # this is to handle changes in already loaded server side methods
+        #after(0.001) { React::State.set_state(self, attribute, value) }
+        React::State.set_state(self, attribute, value, true)
+      end
       if empty_before != changed_attributes.empty?
-        React::State.set_state(self, "!CHANGED!", !changed_attributes.empty?) unless data_loading?
+        React::State.set_state(self, "!CHANGED!", !changed_attributes.empty?, true) unless on_opal_server? or data_loading?
         aggregate_owner.update_attribute(aggregate_attribute) if aggregate_owner
       end
     end
@@ -260,16 +290,8 @@ module ReactiveRecord
 
     def sync!(hash = {})  # does NOT notify (see saved! for notification)
       @attributes.merge! hash
-      @synced_attributes = @attributes.dup
-      @synced_attributes.each do |key, value|
-        if value.is_a? Collection
-          @synced_attributes[key] = value.dup_for_sync
-        elsif aggregation = model.reflect_on_aggregation(key)
-          value.backing_record.sync!
-        elsif !model.reflect_on_association(key)
-          @synced_attributes[key] = JSON.parse(value.to_json)
-        end
-      end
+      @synced_attributes = {}
+      @synced_attributes.each { |attribute, value| sync_attribute(key, value) }
       @changed_attributes = []
       @saving = false
       @errors = nil
@@ -279,8 +301,21 @@ module ReactiveRecord
     end
 
     def sync_attribute(attribute, value)
+
       @synced_attributes[attribute] = attributes[attribute] = value
-      @synced_attributes[attribute] = value.dup if value.is_a? ReactiveRecord::Collection
+
+      #@synced_attributes[attribute] = value.dup if value.is_a? ReactiveRecord::Collection
+
+      if value.is_a? Collection
+        @synced_attributes[attribute] = value.dup_for_sync
+      elsif aggregation = model.reflect_on_aggregation(attribute) and (aggregation.klass < ActiveRecord::Base)
+        value.backing_record.sync!
+      elsif aggregation
+        @synced_attributes[attribute] = aggregation.deserialize(aggregation.serialize(value))
+      elsif !model.reflect_on_association(attribute)
+        @synced_attributes[attribute] = JSON.parse(value.to_json)
+      end
+
       @changed_attributes.delete(attribute)
       value
     end
@@ -347,31 +382,43 @@ module ReactiveRecord
 
     def apply_method(method)
       # Fills in the value returned by sending "method" to the corresponding server side db instance
+      if on_opal_server? and changed?
+        log("Warning fetching virtual attributes (#{model.name}.#{method}) during prerendering on a changed or new model is not implemented.", :warning)
+        # to implement this we would have to sync up any changes during prererendering with a set the cached models (see server_data_cache)
+        # right now server_data cache is read only, BUT we could change this.  However it seems like a tails case.  Why would we create or update
+        # a model during prerendering???
+      end
       if !new?
-        sync_attribute(
-          method,
-          if association = @model.reflect_on_association(method)
-            if association.collection?
-              Collection.new(association.klass, @ar_instance, association, *vector, method)
-            else
-              find_association(association, (id and id != "" and self.class.fetch_from_db([@model, [:find, id], method, @model.primary_key])))
-            end
-          elsif aggregation = @model.reflect_on_aggregation(method)
-            new_from_vector(aggregation.klass, self, *vector, method)
-          elsif id and id != ""
-            self.class.fetch_from_db([@model, [:find, id], method]) || self.class.load_from_db(*vector, method)
-          else  # its a attribute in an aggregate or we are on the client and don't know the id
-            self.class.fetch_from_db([*vector, method]) || self.class.load_from_db(*vector, method)
+        new_value = if association = @model.reflect_on_association(method)
+          if association.collection?
+            Collection.new(association.klass, @ar_instance, association, *vector, method)
+          else
+            find_association(association, (id and id != "" and self.class.fetch_from_db([@model, [:find, id], method, @model.primary_key])))
           end
-        )
+        elsif aggregation = @model.reflect_on_aggregation(method) and (aggregation.klass < ActiveRecord::Base)
+          new_from_vector(aggregation.klass, self, *vector, method)
+        elsif id and id != ""
+          self.class.fetch_from_db([@model, [:find, id], *method]) || self.class.load_from_db(self, *vector, method)
+        else  # its a attribute in an aggregate or we are on the client and don't know the id
+          self.class.fetch_from_db([*vector, *method]) || self.class.load_from_db(self, *vector, method)
+        end
+        new_value = @attributes[method] if new_value.is_a? DummyValue and @attributes.has_key?(method)
+        sync_attribute(method, new_value)
       elsif association = @model.reflect_on_association(method) and association.collection?
         @attributes[method] = Collection.new(association.klass, @ar_instance, association)
-      elsif aggregation = @model.reflect_on_aggregation(method)
+      elsif aggregation = @model.reflect_on_aggregation(method) and (aggregation.klass < ActiveRecord::Base)
         @attributes[method] = aggregation.klass.new.tap do |aggregate|
           backing_record = aggregate.backing_record
           backing_record.aggregate_owner = self
           backing_record.aggregate_attribute = method
         end
+      elsif !aggregation and method != model.primary_key
+        unless @attributes.has_key?(method)
+          log("Warning: reading from new #{model.name}.#{method} before assignment.  Will fetch value from server.  This may not be what you expected!!", :warning)
+        end
+        new_value = self.class.load_from_db(self, *vector, method)
+        new_value = @attributes[method] if new_value.is_a? DummyValue and @attributes.has_key?(method)
+        sync_attribute(method, new_value)
       end
     end
 

data/lib/reactive_record/active_record/reactive_record/collection.rb

@@ -35,7 +35,7 @@ module ReactiveRecord
             @collection << @target_klass.find_by(@target_klass.primary_key => id)
           end
         else
-          @dummy_collection = ReactiveRecord::Base.load_from_db(*@vector, "*all")
+          @dummy_collection = ReactiveRecord::Base.load_from_db(nil, *@vector, "*all")
           @dummy_record = self[0]
         end
       end
@@ -73,7 +73,7 @@ module ReactiveRecord
       elsif @count ||= ReactiveRecord::Base.fetch_from_db([*@vector, "*count"])
         @count
       else
-        ReactiveRecord::Base.load_from_db(*@vector, "*count")
+        ReactiveRecord::Base.load_from_db(nil, *@vector, "*count")
         @count = 1
       end
     end

data/lib/reactive_record/active_record/reactive_record/isomorphic_base.rb

@@ -8,13 +8,14 @@ module ReactiveRecord
 
     before_first_mount do |context|
       if RUBY_ENGINE != 'opal'
-        @server_data_cache = ReactiveRecord::ServerDataCache.new(context.controller.acting_user)
+        @server_data_cache = ReactiveRecord::ServerDataCache.new(context.controller.acting_user, {})
       else
         @fetch_scheduled = nil
         @records = Hash.new { |hash, key| hash[key] = [] }
         @class_scopes = Hash.new { |hash, key| hash[key] = {} }
         if on_opal_client?
           @pending_fetches = []
+          @pending_records = []
           @last_fetch_at = Time.now
           unless `typeof window.ReactiveRecordInitialData === 'undefined'`
             log(["Reactive record prerendered data being loaded: %o", `window.ReactiveRecordInitialData`])
@@ -71,7 +72,7 @@ module ReactiveRecord
     # queue up fetches, and at the end of each rendering cycle fetch the records
     # notify that loads are pending
 
-    def self.load_from_db(*vector)
+    def self.load_from_db(record, *vector)
       return nil unless on_opal_client? # this can happen when we are on the server and a nil value is returned for an attribute
       # only called from the client side
       # pushes the value of vector onto the a list of vectors that will be loaded from the server when the next
@@ -79,8 +80,10 @@ module ReactiveRecord
       # takes care of informing react that there are things to load, and schedules the loader to run
       # Note there is no equivilent to find_in_db, because each vector implicitly does a find.
       raise "attempt to do a find_by_id of nil.  This will return all records, and is not allowed" if vector[1] == ["find_by_id", nil]
+      vector = [record.model.model_name, ["new", record.object_id]]+vector[1..-1] if vector[0].nil?
       unless data_loading?
         @pending_fetches << vector
+        @pending_records << record if record
         schedule_fetch
       end
       DummyValue.new
@@ -177,15 +180,15 @@ module ReactiveRecord
     end
 
     def self.schedule_fetch
-      #ReactiveRecord.loads_pending!
-      #ReactiveRecord::WhileLoading.loading!
       @fetch_scheduled ||= after(0.01) do
-        if @pending_fetches.count > 0  # during testing we might reset the context while there are pending fetches
+        if @pending_fetches.count > 0  # during testing we might reset the context while there are pending fetches otherwise this would never normally happen
           last_fetch_at = @last_fetch_at
           pending_fetches = @pending_fetches.uniq
+          models, associations = gather_records(@pending_records, false, nil)
           log(["Server Fetching: %o", pending_fetches.to_n])
           start_time = Time.now
-          HTTP.post(`window.ReactiveRecordEnginePath`, payload: {pending_fetches: pending_fetches}).then do |response|
+          HTTP.post(`window.ReactiveRecordEnginePath`,
+          payload: {models: models, associations: associations, pending_fetches: pending_fetches}).then do |response|
             fetch_time = Time.now
             log("       Fetched in:   #{(fetch_time-start_time).to_i}s")
             begin
@@ -203,6 +206,7 @@ module ReactiveRecord
             ReactiveRecord.run_blocks_to_load(response.body)
           end
           @pending_fetches = []
+          @pending_records = []
           @last_fetch_at = Time.now
           @fetch_scheduled = nil
         end
@@ -217,6 +221,61 @@ module ReactiveRecord
 
     if RUBY_ENGINE == 'opal'
 
+      def self.gather_records(records_to_process, force, record_being_saved)
+        # we want to pass not just the model data to save, but also enough information so that on return from the server
+        # we can update the models on the client
+
+        # input
+        # list of records to process, will grow as we chase associations
+        # outputs
+        models = [] # the actual data to save {id: record.object_id, model: record.model.model_name, attributes: changed_attributes}
+        associations = [] # {parent_id: record.object_id, attribute: attribute, child_id: assoc_record.object_id}
+
+        # used to keep track of records that have been processed for effeciency
+        # for quick lookup of records that have been or will be processed [record.object_id] => record
+        records_to_process = records_to_process.uniq
+        backing_records = Hash[*records_to_process.collect { |record| [record.object_id, record] }.flatten(1)]
+
+        add_new_association = lambda do |record, attribute, assoc_record|
+          unless backing_records[assoc_record.object_id]
+            records_to_process << assoc_record
+            backing_records[assoc_record.object_id] = assoc_record
+          end
+          associations << {parent_id: record.object_id, attribute: attribute, child_id: assoc_record.object_id}
+        end
+
+        record_index = 0
+        while(record_index < records_to_process.count)
+          record = records_to_process[record_index]
+          if record.id.loading? and record_being_saved
+            raise "Attempt to save a model while it or an associated model is still loading: model being saved: #{record_being_saved.model}:#{record_being_saved.id}#{', associated model: '+record.model.to_s if record != record_being_saved}"
+          end
+          output_attributes = {record.model.primary_key => record.id}
+          vector = record.vector || [record.model.model_name, ["new", record.object_id]]
+          models << {id: record.object_id, model: record.model.model_name, attributes: output_attributes, vector: vector}
+          record.attributes.each do |attribute, value|
+            if association = record.model.reflect_on_association(attribute)
+              if association.collection?
+                value.each { |assoc| add_new_association.call record, attribute, assoc.backing_record }
+              elsif value
+                add_new_association.call record, attribute, value.backing_record
+              else
+                output_attributes[attribute] = nil
+              end
+            elsif aggregation = record.model.reflect_on_aggregation(attribute) and (aggregation.klass < ActiveRecord::Base)
+              add_new_association.call record, attribute, value.backing_record
+            elsif aggregation
+              new_value = aggregation.serialize(value)
+              output_attributes[attribute] = new_value if record.changed?(attribute) or new_value != aggregation.serialize(record.synced_attributes[attribute])
+            elsif record.changed?(attribute)
+              output_attributes[attribute] = value
+            end
+          end if record.changed? || (record == record_being_saved && force)
+          record_index += 1
+        end
+        [models, associations, backing_records]
+      end
+
       def save(validate, force, &block)
 
         if data_loading?
@@ -225,82 +284,50 @@ module ReactiveRecord
 
         elsif force or changed?
 
-          # we want to pass not just the model data to save, but also enough information so that on return from the server
-          # we can update the models on the client
-
-          # input
-          records_to_process = [self]  # list of records to process, will grow as we chase associations
-          # outputs
-          models = [] # the actual data to save {id: record.object_id, model: record.model.model_name, attributes: changed_attributes}
-          associations = [] # {parent_id: record.object_id, attribute: attribute, child_id: assoc_record.object_id}
-          # used to keep track of records that have been processed for effeciency
-          backing_records = {self.object_id => self} # for quick lookup of records that have been or will be processed [record.object_id] => record
-
-          add_new_association = lambda do |record, attribute, assoc_record|
-            unless backing_records[assoc_record.object_id]
-              records_to_process << assoc_record
-              backing_records[assoc_record.object_id] = assoc_record
-            end
-            associations << {parent_id: record.object_id, attribute: attribute, child_id: assoc_record.object_id}
-          end
+          begin
 
-          record_index = 0
-          while(record_index < records_to_process.count)
-            record = records_to_process[record_index]
-            output_attributes = {record.model.primary_key => record.id}
-            models << {id: record.object_id, model: record.model.model_name, attributes: output_attributes}
-            record.attributes.each do |attribute, value|
-              if association = record.model.reflect_on_association(attribute)
-                if association.collection?
-                  value.each { |assoc| add_new_association.call record, attribute, assoc.backing_record }
-                elsif value
-                  add_new_association.call record, attribute, value.backing_record
-                else
-                  output_attributes[attribute] = nil
-                end
-              elsif record.model.reflect_on_aggregation(attribute)
-                add_new_association.call record, attribute, value.backing_record
-              elsif record.changed?(attribute)
-                output_attributes[attribute] = value
-              end
-            end if record.changed? || (record == self && force)
-            record_index += 1
-          end
+            models, associations, backing_records = self.class.gather_records([self], force, self)
 
-          backing_records.each { |id, record| record.saving! }
+            backing_records.each { |id, record| record.saving! }
 
-          promise = Promise.new
+            promise = Promise.new
 
-          HTTP.post(`window.ReactiveRecordEnginePath`+"/save", payload: {models: models, associations: associations, validate: validate}).then do |response|
-            begin
-              response.json[:models] = response.json[:saved_models].collect do |item|
-                backing_records[item[0]].ar_instance
-              end
+            HTTP.post(`window.ReactiveRecordEnginePath`+"/save", payload: {models: models, associations: associations, validate: validate}).then do |response|
+              begin
+                response.json[:models] = response.json[:saved_models].collect do |item|
+                  backing_records[item[0]].ar_instance
+                end
 
-              if response.json[:success]
-                response.json[:saved_models].each { | item | backing_records[item[0]].sync!(item[2]) }
-              else
-                log("Reactive Record Save Failed: #{response.json[:message]}", :error)
-                response.json[:saved_models].each do | item |
-                  log("  Model: #{item[1]}[#{item[0]}]  Attributes: #{item[2]}  Errors: #{item[3]}", :error) if item[3]
+                if response.json[:success]
+                  response.json[:saved_models].each { | item | backing_records[item[0]].sync!(item[2]) }
+                else
+                  log("Reactive Record Save Failed: #{response.json[:message]}", :error)
+                  response.json[:saved_models].each do | item |
+                    log("  Model: #{item[1]}[#{item[0]}]  Attributes: #{item[2]}  Errors: #{item[3]}", :error) if item[3]
+                  end
                 end
-              end
 
-              response.json[:saved_models].each { | item | backing_records[item[0]].errors! item[3] }
+                response.json[:saved_models].each { | item | backing_records[item[0]].errors! item[3] }
 
-              yield response.json[:success], response.json[:message], response.json[:models]  if block
-              promise.resolve response.json
+                yield response.json[:success], response.json[:message], response.json[:models]  if block
+                promise.resolve response.json
 
-              backing_records.each { |id, record| record.saved! }
+                backing_records.each { |id, record| record.saved! }
 
-            rescue Exception => e
-              puts "Save Failed: #{e}"
+              rescue Exception => e
+                puts "Save Failed: #{e}"
+              end
             end
+            promise
+          rescue Exception => e
+            log("Exception raised while saving - #{e}", :error)
+            yield false, e.message, [] if block
+            promise.resolve({success: false, message: e.message, models: []})
+            promise
           end
-          promise
         else
           promise = Promise.new
-          yield true, nil if block
+          yield true, nil, [] if block
           promise.resolve({success: true})
           promise
         end
@@ -308,109 +335,159 @@ module ReactiveRecord
 
     else
 
-      def self.save_records(models, associations, acting_user, validate)
+      def self.find_record(model, id, vector, save)
+        if !save
+          found = vector[1..-1].inject(vector[0]) do |object, method|
+            if method.is_a? Array
+              if method[0] == "new"
+                object.new
+              else
+                object.send(*method)
+              end
+            elsif method.is_a? String and method[0] == "*"
+              object[method.gsub(/^\*/,"").to_i]
+            else
+              object.send(method)
+            end
+          end
+          if id and (found.nil? or !(found.class <= model) or found.id != id)
+            raise "Inconsistent data sent to server - #{model.name}.find(#{id}) != [#{vector}]"
+          end
+          found
+        elsif id
+          model.find(id)
+        else
+          model.new
+        end
+      end
+
+      def self.save_records(models, associations, acting_user, validate, save)
 
         reactive_records = {}
+        vectors = {}
         new_models = []
         saved_models = []
 
         models.each do |model_to_save|
           attributes = model_to_save[:attributes]
           model = Object.const_get(model_to_save[:model])
-          id = attributes.delete(model.primary_key) # if we are saving existing model primary key value will be present
-          reactive_records[model_to_save[:id]] = if id
-            record = model.find(id)
+          id = attributes.delete(model.primary_key) if model.respond_to? :primary_key # if we are saving existing model primary key value will be present
+          vector = model_to_save[:vector]
+          vector[0] = vector[0].constantize
+          reactive_records[model_to_save[:id]] = vectors[vector] = record = find_record(model, id, vector, save)
+          if record and record.respond_to?(:id) and record.id
+            # we have an already exising activerecord model
             keys = record.attributes.keys
             attributes.each do |key, value|
               if keys.include? key
                 record[key] = value
-              else
+              elsif !value.nil? and aggregation = record.class.reflect_on_aggregation(key.to_sym) and !(aggregation.klass < ActiveRecord::Base)
+                aggregation.mapping.each_with_index do |pair, i|
+                  record[pair.first] = value[i]
+                end
+              elsif record.respond_to? "#{key}="
                 record.send("#{key}=",value)
+              else
+                # TODO once reading schema.rb on client is implemented throw an error here
               end
             end
-            record
-          else
-            record = model.new
+          elsif record
+            # either the model is new, or its not even an active record model
             keys = record.attributes.keys
             attributes.each do |key, value|
               if keys.include? key
                 record[key] = value
-              else
+              elsif !value.nil? and aggregation = record.class.reflect_on_aggregation(key) and !(aggregation.klass < ActiveRecord::Base)
+                aggregation.mapping.each_with_index do |pair, i|
+                  record[pair.first] = value[i]
+                end
+              elsif key.to_s != "id"
                 record.send("#{key}=",value)
               end
             end
             new_models << record
-            record
           end
         end
 
         puts "!!!!!!!!!!!!!!attributes updated"
 
-        ActiveRecord::Base.transaction do
-
-          associations.each do |association|
-            parent = reactive_records[association[:parent_id]]
-            parent.instance_variable_set("@reactive_record_#{association[:attribute]}_changed", true)
-            if parent.class.reflect_on_aggregation(association[:attribute].to_sym)
-              puts ">>>>>>AGGREGATE>>>> #{parent.class.name}.send('#{association[:attribute]}=', #{reactive_records[association[:child_id]]})"
-              aggregate = reactive_records[association[:child_id]]
-              current_attributes = parent.send(association[:attribute]).attributes
-              puts "current parent attributes = #{current_attributes}"
-              new_attributes = aggregate.attributes
-              puts "current child attributes = #{new_attributes}"
-              merged_attributes = current_attributes.merge(new_attributes) { |k, current_attr, new_attr| aggregate.send("#{k}_changed?") ? new_attr : current_attr}
-              puts "merged attributes = #{merged_attributes}"
-              aggregate.assign_attributes(merged_attributes)
-              puts "aggregate attributes after merge = #{aggregate.attributes}"
-              parent.send("#{association[:attribute]}=", aggregate)
-              puts "updated  is frozen? #{aggregate.frozen?}, parent attributes = #{parent.send(association[:attribute]).attributes}"
-            elsif parent.class.reflect_on_association(association[:attribute].to_sym).nil?
-              raise "Missing association :#{association[:attribute]} for #{parent.class.name}.  Was association defined on opal side only?"
-            elsif parent.class.reflect_on_association(association[:attribute].to_sym).collection?
-              puts ">>>>>>>>>> #{parent.class.name}.send('#{association[:attribute]}') << #{reactive_records[association[:child_id]]})"
-              #parent.send("#{association[:attribute]}") << reactive_records[association[:child_id]]
-              puts "Skipped (should be done by belongs to)"
-            else
-              puts ">>>>ASSOCIATION>>>> #{parent.class.name}.send('#{association[:attribute]}=', #{reactive_records[association[:child_id]]})"
-              parent.send("#{association[:attribute]}=", reactive_records[association[:child_id]])
-              puts "updated"
-            end
-          end if associations
-
-          puts "!!!!!!!!!!!!associations updated"
-
-          has_errors = false
-
-          saved_models = reactive_records.collect do |reactive_record_id, model|
-            puts "saving rr_id: #{reactive_record_id} model.object_id: #{model.object_id} frozen? <#{model.frozen?}>"
-            if model.frozen?
-              puts "validating frozen model #{model.class.name} #{model} (reactive_record_id = #{reactive_record_id})"
-              valid = model.valid?
-              puts "has_errors before = #{has_errors}, validate= #{validate}, !valid= #{!valid}  (validate and !valid) #{validate and !valid}"
-              has_errors ||= (validate and !valid)
-              puts "validation complete errors = <#{!valid}>, #{model.errors.messages} has_errors #{has_errors}"
-              [reactive_record_id, model.class.name, model.attributes,  (valid ? nil : model.errors.messages)]
-            elsif !model.id or model.changed?
-              puts "saving #{model.class.name} #{model} (reactive_record_id = #{reactive_record_id})"
-              saved = model.check_permission_with_acting_user(acting_user, new_models.include?(model) ? :create_permitted? : :update_permitted?).save(validate: validate)
-              has_errors ||= !saved
-              messages = model.errors.messages if (validate and !saved) or (!validate and !model.valid?)
-              puts "saved complete errors = <#{!saved}>, #{messages} has_errors #{has_errors}"
-              [reactive_record_id, model.class.name, model.attributes, messages]
-            end
-          end.compact
+        associations.each do |association|
+          parent = reactive_records[association[:parent_id]]
+          next unless parent
+          #parent.instance_variable_set("@reactive_record_#{association[:attribute]}_changed", true) remove this????
+          if parent.class.reflect_on_aggregation(association[:attribute].to_sym)
+            puts ">>>>>>AGGREGATE>>>> #{parent.class.name}.send('#{association[:attribute]}=', #{reactive_records[association[:child_id]]})"
+            aggregate = reactive_records[association[:child_id]]
+            current_attributes = parent.send(association[:attribute]).attributes
+            puts "current parent attributes = #{current_attributes}"
+            new_attributes = aggregate.attributes
+            puts "current child attributes = #{new_attributes}"
+            merged_attributes = current_attributes.merge(new_attributes) { |k, current_attr, new_attr| aggregate.send("#{k}_changed?") ? new_attr : current_attr}
+            puts "merged attributes = #{merged_attributes}"
+            aggregate.assign_attributes(merged_attributes)
+            puts "aggregate attributes after merge = #{aggregate.attributes}"
+            parent.send("#{association[:attribute]}=", aggregate)
+            puts "updated  is frozen? #{aggregate.frozen?}, parent attributes = #{parent.send(association[:attribute]).attributes}"
+          elsif parent.class.reflect_on_association(association[:attribute].to_sym).nil?
+            raise "Missing association :#{association[:attribute]} for #{parent.class.name}.  Was association defined on opal side only?"
+          elsif parent.class.reflect_on_association(association[:attribute].to_sym).collection?
+            puts ">>>>>>>>>> #{parent.class.name}.send('#{association[:attribute]}') << #{reactive_records[association[:child_id]]})"
+            puts "Skipped (should be done by belongs to)"
+          else
+            puts ">>>>ASSOCIATION>>>> #{parent.class.name}.send('#{association[:attribute]}=', #{reactive_records[association[:child_id]]})"
+            parent.send("#{association[:attribute]}=", reactive_records[association[:child_id]])
+            puts "updated"
+          end
+        end if associations
+
+        puts "!!!!!!!!!!!!associations updated"
+
+        if save
+
+          ActiveRecord::Base.transaction do
+
+            has_errors = false
+
+            saved_models = reactive_records.collect do |reactive_record_id, model|
+              puts "saving rr_id: #{reactive_record_id} model.object_id: #{model.object_id} frozen? <#{model.frozen?}>"
+              if model.frozen?
+                puts "validating frozen model #{model.class.name} #{model} (reactive_record_id = #{reactive_record_id})"
+                valid = model.valid?
+                puts "has_errors before = #{has_errors}, validate= #{validate}, !valid= #{!valid}  (validate and !valid) #{validate and !valid}"
+                has_errors ||= (validate and !valid)
+                puts "validation complete errors = <#{!valid}>, #{model.errors.messages} has_errors #{has_errors}"
+                [reactive_record_id, model.class.name, model.attributes,  (valid ? nil : model.errors.messages)]
+              elsif !model.id or model.changed?
+                puts "saving #{model.class.name} #{model} (reactive_record_id = #{reactive_record_id})"
+                saved = model.check_permission_with_acting_user(acting_user, new_models.include?(model) ? :create_permitted? : :update_permitted?).save(validate: validate)
+                has_errors ||= !saved
+                messages = model.errors.messages if (validate and !saved) or (!validate and !model.valid?)
+                puts "saved complete errors = <#{!saved}>, #{messages} has_errors #{has_errors}"
+                [reactive_record_id, model.class.name, model.attributes, messages]
+              end
+            end.compact
 
-          raise "Could not save all models" if has_errors
+            raise "Could not save all models" if has_errors
+
+          end
+
+          {success: true, saved_models: saved_models }
+
+        else
+
+          vectors
 
         end
 
-        {success: true, saved_models: saved_models }
 
       rescue Exception => e
         puts "exception #{e}"
         puts e.backtrace.join("\n")
-
-        {success: false, saved_models: saved_models, message: e.message}
+        if save
+          {success: false, saved_models: saved_models, message: e.message}
+        else
+          {}
+        end
 
       end
 
@@ -434,7 +511,7 @@ module ReactiveRecord
 
         promise = Promise.new
 
-        if id or vector
+        if !data_loading? and (id or vector)
           HTTP.post(`window.ReactiveRecordEnginePath`+"/destroy", payload: {model: ar_instance.model_name, id: id, vector: vector}).then do |response|
             yield response.json[:success], response.json[:message] if block
             promise.resolve response.json
@@ -463,7 +540,7 @@ module ReactiveRecord
         record = if id
           model.find(id)
         else
-          ServerDataCache.new(acting_user)[*vector]
+          ServerDataCache.new(acting_user, {})[*vector]
         end
         record.check_permission_with_acting_user(acting_user, :destroy_permitted?).destroy
         {success: true, attributes: {}}

data/lib/reactive_record/serializers.rb

@@ -1,7 +1,7 @@
-ActiveRecord::Base.send(:define_method, :react_serializer) do 
+ActiveRecord::Base.send(:define_method, :react_serializer) do
   serializable_hash.merge(ReactiveRecord::Base.get_type_hash(self))
 end
 
 ActiveRecord::Relation.send(:define_method, :react_serializer) do
-  all.react_serializer
-end
+  all.to_a.react_serializer
+end

data/lib/reactive_record/server_data_cache.rb

@@ -87,16 +87,17 @@ module ReactiveRecord
 
     class ServerDataCache
 
-      def initialize(acting_user)
+      def initialize(acting_user, preloaded_records)
         @acting_user = acting_user
         @cache = []
         @requested_cache_items = []
+        @preloaded_records = preloaded_records
       end
 
       if RUBY_ENGINE != 'opal'
 
         def [](*vector)
-          root = CacheItem.new(@cache, @acting_user, vector[0])
+          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 }
@@ -104,8 +105,8 @@ module ReactiveRecord
           new_items.last.value if new_items.last
         end
 
-        def self.[](vectors, acting_user)
-          cache = new(acting_user)
+        def self.[](models, associations, vectors, acting_user)
+          cache = new(acting_user, ReactiveRecord::Base.save_records(models, associations, acting_user, false, false))
           vectors.each { |vector| cache[*vector] }
           cache.as_json
         end
@@ -129,6 +130,7 @@ module ReactiveRecord
         class CacheItem
 
           attr_reader :vector
+          attr_reader :absolute_vector
           attr_reader :record_chain
           attr_reader :root
           attr_reader :acting_user
@@ -141,7 +143,7 @@ module ReactiveRecord
             vector.last
           end
 
-          def self.new(db_cache, acting_user, klass)
+          def self.new(db_cache, acting_user, klass, preloaded_records)
             klass_constant = klass.constantize
             if existing = db_cache.detect { |cached_item| cached_item.vector == [klass_constant] }
               return existing
@@ -149,19 +151,20 @@ module ReactiveRecord
             super
           end
 
-          def initialize(db_cache, acting_user, klass)
+          def initialize(db_cache, acting_user, klass, preloaded_records)
             klass = klass.constantize
             @db_cache = db_cache
             @acting_user = acting_user
-            @vector = [klass]
+            @vector = @absolute_vector = [klass]
             @ar_object = klass
             @record_chain = []
             @parent = nil
             @root = self
+            @preloaded_records = preloaded_records
             db_cache << self
           end
 
-          def apply_method_to_cache(method, &block)
+          def apply_method_to_cache(method, absolute_method, &block)
             @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)
@@ -171,6 +174,7 @@ module ReactiveRecord
                   new_ar_object = yield cache_item
                   cache_item.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
                     @db_cache << self
                     @parent = cache_item
@@ -199,19 +203,31 @@ module ReactiveRecord
 
           def build_new_instances(method)
             if method == "*all"
-              apply_method_to_cache("*all") { |cache_item| cache_item.value.collect { |record| record.id } }
+              apply_method_to_cache("*all", "*all") { |cache_item| cache_item.value.collect { |record| record.id } }
             elsif method == "*count"
-              apply_method_to_cache("*count") { |cache_item| cache_item.value.count }
+              apply_method_to_cache("*count", "*count") { |cache_item| cache_item.value.count }
             elsif method == "*"
               if @ar_object and @ar_object.length > 0
+                i = -1
                 @ar_object.inject(nil) do | value, record |  # just using inject so we will return the last value
-                  apply_method_to_cache(method) { record }
+                  i += 1
+                  apply_method_to_cache(method, "*#{i}") { |cache_item| @preloaded_records[cache_item.absolute_vector + ["*#{i}"]] || record }
                 end
               else
-                apply_method_to_cache(method) {[]}
+                apply_method_to_cache(method, method) {[]}
               end
             else
-              apply_method_to_cache(method) { |cache_item| cache_item.value.send(*method) }
+              apply_method_to_cache(method, method) do |cache_item|
+                if preloaded_value = @preloaded_records[cache_item.absolute_vector + [method]]
+                  preloaded_value
+                elsif method.is_a? String and cache_item.value.class.respond_to?(:reflect_on_aggregation) and
+                aggregation = cache_item.value.class.reflect_on_aggregation(method.to_sym) and !(aggregation.klass < ActiveRecord::Base) and
+                cache_item.value.send(method)
+                  aggregation.mapping.collect { |attribute, accessor| cache_item.value[attribute] }
+                else
+                  cache_item.value.send(*method)
+                end
+              end
             end
           end
 
@@ -225,7 +241,7 @@ module ReactiveRecord
           def as_hash(children = nil)
             unless children
               return {} if @ar_object.is_a?(Class) and (@ar_object < ActiveRecord::Base)
-              children = [@ar_object]
+              children = [@ar_object.is_a?(BigDecimal) ? @ar_object.to_f : @ar_object]
             end
             if @parent
               if method == "*"
@@ -263,6 +279,10 @@ module ReactiveRecord
           target.replace sorted_collection.collect { |id| target.proxy_association.klass.find(id) }
         end
 
+        if id_value = tree["id"] and id_value.is_a? Array
+          target.id = id_value.first
+        end
+
         tree.each do |method, value|
           method = JSON.parse(method) rescue method
           new_target = nil
@@ -275,15 +295,20 @@ module ReactiveRecord
           elsif method.is_a? Integer or method =~ /^[0-9]+$/
             target << (new_target = target.proxy_association.klass.find(method))
           elsif method.is_a? Array
-            if !(target.class < ActiveRecord::Base)
+            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
               # 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.attributes[[method]] = value.first
+              target.backing_record.update_attribute([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 value.is_a? Array
-            target.send "#{method}=", value.first
+            target.send "#{method}=", value.first unless method == "id" # we handle ids first so things sync nicely
           elsif value.is_a? Hash and value[:id] and value[:id].first #and
             association = target.class.reflect_on_association(method)
             new_target = association.klass.find(value[:id].first)
@@ -293,7 +318,7 @@ module ReactiveRecord
           end
           load_from_json(value, new_target) if new_target
         end
-        target.save if target.respond_to? :save
+        #target.save if target.respond_to? :save
       end
 
 

data/lib/reactive_record/version.rb

@@ -1,3 +1,3 @@
 module ReactiveRecord
-  VERSION = "0.7.22"
+  VERSION = "0.7.24"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reactive-record
 version: !ruby/object:Gem::Version
-  version: 0.7.22
+  version: 0.7.24
 platform: ruby
 authors:
 - Mitch VanDuyn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-02 00:00:00.000000000 Z
+date: 2015-10-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails