reactive-record 0.7.0

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

@@ -0,0 +1,287 @@
+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. 
+  
+    # 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 
+    # 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_from_json(json, target = nil)
+      @data_loading = true
+      ServerDataCache.load_from_json(json, target)
+      @data_loading = false
+    end
+  
+    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}
+      
+      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.
+        # 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} 
+        end
+        # if we don't have a record then create one
+        (record = new(model)).vector = [model, ["find_by_#{attribute}", value]] unless record
+        # and set the value
+        record.sync_attribute(attribute, value)
+        # 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)
+      # 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 
+      # 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.ar_instance ||= infer_type_from_hash(model, record.attributes).new(record)
+    
+    end
+    
+    def initialize(model, hash = {}, ar_instance = nil)
+      @model = model
+      @attributes = hash
+      @synced_attributes = {}
+      @ar_instance = ar_instance
+      records[model] << self
+    end
+  
+    def find(*args)
+      self.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
+        @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 
+        React::State.get_state(self, attribute) unless data_loading?
+        attributes[attribute]
+      end
+    end
+  
+    def reactive_set!(attribute, value)
+      unless @destroyed or attributes[attribute] == value
+        if association = @model.reflect_on_association(attribute) 
+          if association.collection? 
+            collection = Collection.new(association.klass, @ar_instance, association)
+            collection.replace(value || [])
+            value = collection
+          else
+            inverse_of = association.inverse_of
+            inverse_association = association.klass.reflect_on_association(inverse_of)
+            if inverse_association.collection?
+              if !value
+                attributes[attribute].attributes[inverse_of].delete(@ar_instance)
+              elsif value.attributes[inverse_of]
+                value.attributes[inverse_of] << @ar_instance
+              else
+                value.attributes[inverse_of] = Collection.new(@model, value, inverse_association)
+                value.attributes[inverse_of].replace [@ar_instance]
+              end
+            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?
+            else
+              attributes[attribute].attributes[inverse_of] = nil
+            end
+          end
+        end
+        attributes[attribute] = value
+        React::State.set_state(self, attribute, value) unless data_loading?
+      end
+      value
+    end
+  
+    def changed?(*args)
+      if args.count == 0
+        React::State.get_state(self, self)
+        @attributes != @synced_attributes
+      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]
+      end
+    end
+  
+    def sync!(hash = {})
+      @attributes.merge! hash
+      @synced_attributes = @attributes.dup
+      @synced_attributes.each { |key, value| @synced_attributes[key] = value.dup if value.is_a? Collection }
+      @saving = false
+      React::State.set_state(self, self, :synced) unless data_loading?
+      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])
+      end
+      @attributes.delete_if { |attribute, value| !@synced_attributes.has_key?(attribute) }
+    end
+    
+    def saving! 
+      React::State.set_state(self, self, :saving) unless data_loading?
+      @saving = true
+    end
+    
+    def saving?
+      React::State.get_state(self, self)
+      @saving
+    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) 
+        else
+          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 
+      end if inverse_of
+      instance
+    end
+        
+    def apply_method(method)
+      # Fills in the value returned by sending "method" to the corresponding server side db instance
+      if id or vector
+        sync_attribute(
+          method, 
+          if association = @model.reflect_on_association(method)
+            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 != "" 
+            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
+        )
+      elsif association = @model.reflect_on_association(method) and association.collection?
+        @attributes[method] = Collection.new(association.klass, @ar_instance, association)
+      elsif aggregation = @model.reflect_on_aggregation(method)
+        @attributes[method] = aggregation.klass.new
+      end
+    end
+  
+    def self.infer_type_from_hash(klass, hash)
+      klass = klass.base_class  
+      return klass unless hash
+      type = hash[klass.inheritance_column]
+      begin
+        return Object.const_get(type)
+      rescue Exeception => 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
+      klass
+    end
+  
+  end
+end

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

@@ -0,0 +1,100 @@
+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}"
+        `console.error(#{message})`
+      end
+      @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 = []
+      else
+        @vector = vector.count == 0 ? [target_klass] : vector
+      end
+      @scopes = {}
+    end
+
+    def all
+      unless @collection
+        @collection = []
+        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, "*")
+        end
+      end
+      @collection
+    end
+    
+    
+    def ==(other_collection)
+      if @collection
+        @collection == other_collection.all
+      else
+        !other_collection.instance_variable_get(:@collection)
+      end
+    end
+    
+    def apply_scope(scope)
+      # 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)
+    end
+    
+    def proxy_association
+      @association
+    end
+    
+
+    def <<(item)
+      inverse_of = @association.inverse_of
+      if @owner 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 
+        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
+      self
+    end
+    
+    def replace(new_array)
+      return new_array if @collection == new_array
+      if @collection
+        @collection.dup.each { |item| delete(item) } 
+      else
+        @collection = []
+      end
+      new_array.each { |item| self << item }
+      new_array
+    end
+    
+    def delete(item)
+      if @owner 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)
+      else
+        super
+      end
+    end
+    
+  end
+  
+end

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

@@ -0,0 +1,274 @@
+require 'json'
+
+module ReactiveRecord
+
+  class Base
+    
+    include React::IsomorphicHelpers
+        
+    before_first_mount do
+      if RUBY_ENGINE != 'opal'
+        @server_data_cache = ReactiveRecord::ServerDataCache.new
+      else
+        @records = Hash.new { |hash, key| hash[key] = [] }
+        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'`
+        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
+      json = @server_data_cache.as_json.to_json  # can this just be to_json?
+      @server_data_cache.clear_requests
+      path = ::Rails.application.routes.routes.detect { |route| route.app.app == ReactiveRecord::Engine }.path.spec
+      "<script type='text/javascript'>\n"+
+        "window.ReactiveRecordEnginePath = '#{path}';\n"+
+        "if (typeof window.ReactiveRecordInitialData === 'undefined') { window.ReactiveRecordInitialData = [] }\n" +
+        "window.ReactiveRecordInitialData.push(#{json})\n"+
+      "</script>\n"
+    end if RUBY_ENGINE != 'opal'
+    
+    # Client side db access (never called during prerendering):
+    # 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)
+      # 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
+      ""
+    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|
+          begin
+            ReactiveRecord::Base.load_from_json(response.json)
+          rescue Exception => e
+            message = "Exception raised while loading json from server: #{e}"
+            `console.error(#{message})`
+          end
+          ReactiveRecord.run_blocks_to_load
+          ReactiveRecord::WhileLoading.loaded_at last_fetch_at
+        end if @pending_fetches.count > 0
+        @pending_fetches = []
+        @last_fetch_at = Time.now
+        @fetch_scheduled = nil
+      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) 
+
+        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
+
+          # input
+          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  
+
+          add_new_association = lambda do |record, attribute, assoc_record|
+            if assoc_record.changed?
+              unless backing_records[assoc_record.object_id]
+                records_to_process << assoc_record
+                backing_records[assoc_record.object_id] = assoc_record
+              end
+              associations << {parent_id: record.object_id, attribute: attribute, child_id: assoc_record.object_id}
+            end
+          end
+
+          record_index = 0
+          while(record_index < records_to_process.count)
+            record = records_to_process[record_index]
+            output_attributes = {record.model.primary_key => record.id}
+            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? 
+                  value.each { |assoc| add_new_association.call record, attribute, assoc.instance_variable_get(:@backing_record) }
+                else
+                  add_new_association.call record, attribute, value.instance_variable_get(:@backing_record)
+                end
+              elsif record.model.reflect_on_aggregation(attribute)
+                add_new_association.call record, attribute, value.instance_variable_get(:@backing_record)
+              elsif record.changed?(attribute)
+                output_attributes[attribute] = value
+              end
+            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|
+            
+            response.json[:saved_models].each do |item|
+              internal_id, klass, attributes = item
+              backing_records[internal_id].sync!(attributes)
+            end
+            yield response.json[:success], response.json[:message] if block
+            promise.resolve response.json[:success], response.json[:message]
+          end
+          promise
+        end
+      end
+      
+    else
+      
+      def self.save_records(models, associations)
+        
+        reactive_records = {}
+
+        models.each do |model_to_save|
+          attributes = model_to_save[:attributes]
+          model = Object.const_get(model_to_save[:model])
+          id = attributes[model.primary_key] # if we are saving existing model primary key value will be present
+          reactive_records[model_to_save[:id]] = if id
+            record = model.find(id)
+            keys = record.attributes.keys
+            attributes.each do |key, value|
+              record[key] = value if keys.include? key
+            end
+            record
+          else
+            record = model.new
+            keys = record.attributes.keys
+            attributes.each do |key, value|
+              record[key] = value if keys.include? key
+            end
+            record
+          end
+        end
+        
+        associations.each do |association|
+          begin
+            if reactive_records[association[:parent_id]].class.reflect_on_aggregation(association[:attribute].to_sym)
+              reactive_records[association[:parent_id]].send("#{association[:attribute]}=", reactive_records[association[:child_id]])
+            elsif reactive_records[association[:parent_id]].class.reflect_on_association(association[:attribute].to_sym).collection?
+              reactive_records[association[:parent_id]].send("#{association[:attribute]}") << reactive_records[association[:child_id]]
+            else
+              reactive_records[association[:parent_id]].send("#{association[:attribute]}=", reactive_records[association[:child_id]])
+            end
+          end
+        end if associations 
+
+        saved_models = reactive_records.collect do |reactive_record_id, model|
+          unless model.frozen? 
+            saved = model.save
+            [reactive_record_id, model.class.name, model.attributes, saved]
+          end
+        end.compact
+      
+        {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
+
+        model.reflect_on_all_associations.each do |association|
+          if association.collection?
+            attributes[association.attribute].replace([]) if attributes[association.attribute]
+          else
+            @ar_instance.send("#{association.attribute}=", nil)
+          end
+        end
+        
+        promise = Promise.new
+
+        if id or vector
+          HTTP.post(`window.ReactiveRecordEnginePath`+"/destroy", payload: {model: ar_instance.model_name, id: id, vector: vector}).then do |response|
+            yield response.json[:success], response.json[:message] if block
+            promise.resolve response.json[:success], response.json[:message]
+          end
+        else
+          yield true, nil if block
+          promise.resolve true, nil
+        end
+        
+        @attributes = {}
+        sync!
+        @destroyed = true
+        
+        promise
+      end
+      
+    else
+      
+      def self.destroy_record(model, id, vector)
+        model = Object.const_get(model)
+        record = if id 
+          model.find(id)
+        else
+          ServerDataCache.new[*vector]
+        end
+        record.destroy
+        {success: true, attributes: {}}
+      rescue Exception => e
+        {success: false, record: record, message: e.message}
+      end
+      
+    end
+  end
+
+end