reactive-record 0.7.15 → 0.7.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7855dd3a22d52663865ebec642e73a24b63edd47
-  data.tar.gz: 3a383477635ae0dc2cab7375e761acbb9a568323
+  metadata.gz: 139439c144b766200fccb72d67240cbfec0d6eae
+  data.tar.gz: 1d67f45f99d68e4e2dd0ac5db2ee88885b491e80
 SHA512:
-  metadata.gz: 7628e05b00f071724498ba1e9cc562e1786f26818385a021003250428f0b767d49d7afd9a9722beef43c70678856ce7eb9256fc0ce90b7888a111d2ea8d64bae
-  data.tar.gz: 7fed6602d7e6556c50ccd9cd18ce25fa09c1803fcfe55ebe979147b690f0d5460bb0a151f82e103da4ea779773acf6d7d9ee187b369d0dea5d28253fb6da45ce
+  metadata.gz: 4389f9eeecb8e5da8ff5788bdcb5886b2f086111e8a7ca7620e65e78cec26fcdb2b371fb2ab2d38fa0a7f3517a675478557a1a157915e99a93848e6d526b105d
+  data.tar.gz: 1c647b32c2b98182e8e8dbd12672ce1faca07bce3613405baec06c8c30ed56a21f15e27d342448fdd10969dddcd82b40d36acb04669693ea5116262b83969e63

data/app/controllers/reactive_record/reactive_record_controller.rb

@@ -3,16 +3,16 @@ require 'reactive_record/server_data_cache'
 module ReactiveRecord
 
   class ReactiveRecordController < ::ApplicationController
-    
+
     def fetch
       render :json => ReactiveRecord::ServerDataCache[params[:pending_fetches], acting_user]
     end
-        
+
 
     def save
-      render :json => ReactiveRecord::Base.save_records(params[:models], params[:associations], acting_user)
+      render :json => ReactiveRecord::Base.save_records(params[:models], params[:associations], acting_user, params[:validate])
     end
-      
+
     def destroy
       render :json => ReactiveRecord::Base.destroy_record(params[:model], params[:id], params[:vector], acting_user)
     end

data/lib/reactive_record/active_record/class_methods.rb

@@ -90,6 +90,10 @@ module ActiveRecord
       Aggregations::AggregationReflection.new(base_class, :composed_of, name, opts)
     end
 
+    def column_names
+      []  # it would be great to figure out how to get this information on the client!  For now we just return an empty array
+    end
+
     [
       "table_name=", "before_validation", "with_options", "validates_presence_of", "validates_format_of",
       "accepts_nested_attributes_for", "before_create", "after_create", "before_save", "after_save", "before_destroy", "where", "validate",

data/lib/reactive_record/active_record/instance_methods.rb

@@ -1,11 +1,11 @@
 module ActiveRecord
-  
+
   module InstanceMethods
-        
+
     def attributes
       @backing_record.attributes
     end
-    
+
     def initialize(hash = {})
       if hash.is_a? ReactiveRecord::Base
         @backing_record = hash
@@ -14,19 +14,27 @@ module ActiveRecord
         # we have to build the backing record first then initialize it so associations work correctly
         @backing_record = ReactiveRecord::Base.new(self.class, {}, self)
         @backing_record.instance_eval do
-          self.class.load_data { hash.each { |attribute, value| reactive_set!(attribute, value) unless attribute == primary_key } }
+          self.class.load_data do
+            hash.each do |attribute, value|
+              unless attribute == primary_key
+                reactive_set!(attribute, value) unless attribute == primary_key
+                changed_attributes << attribute
+              end
+            end
+            #changed_attributes << primary_key # insures that changed attributes has at least one element
+          end
         end
       end
     end
-    
+
     def primary_key
       self.class.primary_key
     end
-    
+
     def id
       @backing_record.reactive_get!(primary_key)
     end
-    
+
     def id=(value)
       @backing_record.id = value
     end
@@ -35,19 +43,19 @@ module ActiveRecord
       # in reality should return ActiveModel::Name object, blah blah
       self.class.model_name
     end
-    
+
     def revert
       @backing_record.revert
     end
-    
+
     def changed?
       @backing_record.changed?
     end
-    
+
     def ==(ar_instance)
       @backing_record == ar_instance.instance_eval { @backing_record }
     end
-    
+
     def method_missing(name, *args, &block)
       if name =~ /_changed\?$/
         @backing_record.changed?(name.gsub(/_changed\?$/,""))
@@ -55,33 +63,33 @@ module ActiveRecord
         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)
       else
         super
       end
     end
-    
-    def save(&block) 
-      @backing_record.save &block
+
+    def save(opts = {}, &block)
+      @backing_record.save(opts[:validate], &block)
     end
-    
+
     def saving?
       @backing_record.saving?
     end
-    
+
     def destroy(&block)
       @backing_record.destroy &block
     end
-    
+
     def new?
       @backing_record.new?
     end
-    
+
     def errors
+      React::State.get_state(@backing_record, @backing_record)
       @backing_record.errors
     end
-    
+
   end
-  
+
 end
-    

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

@@ -29,6 +29,9 @@ module ReactiveRecord
     attr_accessor :ar_instance
     attr_accessor :vector
     attr_accessor :model
+    attr_accessor :changed_attributes
+    attr_accessor :aggregate_owner
+    attr_accessor :aggregate_attribute
 
     # 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.
@@ -84,7 +87,7 @@ module ReactiveRecord
       record.ar_instance ||= infer_type_from_hash(model, record.attributes).new(record)
     end
 
-    def self.new_from_vector(model, aggregate_method, *vector)
+    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
       # server.  That only happens during find.
@@ -97,6 +100,8 @@ module ReactiveRecord
         record = new model
         record.vector = vector
       end
+      record.aggregate_owner = aggregate_owner
+      record.aggregate_attribute = vector.last
       record.ar_instance ||= infer_type_from_hash(model, record.attributes).new(record)
     end
 
@@ -105,6 +110,7 @@ module ReactiveRecord
       @ar_instance = ar_instance
       @synced_attributes = {}
       @attributes = {}
+      @changed_attributes = []
       records[model] << self
     end
 
@@ -174,39 +180,54 @@ module ReactiveRecord
               attributes[attribute].attributes[inverse_of] = nil
             end
           end
+        elsif @model.reflect_on_aggregation(attribute)
+          attributes[attribute].instance_variable_get(:@backing_record).aggregate_owner = nil if attributes[attribute]
+          aggregate = value.instance_variable_get(:@backing_record)
+          aggregate.aggregate_owner = self
+          aggregate.aggregate_attribute = attribute
         end
-        was_changed = changed2(@attributes.dup)
-        attributes[attribute] = value
-        React::State.set_state(self, attribute, value) unless data_loading?
-        React::State.set_state(self, self, :changed) unless data_loading? or (was_changed == changed2({attribute => value}))
+        update_attribute(attribute, value)
       end
       value
     end
 
-    def changed?(*args)
-      changed2(if args.count == 0
-        React::State.get_state(self, self)
-        @attributes.dup
+    def update_attribute(attribute, *args)
+      value = args[0]
+      changed = if args.count == 0
+        if association = @model.reflect_on_association(attribute) and association.collection?
+          attributes[attribute] != @synced_attributes[attribute]
+        else
+          !attributes[attribute].instance_variable_get(:@backing_record).changed_attributes.empty?
+        end
+      elsif association = @model.reflect_on_association(attribute) and association.collection?
+        value != @synced_attributes[attribute]
       else
-        React::State.get_state(@attributes, args[0])
-        {args[0] => @attributes[args[0]]}
-      end)
+        !@synced_attributes.has_key?(attribute) or @synced_attributes[attribute] != value
+      end
+      empty_before = changed_attributes.empty?
+      if !changed
+        changed_attributes.delete(attribute)
+      elsif !changed_attributes.include?(attribute)
+        changed_attributes << attribute
+      end
+      attributes[attribute] = value if args.count != 0
+      React::State.set_state(self, attribute, value) unless data_loading?
+      if empty_before != changed_attributes.empty?
+        React::State.set_state(self, "!CHANGED!", !changed_attributes.empty?) unless data_loading?
+        aggregate_owner.update_attribute(aggregate_attribute) if aggregate_owner
+      end
     end
 
-    def changed2(attrs)
-      attrs.each do |attribute, value|
-        if association = @model.reflect_on_association(attribute) and association.collection? and value
-          return true unless value == @synced_attributes[attribute]
-        elsif !@synced_attributes.has_key?(attribute)
-          return true
-        elsif @synced_attributes[attribute] != value
-          return true
-        end
+    def changed?(*args)
+      if args.count == 0
+        React::State.get_state(self, "!CHANGED!")
+        !changed_attributes.empty?
+      else
+        React::State.get_state(self, args[0])
+        changed_attributes.include? args[0]
       end
-      false
     end
 
-
     def errors
       @errors ||= ActiveModel::Error.new
     end
@@ -214,15 +235,25 @@ module ReactiveRecord
     def sync!(hash = {})  # does NOT notify (see saved! for notification)
       @attributes.merge! hash
       @synced_attributes = @attributes.dup
-      @synced_attributes.each { |key, value| @synced_attributes[key] = value.dup_for_sync if value.is_a? Collection }
+      @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.instance_variable_get(:@backing_record).sync!
+        end
+      end
+      @changed_attributes = []
       @saving = false
       @errors = nil
+      # set the vector - this only happens when a new record is saved
+      @vector = [@model, ["find_by_#{@model.primary_key}", id]] if (!vector or vector.empty?) and id and id != ""
       self
     end
 
     def sync_attribute(attribute, value)
       @synced_attributes[attribute] = attributes[attribute] = value
       @synced_attributes[attribute] = value.dup if value.is_a? ReactiveRecord::Collection
+      @changed_attributes.delete(attribute)
       value
     end
 
@@ -231,6 +262,7 @@ module ReactiveRecord
         @ar_instance.send("#{attribute}=", @synced_attributes[attribute])
       end
       @attributes.delete_if { |attribute, value| !@synced_attributes.has_key?(attribute) }
+      @changed_attributes = []
       @errors = nil
     end
 
@@ -239,14 +271,16 @@ module ReactiveRecord
       @saving = true
     end
 
-    def saved!(errors = nil)  # sets saving to false AND notifies
+    def errors!(errors)
+      @errors = errors and ActiveModel::Error.new(errors)
+    end
+
+    def saved!  # sets saving to false AND notifies
       @saving = false
-      @errors = ActiveModel::Error.new(errors)
-      if errors
-        #errors.each { |attribute, error| React::State.set_state(self, attribute, attributes[attribute]) }
-        React::State.set_state(self, self, :errors)
-      elsif !data_loading?
+      if !@errors or @errors.empty?
         React::State.set_state(self, self, :saved)
+      elsif !data_loading?
+        React::State.set_state(self, self, :error)
       end
       self
     end
@@ -304,7 +338,11 @@ module ReactiveRecord
       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)
-        @attributes[method] = aggregation.klass.new
+        @attributes[method] = aggregation.klass.new.tap do |aggregate|
+          backing_record = aggregate.instance_variable_get(:@backing_record)
+          backing_record.aggregate_owner = self
+          backing_record.aggregate_attribute = method
+        end
       end
     end
 

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

@@ -1,7 +1,7 @@
 module ReactiveRecord
 
   class Collection
-    
+
     def initialize(target_klass, owner = nil, association = nil, *vector)
       @owner = owner  # can be nil if this is an outer most scope
       @association = association
@@ -13,7 +13,7 @@ module ReactiveRecord
       end
       @scopes = {}
     end
-    
+
     def dup_for_sync
       self.dup.instance_eval do
         @collection = @collection.dup if @collection
@@ -52,11 +52,11 @@ module ReactiveRecord
       scope = [scope, *args] if args.count > 0
       @scopes[scope] ||= Collection.new(@target_klass, @owner, @association, *@vector, [scope])
     end
-    
+
     def proxy_association
       @association || self # returning self allows this to work with things like Model.all
     end
-    
+
     def klass
       @target_klass
     end
@@ -64,17 +64,24 @@ module ReactiveRecord
 
     def <<(item)
       backing_record = item.instance_variable_get(:@backing_record)
-      if backing_record and @owner and @association and inverse_of = @association.inverse_of
-        item.attributes[inverse_of].attributes[@association.attribute].delete(item) if item.attributes[inverse_of] and item.attributes[inverse_of].attributes[@association.attribute]
-        item.attributes[inverse_of] = @owner
-        React::State.set_state(backing_record, inverse_of, @owner) unless backing_record.data_loading?
-      end
+      # if backing_record and @owner and @association and inverse_of = @association.inverse_of
+      #   item.attributes[inverse_of].attributes[@association.attribute].delete(item) if item.attributes[inverse_of] and item.attributes[inverse_of].attributes[@association.attribute]
+      #   item.attributes[inverse_of] = @owner
+      #   React::State.set_state(backing_record, inverse_of, @owner) unless backing_record.data_loading?
+      # end
+      #all << item unless all.include? item
       all << item unless all.include? item
+      if backing_record and @owner and @association and inverse_of = @association.inverse_of and item.attributes[inverse_of] != @owner
+        current_association = item.attributes[inverse_of]
+        backing_record.update_attribute(inverse_of, @owner)
+        current_association.attributes[@association.attribute].delete(item) if current_association and current_association.attributes[@association.attribute]
+        @owner.instance_variable_get(:@backing_record).update_attribute(@association.attribute) # forces a check if association contents have changed from synced values
+      end
       @collection.delete(@dummy_record)
       @dummy_record = @dummy_collection = nil
       self
     end
-    
+
     [:first, :last].each do |method|
       define_method method do |*args|
         if args.count == 0
@@ -84,7 +91,7 @@ module ReactiveRecord
         end
       end
     end
-    
+
     def replace(new_array)
       #return new_array if @collection == new_array  #not sure we need this anymore
       @dummy_collection.notify if @dummy_collection
@@ -103,33 +110,36 @@ module ReactiveRecord
 
     def delete(item)
       if @owner and @association and inverse_of = @association.inverse_of
-        item.attributes[inverse_of] = nil
-        backing_record = item.instance_variable_get(:@backing_record)
-        React::State.set_state(backing_record, inverse_of, nil) unless backing_record.data_loading?
+        if backing_record = item.instance_variable_get(:@backing_record) and backing_record.attributes[inverse_of] == @owner
+          # the if prevents double update if delete is being called from << (see << above)
+          backing_record.update_attribute(inverse_of, nil)
+        end
+        all.delete(item).tap { @owner.instance_variable_get(:@backing_record).update_attribute(@association.attribute) } # forces a check if association contents have changed from synced values
+      else
+        all.delete(item)
       end
-      all.delete(item)
     end
 
     def method_missing(method, *args, &block)
       if [].respond_to? method
         all.send(method, *args, &block)
-      elsif @target_klass.respond_to? method
+      elsif @target_klass.respond_to?(method) or (args.count == 1 && method =~ /^find_by_/)
         apply_scope(method, *args)
       else
         super
       end
     end
-    
+
     protected
-    
+
     def dummy_record
       @dummy_record
     end
-    
+
     def collection
       @collection
     end
-    
+
     def dummy_collection
       @dummy_collection
     end

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

@@ -35,7 +35,12 @@ module ReactiveRecord
 
     isomorphic_method(:fetch_from_db) do |f, vector|
       # vector must end with either "*all", or be a simple attribute
-      f.send_to_server [vector.shift.name, *vector] if  RUBY_ENGINE == 'opal'
+      begin
+        f.send_to_server [vector.shift.name, *vector] if  RUBY_ENGINE == 'opal'
+      rescue Exception => e
+        `debugger`
+        nil
+      end
       f.when_on_server { @server_data_cache[*vector] }
     end
 
@@ -188,7 +193,7 @@ module ReactiveRecord
 
     if RUBY_ENGINE == 'opal'
 
-      def save(&block)
+      def save(validate, &block)
 
         if data_loading?
 
@@ -208,13 +213,11 @@ module ReactiveRecord
           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|
-            if assoc_record.changed?
-              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}
+            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
@@ -236,7 +239,7 @@ module ReactiveRecord
               elsif record.changed?(attribute)
                 output_attributes[attribute] = value
               end
-            end
+            end if record.changed?
             record_index += 1
           end
 
@@ -244,7 +247,7 @@ module ReactiveRecord
 
           promise = Promise.new
 
-          HTTP.post(`window.ReactiveRecordEnginePath`+"/save", payload: {models: models, associations: associations}).then do |response|
+          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
@@ -253,17 +256,19 @@ module ReactiveRecord
               if response.json[:success]
                 response.json[:saved_models].each { | item | backing_records[item[0]].sync!(item[2]) }
               else
-                response.json[:saved_models].each { | item | backing_records[item[0]].saved! item[3] }
                 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
 
+              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
 
-              backing_records.each { |id, record| record.saved! } if response.json[:success]
+              backing_records.each { |id, record| record.saved! }
+
             rescue Exception => e
               puts "Save Failed: #{e}"
             end
@@ -279,7 +284,7 @@ module ReactiveRecord
 
     else
 
-      def self.save_records(models, associations, acting_user)
+      def self.save_records(models, associations, acting_user, validate)
 
         reactive_records = {}
         new_models = []
@@ -288,7 +293,7 @@ module ReactiveRecord
         models.each do |model_to_save|
           attributes = model_to_save[:attributes]
           model = Object.const_get(model_to_save[:model])
-          id = attributes[model.primary_key] # if we are saving existing model primary key value will be present
+          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)
             keys = record.attributes.keys
@@ -315,27 +320,57 @@ module ReactiveRecord
           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)
-              parent.send("#{association[:attribute]}=", reactive_records[association[:child_id]])
+              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, n, o| n or o }
+              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).collection?
-              parent.send("#{association[:attribute]}") << reactive_records[association[:child_id]]
+              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|
-            unless model.frozen?
-              saved = model.check_permission_with_acting_user(acting_user, new_models.include?(model) ? :create_permitted? : :update_permitted?).save
+            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
-              [reactive_record_id, model.class.name, model.attributes, (saved ? nil : model.errors.messages)]
+              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
 
@@ -346,6 +381,7 @@ module ReactiveRecord
         {success: true, saved_models: saved_models }
 
       rescue Exception => e
+        puts "exception #{e}"
 
         {success: false, saved_models: saved_models, message: e.message}
 

data/lib/reactive_record/version.rb

@@ -1,3 +1,3 @@
 module ReactiveRecord
-  VERSION = "0.7.15"
+  VERSION = "0.7.16"
 end

metadata

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