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

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

@@ -38,6 +38,7 @@ module ReactiveRecord
     attr_accessor :aggregate_owner
     attr_accessor :aggregate_attribute
     attr_accessor :destroyed
+    attr_accessor :being_destroyed
     attr_accessor :updated_during
     attr_accessor :synced_attributes
     attr_accessor :virgin
@@ -310,7 +311,7 @@ module ReactiveRecord
       @saving = true
     end
 
-    def errors!(hash, saving)
+    def errors!(hash, saving = false)
       @errors_at_last_sync = hash if saving
       notify_waiting_for_save
       errors.clear && return unless hash
@@ -323,7 +324,6 @@ module ReactiveRecord
     end
 
     def revert_errors!
-      puts "#{inspect}.revert_errors!  @errors_at_last_sync: #{@errors_at_last_sync}"
       errors!(@errors_at_last_sync)
     end
 

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

@@ -141,7 +141,10 @@ To determine this sync_scopes first asks if the record being changed is in the s
 
 
 =end
+      attr_accessor :broadcast_updated_at
+
       def sync_scopes(broadcast)
+        self.broadcast_updated_at = broadcast.updated_at
         # record_with_current_values will return nil if data between
         # the broadcast record and the value on the client is out of sync
         # not running set_pre_sync_related_records will cause sync scopes
@@ -159,6 +162,8 @@ To determine this sync_scopes first asks if the record being changed is in the s
           )
           record.backing_record.sync_unscoped_collection! if record.destroyed? || broadcast.new?
         end
+      ensure
+        self.broadcast_updated_at = nil
       end
 
       def apply_to_all_collections(method, record, dont_gather)
@@ -336,26 +341,26 @@ To determine this sync_scopes first asks if the record being changed is in the s
     end
 
     def observed
-      return if @observing || ReactiveRecord::Base.data_loading?
+      return self if @observing || ReactiveRecord::Base.data_loading?
       begin
         @observing = true
         link_to_parent
         reload_from_db(true) if @out_of_date
         Hyperstack::Internal::State::Variable.get(self, :collection)
+        self
       ensure
         @observing = false
       end
     end
 
-    def set_count_state(val)
+    def count_state=(val)
       unless ReactiveRecord::WhileLoading.observed?
         Hyperstack::Internal::State::Variable.set(self, :collection, collection, true)
       end
+      @count_updated_at = ReactiveRecord::Operations::Base.last_response_sent_at
       @count = val
     end
 
-
-
     def _count_internal(load_from_client)
       # when count is called on a leaf, count_internal is called for each
       # ancestor.  Only the outermost count has load_from_client == true
@@ -462,16 +467,18 @@ To determine this sync_scopes first asks if the record being changed is in the s
     alias << push
 
     def _internal_push(item)
-      item.itself # force get of at least the id
-      if collection
-        self.force_push item
-      else
-        unsaved_children << item
-        update_child(item)
-        @owner.backing_record.sync_has_many(@association.attribute) if @owner && @association
-        if !@count.nil?
-          @count += item.destroyed? ? -1 : 1
-          notify_of_change self
+      insure_sync do
+        item.itself # force get of at least the id
+        if collection
+          self.force_push item
+        else
+          unsaved_children << item
+          update_child(item)
+          @owner.backing_record.sync_has_many(@association.attribute) if @owner && @association
+          if !@count.nil?
+            @count += (item.destroyed? ? -1 : 1)
+            notify_of_change self
+          end
         end
       end
       self
@@ -557,9 +564,9 @@ To determine this sync_scopes first asks if the record being changed is in the s
       notify_of_change new_array
     end
 
-    def delete(item)
-      unsaved_children.delete(item)
-      notify_of_change(
+    def destroy_non_habtm(item)
+      Hyperstack::Internal::State::Mapper.bulk_update do
+        unsaved_children.delete(item)
         if @owner && @association
           inverse_of = @association.inverse_of
           if (backing_record = item.backing_record) && item.attributes[inverse_of] == @owner && !@association.through_association?
@@ -569,17 +576,44 @@ To determine this sync_scopes first asks if the record being changed is in the s
           delete_internal(item) { @owner.backing_record.sync_has_many(@association.attribute) }
         else
           delete_internal(item)
-        end
+        end.tap { Hyperstack::Internal::State::Variable.set(self, :collection, collection) }
+      end
+    end
+
+    def destroy(item)
+      return destroy_non_habtm(item) unless @association&.habtm?
+
+      ta = @association.through_association
+      item_foreign_key = @association.source_belongs_to_association.association_foreign_key
+      join_record = ta.klass.find_by(
+        ta.association_foreign_key => @owner.id,
+        item_foreign_key => item.id
       )
+      return destroy_non_habtm(item) if join_record.nil? ||
+                                        join_record.backing_record.being_destroyed
+
+      join_record&.destroy
+    end
+
+    def insure_sync
+      if Collection.broadcast_updated_at && @count_updated_at && Collection.broadcast_updated_at < @count_updated_at
+        reload_from_db
+      else
+        yield
+      end
     end
 
+    alias delete destroy
+
     def delete_internal(item)
-      if collection
-        all.delete(item)
-      elsif !@count.nil?
-        @count -= 1
+      insure_sync do
+        if collection
+          all.delete(item)
+        elsif !@count.nil?
+          @count -= 1
+        end
+        yield if block_given? # was yield item, but item is not used
       end
-      yield if block_given? # was yield item, but item is not used
       item
     end
 
@@ -594,8 +628,10 @@ To determine this sync_scopes first asks if the record being changed is in the s
       r.backing_record.sync_attributes(attrs).set_ar_instance!
     end
 
-    def find(id)
-      find_by @target_klass.primary_key => id
+    def find(*args)
+      args = args[0] if args[0].is_a? Array
+      return args.collect { |id| find(id) } if args.count > 1
+      find_by(@target_klass.primary_key => args[0])
     end
 
     def _find_by_initializer(scope, attrs)
@@ -616,8 +652,22 @@ To determine this sync_scopes first asks if the record being changed is in the s
       count.zero?
     end
 
-    def any?
-      !count.zero?
+    def any?(*args, &block)
+      # If there are any args passed in, then the collection is being used in the condition
+      #   and we must load it all into memory.
+      return all.any?(*args, &block) if args&.length&.positive? || block.present?
+
+      # Otherwise we can just check the count for efficiency
+      !empty?
+    end
+
+    def none?(*args, &block)
+      # If there are any args passed in, then the collection is being used in the condition
+      #   and we must load it all into memory.
+      return all.none?(*args, &block) if args&.length&.positive? || block.present?
+
+      # Otherwise we can just check the count for efficiency
+      empty?
     end
 
     def method_missing(method, *args, &block)

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

@@ -1,4 +1,4 @@
-# add mehods to Object to determine if this is a dummy object or not
+# add methods to Object to determine if this is a dummy object or not
 class Object
   def loaded?
     !loading?
@@ -7,10 +7,6 @@ class Object
   def loading?
     false
   end
-
-  def present?
-    !!self
-  end
 end
 
 module ReactiveRecord
@@ -36,6 +32,12 @@ module ReactiveRecord
         @column_hash[:default] || nil
       end
 
+      def build_default_value_for_json
+        ::JSON.parse(@column_hash[:default]) if @column_hash[:default]
+      end
+
+      alias build_default_value_for_jsonb build_default_value_for_json
+
       def build_default_value_for_datetime
         if @column_hash[:default]
           ::Time.parse(@column_hash[:default].gsub(' ','T')+'+00:00')
@@ -55,18 +57,20 @@ module ReactiveRecord
         end
       end
 
+      FALSY_VALUES = [false, nil, 0, "0", "f", "F", "false", "FALSE", "off", "OFF"]
+
       def build_default_value_for_boolean
-        @column_hash[:default] || false
+        !FALSY_VALUES.include?(@column_hash[:default])
       end
 
       def build_default_value_for_float
-        @column_hash[:default] || Float(0.0)
+        @column_hash[:default]&.to_f || Float(0.0)
       end
 
       alias build_default_value_for_decimal build_default_value_for_float
 
       def build_default_value_for_integer
-        @column_hash[:default] || Integer(0)
+        @column_hash[:default]&.to_i || Integer(0)
       end
 
       alias build_default_value_for_bigint build_default_value_for_integer
@@ -92,10 +96,6 @@ module ReactiveRecord
         false
       end
 
-      def present?
-        false
-      end
-
       def nil?
         true
       end
@@ -104,6 +104,11 @@ module ReactiveRecord
         true
       end
 
+      def class
+        notify
+        @object.class
+      end
+
       def method_missing(method, *args, &block)
         if method.start_with?("build_default_value_for_")
           nil
@@ -158,7 +163,13 @@ module ReactiveRecord
 
       alias inspect to_s
 
-      `#{self}.$$proto.toString = Opal.Object.$$proto.toString`
+      %x{
+        if (Opal.Object.$$proto) {
+          #{self}.$$proto.toString = Opal.Object.$$proto.toString
+        } else {
+          #{self}.$$prototype.toString = Opal.Object.$$prototype.toString
+        }
+       }
 
       def to_f
         notify
@@ -216,10 +227,10 @@ module ReactiveRecord
       # to convert it to a string, for rendering
       # advantage over a try(:method) is, that it doesnt raise und thus is faster
       # which is important during render
-      def respond_to?(method)
+      def respond_to?(method, all = false)
         return true if method == :acts_as_string?
         return true if %i[inspect to_date to_f to_i to_numeric to_number to_s to_time].include? method
-        return @object.respond_to? if @object
+        return @object.respond_to?(method, all) if @object
         false
       end
 

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

@@ -37,7 +37,8 @@ module ReactiveRecord
 
     def get_server_method(attr, reload = nil)
       non_relationship_getter_common(attr, reload) do |has_key|
-        sync_ignore_dummy attr, Base.load_from_db(self, *(vector ? vector : [nil]), attr), has_key
+        # SPLAT BUG: was sync_ignore_dummy attr, Base.load_from_db(self, *(vector ? vector : [nil]), attr), has_key
+        sync_ignore_dummy attr, Base.load_from_db(self, *(vector || [nil]), *attr), has_key
       end
     end
 
@@ -79,7 +80,8 @@ module ReactiveRecord
         if new?
           yield has_key if block
         elsif on_opal_client?
-          sync_ignore_dummy attr, Base.load_from_db(self, *(vector ? vector : [nil]), attr), has_key
+          # SPLAT BUG: was sync_ignore_dummy attr, Base.load_from_db(self, *(vector ? vector : [nil]), attr), has_key
+          sync_ignore_dummy attr, Base.load_from_db(self, *(vector || [nil]), *attr), has_key
         elsif id.present?
           sync_attribute attr, fetch_by_id(attr)
         else

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

@@ -457,21 +457,18 @@ module ReactiveRecord
               parent.send("#{association[:attribute]}=", aggregate)
               #puts "updated  is frozen? #{aggregate.frozen?}, parent attributes = #{parent.send(association[:attribute]).attributes}"
             elsif parent.class.reflect_on_association(association[:attribute].to_sym).nil?
-              raise "Missing association :#{association[:attribute]} for #{parent.class.name}.  Was association defined on opal side only?"
+               raise "Missing association :#{association[:attribute]} for #{parent.class.name}.  Was association defined on opal side only?"
             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"
-              #else
-                #puts "skipped"
-              #end
+
+              if parent.new_record?
+                parent.send("#{association[:attribute]}") << reactive_records[association[:child_id]]
+              end
             else
               #puts ">>>>ASSOCIATION>>>> #{parent.class.name}.send('#{association[:attribute]}=', #{reactive_records[association[:child_id]]})"
               parent.send("#{association[:attribute]}=", reactive_records[association[:child_id]])
@@ -496,7 +493,8 @@ module ReactiveRecord
             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
+
+            record.check_permission_with_acting_user(acting_user, op).save(validate: validate) || true
           end
 
           # if called from ServerDataCache then save and validate are both false, and we just return the
@@ -551,13 +549,11 @@ module ReactiveRecord
     if RUBY_ENGINE == 'opal'
 
       def destroy(&block)
+        return if @destroyed || @being_destroyed
 
-        return if @destroyed
-
-        #destroy_associations
+        # destroy_associations
 
         promise = Promise.new
-
         if !data_loading? && (id || vector)
           Operations::Destroy.run(model: ar_instance.model_name.to_s, id: id, vector: vector)
           .then do |response|
@@ -569,7 +565,7 @@ module ReactiveRecord
           destroy_associations
           # sync_unscoped_collection! # ? should we do this here was NOT being done before hypermesh integration
           yield true, nil if block
-          promise.resolve({success: true})
+          promise.resolve(success: true)
         end
 
         # DO NOT CLEAR ATTRIBUTES.  Records that are not found, are destroyed, and if they are searched for again, we want to make
@@ -589,18 +585,16 @@ module ReactiveRecord
       def self.destroy_record(model, id, vector, acting_user)
         model = Object.const_get(model)
         record = if id
-          model.find(id)
-        else
-          ServerDataCache.new(acting_user, {})[*vector]
-        end
-
+                   model.find(id)
+                 else
+                   ServerDataCache.new(acting_user, {})[*vector].value
+                 end
 
         record.check_permission_with_acting_user(acting_user, :destroy_permitted?).destroy
-        {success: true, attributes: {}}
-
+        { success: true, attributes: {} }
       rescue Exception => e
-        #ReactiveRecord::Pry.rescued(e)
-        {success: false, record: record, message: e}
+        # ReactiveRecord::Pry.rescued(e)
+        { success: false, record: record, message: e }
       end
     end
   end

data/lib/reactive_record/active_record/reactive_record/operations.rb

@@ -12,6 +12,10 @@ module ReactiveRecord
 
       FORMAT = '0x%x'
 
+      class << self
+        attr_accessor :last_response_sent_at
+      end
+
       def self.serialize_params(hash)
         hash['associations'].each do |assoc|
           assoc['parent_id'] = FORMAT % assoc['parent_id']
@@ -38,6 +42,7 @@ module ReactiveRecord
         response[:saved_models].each do |saved_model|
           saved_model[0] = FORMAT % saved_model[0]
         end if response.is_a?(Hash) && response[:saved_models]
+        response[:sent_at] = Time.now.to_f
         response
       end
 
@@ -45,6 +50,7 @@ module ReactiveRecord
         response[:saved_models].each do |saved_model|
           saved_model[0] = saved_model[0].to_i(16)
         end if response.is_a?(Hash) && response[:saved_models]
+        Base.last_response_sent_at = response.delete(:sent_at)
         response
       end
     end
@@ -93,7 +99,7 @@ module ReactiveRecord
     class Destroy < Base
       param :acting_user, nils: true
       param :model
-      param :id
+      param :id, nils: true
       param :vector
       step do
         ReactiveRecord::Base.destroy_record(

data/lib/reactive_record/active_record/reactive_record/setters.rb

@@ -94,7 +94,7 @@ module ReactiveRecord
     end
 
     def set_attribute_change_status_and_notify(attr, changed, new_value)
-      if @virgin
+      if @virgin || @being_destroyed
         @attributes[attr] = new_value
       else
         change_status_and_notify_helper(attr, changed) do |had_key, current_value|
@@ -108,14 +108,13 @@ module ReactiveRecord
     end
 
     def set_change_status_and_notify_only(attr, changed)
-      return if @virgin
+      return if @virgin || @being_destroyed
       change_status_and_notify_helper(attr, changed) do
         Hyperstack::Internal::State::Variable.set(self, attr, nil) unless data_loading?
       end
     end
 
     def change_status_and_notify_helper(attr, changed)
-      return if @being_destroyed
       empty_before = changed_attributes.empty?
       if !changed || data_loading?
         changed_attributes.delete(attr)