insure async methods dont start after observer is unmounted, plus improvements to stock ticker

Author: catmando

ruby/examples/misc/stock-tickers/app/hyperstack/components/app.rb

@@ -4,14 +4,15 @@ class App < HyperComponent
     UL do
       @symbols.sort.each do |symbol|
         LI(key: symbol) do
-          DisplayTicker(symbol: symbol, key: symbol)
+          DisplayTicker(symbol: symbol)
           .on(:cancel) { mutate @symbols.delete(symbol) }
         end
       end
     end
-    INPUT(placeholder: 'enter a stock symbol').on(:key_down) do |evt|
+    INPUT(placeholder: 'enter a new stock symbol')
+    .on(:key_down) do |evt|
       next unless evt.key_code == 13
-      mutate @symbols << evt.target.value
+      mutate @symbols << evt.target.value.upcase
       evt.target.value = ''
     end
   end

ruby/examples/misc/stock-tickers/app/hyperstack/components/display_ticker.rb

@@ -2,15 +2,20 @@ class DisplayTicker < HyperComponent
   param :symbol
   param :on_cancel, type: Proc
   before_mount { @ticker = StockTicker.new(params.symbol, 10.seconds) }
-  render(DIV) do
+
+  def status
     case @ticker.status
     when :loading
-      SPAN { "#{params.symbol.upcase} loading..."}
+      'loading...'
     when :success
-      SPAN { "#{params.symbol.upcase} current price: #{@ticker.price}" }
+      "current price: #{@ticker.price}"
     when :failed
-      SPAN { "#{params.symbol.upcase} failed to get quote: #{@ticker.reason}"}
+      "failed to get quote: #{@ticker.reason}"
     end
+  end
+
+  render(DIV) do
+    SPAN { "#{params.symbol.upcase} #{status}" }
     BUTTON { 'cancel' }.on(:click) { params.on_cancel } unless @ticker.status == :loading
   end
 end

ruby/examples/misc/stock-tickers/app/hyperstack/stores/stock_ticker.rb

@@ -1,12 +1,13 @@
 class StockTicker
   include Hyperstack::State::Observable
 
+  attr_reader  :symbol
   state_reader :price
-  attr_reader :symbol
   state_reader :status
   state_reader :reason
 
-  def initialize(symbol, update_interval = 5.minutes)
+  def initialize(symbol, update_interval = 5.seconds)
+    puts "creating ticker for #{symbol}"
     @symbol = symbol
     @status = :loading
     @update_interval = update_interval
@@ -16,24 +17,21 @@ def initialize(symbol, update_interval = 5.minutes)
   def fetch
     puts "fetching #{@symbol}"
     HTTP.get("https://api.iextrading.com/1.0/stock/#{@symbol}/delayed-quote")
-    .then do |response|
-      mutate @status = :success
-      mutate @price = response.json[:delayedPrice]
-      after(@update_interval) { fetch }
-    end
-    .fail do |response|
-      mutate @status = :failed
-      mutate @reason = response.body.empty? ? 'Network error' : response.body
-      after(@update_interval) { fetch } unless @reason == "Unknown symbol"
-    end
+        .then do |resp|
+          mutate @status = :success, @price = resp.json[:delayedPrice]
+          after(@update_interval) { fetch }
+        end
+        .fail do |resp|
+          mutate @status = :failed, @reason = resp.body.empty? ? 'Network error' : resp.body
+          after(@update_interval) { fetch } unless @reason == 'Unknown symbol'
+        end
   end
 
   before_unmount do
     # just to demonstrate use of before_unmount - this is not needed
     # but if there were some other cleanups you needed you could put them here
     # however intervals (every) delays (after) and websocket receivers are all
     # cleaned up automatically
-    puts "cancelling #{@symbol}"
+    puts "cancelling #{@symbol} ticker"
   end
-
 end

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

@@ -8,6 +8,10 @@ def self.included(base)
         end
       end
 
+      def unmounted?
+        @__hyperstack_internal_auto_unmount_unmounted
+      end
+
       def unmount
         run_callback(:before_unmount)
         AutoUnmount.objects_to_unmount[self].each(&:unmount)
@@ -20,31 +24,29 @@ def unmount
             nil
           end
         end
+        @__hyperstack_internal_auto_unmount_unmounted = true
       end
 
       def every(*args, &block)
+        return if unmounted?
         super.tap do |id|
           sself = self
           id.define_singleton_method(:unmount) { abort }
-          id.define_singleton_method(:manually_unmount) do
-            AutoUnmount.objects_to_unmount[sself].delete(id)
-          end
           AutoUnmount.objects_to_unmount[self] << id
         end
       end
 
       def after(*args, &block)
+        return if unmounted?
         super.tap do |id|
           sself = self
           id.define_singleton_method(:unmount) { abort }
-          id.define_singleton_method(:manually_unmount) do
-            AutoUnmount.objects_to_unmount[sself].delete(id)
-          end
           AutoUnmount.objects_to_unmount[self] << id
         end
       end
 
       def receives(broadcaster, *args, &block)
+        return if unmounted?
         broadcaster.receiver(self, *args, &block).tap do |id|
           # TODO: broadcaster classes should already defined manually_unmount
           # id.define_singleton_method(:manually_unmount) do

ruby/hyper-state/spec/internal/auto_unmount_spec.rb

@@ -18,19 +18,18 @@ def after
   end
 
   %i[every after].each do |meth|
-    it "will pass through to the super class when mounting and abort calls to the #{meth} method when unmounting" do
+    it "will pass through calls to #{meth} to the super class when mounted, and abort calls to the #{meth} method when unmounting" do
       timer = double('timer')
       expect(@async_obj).to receive(:"#{meth}_called").and_return(timer)
       @async_obj.send(meth)
       expect(timer).to receive(:abort)
       @async_obj.unmount
     end
-    it "will not auto_unmount #{meth} objects if requested using the manually_unmount method" do
-      timer = double('timer')
-      expect(@async_obj).to receive(:"#{meth}_called").and_return(timer)
-      @async_obj.send(meth).manually_unmount
-      expect(timer).not_to receive(:abort)
+
+    it "will ignore calls to the #{meth} method once unmounted" do
       @async_obj.unmount
+      expect(@async_obj).not_to receive(:"#{meth}_called")
+      expect(@async_obj.send(meth)).to be_nil
     end
   end
 
@@ -42,6 +41,13 @@ def after
     @async_obj.unmount
   end
 
+  it "will ignore calls to the receives method once unmounted" do
+    broadcaster = double('Broadcaster')
+    @async_obj.unmount
+    expect(@async_obj).not_to receive(:receiver)
+    expect(@async_obj.receives(broadcaster)).to be_nil
+  end
+
   it 'will unmount objects referenced by instance variables' do
     unmountable_object = double('unmountable_object')
     regular_object = double('regular_object')