signalize 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f252599b06ea9725abc4dd66d0b23562cd5b245dd970106c441b22a0890fe42
-  data.tar.gz: 1e46dc796f6bd28fc80292d0ef526ab5691642ec1fb34d213e547a9b9a0b3b22
+  metadata.gz: 023d2e474c347003b12bef1210945016175838261a5761dae81cb90d749fe51b
+  data.tar.gz: 04adf75c67d46adf30fabfdf996eea3ef1555678f96189444d32355571c5d12d
 SHA512:
-  metadata.gz: b4eb905112dc61711495cca9cca462f37a1a50751b7d0434fd15b916276af57c73e08ac055d14d0e45534e8d82e8a2ad1576197772ffd544036cccc27d548c72
-  data.tar.gz: 8e4bf5a24a1ede2912a1f0b9265598d616829d2d9b0ef28eece14dbb5859d1c1fd75c8a19bbe3eb6ee9bb5922b65a5079e7d578cc75788cac4d13f0f18aca247
+  metadata.gz: 1c6cc8aad7188bde45f3c5e535d8a7c9ceb17e0598f35ebe45791cf194b8489e799fb32680c130f4bd3f0c06e399ae900bfa8dd103fd7431fe779856fb1685cc
+  data.tar.gz: e3eacdfae3cecd69c3b17158e4ae5610119d83e778e369479c487a1ac42e88dcb554cb9c3389cf4d1e1689a337f1bab2f0e02230d6a22b59df3b4bb2993069c3

data/CHANGELOG.md

@@ -1,5 +1,17 @@
+# Changelog
+
 ## [Unreleased]
 
+## [1.1.0] - 2023-03-25
+
+- Provide better signal/computed inspect strings (fixes #1)
+- Use Concurrent::Map for thread-safe globals (fixes #3)
+
+## [1.0.1] - 2023-03-08
+
+- Prevent early returns in effect blocks
+- Use gem's error class (fixes #2)
+
 ## [1.0.0] - 2023-03-07
 
 - Initial release

data/Gemfile.lock

@@ -1,12 +1,14 @@
 PATH
   remote: .
   specs:
-    signalize (1.0.0)
+    signalize (1.1.0)
+      concurrent-ruby (~> 1.2)
 
 GEM
   remote: https://rubygems.org/
   specs:
     coderay (1.1.3)
+    concurrent-ruby (1.2.2)
     ffi (1.15.5)
     formatador (1.1.0)
     guard (2.18.0)
@@ -44,6 +46,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
 ```
 
@@ -189,7 +248,3 @@ This project is intended to be a safe, welcoming space for collaboration, and co
 ## License
 
 The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
-
-## Code of Conduct
-
-Everyone interacting in the Signalize project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/whitefusionhq/signalize/blob/main/CODE_OF_CONDUCT.md).

data/lib/signalize/version.rb

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

data/lib/signalize.rb

@@ -1,23 +1,24 @@
 # frozen_string_literal: true
 
+require "concurrent"
 require_relative "signalize/version"
 
 module Signalize
   class Error < StandardError; end
 
   class << self
-    def class_variablize(name)
+    def global_map_accessor(name)
       define_singleton_method "#{name}" do
-        class_variable_get("@@#{name}")
+        GLOBAL_MAP[name]
       end
       define_singleton_method "#{name}=" do |value|
-        class_variable_set("@@#{name}", value)
+        GLOBAL_MAP[name] = value
       end
     end
   end
 
   def self.cycle_detected
-	  raise "Cycle detected"
+	  raise Signalize::Error, "Cycle detected"
   end
 
   RUNNING = 1 << 0
@@ -27,24 +28,26 @@ module Signalize
   HAS_ERROR = 1 << 4
   TRACKING = 1 << 5
 
+  GLOBAL_MAP = Concurrent::Map.new
+
   # Computed | Effect | nil
-  @@eval_context = nil
-  class_variablize :eval_context
+  global_map_accessor :eval_context
+  self.eval_context = nil
 
   # Effects collected into a batch.
-  @@batched_effect = nil
-  class_variablize :batched_effect
-  @@batch_depth = 0
-  class_variablize :batch_depth
-  @@batch_iteration = 0
-  class_variablize :batch_iteration
+  global_map_accessor :batched_effect
+  self.batched_effect = nil
+  global_map_accessor :batch_depth
+  self.batch_depth = 0
+  global_map_accessor :batch_iteration
+  self.batch_iteration = 0
 
   # NOTE: we have removed the global version optimization for Ruby, due to
   # the possibility of long-running server processes and the number reaching
   # a dangerously high integer value.
   #
-  # @@global_version = 0  
-  # class_variablize :global_version
+  # global_map_accessor :global_version
+  # self.global_version = 0
 
   Node = Struct.new(
     :_version,
@@ -339,7 +342,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
@@ -436,6 +439,10 @@ module Signalize
     end
 
     def peek = @value
+
+    def inspect
+      "#<#{self.class} value: #{peek.inspect}>"
+    end
   end
 
   class Computed < Signal
@@ -586,8 +593,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

data/signalize.gemspec

@@ -27,7 +27,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
+  spec.add_dependency "concurrent-ruby", "~> 1.2"
 
   # For more information and examples about making a new gem, check out our
   # guide at: https://bundler.io/guides/creating_gem.html

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: signalize
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Jared White
@@ -9,8 +9,22 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-08 00:00:00.000000000 Z
-dependencies: []
+date: 2023-03-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
 description: A Ruby port of Signals, providing reactive variables, derived computed
   state, side effect callbacks, and batched updates.
 email: