reactive-record 0.7.18 → 0.7.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7767643d2625ad16929d2179c33f286d67f841cc
-  data.tar.gz: 4f717b2c85e11fd7e8eaf793092000c944ba67b5
+  metadata.gz: 7dec62330066fcb6cd84f0de9fc581b8dadde082
+  data.tar.gz: 9253a7995a08e7ff5c066d834768c22ed84e718c
 SHA512:
-  metadata.gz: 1537f31bcbed3cd4b14d254e4077c5de1fd1e9cba2b89548bd65b41877aa353913b8cab4e09e944dde038ac950a1b83a37253e2490df12b079bfff918198b01e
-  data.tar.gz: 6f8beda7d146de1915604aca96f7ea8a35799ae7a990e5b436c60747bc50a4d80146ce2a5ef06bb3b0c9c070bc0a8f21d32c88295b19395a38e8cb5bbb22f5e8
+  metadata.gz: c538da9a135037d64fccdd1137b17db4ddc1b1f4a288662389c0b491c6e8b1c110fcb211185f5607840c5484bc9922cc0a2b638658d53a9b84e753c53638a511
+  data.tar.gz: 8ce68f8a2c4c2eea795e96605b02cd941404e4cc1add15fd7aa11a8220b786d978f7c4e64d763e965f6bdb4bcffdc73c704b8543c4aadbbce69322b5b11bc9a7

data/lib/reactive_record/active_record/aggregations.rb

@@ -25,7 +25,12 @@ module ActiveRecord
         @owner_class = owner_class
         @klass_name =  options[:class_name] || name.camelize
         @attribute =   name
-        @mapped_attributes = options[:mapping].collect &:last
+        if options[:mapping].respond_to? :collect
+          @mapped_attributes = options[:mapping].collect &:last
+        else
+          ReactiveRecord::Base.log("improper aggregate definition #{@owner_class}, :#{name}, class_name: #{@klass_name} - missing mapping", :error)
+          @mapped_attributes = []
+        end
       end
 
       def klass

data/lib/reactive_record/active_record/class_methods.rb

@@ -62,8 +62,9 @@ module ActiveRecord
     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)
+      singleton_class.send(:define_method, name) do | *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|
         ReactiveRecord::Base.class_scopes(self)[name] = collection
@@ -105,9 +106,12 @@ module ActiveRecord
 
     def _react_param_conversion(param, opt = nil)
       # defines how react will convert incoming json to this ActiveRecord model
+      times = {start: Time.now.to_f, json_start: 0, json_end: 0, db_load_start: 0, db_load_end: 0}
       param_is_native = !param.respond_to?(:is_a?) rescue true
+      times[:json_start] = Time.now.to_f
       param = JSON.from_object param if param_is_native
-      if param.is_a? self
+      times[:json_end] = Time.now.to_f
+      result = if param.is_a? self
         param
       elsif param.is_a? Hash
         if opt == :validate_only
@@ -119,12 +123,17 @@ module ActiveRecord
           else
             target = new
           end
+          times[:db_load_start] = Time.now.to_f
           ReactiveRecord::Base.load_from_json(Hash[param.collect { |key, value| [key, [value]] }], target)
+          times[:db_load_end] = Time.now.to_f
           target
         end
       else
         nil
       end
+      times[:end] = Time.now.to_f
+      #puts "times - total: #{'%.04f' % (times[:end]-times[:start])}, native conversion: #{'%.04f' % (times[:json_end]-times[:json_start])}, loading: #{'%.04f' % (times[:db_load_end]-times[:db_load_start])}"
+      result
     end
 
   end

data/lib/reactive_record/active_record/instance_methods.rb

@@ -2,6 +2,8 @@ module ActiveRecord
 
   module InstanceMethods
 
+    attr_reader :backing_record
+
     def attributes
       @backing_record.attributes
     end
@@ -68,13 +70,15 @@ module ActiveRecord
         @backing_record.reactive_set!(attribute_name, args[0])
       elsif args.count == 0 && !block
         @backing_record.reactive_get!(name)
+      elsif !block
+        @backing_record.reactive_get!([[name]+args])
       else
         super
       end
     end
 
     def save(opts = {}, &block)
-      @backing_record.save(opts.has_key?(:validate) ? opts[:validate] : true, &block)
+      @backing_record.save(opts.has_key?(:validate) ? opts[:validate] : true, opts[:force], &block)
     end
 
     def saving?

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

@@ -49,6 +49,7 @@ module ReactiveRecord
     def self.load_data(&block)
       current_data_loading, @data_loading = [@data_loading, true]
       yield
+    ensure
       @data_loading = current_data_loading
     end
 
@@ -143,7 +144,7 @@ module ReactiveRecord
       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 }
+        @ar_instance.instance_variable_set(:@backing_record, existing_record)
         existing_record.attributes.merge!(attributes) { |key, v1, v2| v1 }
       end
     end
@@ -183,7 +184,7 @@ module ReactiveRecord
             elsif value
               attributes[attribute].attributes[inverse_of] = nil if attributes[attribute]
               value.attributes[inverse_of] = @ar_instance
-              React::State.set_state(value.instance_variable_get(:@backing_record), inverse_of, @ar_instance) unless data_loading?
+              React::State.set_state(value.backing_record, inverse_of, @ar_instance) unless data_loading?
             elsif attributes[attribute]
               attributes[attribute].attributes[inverse_of] = nil
             end
@@ -194,10 +195,10 @@ module ReactiveRecord
             raise "unitialized aggregate attribute - should never happen"
           end
 
-          aggregate_record = attributes[attribute].instance_variable_get(:@backing_record)
+          aggregate_record = attributes[attribute].backing_record
 
           if value
-            value_attributes = value.instance_variable_get(:@backing_record).attributes
+            value_attributes = value.backing_record.attributes
             aggregation.mapped_attributes.each { |mapped_attribute| aggregate_record.update_attribute(mapped_attribute, value_attributes[mapped_attribute])}
           else
             aggregation.mapped_attributes.each { |mapped_attribute| aggregate_record.update_attribute(mapped_attribute, nil) }
@@ -217,7 +218,7 @@ module ReactiveRecord
         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?
+          !attributes[attribute].backing_record.changed_attributes.empty?
         end
       elsif association = @model.reflect_on_association(attribute) and association.collection?
         value != @synced_attributes[attribute]
@@ -259,7 +260,9 @@ module ReactiveRecord
         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!
+          value.backing_record.sync!
+        else
+          @synced_attributes[key] = JSON.parse(value.to_json)
         end
       end
       @changed_attributes = []
@@ -322,7 +325,7 @@ module ReactiveRecord
       else
         new_from_vector(association.klass, nil, *vector, association.attribute)
       end
-      instance_backing_record_attributes = instance.instance_variable_get(:@backing_record).attributes
+      instance_backing_record_attributes = instance.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 != ""
@@ -360,7 +363,7 @@ module ReactiveRecord
         @attributes[method] = Collection.new(association.klass, @ar_instance, association)
       elsif aggregation = @model.reflect_on_aggregation(method)
         @attributes[method] = aggregation.klass.new.tap do |aggregate|
-          backing_record = aggregate.instance_variable_get(:@backing_record)
+          backing_record = aggregate.backing_record
           backing_record.aggregate_owner = self
           backing_record.aggregate_attribute = method
         end

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

@@ -11,7 +11,7 @@ module ReactiveRecord
       elsif vector.length > 0
         @vector = vector
       elsif owner
-        @vector = owner.instance_variable_get(:@backing_record).vector + [association.attribute]
+        @vector = owner.backing_record.vector + [association.attribute]
       else
         @vector = [target_klass]
       end
@@ -37,7 +37,7 @@ module ReactiveRecord
         else
           @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
+          @dummy_record.backing_record.attributes[@association.inverse_of] = @owner if @association and @association.inverse_of
           @collection << @dummy_record
         end
       end
@@ -67,7 +67,7 @@ module ReactiveRecord
 
 
     def <<(item)
-      backing_record = item.instance_variable_get(:@backing_record)
+      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
@@ -79,7 +79,7 @@ module ReactiveRecord
         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
+        @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
@@ -114,11 +114,11 @@ module ReactiveRecord
 
     def delete(item)
       if @owner and @association and inverse_of = @association.inverse_of
-        if backing_record = item.instance_variable_get(:@backing_record) and backing_record.attributes[inverse_of] == @owner
+        if backing_record = item.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
+        all.delete(item).tap { @owner.backing_record.update_attribute(@association.attribute) } # forces a check if association contents have changed from synced values
       else
         all.delete(item)
       end

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

@@ -90,8 +90,8 @@ module ReactiveRecord
 
       def notify
         unless ReactiveRecord::Base.data_loading?
-          ReactiveRecord.loads_pending!
-          ReactiveRecord::WhileLoading.loading!
+          ReactiveRecord.loads_pending!           #loads
+          ReactiveRecord::WhileLoading.loading!   #loads
         end
       end
 
@@ -140,6 +140,7 @@ module ReactiveRecord
       end
 
       def to_date
+        notify
         "2001-01-01T00:00:00.000-00:00".to_date
       end
 
@@ -151,7 +152,9 @@ module ReactiveRecord
 
 
     def self.schedule_fetch
-      @fetch_scheduled ||= after(0.001) do
+      #ReactiveRecord.loads_pending!
+      #ReactiveRecord::WhileLoading.loading!
+      @fetch_scheduled ||= after(0.01) do
         if @pending_fetches.count > 0  # during testing we might reset the context while there are pending fetches
           last_fetch_at = @last_fetch_at
           pending_fetches = @pending_fetches.uniq
@@ -169,6 +172,7 @@ module ReactiveRecord
             log(["       Returned: %o", response.json.to_n])
             ReactiveRecord.run_blocks_to_load
             ReactiveRecord::WhileLoading.loaded_at last_fetch_at
+            ReactiveRecord::WhileLoading.quiet! if @pending_fetches.empty?
           end.fail do |response|
             log("Fetch failed", :error)
             ReactiveRecord.run_blocks_to_load(response.body)
@@ -188,13 +192,13 @@ module ReactiveRecord
 
     if RUBY_ENGINE == 'opal'
 
-      def save(validate, &block)
+      def save(validate, force, &block)
 
         if data_loading?
 
           sync!
 
-        elsif changed?
+        elsif force or 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
@@ -223,18 +227,18 @@ module ReactiveRecord
             record.attributes.each do |attribute, value|
               if association = record.model.reflect_on_association(attribute)
                 if association.collection?
-                  value.each { |assoc| add_new_association.call record, attribute, assoc.instance_variable_get(:@backing_record) }
+                  value.each { |assoc| add_new_association.call record, attribute, assoc.backing_record }
                 elsif value
-                  add_new_association.call record, attribute, value.instance_variable_get(:@backing_record)
+                  add_new_association.call record, attribute, value.backing_record
                 else
                   output_attributes[attribute] = nil
                 end
               elsif record.model.reflect_on_aggregation(attribute)
-                add_new_association.call record, attribute, value.instance_variable_get(:@backing_record)
+                add_new_association.call record, attribute, value.backing_record
               elsif record.changed?(attribute)
                 output_attributes[attribute] = value
               end
-            end if record.changed?
+            end if record.changed? || (record == self && force)
             record_index += 1
           end
 

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

@@ -17,6 +17,8 @@ module ReactiveRecord
     end
     @loads_pending = @load_stack.pop
     promise
+  rescue Exception => e
+    log "ReactiveRecord.load exception raised during retry: #{e}", :error
   end
 
   def self.loads_pending!
@@ -27,7 +29,9 @@ module ReactiveRecord
     if @blocks_to_load
       blocks_to_load = @blocks_to_load
       @blocks_to_load = []
+      @load_stack ||= []
       blocks_to_load.each do |promise_and_block|
+        @load_stack << @loads_pending
         @loads_pending = nil
         result = promise_and_block.last.call(failure)
         if @loads_pending and !failure
@@ -35,65 +39,66 @@ module ReactiveRecord
         else
           promise_and_block.first.resolve result
         end
+        @loads_pending = @load_stack.pop
       end
     end
   rescue Exception => e
-    message = "ReactiveRecord.run_blocks_to_load exception raised: #{e}"
-    `console.error(#{message})`
+    log "ReactiveRecord.load exception raised during retry: #{e}", :error
   end
 
-  
+
   # Adds while_loading feature to React
   # to use attach a .while_loading handler to any element for example
   # div { "displayed if everything is loaded" }.while_loading { "displayed while I'm loading" }
   # the contents of the div will be switched (using jQuery.show/hide) depending on the state of contents of the first block
-  
+
   # To notify React that something is loading use React::WhileLoading.loading!
   # once everything is loaded then do React::WhileLoading.loaded_at message (typically a time stamp just for debug purposes)
-  
+
   class WhileLoading
-    
+
     include React::IsomorphicHelpers
-        
-    before_first_mount do 
+
+    before_first_mount do
       @css_to_preload = ""
       @while_loading_counter = 0
     end
-    
+
     def get_next_while_loading_counter
       @while_loading_counter += 1
     end
-    
+
     def preload_css(css)
       @css_to_preload << css << "\n"
     end
-    
+
     prerender_footer do
       "<style>\n#{@css_to_preload}\n</style>".tap { @css_to_preload = ""}
     end
-    
+
     if RUBY_ENGINE == 'opal'
-      
+
       # I DONT THINK WE USE opal-jquery in this module anymore - require 'opal-jquery' if opal_client?
-    
+
       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: ""
-     
+
       class << self
-        
+
         def loading?
           @is_loading
         end
-            
+
         def loading!
           React::RenderingContext.waiting_on_resources = true
           React::State.get_state(self, :loaded_at)
+          React::State.set_state(self, :quiet, false)
           @is_loading = true
         end
 
@@ -101,27 +106,41 @@ module ReactiveRecord
           React::State.set_state(self, :loaded_at, loaded_at)
           @is_loading = false
         end
-     
+
+        def quiet?
+          React::State.get_state(self, :quiet)
+        end
+
+        def page_loaded?
+          React::State.get_state(self, :page_loaded)
+        end
+
+        def quiet!
+          React::State.set_state(self, :quiet, true)
+          after(1) { React::State.set_state(self, :page_loaded, true) } unless on_opal_server? or @page_loaded
+          @page_loaded = true
+        end
+
         def add_style_sheet
           @style_sheet ||= %x{
             $('<style type="text/css">'+
               '  .reactive_record_is_loading > .reactive_record_show_when_loaded { display: none; }'+
               '  .reactive_record_is_loaded > .reactive_record_show_while_loading { display: none; }'+
-              '</style>').appendTo("head") 
-          } 
+              '</style>').appendTo("head")
+          }
         end
-          
+
       end
-            
+
       before_mount do
         @uniq_id = WhileLoading.get_next_while_loading_counter
         WhileLoading.preload_css(
           ".reactive_record_while_loading_container_#{@uniq_id} > :nth-child(1n+#{loaded_children.count+1}) {\n"+
-          "  display: none;\n"+ 
+          "  display: none;\n"+
           "}\n"
         )
       end
-    
+
       after_mount do
         @waiting_on_resources = loading
         WhileLoading.add_style_sheet
@@ -131,11 +150,11 @@ module ReactiveRecord
           $(node).children(':nth-child(1n+'+#{loaded_children.count+1}+')').addClass('reactive_record_show_while_loading');
         }
       end
-    
+
       after_update do
         @waiting_on_resources = loading
       end
-    
+
       def render
         props = element_props.dup
         classes = [props[:class], props[:className], "reactive_record_while_loading_container_#{@uniq_id}"].compact.join(" ")
@@ -146,64 +165,64 @@ module ReactiveRecord
         })
         React.create_element(element_type, props) { loaded_children + loading_children }
       end
-      
+
     end
-    
+
   end
-  
+
 end
-  
+
 module React
-  
+
   class Element
-        
+
     def while_loading(display = "", &loading_display_block)
-      
+
       loaded_children = []
       loaded_children = block.call.dup if block
-      
+
       loading_children = [display]
       loading_children = RenderingContext.build do |buffer|
         result = loading_display_block.call
         buffer << result.to_s if result.is_a? String
         buffer.dup
-      end if loading_display_block 
+      end if loading_display_block
       RenderingContext.replace(
         self,
         React.create_element(
-          ReactiveRecord::WhileLoading, 
-          loading: waiting_on_resources, 
-          loading_children: loading_children, 
-          loaded_children: loaded_children, 
-          element_type: type, 
-          element_props: properties) 
+          ReactiveRecord::WhileLoading,
+          loading: waiting_on_resources,
+          loading_children: loading_children,
+          loaded_children: loaded_children,
+          element_type: type,
+          element_props: properties)
         )
     end
-    
+
     def hide_while_loading
       while_loading
     end
-    
+
   end
-      
+
   module Component
-    
+
     alias_method :original_component_did_mount, :component_did_mount
-    
+
     def component_did_mount(*args)
       original_component_did_mount(*args)
       reactive_record_link_to_enclosing_while_loading_container
       reactive_record_link_set_while_loading_container_class
     end
-    
+
     alias_method :original_component_did_update, :component_did_update
-    
+
     def component_did_update(*args)
       original_component_did_update(*args)
       reactive_record_link_set_while_loading_container_class
     end
-    
-    def reactive_record_link_to_enclosing_while_loading_container 
+
+    def reactive_record_link_to_enclosing_while_loading_container
       # Call after any component mounts - attaches the containers loading id to this component
       # Fyi, the while_loading container is responsible for setting its own link to itself
 
@@ -219,11 +238,11 @@ module React
       }
 
     end
-    
+
     def reactive_record_link_set_while_loading_container_class
-      
+
       %x{
-        
+
         var node = #{@native}.getDOMNode();
         var while_loading_container_id = $(node).attr('data-reactive_record_enclosing_while_loading_container_id');
         if (while_loading_container_id) {
@@ -234,12 +253,12 @@ module React
             $(node).removeClass('reactive_record_is_loaded');
             $(while_loading_container).addClass('reactive_record_is_loading');
             $(while_loading_container).removeClass('reactive_record_is_loaded');
-            
+
           } else if (!$(node).hasClass('reactive_record_is_loaded')) {
-            
+
             if (!$(node).attr('data-reactive_record_while_loading_container_id')) {
               $(node).removeClass('reactive_record_is_loading');
-              $(node).addClass('reactive_record_is_loaded');  
+              $(node).addClass('reactive_record_is_loaded');
             }
             if (!$(while_loading_container).hasClass('reactive_record_is_loaded')) {
               var loading_children = $(while_loading_container).
@@ -247,16 +266,16 @@ module React
               if (loading_children.length == 0) {
                 $(while_loading_container).removeClass('reactive_record_is_loading')
                 $(while_loading_container).addClass('reactive_record_is_loaded')
-              } 
+              }
             }
-               
+
           }
-          
+
         }
-      } 
-      
+      }
+
     end
-    
+
   end if RUBY_ENGINE == 'opal'
 
-end
+end

data/lib/reactive_record/server_data_cache.rb

@@ -177,7 +177,8 @@ module ReactiveRecord
                     @root = cache_item.root
                     self
                   end
-                rescue
+                rescue Exception => e
+                  raise "ReactiveRecord exception caught when applying #{method} to db objects #{e}" if cache_item.value and cache_item.value != []
                   representative
                 end
               else
@@ -208,6 +209,13 @@ module ReactiveRecord
             end
           end
 
+          def jsonize(method)
+            # sadly standard json converts {[:foo, nil] => 123} to {"['foo', nil]": 123}
+            # luckily [:foo, nil] does convert correctly
+            # so we check the methods and force proper conversion
+            method.is_a?(Array) ? method.to_json : method
+          end
+
           def as_hash(children = nil)
             unless children
               return {} if @ar_object.is_a?(Class) and (@ar_object < ActiveRecord::Base)
@@ -221,14 +229,14 @@ module ReactiveRecord
                   @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({
+                @parent.as_hash({jsonize(method) => children.merge({
                   :id => [@ar_object.id],
                   @ar_object.class.inheritance_column => [@ar_object[@ar_object.class.inheritance_column]],
                   })})
               elsif method == "*all"
-                @parent.as_hash({method => children.first})
+                @parent.as_hash({jsonize(method) => children.first})
               else
-                @parent.as_hash({method => children})
+                @parent.as_hash({jsonize(method) => children})
               end
             else
               {method.name => children}
@@ -258,14 +266,21 @@ module ReactiveRecord
             ignore_all = true
             target << (new_target = target.proxy_association.klass.find(method))
           elsif method.is_a? Array
-            new_target = target.send *method unless value.is_a? Array # value is an array if scope returns nil
+            if !(target.class < ActiveRecord::Base)
+              new_target = target.send *method unless value.is_a? Array # value is an array if scope returns nil
+            else
+              target.attributes[[method]] = value.first
+            end
           elsif value.is_a? Array
-            target.send "#{method}=", value.first
+            #target.send "#{method}=", value.first
+            target.backing_record.reactive_set!(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.send "#{method}=", new_target
+            target.backing_record.reactive_set!(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.18"
+  VERSION = "0.7.19"
 end

metadata

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