signalize 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f252599b06ea9725abc4dd66d0b23562cd5b245dd970106c441b22a0890fe42
-  data.tar.gz: 1e46dc796f6bd28fc80292d0ef526ab5691642ec1fb34d213e547a9b9a0b3b22
+  metadata.gz: 4e4f4fc25e9d3e2f4e343a22ecd6bf37daa4628da775f9c5d7709177881c927e
+  data.tar.gz: e91df598b0d5c11a6f4a803481e3fabb8476e59ac873c6fa8d0e2f57d3851cae
 SHA512:
-  metadata.gz: b4eb905112dc61711495cca9cca462f37a1a50751b7d0434fd15b916276af57c73e08ac055d14d0e45534e8d82e8a2ad1576197772ffd544036cccc27d548c72
-  data.tar.gz: 8e4bf5a24a1ede2912a1f0b9265598d616829d2d9b0ef28eece14dbb5859d1c1fd75c8a19bbe3eb6ee9bb5922b65a5079e7d578cc75788cac4d13f0f18aca247
+  metadata.gz: d9bb28f9f5e35093aaf5567df71a9f8c05edd1467c5788f6afd7a4678790a9bd6a8f08c2296641a9bc7bed8c303da594b17ee308f7b57dcb6754d1bc6a9a7451
+  data.tar.gz: a85f5867add9ecce1cad3bb7bcc9cd975c69097436ec8d9bfccdc260245aa1c5c93f1031b4aa0337cc144ad5453bc4a67ec71611b8dad850e17481d614b5b5c6

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    signalize (1.0.0)
+    signalize (1.0.1)
 
 GEM
   remote: https://rubygems.org/
@@ -44,6 +44,7 @@ GEM
 
 PLATFORMS
   arm64-darwin-21
+  x86_64-linux
 
 DEPENDENCIES
   guard

data/README.md

@@ -32,6 +32,8 @@ Signalize's public API consists of four methods (you can think of them almost li
 The first building block is the `Signalize::Signal` class. You can think of this as a reactive value object which wraps an underlying primitive like String, Integer, Array, etc.
 
 ```ruby
+require "signalize"
+
 counter = Signalize.signal(0)
 
 # Read value from signal, logs: 0
@@ -44,6 +46,7 @@ counter.value = 1
 You can include the `Signalize::API` mixin to access these methods directly in any context:
 
 ```ruby
+require "signalize"
 include Signalize::API
 
 counter = signal(0)
@@ -56,6 +59,7 @@ counter.value += 1
 You derive computed state by accessing a signal's value within a `computed` block and returning a new value. Every time that signal value is updated, a computed value will likewise be updated. Actually, that's not quite accurate — the computed value only computes when it's read. In this sense, we can call computed values "lazily-evaluated".
 
 ```ruby
+require "signalize"
 include Signalize::API
 
 name = signal("Jane")
@@ -82,6 +86,7 @@ puts full_name.value
 Effects are callbacks which are executed whenever values which the effect has "subscribed" to by referencing them have changed. An effect callback is run immediately when defined, and then again for any future mutations.
 
 ```ruby
+require "signalize"
 include Signalize::API
 
 name = signal("Jane")
@@ -99,6 +104,7 @@ name.value = "John"
 You can dispose of an effect whenever you want, thereby unsubscribing it from signal notifications.
 
 ```ruby
+require "signalize"
 include Signalize::API
 
 name = signal("Jane")
@@ -117,11 +123,62 @@ dispose.()
 surname.value = "Doe 2"
 ```
 
+**IMPORTANT:** you cannot use `return` or `break` within an effect block. Doing so will raise an exception (due to it breaking the underlying execution model).
+
+```ruby
+def my_method(signal_obj)
+  effect do
+    return if signal_obj.value > 5 # DON'T DO THIS!
+
+    puts signal_obj.value
+  end
+
+  # more code here
+end
+```
+
+Instead, try to resolve it using more explicit logic:
+
+```ruby
+def my_method(signal_obj)
+  should_exit = false
+
+  effect do
+    should_exit = true && next if signal_obj.value > 5
+
+    puts signal_obj.value
+  end
+
+  return if should_exit
+
+  # more code here
+end
+```
+
+However, there's no issue if you pass in a method proc directly:
+
+```ruby
+def my_method(signal_obj)
+  @signal_obj = signal_obj
+
+  effect &method(:an_effect_method)
+
+  # more code here
+end
+
+def an_effect_method
+  return if @signal_obj.value > 5
+
+  puts @signal_obj.value
+end
+```
+
 ### `batch { }`
 
-You can write to  multiple signals within a batch, and flush the updates at all once (thereby notifying computed refreshes and effects).
+You can write to multiple signals within a batch, and flush the updates at all once (thereby notifying computed refreshes and effects).
 
 ```ruby
+require "signalize"
 include Signalize::API
 
 name = signal("Jane")
@@ -132,8 +189,8 @@ full_name = computed { name.value + " " + surname.value }
 dispose = effect { puts full_name.value }
 
 batch do
-	name.value = "Foo"
-	surname.value = "Bar"
+  name.value = "Foo"
+  surname.value = "Bar"
 end
 ```
 
@@ -142,6 +199,7 @@ end
 You can explicitly subscribe to a signal signal value and be notified on every change. (Essentially the Observable pattern.) In your block, the new signal value will be supplied as an argument.
 
 ```ruby
+require "signalize"
 include Signalize::API
 
 counter = signal(0)
@@ -158,17 +216,18 @@ counter.value = 1 # logs the new value
 If you need to access a signal's value inside an effect without subscribing to that signal's updates, use the `peek` method instead of `value`.
 
 ```ruby
+require "signalize"
 include Signalize::API
 
 counter = signal(0)
 effect_count = signal(0)
 
 effect do
-	puts counter.value
+  puts counter.value
 
-	# Whenever this effect is triggered, increase `effect_count`.
-	# But we don't want this signal to react to `effect_count`
-	effect_count.value = effect_count.peek
+  # Whenever this effect is triggered, increase `effect_count`.
+  # But we don't want this signal to react to `effect_count`
+  effect_count.value = effect_count.peek + 1
 end
 ```
 

data/lib/signalize/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Signalize
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

data/lib/signalize.rb

@@ -17,7 +17,7 @@ module Signalize
   end
 
   def self.cycle_detected
-	  raise "Cycle detected"
+	  raise Signalize::Error, "Cycle detected"
   end
 
   RUNNING = 1 << 0
@@ -339,7 +339,7 @@ module Signalize
     end
 
     def end_effect(effect, prev_context, *_) # allow additional args for currying
-      raise "Out-of-order effect" if eval_context != effect
+      raise Signalize::Error, "Out-of-order effect" if eval_context != effect
 
       cleanup_sources(effect)
       self.eval_context = prev_context
@@ -586,8 +586,13 @@ module Signalize
       finis = _start
 
       begin
+        compute_executed = false
         @_cleanup = _compute.() if (@_flags & DISPOSED).zero? && @_compute.nil?.!
+        compute_executed = true
       ensure
+        unless compute_executed
+          raise Signalize::Error, "Early return or break detected in effect block"
+        end
         finis.(nil) # TODO: figure out this weird shit
       end
     end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: signalize
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Jared White
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-08 00:00:00.000000000 Z
+date: 2023-03-09 00:00:00.000000000 Z
 dependencies: []
 description: A Ruby port of Signals, providing reactive variables, derived computed
   state, side effect callbacks, and batched updates.