reactive-record 0.7.14 → 0.7.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2018a59b979681b71ceb6af018e1acac2a79f92b
-  data.tar.gz: 22f1155c538b61a0ea36a1fb594c9570ddbb7882
+  metadata.gz: 7855dd3a22d52663865ebec642e73a24b63edd47
+  data.tar.gz: 3a383477635ae0dc2cab7375e761acbb9a568323
 SHA512:
-  metadata.gz: 3da93c95969beaee6501c52670b339b47b221049c8e85a505136ee1a2f9cb2649d3b15da4b8f42ad5968a09538921af24b74a25d5ec243d959736761ef45adc4
-  data.tar.gz: 6fb6c6d9d1393317ec6f21ea04d904e4f590f19edceab92fa220202670d198179780ce7510f3d7acd7ab2da1653d90dd963b1839af9d8d08e1c771da8a2da33a
+  metadata.gz: 7628e05b00f071724498ba1e9cc562e1786f26818385a021003250428f0b767d49d7afd9a9722beef43c70678856ce7eb9256fc0ce90b7888a111d2ea8d64bae
+  data.tar.gz: 7fed6602d7e6556c50ccd9cd18ce25fa09c1803fcfe55ebe979147b690f0d5460bb0a151f82e103da4ea779773acf6d7d9ee187b369d0dea5d28253fb6da45ce

data/lib/reactive_record/active_record/associations.rb

@@ -1,25 +1,32 @@
 module ActiveRecord
-  
+
   class Base
-    
+
     def self.reflect_on_all_associations
       base_class.instance_eval { @associations ||= superclass.instance_eval { (@associations && @associations.dup) || [] } }
     end
-    
+
     def self.reflect_on_association(attribute)
-      reflect_on_all_associations.detect { |association| association.attribute == attribute }
+      if found = reflect_on_all_associations.detect { |association| association.attribute == attribute and association.owner_class == self }
+        found
+      elsif superclass == Base
+        nil
+      else
+        superclass.reflect_on_association(attribute)
+      end
     end
-  
+
   end
-  
+
   module Associations
-    
+
     class AssociationReflection
-      
+
       attr_reader :association_foreign_key
       attr_reader :attribute
       attr_reader :macro
-            
+      attr_reader :owner_class
+
       def initialize(owner_class, macro, name, options = {})
         owner_class.reflect_on_all_associations << self
         @owner_class = owner_class
@@ -33,29 +40,29 @@ module ActiveRecord
         @association_foreign_key = options[:foreign_key] || (macro == :belongs_to && "#{name}_id") || "#{@owner_class.name.underscore}_id"
         @attribute =   name
       end
-      
+
       def inverse_of
         unless @options[:through] or @inverse_of
-          inverse_association = klass.reflect_on_all_associations.detect do | association | 
-            association.association_foreign_key == @association_foreign_key and association.klass.base_class == @owner_class.base_class and association.attribute != attribute
+          inverse_association = klass.reflect_on_all_associations.detect do | association |
+            association.association_foreign_key == @association_foreign_key and association.klass == @owner_class and association.attribute != attribute and klass == association.owner_class
           end
           raise "Association #{@owner_class}.#{attribute} (foreign_key: #{@association_foreign_key}) has no inverse in #{@klass_name}" unless inverse_association
           @inverse_of = inverse_association.attribute
         end
         @inverse_of
       end
-      
+
       def klass
         @klass ||= Object.const_get(@klass_name)
       end
-      
+
       def collection?
         [:has_many].include? @macro
       end
-      
+
     end
-    
+
   end
-  
-  
-end
+
+
+end

data/lib/reactive_record/active_record/class_methods.rb

@@ -1,7 +1,7 @@
 module ActiveRecord
-  
+
   module ClassMethods
-    
+
     def base_class
 
       unless self < Base
@@ -27,7 +27,7 @@ module ActiveRecord
     def primary_key=(val)
      base_class.instance_eval {  @primary_key_value = val }
     end
-    
+
     def inheritance_column
       base_class.instance_eval {@inheritance_column_value || "type"}
     end
@@ -44,11 +44,11 @@ module ActiveRecord
     def find(id)
       base_class.instance_eval {ReactiveRecord::Base.find(self, primary_key, id)}
     end
-    
+
     def find_by(opts = {})
       base_class.instance_eval {ReactiveRecord::Base.find(self, opts.first.first, opts.first.last)}
     end
-    
+
     def method_missing(name, *args, &block)
       if args.count == 1 && name =~ /^find_by_/ && !block
         find_by(name.gsub(/^find_by_/, "") => args[0])
@@ -56,49 +56,49 @@ module ActiveRecord
         raise "#{self.name}.#{name}(#{args}) (called class method missing)"
       end
     end
-    
+
     def abstract_class=(val)
       @abstract_class = val
     end
-    
+
     def scope(name, body)
       singleton_class.send(:define_method, name) do
-        ReactiveRecord::Base.class_scopes(self)[name] ||= ReactiveRecord::Collection.new(self, nil, nil, self, name) 
+        ReactiveRecord::Base.class_scopes(self)[name] ||= ReactiveRecord::Collection.new(self, nil, nil, self, name)
       end
-      singleton_class.send(:define_method, "#{name}=") do |collection| 
+      singleton_class.send(:define_method, "#{name}=") do |collection|
         ReactiveRecord::Base.class_scopes(self)[name] = collection
       end
     end
-    
+
     def all
       ReactiveRecord::Base.class_scopes(self)[:all] ||= ReactiveRecord::Collection.new(self, nil, nil, self, "all")
     end
-    
+
     def all=(collection)
       ReactiveRecord::Base.class_scopes(self)[:all] = collection
     end
-        
-    [:belongs_to, :has_many, :has_one].each do |macro| 
+
+    [: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
         opts = (args.count > 1 and args.last.is_a? Hash) ? args.last : {}
-        Associations::AssociationReflection.new(base_class, macro, name, opts)
+        Associations::AssociationReflection.new(self, macro, name, opts)
       end
     end
-    
+
     def composed_of(name, opts = {})
       Aggregations::AggregationReflection.new(base_class, :composed_of, name, opts)
     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", 
+      "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",
       "attr_protected", "validates_numericality_of", "default_scope", "has_attached_file", "attr_accessible",
       "serialize"
     ].each do |method|
       define_method(method.to_s) { |*args, &block| }
     end
-    
+
     def _react_param_conversion(param, opt = nil)
       # defines how react will convert incoming json to this ActiveRecord model
       param_is_native = !param.respond_to?(:is_a?) rescue true
@@ -122,7 +122,7 @@ module ActiveRecord
         nil
       end
     end
-    
+
   end
-  
-end
+
+end

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

@@ -1,66 +1,66 @@
 module ReactiveRecord
   class Base
-  
+
     # Its all about lazy loading. This prevents us from grabbing enormous association collections, or large attributes
     # unless they are explicitly requested.
-  
+
     # During prerendering we get each attribute as its requested and fill it in both on the javascript side, as well as
-    # remember that the attribute needs to be part of the download to client. 
-  
+    # remember that the attribute needs to be part of the download to client.
+
     # On the client we fill in the record data with empty values (nil, or one element collections) but only as the attribute
     # is requested.  Each request queues up a request to get the real data from the server.
-  
-    # The ReactiveRecord class serves two purposes.  First it is the unique data corresponding to the last known state of a 
-    # database record.  This means All records matching a specific database record are unique.  This is unlike AR but is 
+
+    # The ReactiveRecord class serves two purposes.  First it is the unique data corresponding to the last known state of a
+    # database record.  This means All records matching a specific database record are unique.  This is unlike AR but is
     # important both for the lazy loading and also so that when values change react can be informed of the change.
-  
+
     # Secondly it serves as name space for all the ReactiveRecord specific methods, so every AR Instance has a ReactiveRecord
-  
+
     # Because there is no point in generating a new ar_instance everytime a search is made we cache the first ar_instance created.
     # Its possible however during loading to create a new ar_instances that will in the end point to the same record.
-  
+
     # VECTORS... are an important concept.  They are the substitute for a primary key before a record is loaded.
     # Vectors have the form [ModelClass, method_call, method_call, method_call...]
-  
+
     # Each method call is either a simple method name or an array in the form [method_name, param, param ...]
     # Example [User, [find, 123], todos, active, [due, "1/1/2016"], title]
     # Roughly corresponds to this query: User.find(123).todos.active.due("1/1/2016").select(:title)
-  
+
     attr_accessor :ar_instance
     attr_accessor :vector
     attr_accessor :model
-    
+
     # 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.
     # This is implemented this way so that the ServerDataCache class can use pure active
     # record methods in its implementation
-    
+
     def self.data_loading?
       @data_loading
     end
-    
+
     def data_loading?
       self.class.data_loading?
     end
-    
+
     def self.load_data(&block)
       current_data_loading, @data_loading = [@data_loading, true]
       yield
       @data_loading = current_data_loading
     end
-    
+
     def self.load_from_json(json, target = nil)
       load_data { ServerDataCache.load_from_json(json, target) }
     end
-    
+
     def self.class_scopes(model)
       @class_scopes[model.base_class]
     end
-  
-    def self.find(model, attribute, value) 
+
+    def self.find(model, attribute, value)
       # will return the unique record with this attribute-value pair
       # value cannot be an association or aggregation
-        
+
       model = model.base_class
       # already have a record with this attribute-value pair?
       record = @records[model].detect { |record| record.attributes[attribute] == value}
@@ -70,7 +70,7 @@ module ReactiveRecord
         # find_in_db returns nil if we are not prerendering which will force us to create a new record
         # because there is no way of knowing the id.
         if attribute != model.primary_key and id = find_in_db(model, attribute, value)
-          record = @records[model].detect { |record| record.id == id} 
+          record = @records[model].detect { |record| record.id == id}
         end
         # if we don't have a record then create one
         (record = new(model)).vector = [model, ["find_by_#{attribute}", value]] unless record
@@ -79,26 +79,27 @@ module ReactiveRecord
         # and set the primary if we have one
         record.sync_attribute(model.primary_key, id) if id
       end
-    
+
       # finally initialize and return the ar_instance
       record.ar_instance ||= infer_type_from_hash(model, record.attributes).new(record)
     end
-  
-    def self.new_from_vector(model, aggregate_parent, *vector)
+
+    def self.new_from_vector(model, aggregate_method, *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 
+      # because we are not fetching a specific attribute yet, there is NO communication with the
       # server.  That only happens during find.
-    
       model = model.base_class
-    
+
       # do we already have a record with this vector?  If so return it, otherwise make a new one.
-    
-      record = @records[model].detect { |record| record.vector == vector}
-      (record = new(model)).vector = vector unless record
+
+      record = @records[model].detect { |record| record.vector == vector }
+      unless record
+        record = new model
+        record.vector = vector
+      end
       record.ar_instance ||= infer_type_from_hash(model, record.attributes).new(record)
-    
     end
-    
+
     def initialize(model, hash = {}, ar_instance = nil)
       @model = model
       @ar_instance = ar_instance
@@ -106,51 +107,50 @@ module ReactiveRecord
       @attributes = {}
       records[model] << self
     end
-  
+
     def find(*args)
       self.class.find(*args)
     end
-  
+
     def new_from_vector(*args)
       self.class.new_from_vector(*args)
     end
-  
+
     def primary_key
       @model.primary_key
     end
-  
+
     def id
       attributes[primary_key]
     end
-  
+
     def id=(value)
-      # we need to keep the id unique
-      existing_record = records[@model].detect { |record| record.attributes[primary_key] == value}
-      if existing_record
+      # value can be nil if we are loading an aggregate otherwise check if it already exists
+      if !(value and existing_record = records[@model].detect { |record| record.attributes[primary_key] == value})
+        attributes[primary_key] = value
+      else
         @ar_instance.instance_eval { @backing_record = existing_record }
         existing_record.attributes.merge!(attributes) { |key, v1, v2| v1 }
-      else
-        attributes[primary_key] = value
       end
     end
-  
+
     def attributes
       @last_access_at = Time.now
       @attributes
     end
-  
+
     def reactive_get!(attribute)
       unless @destroyed
-        apply_method(attribute) unless @attributes.has_key? attribute 
+        apply_method(attribute) unless @attributes.has_key? attribute
         React::State.get_state(self, attribute) unless data_loading?
         attributes[attribute]
       end
     end
-  
+
     def reactive_set!(attribute, value)
       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? 
+        if association = @model.reflect_on_association(attribute)
+          if association.collection?
             collection = Collection.new(association.klass, @ar_instance, association)
             collection.replace(value || [])
             value = collection
@@ -168,7 +168,7 @@ module ReactiveRecord
               end
             elsif value
               attributes[attribute].attributes[inverse_of] = nil if attributes[attribute]
-              value.attributes[inverse_of] = @ar_instance 
+              value.attributes[inverse_of] = @ar_instance
               React::State.set_state(value.instance_variable_get(:@backing_record), inverse_of, @ar_instance) unless data_loading?
             elsif attributes[attribute]
               attributes[attribute].attributes[inverse_of] = nil
@@ -182,7 +182,7 @@ module ReactiveRecord
       end
       value
     end
-    
+
     def changed?(*args)
       changed2(if args.count == 0
         React::State.get_state(self, self)
@@ -192,7 +192,7 @@ module ReactiveRecord
         {args[0] => @attributes[args[0]]}
       end)
     end
-  
+
     def changed2(attrs)
       attrs.each do |attribute, value|
         if association = @model.reflect_on_association(attribute) and association.collection? and value
@@ -205,12 +205,12 @@ module ReactiveRecord
       end
       false
     end
-    
-    
+
+
     def errors
       @errors ||= ActiveModel::Error.new
     end
-  
+
     def sync!(hash = {})  # does NOT notify (see saved! for notification)
       @attributes.merge! hash
       @synced_attributes = @attributes.dup
@@ -219,13 +219,13 @@ module ReactiveRecord
       @errors = nil
       self
     end
-  
+
     def sync_attribute(attribute, value)
       @synced_attributes[attribute] = attributes[attribute] = value
       @synced_attributes[attribute] = value.dup if value.is_a? ReactiveRecord::Collection
       value
     end
-    
+
     def revert
       @attributes.each do |attribute, value|
         @ar_instance.send("#{attribute}=", @synced_attributes[attribute])
@@ -233,33 +233,33 @@ module ReactiveRecord
       @attributes.delete_if { |attribute, value| !@synced_attributes.has_key?(attribute) }
       @errors = nil
     end
-    
-    def saving! 
+
+    def saving!
       React::State.set_state(self, self, :saving) unless data_loading?
       @saving = true
     end
-    
+
     def saved!(errors = nil)  # 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? 
+      elsif !data_loading?
         React::State.set_state(self, self, :saved)
       end
       self
     end
-    
+
     def saving?
       React::State.get_state(self, self)
       @saving
     end
-    
+
     def new?
       !id and !vector
     end
-  
+
     def find_association(association, id)
       inverse_of = association.inverse_of
       instance = if id
@@ -271,32 +271,32 @@ module ReactiveRecord
       inverse_association = association.klass.reflect_on_association(inverse_of)
       if inverse_association.collection?
         instance_backing_record_attributes[inverse_of] = if id and id != ""
-          Collection.new(@model, instance, inverse_association, association.klass, ["find", id], inverse_of) 
+          Collection.new(@model, instance, inverse_association, association.klass, ["find", id], inverse_of)
         else
-          Collection.new(@model, instance, inverse_association, *vector, association.attribute, inverse_of) 
+          Collection.new(@model, instance, inverse_association, *vector, association.attribute, inverse_of)
         end unless instance_backing_record_attributes[inverse_of]
         instance_backing_record_attributes[inverse_of].replace [@ar_instance]
       else
-        instance_backing_record_attributes[inverse_of] = @ar_instance 
+        instance_backing_record_attributes[inverse_of] = @ar_instance
       end if inverse_of and !instance_backing_record_attributes.has_key?(inverse_of)
       instance
     end
-        
+
     def apply_method(method)
       # Fills in the value returned by sending "method" to the corresponding server side db instance
       if !new?
         sync_attribute(
-          method, 
+          method,
           if association = @model.reflect_on_association(method)
-            if association.collection? 
+            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 != "" 
-            value = self.class.fetch_from_db([@model, [:find, id], method]) || self.class.load_from_db(*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)
           end
@@ -307,9 +307,9 @@ module ReactiveRecord
         @attributes[method] = aggregation.klass.new
       end
     end
-  
+
     def self.infer_type_from_hash(klass, hash)
-      klass = klass.base_class  
+      klass = klass.base_class
       return klass unless hash
       type = hash[klass.inheritance_column]
       begin
@@ -320,6 +320,6 @@ module ReactiveRecord
       end if type
       klass
     end
-  
+
   end
-end
+end

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

@@ -3,9 +3,9 @@ require 'json'
 module ReactiveRecord
 
   class Base
-    
+
     include React::IsomorphicHelpers
-        
+
     before_first_mount do |context|
       if RUBY_ENGINE != 'opal'
         @server_data_cache = ReactiveRecord::ServerDataCache.new(context.controller.acting_user)
@@ -13,7 +13,7 @@ module ReactiveRecord
         @fetch_scheduled = nil
         @records = Hash.new { |hash, key| hash[key] = [] }
         @class_scopes = Hash.new { |hash, key| hash[key] = {} }
-        if on_opal_client? 
+        if on_opal_client?
           @pending_fetches = []
           @last_fetch_at = Time.now
           unless `typeof window.ReactiveRecordInitialData === 'undefined'`
@@ -25,25 +25,25 @@ module ReactiveRecord
         end
       end
     end
-    
+
     def records
       self.class.instance_variable_get(:@records)
     end
-    
+
     # Prerendering db access (returns nil if on client):
     # at end of prerendering dumps all accessed records in the footer
-    
+
     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'
       f.when_on_server { @server_data_cache[*vector] }
     end
-    
+
     isomorphic_method(:find_in_db) do |f, klass, attribute, value|
       f.send_to_server klass.name, attribute, value if  RUBY_ENGINE == 'opal'
       f.when_on_server { @server_data_cache[klass, ["find_by_#{attribute}", value], :id] }
     end
-    
+
     prerender_footer do
       if @server_data_cache
         json = @server_data_cache.as_json.to_json  # can this just be to_json?
@@ -51,7 +51,7 @@ module ReactiveRecord
       else
         json = {}.to_json
       end
-      path = ::Rails.application.routes.routes.detect do |route| 
+      path = ::Rails.application.routes.routes.detect do |route|
         # not sure why the second check is needed.  It happens in the test app
         route.app == ReactiveRecord::Engine or (route.app.respond_to?(:app) and route.app.app == ReactiveRecord::Engine)
       end.path.spec
@@ -61,13 +61,13 @@ module ReactiveRecord
         "window.ReactiveRecordInitialData.push(#{json})\n"+
       "</script>\n"
     end if RUBY_ENGINE != 'opal'
-    
+
     # Client side db access (never called during prerendering):
-    
+
     # Always returns an object of class DummyValue which will act like most standard AR field types
     # Whenever a dummy value is accessed it notify React that there are loads pending so appropriate rerenders
     # will occur when the value is eventually loaded.
-    
+
     # queue up fetches, and at the end of each rendering cycle fetch the records
     # notify that loads are pending
 
@@ -75,7 +75,7 @@ module ReactiveRecord
       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
-      # rendering cycle completes.  
+      # rendering cycle completes.
       # 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]
@@ -85,20 +85,20 @@ module ReactiveRecord
       end
       DummyValue.new
     end
-    
+
     class DummyValue < NilClass
-      
+
       def notify
         unless ReactiveRecord::Base.data_loading?
           ReactiveRecord.loads_pending!
           ReactiveRecord::WhileLoading.loading!
         end
       end
-      
+
       def initialize()
         notify
       end
-      
+
       def method_missing(method, *args, &block)
         if 0.respond_to? method
           notify
@@ -110,45 +110,45 @@ module ReactiveRecord
           super
         end
       end
-      
+
       def coerce(s)
         [self.send("to_#{s.class.name.downcase}"), s]
       end
-      
+
       def ==(other_value)
         other_value.is_a? DummyValue
       end
-      
-      def to_s 
+
+      def to_s
         notify
         ""
       end
-      
+
       def to_f
         notify
         0.0
       end
-      
+
       def to_i
         notify
         0
       end
-      
+
       def to_numeric
         notify
         0
       end
-      
+
       def to_date
         "2001-01-01T00:00:00.000-00:00".to_date
       end
-      
+
       def acts_as_string?
         true
       end
-      
+
     end
-    
+
 
     def self.schedule_fetch
       @fetch_scheduled ||= after(0.001) do
@@ -179,23 +179,23 @@ module ReactiveRecord
         end
       end
     end
-    
+
     def self.get_type_hash(record)
       {record.class.inheritance_column => record[record.class.inheritance_column]}
     end
-    
+
     # save records
-    
+
     if RUBY_ENGINE == 'opal'
-      
-      def save(&block) 
-        
+
+      def save(&block)
+
         if data_loading?
 
           sync!
 
         elsif 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
 
@@ -203,9 +203,9 @@ module ReactiveRecord
           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  
+          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|
             if assoc_record.changed?
@@ -224,7 +224,7 @@ module ReactiveRecord
             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? 
+                if association.collection?
                   value.each { |assoc| add_new_association.call record, attribute, assoc.instance_variable_get(:@backing_record) }
                 elsif value
                   add_new_association.call record, attribute, value.instance_variable_get(:@backing_record)
@@ -239,9 +239,9 @@ module ReactiveRecord
             end
             record_index += 1
           end
-          
+
           backing_records.each { |id, record| record.saving! }
-          
+
           promise = Promise.new
 
           HTTP.post(`window.ReactiveRecordEnginePath`+"/save", payload: {models: models, associations: associations}).then do |response|
@@ -254,7 +254,7 @@ module ReactiveRecord
                 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) 
+                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
@@ -262,7 +262,7 @@ module ReactiveRecord
 
               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]
             rescue Exception => e
               puts "Save Failed: #{e}"
@@ -276,11 +276,11 @@ module ReactiveRecord
           promise
         end
       end
-      
+
     else
-      
+
       def self.save_records(models, associations, acting_user)
-        
+
         reactive_records = {}
         new_models = []
         saved_models = []
@@ -293,7 +293,7 @@ module ReactiveRecord
             record = model.find(id)
             keys = record.attributes.keys
             attributes.each do |key, value|
-              if keys.include? key 
+              if keys.include? key
                 record[key] = value
               else
                 record.send("#{key}=",value)
@@ -304,7 +304,7 @@ module ReactiveRecord
             record = model.new
             keys = record.attributes.keys
             attributes.each do |key, value|
-              if keys.include? key 
+              if keys.include? key
                 record[key] = value
               else
                 record.send("#{key}=",value)
@@ -314,9 +314,9 @@ module ReactiveRecord
             record
           end
         end
-        
+
         ActiveRecord::Base.transaction do
-          
+
           associations.each do |association|
             parent = reactive_records[association[:parent_id]]
             parent.instance_variable_set("@reactive_record_#{association[:attribute]}_changed", true)
@@ -327,36 +327,36 @@ module ReactiveRecord
             else
               parent.send("#{association[:attribute]}=", reactive_records[association[:child_id]])
             end
-          end if associations 
-          
+          end if associations
+
           has_errors = false
 
           saved_models = reactive_records.collect do |reactive_record_id, model|
-            unless model.frozen? 
+            unless model.frozen?
               saved = model.check_permission_with_acting_user(acting_user, new_models.include?(model) ? :create_permitted? : :update_permitted?).save
               has_errors ||= !saved
               [reactive_record_id, model.class.name, model.attributes, (saved ? nil : model.errors.messages)]
             end
           end.compact
-          
+
           raise "Could not save all models" if has_errors
-        
+
         end
-        
+
         {success: true, saved_models: saved_models }
-      
+
       rescue Exception => e
-        
+
         {success: false, saved_models: saved_models, message: e.message}
-        
+
       end
-      
+
     end
-    
+
     # destroy records
-    
+
     if RUBY_ENGINE == 'opal'
-      
+
       def destroy(&block)
 
         return if @destroyed
@@ -380,19 +380,19 @@ module ReactiveRecord
           yield true, nil if block
           promise.resolve({success: true})
         end
-        
+
         @attributes = {}
         sync!
         @destroyed = true
-        
+
         promise
       end
-      
+
     else
-      
+
       def self.destroy_record(model, id, vector, acting_user)
         model = Object.const_get(model)
-        record = if id 
+        record = if id
           model.find(id)
         else
           ServerDataCache.new(acting_user)[*vector]
@@ -403,8 +403,8 @@ module ReactiveRecord
       rescue Exception => e
         {success: false, record: record, message: e.message}
       end
-      
+
     end
   end
 
-end
+end

data/lib/reactive_record/server_data_cache.rb

@@ -1,5 +1,5 @@
 module ReactiveRecord
-  
+
   # 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
 
@@ -9,7 +9,7 @@ module ReactiveRecord
   # tree ::= {method => tree | [value]} |      method's value is either a nested tree or a single value which is wrapped in array
   #          {:id => primary_key_id_value} |   if its the id method we leave the array off because we know it must be an int
   #          {integer => tree}                 for collections, each item retrieved will be represented by its id
-  # 
+  #
   # example
   # {
   #   "User" => {
@@ -18,12 +18,12 @@ module ReactiveRecord
   #       "email" => ["mitch@catprint.com"]
   #       "todos" => {
   #         "active" => {
-  #           123 => 
+  #           123 =>
   #             {
   #               id: 123,
   #               title: ["get fetch_records_from_db done"]
   #             },
-  #           119 => 
+  #           119 =>
   #             {
   #               id: 119
   #               title: ["go for a swim"]
@@ -38,14 +38,14 @@ module ReactiveRecord
 
   # To build this tree we first fill values for each individual vector, saving all the intermediate data
   # when all these are built we build the above hash structure
-  
+
   # basic
-  # [Todo, [find, 123], title]                                 
+  # [Todo, [find, 123], title]
   # -> [[Todo, [find, 123], title], "get fetch_records_from_db done", 123]
 
-  # [User, [find_by_email, "mitch@catprint.com"], first_name]  
+  # [User, [find_by_email, "mitch@catprint.com"], first_name]
   # -> [[User, [find_by_email, "mitch@catprint.com"], first_name], "Mitch", 12]
-  
+
   # misses
   # [User, [find_by_email, "foobar@catprint.com"], first_name]
   #   nothing is found so nothing is downloaded
@@ -54,20 +54,20 @@ module ReactiveRecord
   #   which will return a cache object whose id is nil, and value is nil
 
   # scoped collection
-  # [User, [find, 12], todos, active, *, title] 
-  # -> [[User, [find, 12], todos, active, *, title], "get fetch_records_from_db done", 12, 123] 
-  # -> [[User, [find, 12], todos, active, *, title], "go for a swim", 12, 119]    
+  # [User, [find, 12], todos, active, *, title]
+  # -> [[User, [find, 12], todos, active, *, title], "get fetch_records_from_db done", 12, 123]
+  # -> [[User, [find, 12], todos, active, *, title], "go for a swim", 12, 119]
 
   # collection with nested belongs_to
   # [User, [find, 12], todos, *, team]
   # -> [[User, [find, 12], todos, *, team, name], "developers", 12, 123, 252]
   #    [[User, [find, 12], todos, *, team, name], nil, 12, 119]  <- no team defined for todo<119> so list ends early
-  
+
   # collections that are empty will deliver nothing
   # [User, [find, 13], todos, *, team, name]   # no todos for user 13
   #   evaluation will get this far: [[User, [find, 13], todos], nil, 13]
   #   nothing will match [User, [find, 13], todos, team, name] so nothing will be downloaded
-  
+
 
   # aggregate
   # [User, [find, 12], address, zip_code]
@@ -79,22 +79,22 @@ module ReactiveRecord
 
   # collection * (for iterators etc)
   # [User, [find, 12], todos, overdue, *all]
-  # -> [[User, [find, 12], todos, active, *all], [119, 123], 12]  
+  # -> [[User, [find, 12], todos, active, *all], [119, 123], 12]
 
   # [Todo, [find, 119], owner, todos, active, *all]
   # -> [[Todo, [find, 119], owner, todos, active, *all], [119, 123], 119, 12]
-  
+
 
     class ServerDataCache
-            
+
       def initialize(acting_user)
         @acting_user = acting_user
         @cache = []
         @requested_cache_items = []
       end
-      
+
       if RUBY_ENGINE != 'opal'
-      
+
         def [](*vector)
           root = CacheItem.new(@cache, @acting_user, vector[0])
           vector[1..-1].inject(root) { |cache_item, method| cache_item.apply_method method if cache_item }
@@ -103,29 +103,29 @@ module ReactiveRecord
           @requested_cache_items += new_items
           new_items.last.value if new_items.last
         end
-      
+
         def self.[](vectors, acting_user)
           cache = new(acting_user)
           vectors.each { |vector| cache[*vector] }
           cache.as_json
         end
-        
+
         def clear_requests
           @requested_cache_items = []
         end
-        
+
         def as_json
           @requested_cache_items.inject({}) do | hash, cache_item|
             hash.deep_merge! cache_item.as_hash
           end
         end
-        
+
         def select(&block); @cache.select &block; end
-        
+
         def detect(&block); @cache.detect &block; end
-        
+
         def inject(initial, &block); @cache.inject(initial) &block; end
-        
+
         class CacheItem
 
           attr_reader :vector
@@ -133,14 +133,14 @@ module ReactiveRecord
           attr_reader :root
           attr_reader :acting_user
 
-          def value 
+          def value
             @ar_object
           end
-          
+
           def method
             vector.last
           end
-          
+
           def self.new(db_cache, acting_user, klass)
             klass_constant = klass.constantize
             if existing = db_cache.detect { |cached_item| cached_item.vector == [klass_constant] }
@@ -160,7 +160,7 @@ module ReactiveRecord
             @root = self
             db_cache << self
           end
-          
+
           def apply_method_to_cache(method, &block)
             @db_cache.inject(nil) do | representative, cache_item |
               if cache_item.vector == vector
@@ -191,11 +191,11 @@ module ReactiveRecord
             new_vector = vector + [method]
             @db_cache.detect { |cached_item| cached_item.vector == new_vector} || build_new_instances(method)
           end
-          
+
           def build_new_instances(method)
             if method == "*all"
               apply_method_to_cache("*all") { |cache_item| cache_item.value.collect { |record| record.id } }
-            elsif method == "*" 
+            elsif method == "*"
               if @ar_object and @ar_object.length > 0
                 @ar_object.inject(nil) do | value, record |  # just using inject so we will return the last value
                   apply_method_to_cache(method) { record }
@@ -203,22 +203,22 @@ module ReactiveRecord
               else
                 apply_method_to_cache(method) {[]}
               end
-            else 
+            else
               apply_method_to_cache(method) { |cache_item| cache_item.value.send(*method) }
             end
           end
-          
+
           def as_hash(children = [@ar_object])
             if @parent
               if method == "*"
                 if @ar_object.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({@ar_object.id => children})
                 end
               elsif @ar_object.class < ActiveRecord::Base and children.is_a? Hash
                 @parent.as_hash({method => children.merge({
-                  :id => [@ar_object.id], 
+                  :id => [@ar_object.id],
                   @ar_object.class.inheritance_column => [@ar_object[@ar_object.class.inheritance_column]],
                   })})
               elsif method == "*all"
@@ -232,9 +232,9 @@ module ReactiveRecord
           end
 
         end
-      
+
       end
-              
+
       def self.load_from_json(tree, target = nil)
         ignore_all = nil
         tree.each do |method, value|
@@ -251,21 +251,20 @@ module ReactiveRecord
             new_target = target.send *method unless value.is_a? Array # value is an array if scope returns nil
           elsif value.is_a? Array
             target.send "#{method}=", value.first
-          elsif value.is_a? Hash and value[:id] and value[:id].first #and 
+          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)
             target.send "#{method}=", new_target
           else
-            new_target = target.send("#{method}=", target.send(method)) 
+            new_target = target.send("#{method}=", target.send(method))
           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
-      
-      
+
+
     end
-    
-        
-  end
+
+
+  end

data/lib/reactive_record/version.rb

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

metadata

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