bug fixes in legacy store and state management

Author: catmando

ruby/hyper-state/lib/hyperstack/internal/auto_unmount.rb

@@ -24,6 +24,7 @@ def unmount
             nil
           end
         end
+        remove
         @__hyperstack_internal_auto_unmount_unmounted = true
       end
 

ruby/hyper-state/lib/hyperstack/internal/state/mapper.rb

@@ -130,6 +130,8 @@ def update_objects_to_observe(observer = @current_observer)
           def remove(observer = @current_observer)
             remove_current_observers_and_objects(observer)
             new_objects.delete observer
+            # see run_delayed_updater for the purpose of @removed_observers
+            @removed_observers << observer if @removed_observers
           end
 
           # Internal (Private) Methods
@@ -166,11 +168,13 @@ def current_objects
           # lists by not adding an object hash key unless the object
           # already has pending state changes. (See the
           # schedule_delayed_updater method below)
+
           def update_exclusions
             @update_exclusions ||= Hash.new
           end
 
           # remove_current_observers_and_objects clears the hashes between renders
+
           def remove_current_observers_and_objects(observer)
             raise 'state management called outside of watch block' unless observer
             deleted_objects = current_objects.delete(observer)
@@ -190,6 +194,7 @@ def remove_current_observers_and_objects(observer)
           # Hyperstack.on_client? is true WITH ONE EXCEPTION:
           # observers can indicate that they need immediate updates in
           # case that the object being updated is themselves.
+
           def delay_updates?(object)
             @bulk_update_flag ||
               (Hyperstack.on_client? &&
@@ -211,21 +216,36 @@ def delay_updates?(object)
           # If an object changes state again then the Set will be reinitialized, and all
           # the observers that might have been on a previous exclusion list, will now be
           # notified.
+
           def schedule_delayed_updater(object)
             update_exclusions[object] = Set.new
-            @delayed_updater ||= after(0) do
-              current_update_exclusions = @update_exclusions
-              @update_exclusions = @delayed_updater = nil
-              observers_to_update(current_update_exclusions).each do |observer, objects|
-                observer.mutations objects
-              end
+            @delayed_updater ||= after(0) { run_delayed_updater }
+          end
+
+          # run_delayed_updater will call the mutations method for each observer passing
+          # the entire list of objects that changed while waiting for the delay except
+          # those that the observer has already seen (the exclusion list).  The observers
+          # mutation method may cause some other observer already on the observers_to_update
+          # list to be removed.  To prevent these observers from receiving mutations we keep a
+          # temporary set of removed_observers.  This is initialized before the mutations,
+          # and then cleared as soon as we are done.
+
+          def run_delayed_updater
+            current_update_exclusions = @update_exclusions
+            @update_exclusions = @delayed_updater = nil
+            @removed_observers = Set.new
+            observers_to_update(current_update_exclusions).each do |observer, objects|
+              observer.mutations objects unless @removed_observers.include? observer
             end
+          ensure
+            @removed_observers = nil
           end
 
           # observers_to_update returns a hash with observers as keys, and lists of objects
           # as values. The hash is built by filtering the current_observers list
           # including only observers that have mutated objects, that are not on the exclusion
           # list.
+
           def observers_to_update(exclusions)
             Hash.new { |hash, key| hash[key] = Array.new }.tap do |updates|
               exclusions.each do |object, excluded_observers|

ruby/hyper-state/lib/hyperstack/state/observer.rb

@@ -10,7 +10,7 @@ def update_objects_to_observe
       end
 
       def remove
-        Internal::State::Mapper.remove
+        Internal::State::Mapper.remove(self)
       end
     end
   end

ruby/hyper-store/lib/hyperstack/internal/store/instance_methods.rb

@@ -4,6 +4,7 @@ module Store
       module InstanceMethods
         def init_store
           return if @__hyperstack_store_initialized
+          @__hyperstack_store_initialized = true
           self.class.__instance_states.each do |instance_state|
             # If the scope is shared then we initialize at the class level
             next if instance_state[1][:scope] == :shared
@@ -21,7 +22,6 @@ def init_store
             block_value = instance_eval(&instance_state[1][:block])
             mutate.__send__(:"#{instance_state[0]}", block_value)
           end
-          @__hyperstack_store_initialized = true
         end
 
         def state

ruby/hyper-store/lib/hyperstack/internal/store/mutator_wrapper.rb

@@ -7,6 +7,7 @@ class << self
           def add_method(klass, method_name, opts = {})
             define_method(:"#{method_name}") do |*args|
               from = opts[:scope] == :shared ? klass.state.__from__ : __from__
+              from.init_store if from.respond_to? :init_store
               current_value = State.get_state(from, method_name.to_s)
 
               if args.count > 0

ruby/hyper-store/lib/hyperstack/internal/store/state.rb

@@ -9,12 +9,15 @@ def legacy_map
 
           def get_state(obj, name)
             map_object = legacy_map[obj][name]
-            map_object[0].tap { Hyperstack::Internal::State::Mapper.observed!(map_object.object_id) }
+            Hyperstack::Internal::State::Mapper.observed!(map_object.object_id)
+            map_object[0]
           end
 
           def set_state(obj, name, value)
             map_object = legacy_map[obj][name]
-            (map_object[0] = value).tap { Hyperstack::Internal::State::Mapper.mutated!(map_object.object_id) }
+            map_object[0] = value
+            Hyperstack::Internal::State::Mapper.mutated!(map_object.object_id)
+            value
           end
         end
       end