hyper-model 1.0.alpha1.4 → 1.0.alpha1.5

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

@@ -4,11 +4,11 @@ module ReactiveRecord
   # the appropriate string.  The order of execution is important!
   module BackingRecordInspector
     def inspection_details
-      return error_details    unless errors.empty?
-      return new_details      if new?
+      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 dirty_details    unless changed_attributes.empty?
+      return loading_details   unless @attributes.key? primary_key
+      return dirty_details     unless changed_attributes.empty?
       "[loaded id: #{id}]"
     end
 

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

@@ -71,7 +71,7 @@ module ReactiveRecord
       if (id_to_find = attrs[model.primary_key])
         !new_only && lookup_by_id(model, id_to_find)
       else
-        @records[model].detect do |r|
+        @records[model.base_class].detect do |r|
           (r.new? || !new_only) &&
             !attrs.detect { |attr, value| r.synced_attributes[attr] != value }
         end
@@ -118,6 +118,9 @@ module ReactiveRecord
       # 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.
+
+      return DummyPolymorph.new(vector) unless model
+
       model = model.base_class
 
       # do we already have a record with this vector?  If so return it, otherwise make a new one.
@@ -147,7 +150,7 @@ module ReactiveRecord
       @attributes = {}
       @changed_attributes = []
       @virgin = true
-      records[model] << self
+      records[model.base_class] << self
       Base.set_object_id_lookup(self)
     end
 
@@ -204,7 +207,7 @@ module ReactiveRecord
     end
 
     def errors
-      @errors ||= ActiveModel::Errors.new(self)
+      @errors ||= ActiveModel::Errors.new(ar_instance)
     end
 
     # called when we have a newly created record, to initialize
@@ -250,7 +253,7 @@ module ReactiveRecord
         return if @create_sync
         @create_sync = true
       end
-      model.unscoped << ar_instance
+      model.unscoped._internal_push ar_instance
       @synced_with_unscoped = !@synced_with_unscoped
     end
 
@@ -307,9 +310,11 @@ module ReactiveRecord
       @saving = true
     end
 
-    def errors!(hash)
+    def errors!(hash, saving)
+      @errors_at_last_sync = hash if saving
       notify_waiting_for_save
       errors.clear && return unless hash
+      errors.non_reactive_clear
       hash.each do |attribute, messages|
         messages.each do |message|
           errors.add(attribute, message)
@@ -317,6 +322,11 @@ module ReactiveRecord
       end
     end
 
+    def revert_errors!
+      puts "#{inspect}.revert_errors!  @errors_at_last_sync: #{@errors_at_last_sync}"
+      errors!(@errors_at_last_sync)
+    end
+
     def saved!(save_only = nil) # sets saving to false AND notifies
       notify_waiting_for_save
       return self if save_only
@@ -418,6 +428,7 @@ module ReactiveRecord
 
     def destroy_associations
       @destroyed = false
+      @being_destroyed = true
       model.reflect_on_all_associations.each do |association|
         if association.collection?
           @attributes[association.attribute].replace([]) if @attributes[association.attribute]

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

@@ -77,6 +77,8 @@ module ReactiveRecord
         (@collection.length..index).each do |i|
           new_dummy_record = ReactiveRecord::Base.new_from_vector(@target_klass, nil, *@vector, "*#{i}")
           new_dummy_record.attributes[@association.inverse_of] = @owner if @association && !@association.through_association?
+          # HMT-TODO: the above needs to be looked into... if we are a hmt then don't we need to create a dummy on the joins collection as well?
+          # or maybe this just does not work for HMT?
           @collection << new_dummy_record
         end
       end
@@ -212,7 +214,7 @@ To determine this sync_scopes first asks if the record being changed is in the s
       return [] unless attrs[@association.inverse_of] == @owner
       if !@association.through_association
         [record]
-      elsif (source = attrs[@association.source])
+      elsif (source = attrs[@association.source]) && source.is_a?(@target_klass)
         [source]
       else
         []
@@ -233,7 +235,8 @@ To determine this sync_scopes first asks if the record being changed is in the s
     end
 
     def in_this_collection(related_records)
-      return related_records unless @association
+      # HMT-TODO: I don't think we can get a set of related records here with a through association unless they are part of the collection
+      return related_records if !@association || @association.through_association?
       related_records.select do |r|
         r.backing_record.attributes[@association.inverse_of] == @owner
       end
@@ -406,7 +409,11 @@ To determine this sync_scopes first asks if the record being changed is in the s
     def set_belongs_to(child)
       if @owner
         # TODO this is major broken...current
-        child.send("#{@association.inverse_of}=", @owner) if @association && !@association.through_association
+        if (through_association = @association.through_association)
+          # HMT-TODO: create a new record with owner and child
+        else
+          child.send("#{@association.inverse_of}=", @owner) if @association && !@association.through_association
+        end
       elsif @parent
         @parent.set_belongs_to(child)
       end
@@ -421,19 +428,40 @@ To determine this sync_scopes first asks if the record being changed is in the s
 
     def update_child(item)
       backing_record = item.backing_record
-      if backing_record && @owner && @association && !@association.through_association? && item.attributes[@association.inverse_of] != @owner
+      # HMT TODO:  The following && !association.through_association was commented out, causing wrong class items to be added to
+      # associations
+      # Why was it commented out.
+      if backing_record && @owner && @association && item.attributes[@association.inverse_of] != @owner && !@association.through_association?
         inverse_of = @association.inverse_of
-        current_association = item.attributes[inverse_of]
+        current_association_value = item.attributes[inverse_of]
         backing_record.virgin = false unless backing_record.data_loading?
+        # next line was commented out and following line was active.
         backing_record.update_belongs_to(inverse_of, @owner)
-        if current_association && current_association.attributes[@association.attribute]
-          current_association.attributes[@association.attribute].delete(item)
-        end
+        #backing_record.set_belongs_to_via_has_many(@association, @owner)
+        # following is handled by update_belongs_to and is redundant
+        # unless current_association_value.nil?  # might be a dummy value which responds to nil
+        #   current_association = @association.inverse.inverse(current_association_value)
+        #   current_association_attribute = current_association.attribute
+        #   if current_association.collection? && current_association_value.attributes[current_association_attribute]
+        #     current_association.attributes[current_association_attribute].delete(item)
+        #   end
+        # end
         @owner.backing_record.sync_has_many(@association.attribute)
       end
     end
 
     def push(item)
+      if (through_association = @association&.through_association)
+        through_association.klass.create(@association.inverse_of => @owner, @association.source => item)
+        self
+      else
+        _internal_push(item)
+      end
+    end
+
+    alias << push
+
+    def _internal_push(item)
       item.itself # force get of at least the id
       if collection
         self.force_push item
@@ -449,8 +477,6 @@ To determine this sync_scopes first asks if the record being changed is in the s
       self
     end
 
-    alias << push
-
     def sort!(*args, &block)
       replace(sort(*args, &block))
     end
@@ -514,19 +540,19 @@ To determine this sync_scopes first asks if the record being changed is in the s
         @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.new? and r.backing_record.vector.last =~ /^\*[0-9]+$/
+          r.id = new_array[i].id if array[i] and array[i].id and !r.new_record? 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
+      # the following makes sure that the existing elements are properly removed from the collection
+      @collection.dup.each { |item| delete(item) } if @collection
       @collection = []
       if new_array.is_a? Collection
         @dummy_collection = new_array.dummy_collection
         @dummy_record = new_array.dummy_record
-        new_array.collection.each { |item| self << item } if new_array.collection
+        new_array.collection.each { |item| _internal_push item } if new_array.collection
       else
         @dummy_collection = @dummy_record = nil
-        new_array.each { |item| self << item }
+        new_array.each { |item| _internal_push item }
       end
       notify_of_change new_array
     end
@@ -534,9 +560,9 @@ To determine this sync_scopes first asks if the record being changed is in the s
     def delete(item)
       unsaved_children.delete(item)
       notify_of_change(
-        if @owner && @association && !@association.through_association?
+        if @owner && @association
           inverse_of = @association.inverse_of
-          if (backing_record = item.backing_record) && item.attributes[inverse_of] == @owner
+          if (backing_record = item.backing_record) && item.attributes[inverse_of] == @owner && !@association.through_association?
             # the if prevents double update if delete is being called from << (see << above)
             backing_record.update_belongs_to(inverse_of, nil)
           end
@@ -562,20 +588,8 @@ To determine this sync_scopes first asks if the record being changed is in the s
       @dummy_collection.loading?
     end
 
-    def loaded?
-      false && @collection && (!@dummy_collection || !@dummy_collection.loading?) && (!@owner || @owner.id || @vector.length > 1)
-    end
-
-    def empty?
-      # should be handled by method missing below, but opal-rspec does not deal well
-      # with method missing, so to test...
-      all.empty?
-    end
-
     def find_by(attrs)
       attrs = @target_klass.__hyperstack_preprocess_attrs(attrs)
-      # r = @collection&.detect { |lr| lr.new_record? && !attrs.detect { |k, v| lr.attributes[k] != v } }
-      # return r if r
       (r = __hyperstack_internal_scoped_find_by(attrs)) || return
       r.backing_record.sync_attributes(attrs).set_ar_instance!
     end
@@ -596,6 +610,16 @@ To determine this sync_scopes first asks if the record being changed is in the s
       found
     end
 
+    # to avoid fetching the entire collection array we check empty and any against the count
+
+    def empty?
+      count.zero?
+    end
+
+    def any?
+      !count.zero?
+    end
+
     def method_missing(method, *args, &block)
       if args.count == 1 && method.start_with?('find_by_')
         find_by(method.sub(/^find_by_/, '') => args[0])

data/lib/reactive_record/active_record/reactive_record/dummy_polymorph.rb

@@ -0,0 +1,22 @@
+module ReactiveRecord
+  class DummyPolymorph
+    def initialize(vector)
+      @vector = vector
+      puts "VECTOR: #{@vector.inspect}"
+      Base.load_from_db(nil, *vector, 'id')
+      Base.load_from_db(nil, *vector, 'model_name')
+    end
+
+    def nil?
+      true
+    end
+
+    def method_missing(*)
+      self
+    end
+
+    def self.reflect_on_all_associations(*)
+      []
+    end
+  end
+end

data/lib/reactive_record/active_record/reactive_record/dummy_value.rb

@@ -72,6 +72,7 @@ module ReactiveRecord
       alias build_default_value_for_bigint build_default_value_for_integer
 
       def build_default_value_for_string
+        return @column_hash[:default] if @column_hash[:serialized?]
         @column_hash[:default] || ''
       end
 

data/lib/reactive_record/active_record/reactive_record/getters.rb

@@ -4,9 +4,13 @@ module ReactiveRecord
   module Getters
     def get_belongs_to(assoc, reload = nil)
       getter_common(assoc.attribute, reload) do |has_key, attr|
-        return if new?
-        value = fetch_by_id(attr, @model.primary_key) if id.present?
-        value = find_association(assoc, value)
+        next if new?
+        if id.present?
+          value = fetch_by_id(attr, @model.primary_key)
+          klass = fetch_by_id(attr, 'model_name')
+          klass &&= Object.const_get(klass)
+        end
+        value = find_association(assoc, value, klass)
         sync_ignore_dummy attr, value, has_key
       end&.cast_to_current_sti_type
     end
@@ -104,18 +108,26 @@ module ReactiveRecord
       else
         virtual_fetch_on_server_warning(attribute) if on_opal_server? && changed?
         yield false, attribute
-      end.tap { |value| Hyperstack::Internal::State::Variable.get(self, attribute) unless data_loading? }
+      end.tap { Hyperstack::Internal::State::Variable.get(self, attribute) unless data_loading? }
     end
 
-    def find_association(association, id)
-      inverse_of = association.inverse_of
+    def find_association(association, id, klass)
       instance = if id
-        find(association.klass, association.klass.primary_key => id)
+        find(klass, klass.primary_key => id)
+      elsif association.polymorphic?
+        new_from_vector(nil, nil, *vector, association.attribute)
       else
         new_from_vector(association.klass, nil, *vector, association.attribute)
       end
+      return instance if instance.is_a? DummyPolymorph
+      inverse_of = association.inverse_of(instance)
       instance_backing_record_attributes = instance.attributes
       inverse_association = association.klass.reflect_on_association(inverse_of)
+      # HMT-TODO: don't we need to do something with the through association case.
+      # perhaps we never hit this point...
+      if association.through_association?
+        IsomorphicHelpers.log "*********** called #{ar_instance}.find_association(#{association.attribute}) which is has many through!!!!!!!", :error
+      end
       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)

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

@@ -135,7 +135,6 @@ module ReactiveRecord
       model.columns_hash[method_name] || model.server_methods[method_name]
     end
 
-
     class << self
 
       attr_reader :pending_fetches
@@ -234,7 +233,7 @@ module ReactiveRecord
               if association.collection?
                 # following line changed from .all to .collection on 10/28
                 [*value.collection, *value.unsaved_children].each do |assoc|
-                  add_new_association.call(record, attribute, assoc.backing_record) if assoc.changed?(association.inverse_of) or assoc.new?
+                  add_new_association.call(record, attribute, assoc.backing_record) if assoc.changed?(association.inverse_of(assoc)) or assoc.new_record?
                 end
               elsif record.new? || record.changed?(attribute) || (record == record_being_saved && force)
                 if value.nil?
@@ -243,7 +242,7 @@ module ReactiveRecord
                   add_new_association.call record, attribute, value.backing_record
                 end
               end
-            elsif aggregation = record.model.reflect_on_aggregation(attribute) and (aggregation.klass < ActiveRecord::Base)
+            elsif (aggregation = record.model.reflect_on_aggregation(attribute)) && (aggregation.klass < ActiveRecord::Base)
               add_new_association.call record, attribute, value.backing_record unless value.nil?
             elsif aggregation
               new_value = aggregation.serialize(value)
@@ -264,8 +263,17 @@ module ReactiveRecord
           HyperMesh.load do
             ReactiveRecord.loads_pending! unless self.class.pending_fetches.empty?
           end.then { send_save_to_server(save, validate, force, &block) }
-          #save_to_server(validate, force, &block)
         else
+          if validate
+            # Handles the case where a model is valid, then some attribute is
+            # updated, and model.validate is called updating the error data.
+            # Now lets say the attribute changes back to the last synced value.  In
+            # this case we need to revert the error records.
+            models, _, backing_records = self.class.gather_records([self], true, self)
+            models.each do |item|
+              backing_records[item[:id]].revert_errors!
+            end
+          end
           promise = Promise.new
           yield true, nil, [] if block
           promise.resolve({success: true})
@@ -302,14 +310,13 @@ module ReactiveRecord
 
               response[:saved_models].each do | item |
                 backing_records[item[0]].sync_unscoped_collection! if save
-                backing_records[item[0]].errors! item[3]
+                backing_records[item[0]].errors! item[3], save
               end
 
               yield response[:success], response[:message], response[:models]  if block
               promise.resolve response  # TODO this could be problematic... there was no .json here, so .... what's to do?
 
             rescue Exception => e
-              # debugger
               log("Exception raised while saving - #{e}", :error)
             ensure
               backing_records.each { |_id, record| record.saved! rescue nil } if save
@@ -454,6 +461,11 @@ module ReactiveRecord
             elsif parent.class.reflect_on_association(association[:attribute].to_sym).collection?
               #puts ">>>>>>>>>> #{parent.class.name}.send('#{association[:attribute]}') << #{reactive_records[association[:child_id]]})"
               dont_save_list.delete(parent)
+
+
+              # if reactive_records[association[:child_id]]&.new_record?
+              #   dont_save_list << reactive_records[association[:child_id]]
+              # end
               #if false and parent.new?
                 #parent.send("#{association[:attribute]}") << reactive_records[association[:child_id]]
                 # puts "updated"
@@ -464,10 +476,13 @@ module ReactiveRecord
               #puts ">>>>ASSOCIATION>>>> #{parent.class.name}.send('#{association[:attribute]}=', #{reactive_records[association[:child_id]]})"
               parent.send("#{association[:attribute]}=", reactive_records[association[:child_id]])
               dont_save_list.delete(parent)
-              #puts "updated"
+
+              # if parent.class.reflect_on_association(association[:attribute].to_sym).macro == :has_one &&
+              #    reactive_records[association[:child_id]]&.new_record?
+              #   dont_save_list << reactive_records[association[:child_id]]
+              # end
             end
           end if associations
-
           # get rid of any records that don't require further processing, as a side effect
           # we also save any records that need to be saved (these may be rolled back later.)
 
@@ -476,7 +491,9 @@ module ReactiveRecord
             next true  if record.frozen?  # skip (but process later) frozen records
             next true  if dont_save_list.include?(record) # skip if the record is on the don't save list
             next true  if record.changed.include?(record.class.primary_key)  # happens on an aggregate
-            next false if record.id && !record.changed? # throw out any existing records with no changes
+            #next true  if record.persisted? # record may be have been saved as result of has_one assignment
+            # next false if record.id && !record.changed? # throw out any existing records with no changes
+            next record.persisted? if record.id && !record.changed?
             # if we get to here save the record and return true to keep it
             op = new_models.include?(record) ? :create_permitted? : :update_permitted?
             record.check_permission_with_acting_user(acting_user, op).save(validate: false) || true
@@ -492,14 +509,15 @@ module ReactiveRecord
           # the all the error messages during a save so we can dump them to the server log.
 
           all_messages = []
+          attributes = nil
 
           saved_models = reactive_records.collect do |reactive_record_id, model|
             messages = model.errors.messages if validate && !model.valid?
             all_messages << [model, messages] if save && messages
             attributes = model.__hyperstack_secure_attributes(acting_user)
+            attributes[model.class.primary_key] = model[model.class.primary_key]
             [reactive_record_id, model.class.name, attributes, messages]
           end
-
           # if we are not saving (i.e. just validating) then we rollback the transaction
 
           raise ActiveRecord::Rollback, 'This Rollback is intentional!' unless save
@@ -514,7 +532,6 @@ module ReactiveRecord
             end
             raise 'HyperModel saving records failed!'
           end
-
         end
 
         { success: true, saved_models: saved_models }