reactive-record 0.7.20 → 0.7.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6c2c4283d8c482a6dc3b9ca9f0c9980ce4a9bad8
-  data.tar.gz: 55dbf1be5bc98e3bfa115f4e13e10591e3febf78
+  metadata.gz: 8ac17cb9431cfb70da2b36ad364d6f6daddabfad
+  data.tar.gz: 1ce72b88c991bcd5bd7b2b643a64c10b0da1173b
 SHA512:
-  metadata.gz: 9d827bab1ca8da5f8321808357a97e32b33151de2a04e2c7e89826b84b8e54ebd6b543edcbc76675b5ed3e501a447082a59a6a3e336b4e9bee98c7eb0f043de3
-  data.tar.gz: 2f8e98cabf83f5bdf67c4e27e51aa0ead8917de7e25b0bc53d91a5f22bd473c8a600cb018c767d50f5d517cc54f287d8eb6d4c3e398fc24c374211683e826716
+  metadata.gz: 4f030a78f2bfb6be443e26f00a3782f33730abbfea6fcdf9897fde842436e14f113cd7c2d152ed2280536ef245e67ec91629c97080f1fbb4e6a882b8a00baabc
+  data.tar.gz: 8ced444a4e20aeabba7536f3acddfee6aad92c195f9ffbee484955e53ba0714b08b8f6b53c35d71f28694cc32a65d49d6076581b283fc9fd2fcd68f385d754f6

data/lib/reactive-record.rb

@@ -1,5 +1,5 @@
 if RUBY_ENGINE == 'opal'
-  
+
   require "reactive-ruby"
   require "reactive_record/active_record/error"
   require "reactive_record/server_data_cache"
@@ -13,30 +13,30 @@ if RUBY_ENGINE == 'opal'
   require "reactive_record/active_record/instance_methods"
   require "reactive_record/active_record/base"
   require "reactive_record/interval"
-  
+
 else
-  
+
   module ::ActiveRecord
     module Core
       module ClassMethods
-        def inherited(child_class) 
+        def inherited(child_class)
           begin
             file = Rails.root.join('app','models',"#{child_class.name.underscore}.rb").to_s rescue nil
-            begin 
-              require file 
+            begin
+              require file
             rescue LoadError
             end
             # from active record:
             child_class.initialize_find_by_cache
-          rescue 
+          rescue
           end
           super
         end
       end
     end
   end
-  
-  
+
+
   require "opal"
   require "reactive_record/version"
   require "reactive_record/permissions"
@@ -47,5 +47,5 @@ else
 
   Opal.append_path File.expand_path('../', __FILE__).untaint
   Opal.append_path File.expand_path('../../vendor', __FILE__).untaint
-  
+
 end

data/lib/reactive_record/active_record/class_methods.rb

@@ -63,7 +63,7 @@ module ActiveRecord
 
     def scope(name, body)
       singleton_class.send(:define_method, name) do | *args |
-        args = args.count == 0 ? name : [name, *args]
+        args = (args.count == 0) ? name : [name, *args]
         ReactiveRecord::Base.class_scopes(self)[name] ||= ReactiveRecord::Collection.new(self, nil, nil, self, args)
       end
       singleton_class.send(:define_method, "#{name}=") do |collection|

data/lib/reactive_record/active_record/instance_methods.rb

@@ -89,6 +89,10 @@ module ActiveRecord
       @backing_record.destroy &block
     end
 
+    def destroyed?
+      @backing_record.destroyed
+    end
+
     def new?
       @backing_record.new?
     end

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

@@ -32,6 +32,7 @@ module ReactiveRecord
     attr_accessor :changed_attributes
     attr_accessor :aggregate_owner
     attr_accessor :aggregate_attribute
+    attr_accessor :destroyed
 
     # 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.
@@ -156,7 +157,11 @@ module ReactiveRecord
 
     def reactive_get!(attribute)
       unless @destroyed
-        apply_method(attribute) unless @attributes.has_key? attribute
+        if @attributes.has_key? attribute
+          attributes[attribute].notify if @attributes[attribute].is_a? DummyValue
+        else
+          apply_method(attribute)
+        end
         React::State.get_state(self, attribute) unless data_loading?
         attributes[attribute]
       end
@@ -261,7 +266,7 @@ module ReactiveRecord
           @synced_attributes[key] = value.dup_for_sync
         elsif aggregation = model.reflect_on_aggregation(key)
           value.backing_record.sync!
-        else
+        elsif !model.reflect_on_association(key)
           @synced_attributes[key] = JSON.parse(value.to_json)
         end
       end

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

@@ -36,14 +36,24 @@ module ReactiveRecord
           end
         else
           @dummy_collection = ReactiveRecord::Base.load_from_db(*@vector, "*all")
-          @dummy_record = ReactiveRecord::Base.new_from_vector(@target_klass, nil, *@vector, "*")
-          @dummy_record.backing_record.attributes[@association.inverse_of] = @owner if @association and @association.inverse_of
-          @collection << @dummy_record
+          @dummy_record = self[0]
         end
       end
       @collection
     end
 
+    def [](index)
+
+      if (@collection || all).length <= index and @dummy_collection
+        (@collection.length..index).each do |i|
+          new_dummy_record = ReactiveRecord::Base.new_from_vector(@target_klass, nil, *@vector, "*#{i}")
+          new_dummy_record.backing_record.attributes[@association.inverse_of] = @owner if @association and @association.inverse_of
+          @collection << new_dummy_record
+        end
+      end
+      @collection[index]
+    end
+
     def ==(other_collection)
       my_collection = (@collection || []).select { |target| target != @dummy_record }
       other_collection = (other_collection ? (other_collection.collection || []) : []).select { |target| target != other_collection.dummy_record }
@@ -57,6 +67,19 @@ module ReactiveRecord
       @scopes[scope] ||= Collection.new(@target_klass, @owner, @association, *@vector, [scope])
     end
 
+    def count
+      if @collection
+        @collection.count
+      elsif @count ||= ReactiveRecord::Base.fetch_from_db([*@vector, "*count"])
+        @count
+      else
+        ReactiveRecord::Base.load_from_db(*@vector, "*count")
+        @count = 1
+      end
+    end
+
+    alias_method :length, :count
+
     def proxy_association
       @association || self # returning self allows this to work with things like Model.all
     end
@@ -65,24 +88,21 @@ module ReactiveRecord
       @target_klass
     end
 
-
     def <<(item)
       backing_record = item.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
-      #all << item unless all.include? item
-      all << item unless all.include? item
+      all << item unless all.include? item # does this use == if so we are okay...
       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.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
+      if item.id and @dummy_record
+        @dummy_record.id = item.id
+        @collection.delete(@dummy_record)
+        @dummy_record = @collection.detect { |r| r.backing_record.vector.last =~ /^\*[0-9]+$/ }
+        @dummy_collection = nil
+      end
       self
     end
 
@@ -97,9 +117,20 @@ module ReactiveRecord
     end
 
     def replace(new_array)
-      #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
+
+      # not tested if you do all[n] where n > 0... this will create additional dummy items, that this will not sync up.
+      # probably just moving things around so the @dummy_collection and @dummy_record are updated AFTER the new items are pushed
+      # should work.
+
+      if @dummy_collection
+        @dummy_collection.notify
+        array = new_array.is_a?(Collection) ? new_array.collection : new_array
+        @collection.each_with_index do |r, i|
+          r.id = new_array[i].id if array[i] and array[i].id and r.backing_record.vector.last =~ /^\*[0-9]+$/
+        end
+      end
+
+      @collection.dup.each { |item| delete(item) } if @collection  # this line is a big nop I think
       @collection = []
       if new_array.is_a? Collection
         @dummy_collection = new_array.dummy_collection
@@ -124,6 +155,11 @@ module ReactiveRecord
       end
     end
 
+    def loading?
+      all # need to force initialization at this point
+      @dummy_collection.loading?
+    end
+
     def method_missing(method, *args, &block)
       if [].respond_to? method
         all.send(method, *args, &block)

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

@@ -86,70 +86,95 @@ module ReactiveRecord
       DummyValue.new
     end
 
-    class DummyValue < NilClass
+    if RUBY_ENGINE == 'opal'
+      class ::Object
 
-      def notify
-        unless ReactiveRecord::Base.data_loading?
-          ReactiveRecord.loads_pending!           #loads
-          ReactiveRecord::WhileLoading.loading!   #loads
+        def loaded?
+          !loading?
+        end
+
+        def loading?
+          false
+        end
+
+        def present?
+          !!self
         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
+      class DummyValue < NilClass
+
+        def notify
+          unless ReactiveRecord::Base.data_loading?
+            ReactiveRecord.loads_pending!           #loads
+            ReactiveRecord::WhileLoading.loading!   #loads
+          end
+        end
+
+        def initialize()
           notify
-          "".send(method, *args, &block)
-        else
-          super
         end
-      end
 
-      def coerce(s)
-        [self.send("to_#{s.class.name.downcase}"), s]
-      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 ==(other_value)
-        other_value.is_a? DummyValue
-      end
+        def loading?
+          true
+        end
 
-      def to_s
-        notify
-        ""
-      end
+        def present?
+          false
+        end
 
-      def to_f
-        notify
-        0.0
-      end
+        def coerce(s)
+          [self.send("to_#{s.class.name.downcase}"), s]
+        end
 
-      def to_i
-        notify
-        0
-      end
+        def ==(other_value)
+          other_value.object_id == self.object_id
+        end
 
-      def to_numeric
-        notify
-        0
-      end
+        def to_s
+          notify
+          ""
+        end
 
-      def to_date
-        notify
-        "2001-01-01T00:00:00.000-00:00".to_date
-      end
+        def to_f
+          notify
+          0.0
+        end
 
-      def acts_as_string?
-        true
-      end
+        def to_i
+          notify
+          0
+        end
 
-    end
+        def to_numeric
+          notify
+          0
+        end
 
+        def to_date
+          notify
+          "2001-01-01T00:00:00.000-00:00".to_date
+        end
+
+        def acts_as_string?
+          true
+        end
+
+      end
+    end
 
     def self.schedule_fetch
       #ReactiveRecord.loads_pending!
@@ -166,7 +191,7 @@ module ReactiveRecord
             begin
               ReactiveRecord::Base.load_from_json(response.json)
             rescue Exception => e
-              log("Exception raised while loading json from server: #{e}", :error)
+              log("Unexpected exception raised while loading json from server: #{e}", :error)
             end
             log("       Processed in: #{(Time.now-fetch_time).to_i}s")
             log(["       Returned: %o", response.json.to_n])
@@ -339,6 +364,8 @@ module ReactiveRecord
               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]]
@@ -417,8 +444,13 @@ module ReactiveRecord
           promise.resolve({success: true})
         end
 
-        @attributes = {}
-        sync!
+        # DO NOT CLEAR ATTRIBUTES.  Records that are not found, are destroyed, and if they are searched for again, we want to make
+        # sure to find them.  We may want to change this, and provide a separate flag called not_found.  In this case you
+        # would put these lines here:
+        # @attributes = {}
+        # sync!
+        # and modify server_data_cache so that it does NOT call destroy
+
         @destroyed = true
 
         promise

data/lib/reactive_record/server_data_cache.rb

@@ -188,7 +188,11 @@ module ReactiveRecord
           end
 
           def apply_method(method)
-            method[0] = "find" if method.is_a? Array and method.first == "find_by_id"
+            if method.is_a? Array and method.first == "find_by_id"
+              method[0] = "find"
+            elsif method.is_a? String and method =~ /^\*[0-9]+$/
+              method = "*"
+            end
             new_vector = vector + [method]
             @db_cache.detect { |cached_item| cached_item.vector == new_vector} || build_new_instances(method)
           end
@@ -196,6 +200,8 @@ module ReactiveRecord
           def build_new_instances(method)
             if method == "*all"
               apply_method_to_cache("*all") { |cache_item| cache_item.value.collect { |record| record.id } }
+            elsif method == "*count"
+              apply_method_to_cache("*count") { |cache_item| cache_item.value.count }
             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
@@ -251,36 +257,38 @@ module ReactiveRecord
         ignore_all = nil
 
         # have to process *all before any other items
-        if sorted_collection = tree.delete("*all")
+        # we leave the "*all" key in just for debugging purposes, and then skip it below
+
+        if sorted_collection = tree["*all"]
           target.replace sorted_collection.collect { |id| target.proxy_association.klass.find(id) }
         end
 
         tree.each do |method, value|
           method = JSON.parse(method) rescue method
           new_target = nil
-          if !target
+          if method == "*all"
+            next # its already been processed above
+          elsif !target
             load_from_json(value, Object.const_get(method))
-          elsif method == "*all"
-            target.replace value.collect { |id| target.proxy_association.klass.find(id) } unless ignore_all
+          elsif method == "*count"
+            target.instance_variable_set(:@count, value.first)
           elsif method.is_a? Integer or method =~ /^[0-9]+$/
-            ignore_all = true
             target << (new_target = target.proxy_association.klass.find(method))
           elsif method.is_a? Array
             if !(target.class < ActiveRecord::Base)
-              new_target = target.send *method unless value.is_a? Array # value is an array if scope returns nil
+              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
             end
           elsif value.is_a? Array
-            #target.send "#{method}=", value.first
-            target.backing_record.reactive_set!(method, value.first)
+            target.send "#{method}=", value.first
           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
-            target.backing_record.reactive_set!(method, new_target)
+            target.send "#{method}=", new_target
           else
-            # target might be able to respond to method directly so we can't optimize out the target send
             new_target = target.send("#{method}=", target.send(method))
           end
           load_from_json(value, new_target) if new_target

data/lib/reactive_record/version.rb

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

metadata

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