reactive-record 0.7.1 → 0.7.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 843b69d8493a801694376fe0fe8d2757bf277059
-  data.tar.gz: 1db4525dedaefe2c5a8a7a1459ad98f9416743d6
+  metadata.gz: 7340611c4d6c163c466a2a69ae056e7f03ec5cc8
+  data.tar.gz: 12a5dd997cec60c8b9226b3877156ec07a4a0ffa
 SHA512:
-  metadata.gz: dc2ef1e11a2687ae53571e8c72c96c89c7164213d6d8477a4fb1413ebde429c83c95ac31d8df71f8bf0668e53029fde1e5209ac28b7a27e6f7f36795942e7f4f
-  data.tar.gz: 4c66f3c3cc35bdee46bce7f2bb7b1b89829f5ae548546cb642a1759d8d5156e01b73f6fb174c7897e3ce877770f9d6575e63b47f40ae29f7676a64330961d45a
+  metadata.gz: 007ed1a1b5f3ed796537f52e2bde0e28869b29887c77e6881e34978bdd1d7e72375b696e0d761b28a8f5825df5ad0ac941ce09a0e04afc5e0609b6fff46b90a9
+  data.tar.gz: fdf1e5c4faf0eba8f5b85a44209bedac7802e0ce17f9b71a3ecf21b7192177dd95295f254c0038a3e304b5c1c868de68ccfb39a378d2bc234baebf5649b8fe7d

data/lib/reactive_record/active_record/class_methods.rb

@@ -66,7 +66,7 @@ module ActiveRecord
     end
     
     def all
-      ReactiveRecord::Collection.new(self)
+      ReactiveRecord::Collection.new(self, nil, nil, self, "all")
     end
         
     [:belongs_to, :has_many, :has_one].each do |macro| 

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

@@ -49,15 +49,16 @@ module ReactiveRecord
       @data_loading = false
     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}
-      
+      if !record and attribute == 'id' and !@disabled_debugging
+       # `debugger`
+      end
       unless record
         # if not, and then the record may be loaded, but not have this attribute set yet,
         # so find the id of of record with the attribute-value pair, and see if that is loaded.
@@ -95,14 +96,14 @@ module ReactiveRecord
     
     def initialize(model, hash = {}, ar_instance = nil)
       @model = model
-      @attributes = hash
       @synced_attributes = {}
+      @attributes = hash
       @ar_instance = ar_instance
       records[model] << self
     end
   
     def find(*args)
-      self.find(*args)
+      self.class.find(*args)
     end
   
     def new_from_vector(*args)
@@ -142,7 +143,7 @@ module ReactiveRecord
     end
   
     def reactive_set!(attribute, value)
-      unless @destroyed or attributes[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? 
             collection = Collection.new(association.klass, @ar_instance, association)
@@ -153,7 +154,7 @@ module ReactiveRecord
             inverse_association = association.klass.reflect_on_association(inverse_of)
             if inverse_association.collection?
               if !value
-                attributes[attribute].attributes[inverse_of].delete(@ar_instance)
+                attributes[attribute].attributes[inverse_of].delete(@ar_instance) if attributes[attribute]
               elsif value.attributes[inverse_of]
                 value.attributes[inverse_of] << @ar_instance
               else
@@ -176,14 +177,23 @@ module ReactiveRecord
     end
   
     def changed?(*args)
-      if args.count == 0
+      attrs = if args.count == 0
         React::State.get_state(self, self)
-        @attributes != @synced_attributes
+        @attributes.dup
       else
-        key = args[0]
-        React::State.get_state(@attributes, key)
-        @attributes.has_key?(key) != @synced_attributes.has_key?(key) or @attributes[key] != @synced_attributes[key]
+        React::State.get_state(@attributes, args[0])
+        {args[0] => @attributes[args[0]]}
+      end
+      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
       end
+      false
     end
   
     def sync!(hash = {})
@@ -219,18 +229,14 @@ module ReactiveRecord
     end
   
     def find_association(association, id)
-      
       inverse_of = association.inverse_of
-      
       instance = if id
         find(association.klass, association.klass.primary_key, id)
       else
         new_from_vector(association.klass, nil, *vector, association.attribute)
       end
-      
       instance_backing_record_attributes = instance.instance_variable_get(:@backing_record).attributes
       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) 
@@ -240,7 +246,7 @@ module ReactiveRecord
         instance_backing_record_attributes[inverse_of].replace [@ar_instance]
       else
         instance_backing_record_attributes[inverse_of] = @ar_instance 
-      end if inverse_of
+      end if inverse_of and !instance_backing_record_attributes.has_key?(inverse_of)
       instance
     end
         
@@ -258,7 +264,7 @@ module ReactiveRecord
           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)
+            value = 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
@@ -276,7 +282,7 @@ module ReactiveRecord
       type = hash[klass.inheritance_column]
       begin
         return Object.const_get(type)
-      rescue Exeception => e
+      rescue Exception => e
         message = "Could not subclass #{@model_klass.model_name} as #{type}.  Perhaps #{type} class has not been required. Exception: #{e}"
         `console.error(#{message})`
       end if type

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)
       if association and (association.macro != :has_many or association.klass != target_klass)
         message = "unimplemented association #{owner} :#{association.macro} #{association.attribute}"
@@ -10,8 +10,8 @@ module ReactiveRecord
       @owner = owner  # can be nil if this is an outer most scope
       @association = association
       @target_klass = target_klass
-      if owner and !owner.id and !owner.vector
-        @synced_collection = @collection = []
+      if owner and !owner.id and vector.length <= 1
+        @collection = []
       else
         @vector = vector.count == 0 ? [target_klass] : vector
       end
@@ -19,82 +19,117 @@ module ReactiveRecord
     end
 
     def all
+      @dummy_collection.notify if @dummy_collection
       unless @collection
         @collection = []
-        if ids = ReactiveRecord::Base.fetch_from_db([*@vector, "*all"])  
-          ids.each do |id| 
+        if ids = ReactiveRecord::Base.fetch_from_db([*@vector, "*all"])
+          ids.each do |id|
             @collection << @target_klass.find_by(@target_klass.primary_key => id)
           end
         else
-          ReactiveRecord::Base.load_from_db(*@vector, "*all")
-          @collection << ReactiveRecord::Base.new_from_vector(@target_klass, nil, *@vector, "*")
+          @dummy_collection = ReactiveRecord::Base.load_from_db(*@vector, "*all")
+          @dummy_record = ReactiveRecord::Base.new_from_vector(@target_klass, nil, *@vector, "*")
+          @dummy_record.instance_variable_get(:@backing_record).attributes[@association.inverse_of] = @owner if @association and @association.inverse_of
+          @collection << @dummy_record
         end
       end
       @collection
     end
-    
-    
+
     def ==(other_collection)
-      if @collection
-        @collection == other_collection.all
-      else
-        !other_collection.instance_variable_get(:@collection)
-      end
+      my_collection = (@collection || []).select { |target| target != @dummy_record }
+      other_collection = (other_collection ? (other_collection.collection || []) : []).select { |target| target != other_collection.dummy_record }
+      my_collection == other_collection
     end
-    
-    def apply_scope(scope)
+
+    def apply_scope(scope, *args)
       # The value returned is another ReactiveRecordCollection with the scope added to the vector
       # no additional action is taken
-      @scopes[scope] ||= new(@target_klass, @owner, @association, *vector, scope)
+      scope = [scope, *args] if args.count > 0
+      @scopes[scope] ||= Collection.new(@target_klass, @owner, @association, *@vector, [scope])
     end
     
     def proxy_association
-      @association
+      @association || self # returning self allows this to work with things like Model.all
     end
     
+    def klass
+      @target_klass
+    end
+
 
     def <<(item)
-      inverse_of = @association.inverse_of
-      if @owner and inverse_of = @association.inverse_of
+      if @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 
+        item.attributes[inverse_of] = @owner
         backing_record = item.instance_variable_get(:@backing_record)
         React::State.set_state(backing_record, inverse_of, @owner) unless backing_record.data_loading?
       end
       all << item unless all.include? item
+      @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
+          all.send(method)
+        else
+          apply_scope(method, *args)
+        end
+      end
+    end
+    
     def replace(new_array)
-      return new_array if @collection == new_array
-      if @collection
-        @collection.dup.each { |item| delete(item) } 
+      #return new_array if @collection == new_array  #not sure we need this anymore
+      @dummy_collection.notify if @dummy_collection
+      @collection.dup.each { |item| delete(item) } if @collection
+      @collection = []
+      if new_array.is_a? Collection
+        @dummy_collection = new_array.dummy_collection
+        @dummy_record = new_array.dummy_record
+        new_array.collection.each { |item| self << item } if new_array.collection
       else
-        @collection = []
+        @dummy_collection = @dummy_record = nil
+        new_array.each { |item| self << item }
       end
-      new_array.each { |item| self << item }
       new_array
     end
-    
+
     def delete(item)
-      if @owner and inverse_of = @association.inverse_of
+      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?
       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
-        apply_scope(method)
+        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
+
   end
-  
-end
+
+end

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

@@ -14,9 +14,12 @@ module ReactiveRecord
         if on_opal_client? 
           @pending_fetches = []
           @last_fetch_at = Time.now
-          JSON.from_object(`window.ReactiveRecordInitialData`).each do |hash|
-            load_from_json hash
-          end unless `typeof window.ReactiveRecordInitialData === 'undefined'`
+          unless `typeof window.ReactiveRecordInitialData === 'undefined'`
+            log(["Reactive record prerendered data being loaded: %o", `window.ReactiveRecordInitialData`])
+            JSON.from_object(`window.ReactiveRecordInitialData`).each do |hash|
+              load_from_json hash
+            end
+          end
         end
       end
     end
@@ -40,8 +43,12 @@ module ReactiveRecord
     end
     
     prerender_footer do
-      json = @server_data_cache.as_json.to_json  # can this just be to_json?
-      @server_data_cache.clear_requests
+      if @server_data_cache
+        json = @server_data_cache.as_json.to_json  # can this just be to_json?
+        @server_data_cache.clear_requests
+      else
+        json = {}.to_json
+      end
       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)
@@ -54,33 +61,104 @@ module ReactiveRecord
     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
 
     def self.load_from_db(*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
       # 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.
-      return "" if data_loading?
-      ReactiveRecord.loads_pending!
-      ReactiveRecord::WhileLoading.loading! # inform react that the current value is bogus
-      @pending_fetches << vector
-      schedule_fetch
-      ""
+      unless data_loading?
+        @pending_fetches << vector
+        schedule_fetch
+      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
+          0.send(method, *args, &block)
+        elsif "".respond_to? method
+          notify
+          "".send(method, *args, &block)
+        else
+          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 
+        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
         last_fetch_at = @last_fetch_at
-        HTTP.post(`window.ReactiveRecordEnginePath`, payload: {pending_fetches: @pending_fetches.uniq}).then do |response|
+        pending_fetches = @pending_fetches.uniq
+        log(["Server Fetching: %o", pending_fetches.to_n])
+        HTTP.post(`window.ReactiveRecordEnginePath`, payload: {pending_fetches: pending_fetches}).then do |response|
           begin
             ReactiveRecord::Base.load_from_json(response.json)
           rescue Exception => e
-            message = "Exception raised while loading json from server: #{e}"
-            `console.error(#{message})`
+            log("Exception raised while loading json from server: #{e}", :error)
           end
+          log(["       Returned: %o", response.json.to_n])
           ReactiveRecord.run_blocks_to_load
           ReactiveRecord::WhileLoading.loaded_at last_fetch_at
         end if @pending_fetches.count > 0
@@ -236,7 +314,7 @@ module ReactiveRecord
             @ar_instance.send("#{association.attribute}=", nil)
           end
         end
-        
+
         promise = Promise.new
 
         if id or vector

data/lib/reactive_record/server_data_cache.rb

@@ -169,20 +169,24 @@ module ReactiveRecord
           end
 
           def apply_method(method)
+            method[0] = "find" if method.is_a? Array and method.first == "find_by_id"
             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(method) { |cache_item| cache_item.value.collect { |record| record.id }}
-            elsif method == "*" and @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 }
+            if method == "*all"
+              apply_method_to_cache("*all") { |cache_item| cache_item.value.collect { |record| record.id } }
+            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 }
+                end
+              else
+                apply_method_to_cache(method) {[]}
               end
             elsif @ar_object.respond_to? [*method].first  
-              apply_method_to_cache(method) { |cache_item| 
-                cache_item.value.send(*method)}
+              apply_method_to_cache(method) { |cache_item| cache_item.value.send(*method)  rescue nil } # rescue in case we are on a nil association
             else
               self
             end
@@ -212,6 +216,7 @@ module ReactiveRecord
       end
               
       def self.load_from_json(tree, target = nil)
+        tree.delete("*all") if tree["*"]
         tree.each do |method, value|
           method = JSON.parse(method) rescue method
           new_target = nil
@@ -220,7 +225,7 @@ module ReactiveRecord
           elsif method == "*all"
             target.replace value.collect { |id| target.proxy_association.klass.find(id) }
           elsif method.is_a? Integer or method =~ /^[0-9]+$/
-            new_target = target.proxy_association.klass.find(method)
+            new_target = target.proxy_association.klass.find(method) 
             target << new_target
           elsif method.is_a? Array
             new_target = target.send *method
@@ -231,12 +236,7 @@ module ReactiveRecord
             target.send "#{method}=", new_target
           else
             new_target = target.send *method
-            begin 
-              new_target = target.send "#{method}=", new_target
-            rescue Exception => e
-              message = "FAILED #{target}.#{method} not set to #{new_target}"
-              `console.error(message)`
-            end
+            (new_target = target.send "#{method}=", new_target) rescue nil # this can happen for example if you say TodoItems.all
           end
           load_from_json(value, new_target) if new_target
         end

data/lib/reactive_record/version.rb

@@ -1,3 +1,3 @@
 module ReactiveRecord
-  VERSION = "0.7.1"
+  VERSION = "0.7.4"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: reactive-record
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.7.4
 platform: ruby
 authors:
 - Mitch VanDuyn
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-08-12 00:00:00.000000000 Z
+date: 2015-08-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails