hyper-mesh 1.0.0.lap27 → 1.0.0.lap28

data/lib/reactive_record/active_record/reactive_record/backing_record_inspector.rb

@@ -7,7 +7,7 @@ module ReactiveRecord
       return error_details    unless errors.empty?
       return new_details      if new?
       return destroyed_details if destroyed
-      return loading_details  unless attributes.key? primary_key
+      return loading_details  unless @attributes.key? primary_key
       return dirty_details    unless changed_attributes.empty?
       "[loaded id: #{id}]"
     end
@@ -30,9 +30,6 @@ module ReactiveRecord
     end
 
     def dirty_details
-      changes = Hash[changed_attributes.collect do |attr|
-        [attr, [@synced_attributes[attr], attributes[attr]]] if column_type(attr)
-      end.compact]
       "[changed id: #{id} #{changes}]"
     end
   end

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

@@ -1,6 +1,9 @@
 module ReactiveRecord
   class Base
     include BackingRecordInspector
+    include Setters
+    include Getters
+    extend  LookupTables
 
     # Its all about lazy loading. This prevents us from grabbing enormous association collections, or large attributes
     # unless they are explicitly requested.
@@ -8,7 +11,8 @@ module ReactiveRecord
     # 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
+    # On the client we fill in the record data with empty values (the default value for the attribute,
+    # 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
@@ -37,9 +41,10 @@ module ReactiveRecord
     attr_accessor :updated_during
     attr_accessor :synced_attributes
     attr_accessor :virgin
+    attr_reader   :attributes
 
     # 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.
+    # for example 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
 
@@ -62,44 +67,48 @@ module ReactiveRecord
       load_data { ServerDataCache.load_from_json(json, target) }
     end
 
-    def self.class_scopes(model)
-      @class_scopes[model.base_class]
-    end
-
-    # def self.sync_blocks
-    #   # @sync_blocks[watch_model][sync_model][scope_name][...array of blocks...]
-    #   @sync_blocks ||= Hash.new { |hash, key| hash[key] = Hash.new { |hash, key| hash[key] = Hash.new { |hash, key| hash[key] = [] } } }
-    # end
-
-
-    def self.find(model, attribute, value)
+    def self.find(model, attrs)
       # will return the unique record with this attribute-value pair
       # value cannot be an association or aggregation
 
+      # add the inheritance column if this is an STI subclass
+
+      inher_col = model.inheritance_column
+      if inher_col && model < model.base_class && !attrs.key?(inher_col)
+        attrs = attrs.merge(inher_col => model.model_name)
+      end
+
       model = model.base_class
-      # already have a record with this attribute-value pair?
-      record = @records[model].detect { |record| record.attributes[attribute] == value}
+      primary_key = model.primary_key
+
+      # already have a record with these attribute-value pairs?
+
+      record =
+        if (id_to_find = attrs[primary_key])
+          lookup_by_id(model, id_to_find)
+        else
+          @records[model].detect do |r|
+            !attrs.detect { |attr, value| r.synced_attributes[attr] != value }
+          end
+        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.
         # 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}
+        if !attrs.key?(primary_key) && (id = find_in_db(model, attrs))
+          record = lookup_by_id(model, id) # @records[model].detect { |record| record.id == id}
+          attrs = attrs.merge primary_key => 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
+        # (record = new(model)).vector = [model, [:find_by, attribute => value]] unless record
+        record ||= set_vector_lookup(new(model), [model, [:find_by, attrs]])
+        # and set the values
+        attrs.each { |attr, value| record.sync_attribute(attr, value) }
       end
       # finally initialize and return the ar_instance
-      record.ar_instance ||= infer_type_from_hash(model, record.attributes).new(record)
-    end
-
-    def self.find_by_object_id(model, object_id)
-      @records[model].detect { |record| record.object_id == object_id }.ar_instance
+      record.set_ar_instance!
     end
 
     def self.new_from_vector(model, aggregate_owner, *vector)
@@ -110,13 +119,15 @@ module ReactiveRecord
 
       # 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 = @records[model].detect { |record| record.vector == vector }
+      record = lookup_by_vector(vector)
       unless record
+
         record = new model
-        record.vector = vector
+        set_vector_lookup(record, vector)
       end
 
-      record.ar_instance ||= infer_type_from_hash(model, record.attributes).new(record)
+      record.set_ar_instance!
 
       if aggregate_owner
         record.aggregate_owner = aggregate_owner
@@ -125,7 +136,6 @@ module ReactiveRecord
       end
 
       record.ar_instance
-
     end
 
     def initialize(model, hash = {}, ar_instance = nil)
@@ -136,6 +146,7 @@ module ReactiveRecord
       @changed_attributes = []
       @virgin = true
       records[model] << self
+      Base.set_object_id_lookup(self)
     end
 
     def find(*args)
@@ -151,13 +162,15 @@ module ReactiveRecord
     end
 
     def id
-      attributes[primary_key]
+      @attributes[primary_key]
     end
 
     def id=(value)
       # value can be nil if we are loading an aggregate otherwise check if it already exists
-      if !(value and existing_record = records[@model].detect { |record| record.attributes[primary_key] == value})
-        attributes[primary_key] = value
+      # if !(value && (existing_record = records[@model].detect { |record| record.attributes[primary_key] == value}))
+      if !(value && (existing_record = Base.lookup_by_id(model, value)))
+        @attributes[primary_key] = value
+        Base.set_id_lookup(self)
       else
         @ar_instance.instance_variable_set(:@backing_record, existing_record)
         existing_record.attributes.merge!(attributes) { |key, v1, v2| v1 }
@@ -165,85 +178,6 @@ module ReactiveRecord
       value
     end
 
-    def attributes
-      @last_access_at = Time.now
-      @attributes
-    end
-
-    def reactive_get!(attribute, reload = nil)
-      @virgin = false unless data_loading?
-      unless @destroyed
-        if @attributes.has_key? attribute
-          attributes[attribute].notify if @attributes[attribute].is_a? DummyValue
-          apply_method(attribute) if reload
-        else
-          apply_method(attribute)
-        end
-        React::State.get_state(self, attribute) unless data_loading?
-        attributes[attribute]
-      end
-    end
-
-    def reactive_set!(attribute, value)
-      @virgin = false unless data_loading?
-      return value if @destroyed || dont_update_attribute?(attribute, value)
-      return attributes[attribute] if update_aggregate(attribute, value)
-      value = update_relationships(attribute, value)
-      update_attribute(attribute, value)
-      value
-    end
-
-    def dont_update_attribute?(attribute, value)
-      return false if attributes[attribute].is_a?(DummyValue)
-      return false unless attributes.key?(attribute)
-      return false if attributes[attribute] != value
-      true
-    end
-
-    def update_attribute(attribute, *args)
-      value = args[0]
-      if args.count != 0 and data_loading?
-        if (aggregation = model.reflect_on_aggregation(attribute)) and !(aggregation.klass < ActiveRecord::Base)
-          @synced_attributes[attribute] = aggregation.deserialize(aggregation.serialize(value))
-        else
-          @synced_attributes[attribute] = value
-        end
-      end
-      if @virgin
-        attributes[attribute] = value if args.count != 0
-        return
-      end
-      changed = if args.count == 0
-        if (association = @model.reflect_on_association(attribute)) and association.collection?
-          attributes[attribute] != @synced_attributes[attribute]
-        else
-          !attributes[attribute].backing_record.changed_attributes.empty?
-        end
-      elsif (association = @model.reflect_on_association(attribute)) and association.collection?
-        value != @synced_attributes[attribute]
-      else
-        !@synced_attributes.has_key?(attribute) or @synced_attributes[attribute] != value
-      end
-      empty_before = changed_attributes.empty?
-      if !changed
-        changed_attributes.delete(attribute)
-      elsif !changed_attributes.include?(attribute)
-        changed_attributes << attribute
-      end
-      had_key = attributes.has_key? attribute
-      current_value = attributes[attribute]
-      attributes[attribute] = value if args.count != 0
-      if !data_loading?
-        React::State.set_state(self, attribute, value)
-      elsif on_opal_client? and had_key and current_value.loaded? and current_value != value and args.count > 0  # this is to handle changes in already loaded server side methods
-        React::State.set_state(self, attribute, value, true)
-      end
-      if empty_before != changed_attributes.empty?
-        React::State.set_state(self, "!CHANGED!", !changed_attributes.empty?, true) unless on_opal_server? or data_loading?
-        aggregate_owner.update_attribute(aggregate_attribute) if aggregate_owner
-      end
-    end
-
     def changed?(*args)
       if args.count == 0
         React::State.get_state(self, "!CHANGED!")
@@ -254,20 +188,34 @@ module ReactiveRecord
       end
     end
 
+    def changed_attributes_and_values
+      Hash[changed_attributes.collect do |attr|
+        [attr, @attributes[attr]] if column_type(attr)
+      end.compact]
+    end
+
+    def changes
+      Hash[changed_attributes.collect do |attr|
+        [attr, [@synced_attributes[attr], @attributes[attr]]] if column_type(attr)
+      end.compact]
+    end
+
     def errors
-      @errors ||= ActiveModel::Error.new
+      @errors ||= ActiveModel::Errors.new(self)
     end
 
     # called when we have a newly created record, to initialize
     # any nil collections to empty arrays.  We can do this because
     # if its a brand new record, then any collections that are still
     # nil must not have any children.
+
     def initialize_collections
       if (!vector || vector.empty?) && id && id != ''
-        @vector = [@model, [:find_by, @model.primary_key => id]]
+        Base.set_vector_lookup(self, [@model, [:find_by, @model.primary_key => id]])
       end
-      @model.reflect_on_all_associations.each do |assoc|
-        if assoc.collection? && attributes[assoc.attribute].nil?
+      Base.load_data do
+        @model.reflect_on_all_associations.each do |assoc|
+          next if !assoc.collection? || @attributes[assoc.attribute]
           ar_instance.send("#{assoc.attribute}=", [])
         end
       end
@@ -275,14 +223,14 @@ module ReactiveRecord
 
     # sync! now will also initialize any nil collections
     def sync!(hash = {}) # does NOT notify (see saved! for notification)
-      hash.each do |attr, value|
-        @attributes[attr] = convert(attr, value)
-      end
+      # hash.each do |attr, value|
+      #   @attributes[attr] = convert(attr, value)
+      # end
       @synced_attributes = {}
-      @synced_attributes.each { |attribute, value| sync_attribute(key, value) }
+      hash.each { |attr, value| sync_attribute(attr, convert(attr, value)) }
       @changed_attributes = []
       @saving = false
-      @errors = nil
+      errors.clear
       # set the vector and clear collections - this only happens when a new record is saved
       initialize_collections if (!vector || vector.empty?) && id && id != ''
       self
@@ -305,7 +253,8 @@ module ReactiveRecord
 
     def sync_attribute(attribute, value)
 
-      @synced_attributes[attribute] = attributes[attribute] = value
+      @synced_attributes[attribute] = @attributes[attribute] = value
+      Base.set_id_lookup(self) if attribute == primary_key
 
       #@synced_attributes[attribute] = value.dup if value.is_a? ReactiveRecord::Collection
 
@@ -326,7 +275,7 @@ module ReactiveRecord
     # helper so we can tell if model exists.  We need this so we can detect
     # if a record has local changes that are out of sync.
     def self.exists?(model, id)
-      @records[model].detect { |record| record.attributes[model.primary_key] == id }
+      Base.lookup_by_id(model, id)
     end
 
     def revert
@@ -335,7 +284,7 @@ module ReactiveRecord
         @attributes.delete(attribute) unless @synced_attributes.key?(attribute)
       end
       @changed_attributes = []
-      @errors = nil
+      errors.clear
     end
 
     def saving!
@@ -343,14 +292,20 @@ module ReactiveRecord
       @saving = true
     end
 
-    def errors!(errors)
-      @saving = false
-      @errors = errors && ActiveModel::Error.new(errors)
+    def errors!(hash)
+      notify_waiting_for_save
+      errors.clear && return unless hash
+      hash.each do |attribute, messages|
+        messages.each do |message|
+          errors.add(attribute, message: message)
+        end
+      end
     end
 
-    def saved!  # sets saving to false AND notifies
-      @saving = false
-      if !@errors or @errors.empty?
+    def saved!(save_only = nil) # sets saving to false AND notifies
+      notify_waiting_for_save
+      return self if save_only
+      if errors.empty?
         React::State.set_state(self, self, :saved)
       elsif !data_loading?
         React::State.set_state(self, self, :error)
@@ -358,6 +313,26 @@ module ReactiveRecord
       self
     end
 
+    def self.when_not_saving(model, &block)
+      if @records[model].detect(&:saving?)
+        wait_for_save(model, &block)
+      else
+        yield model
+      end
+    end
+
+    def notify_waiting_for_save
+      @saving = false
+      self.class.notify_waiting_for_save(model)
+    end
+
+    def self.notify_waiting_for_save(model)
+      waiters = waiting_for_save(model)
+      return if waiters.empty? || @records[model].detect(&:saving?)
+      waiters.each { |waiter| waiter.call model }
+      clear_waiting_for_save(model)
+    end
+
     def saving?
       React::State.get_state(self, self)
       @saving
@@ -367,88 +342,26 @@ module ReactiveRecord
       !id && !vector
     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.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 unless association.through_association? || instance_backing_record_attributes.key?(inverse_of)
-      instance
-    end
-
-    def apply_method(method)
-      # Fills in the value returned by sending "method" to the corresponding server side db instance
-      if on_opal_server? and changed?
-        log("Warning fetching virtual attributes (#{model.name}.#{method}) during prerendering on a changed or new model is not implemented.", :warning)
-        # to implement this we would have to sync up any changes during prererendering with a set the cached models (see server_data_cache)
-        # right now server_data cache is read only, BUT we could change this.  However it seems like a tails case.  Why would we create or update
-        # a model during prerendering???
-      end
-      if !new?
-        new_value = 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) and (aggregation.klass < ActiveRecord::Base)
-          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(self, *(vector ? vector : [nil]), 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(self, *(vector ? vector : [nil]), method)
-        end
-        new_value = @attributes[method] if new_value.is_a? DummyValue and @attributes.has_key?(method)
-        sync_attribute(method, new_value)
-      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) and (aggregation.klass < ActiveRecord::Base)
-        @attributes[method] = aggregation.klass.new.tap do |aggregate|
-          backing_record = aggregate.backing_record
-          backing_record.aggregate_owner = self
-          backing_record.aggregate_attribute = method
-        end
-      elsif !aggregation and method != model.primary_key
-        if model.columns_hash[method]
-          new_value = convert(method, model.columns_hash[method][:default])
-        else
-          unless @attributes.key?(method)
-            log("Warning: reading from new #{model.name}.#{method} before assignment.  Will fetch value from server.  This may not be what you expected!!", :warning)
-          end
-          new_value = self.class.load_from_db(self, *(vector ? vector : [nil]), method)
-          new_value = @attributes[method] if new_value.is_a?(DummyValue) && @attributes.key?(method)
-        end
-        sync_attribute(method, new_value)
-      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 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
-      klass
+    def set_ar_instance!
+      klass = self.class.infer_type_from_hash(model, @attributes)
+      @ar_instance = klass._new_without_sti_type_cast(self) unless @ar_instance.class == klass
+      @ar_instance
     end
 
     class << self
+      def 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 Exception => e
+          message = "Could not subclass #{klass} as #{type}.  Perhaps #{type} class has not been required. Exception: #{e}"
+          `console.error(#{message})`
+        end unless !type || type == ''
+        klass
+      end
+
       attr_reader :outer_scopes
 
       def default_scope
@@ -462,36 +375,19 @@ module ReactiveRecord
       def add_to_outer_scopes(item)
         @outer_scopes << item
       end
-    end
 
-    # when_not_saving will wait until reactive-record is not saving a model.
-    # Currently there is no easy way to do this without polling.
-    def self.when_not_saving(model)
-      if @records[model].detect(&:saving?)
-        poller = every(0.1) do
-          unless @records[model].detect(&:saving?)
-            poller.stop
-            yield model
-          end
-        end
-      else
-        yield model
-      end
-    end
-
-    # While evaluating scopes we want to catch any requests
-    # to the server.  Once we catch any requests to the server
-    # then all the further scopes in that chain will be made
-    # at the server.
+      # While evaluating scopes we want to catch any requests
+      # to the server.  Once we catch any requests to the server
+      # then all the further scopes in that chain will be made
+      # at the server.
 
-    class << self
       class DbRequestMade < RuntimeError; end
 
       def catch_db_requests(return_val = nil)
         @catch_db_requests = true
         yield
       rescue DbRequestMade => e
-        puts "Warning request for server side data during scope evaluation: #{e.message}"
+        React::IsomorphicHelpers.log "Warning: request for server side data during scope evaluation: #{e.message}", :warning
         return_val
       ensure
         @catch_db_requests = false
@@ -509,13 +405,12 @@ module ReactiveRecord
       @destroyed = false
       model.reflect_on_all_associations.each do |association|
         if association.collection?
-          attributes[association.attribute].replace([]) if attributes[association.attribute]
+          @attributes[association.attribute].replace([]) if @attributes[association.attribute]
         else
           @ar_instance.send("#{association.attribute}=", nil)
         end
       end
       @destroyed = true
     end
-
   end
 end