reactive-record 0.7.30 → 0.7.31

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b6bb1cc3265c0141b9757c88ceb4e7fcbf958d00
-  data.tar.gz: 6c55106b465a686d47393255977e7044d1841ce6
+  metadata.gz: b418800c8ef12fe914f24f8a948bc7a923ff944d
+  data.tar.gz: 93880104e8ae61b61f98f49d334fb2523f908274
 SHA512:
-  metadata.gz: 1721fdfe1bc81b417c9c722efa2b1ec89a8726cedf474d5811a2cd3bdfba30506343d3b33c54115a575ca8d53f3596ffbcaf3f702993fadee41f86e424fa8852
-  data.tar.gz: 42145c75a12201d4c8d699019dc16f12a86a4f6c0d55e16457c82f3cf6033d98091b5c8fd4496f94feaa888502fd3bccecec62c0fa00c78e5ce688f7a079d09c
+  metadata.gz: 03c0edb07af6406c102deefbf5671f64be507ad6d92a81971eb0adfa2ce28a8542b48d3e63da6af219338225e961aa22e07b841e9e8412626df16d365552f7ce
+  data.tar.gz: 2dcefccee1f3b7deb11d4ef26736438dfc8fb30a1f6c28172d9927d1229a5a3834cb648abbc46bd1fc74ff9a3985c8c85a38ded7b07d66199f3257e80d69d765

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

@@ -224,8 +224,6 @@ module ReactiveRecord
       {record.class.inheritance_column => record[record.class.inheritance_column]}
     end
 
-    # save records
-
     if RUBY_ENGINE == 'opal'
 
       def self.gather_records(records_to_process, force, record_being_saved)

data/lib/reactive_record/active_record/reactive_record/while_loading.rb

@@ -94,12 +94,12 @@ module ReactiveRecord
 
       include React::Component
 
-      required_param :loading
-      required_param :loaded_children
-      required_param :loading_children
-      required_param :element_type
-      required_param :element_props
-      optional_param :display, default: ""
+      param :loading
+      param :loaded_children
+      param :loading_children
+      param :element_type
+      param :element_props
+      param :display, default: ""
 
       class << self
 

data/lib/reactive_record/server_data_cache.rb

@@ -169,28 +169,31 @@ module ReactiveRecord
             db_cache << self
           end
 
-          def apply_method_to_cache(method, absolute_method, &block)
+          def apply_method_to_cache(method)
             @db_cache.inject(nil) do | representative, cache_item |
               if cache_item.vector == vector
                 if @ar_object.class < ActiveRecord::Base and @ar_object.attributes.has_key?(method)
                   @ar_object.check_permission_with_acting_user(acting_user, :view_permitted?, method)
                 end
-                begin
-                  new_ar_object = yield cache_item
-                  cache_item.clone.instance_eval do
-                    @vector = @vector + [method]  # don't push it on since you need a new vector!
-                    @absolute_vector = @absolute_vector + [absolute_method]
-                    @ar_object = new_ar_object
-                    @db_cache << self
-                    @parent = cache_item
-                    @root = cache_item.root
-                    self
-                  end
-                rescue Exception => e
-                  if cache_item.value and cache_item.value != []
-                    raise "ReactiveRecord exception caught when applying #{method} to db object #{cache_item.value}: #{e}"
-                  else
-                    representative
+                if method == "*"
+                  cache_item.apply_star || representative
+                elsif method == "*all"
+                  cache_item.build_new_cache_item(cache_item.value.collect { |record| record.id }, method, method)
+                elsif method == "*count"
+                  cache_item.build_new_cache_item(cache_item.value.count, method, method)
+                elsif preloaded_value = @preloaded_records[cache_item.absolute_vector + [method]]
+                  cache_item.build_new_cache_item(preloaded_value, method, method)
+                elsif aggregation = cache_item.aggregation?(method)
+                  cache_item.build_new_cache_item(aggregation.mapping.collect { |attribute, accessor| cache_item.value[attribute] }, method, method)
+                else
+                  begin
+                    cache_item.build_new_cache_item(cache_item.value.send(*method), method, method)
+                  rescue Exception => e
+                    if cache_item.value and cache_item.value != []
+                      raise "ReactiveRecord exception caught when applying #{method} to db object #{cache_item.value}: #{e}"
+                    else
+                      representative
+                    end
                   end
                 end
               else
@@ -199,46 +202,54 @@ module ReactiveRecord
             end
           end
 
-          def apply_method(method)
-            if method.is_a? Array and method.first == "find_by_id"
-              method[0] = "find"
-            elsif method.is_a? String and method =~ /^\*[0-9]+$/
-              method = "*"
+          def aggregation?(method)
+            if method.is_a?(String) && value.class.respond_to?(:reflect_on_aggregation)
+              aggregation = value.class.reflect_on_aggregation(method.to_sym)
+              if aggregation && !(aggregation.klass < ActiveRecord::Base) && value.send(method)
+                aggregation
+              end
             end
-            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", "*all") { |cache_item| cache_item.value.collect { |record| record.id } }
-            elsif method == "*count"
-              apply_method_to_cache("*count", "*count") { |cache_item| cache_item.value.count }
-            elsif method == "*"
-              if @ar_object and @ar_object.length > 0
-                i = -1
-                @ar_object.inject(nil) do | value, record |  # just using inject so we will return the last value
-                  i += 1
-                  apply_method_to_cache(method, "*#{i}") { |cache_item| @preloaded_records[cache_item.absolute_vector + ["*#{i}"]] || record }
-                end
-              else
-                apply_method_to_cache(method, method) {[]}
-              end
-            else
-              apply_method_to_cache(method, method) do |cache_item|
-                if preloaded_value = @preloaded_records[cache_item.absolute_vector + [method]]
-                  preloaded_value
-                elsif method.is_a? String and cache_item.value.class.respond_to?(:reflect_on_aggregation) and
-                aggregation = cache_item.value.class.reflect_on_aggregation(method.to_sym) and !(aggregation.klass < ActiveRecord::Base) and
-                cache_item.value.send(method)
-                  aggregation.mapping.collect { |attribute, accessor| cache_item.value[attribute] }
+          def apply_star
+            if value && value.length > 0
+              i = -1
+              value.inject(nil) do | representative, ar_object |
+                i += 1
+                if preloaded_value = @preloaded_records[absolute_vector + ["*#{i}"]]
+                  build_new_cache_item(preloaded_value, "*", "*#{i}")
                 else
-                  cache_item.value.send(*method)
+                  build_new_cache_item(ar_object, "*", "*#{i}")
                 end
               end
+            else
+              build_new_cache_item([], "*", "*")
+            end
+          end
+
+          def build_new_cache_item(new_ar_object, method, absolute_method)
+            new_parent = self
+            self.clone.instance_eval do
+              @vector = @vector + [method]  # don't push it on since you need a new vector!
+              @absolute_vector = @absolute_vector + [absolute_method]
+              @ar_object = new_ar_object
+              @db_cache << self
+              @parent = new_parent
+              @root = new_parent.root
+              self
             end
           end
 
+          def apply_method(method)
+            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} || apply_method_to_cache(method)
+          end
+
           def jsonize(method)
             # sadly standard json converts {[:foo, nil] => 123} to {"['foo', nil]": 123}
             # luckily [:foo, nil] does convert correctly

data/lib/reactive_record/version.rb

@@ -1,3 +1,3 @@
 module ReactiveRecord
-  VERSION = "0.7.30"
+  VERSION = "0.7.31"
 end

metadata

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