observers 0.5.3 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3ab0c93bff9df65a8fcf5bf39a6196ac9f4be51bf823dfc7eeabebe0d2ec21e8
-  data.tar.gz: ec0de69288f9ea75794b5027d4eb1df90810c399310fcc43dfac873ae6accee0
+  metadata.gz: e2d0c58f136cc23164aa0cf64ded4ff642c86d8f82842fedaf459a0205024b17
+  data.tar.gz: 4ab7392ec00ad1fcb13ad891051c807c40c496037bcd6e730c9692f9c6acfdbb
 SHA512:
-  metadata.gz: d09f8cd88c509452aa3d9627f3326a7fb2ba3120a938fa8b32b397f64908bb668f52d5750527f96d70ee140071c220693e7f916908dfac09a2e0b1521e624aa1
-  data.tar.gz: 4ac4a3bddaf49ae0e000fd44402e3c9cca88e3078dab7a7e9b02046d6cf4246c8a9ece9c8dcc8b5d5795c5fe531991478383d6db2739cbe3dc7ef3aa03069149
+  metadata.gz: fb4a46da4a46c8036f5f8acdebff74817138eb3566db27e929054d4b6d4670715324cb31cead6371bcd45b6f1ea11b927aadb8508dc5707bd417a8c6d7631e2b
+  data.tar.gz: e30650c3284a90f0a94c6fbf80ab0aa549e8676b2f93531d4d99da16944f4e0fa70922a220c224b41ccf8e839dfa01b2162a08c936a56c12350e1b6445a9c232

data/lib/keys.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative 'models/key'
+
+module Observers
+  class Keys
+    class << self
+      def [](key)
+        keys[key] ||= Key.new(key:)
+      end
+
+      def keys
+        @keys ||= {}
+        @keys
+      end
+
+      def reset
+        @keys = {}
+      end
+    end
+  end
+end

data/lib/models/{observable.rb → key.rb}

@@ -1,19 +1,24 @@
 # frozen_string_literal: true
 
 module Observers
-  class Observable
+  class Key
     attr_reader :observers
 
-    def initialize
+    def initialize(key:)
+      @key = key
       @observers = []
     end
 
     def observe(object:, action:)
+      # TODO: We can observe objects directly, no need to wrap in an observer... no need to let the object's observer override the action?
+      # A future reason I can think of for keeping observer wrapper is to track whether the object has implemented certain actions/methods.
       @observers << Observer.new(object:, action:)
     end
 
     # @returns: The result of the last observer with a non-nil value.
-    def trigger(action:, event:)
+    def trigger(action: nil, event: nil)
+      key_callback
+
       action = event.action if event && action.nil?
       action = :handle if action.nil?
 
@@ -22,22 +27,32 @@ module Observers
       @observers.each do |observer|
         result = observer.trigger(action:, event:)
         last_result = result unless result.nil?
+        yield if block_given?
       end
 
       last_result
     end
 
     # @returns: The result of the first observer with a non-nil value.
-    def take(action:, event:)
+    def take(action: nil, event: nil)
+      key_callback
+
       action = event.action if event && action.nil?
       action = :handle if action.nil?
 
       @observers.each do |observer|
         result = observer.trigger(action:, event:)
+        yield if block_given?
         return result unless result.nil?
       end
 
       nil # This is a bad day for the take method, one of the worst.
     end
+
+    private
+
+    def key_callback
+      Observers.config.key_callback.call(@key) if Observers.config.key_callback && @observers.empty?
+    end
   end
 end

data/lib/observers.rb

@@ -1,44 +1,53 @@
 # frozen_string_literal: true
 
-require_relative 'observables'
+require_relative 'keys'
 require_relative 'models/observer'
 
 module Observers
+  Config = Struct.new(:key_callback)
+
   class << self
+    def [](key)
+      Keys[key].observers
+    end
+
     def included(klass)
       klass.extend Observers
     end
+
+    def config
+      @config ||= Config.new(key_callback: nil)
+    end
+
+    def configure
+      yield(config)
+    end
   end
 
-  # Add an observer on the observable side.
   def observers(key = self)
     Struct.new(:key) do
       def push(object, action: nil)
-        Observables[key].observe(object:, action:)
+        Keys[key].observe(object:, action:)
       end
       alias :<< :push
 
       def count
-        Observables[key].observers.count
+        Keys[key].observers.count
       end
     end.new(key)
   end
 
-  # Add an observer on the observer side.
   def observe(key, action: nil)
-    Observables[key].observe(object: self, action:)
+    Keys[key].observe(object: self, action:)
   end
 
-  def trigger(key = self, action: nil, event: nil)
-    Observables.fetch(key).trigger(action:, event:)
+  def trigger(key: self, action: nil, event: nil)
+    Keys[key].trigger(action:, event:)
   end
 
-  def take(key = self, action: nil, event: nil)
-    Observables.fetch(key).take(action:, event:)
+  def take(key: self, action: nil, event: nil)
+    Keys[key].take(action:, event:)
   end
 
   # TODO: Provide a "pipe/port/take" method that uses ractors to be concurrent... if supplied with immutable Data?
 end
-
-# For quick debugging, not official API.
-OOO = Observers::Observables.observables unless defined?(OOO)

data/lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Observers
-  VERSION = '0.5.3'
+  VERSION = '0.7.0'
 end

metadata

@@ -1,28 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: observers
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.7.0
 platform: ruby
 authors:
 - maedi
 bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: low_dependency
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
+dependencies: []
 description: Observe events for objects of any kind
 email:
 - maediprichard@gmail.com
@@ -30,9 +16,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- lib/models/observable.rb
+- lib/keys.rb
+- lib/models/key.rb
 - lib/models/observer.rb
-- lib/observables.rb
 - lib/observers.rb
 - lib/version.rb
 homepage: https://github.com/maedi/observers
@@ -54,7 +40,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.7.2
+rubygems_version: 4.0.6
 specification_version: 4
 summary: Observe objects of any kind
 test_files: []

data/lib/observables.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'models/observable'
-
-module Observers
-  class Observables
-    class MissingKeyError < StandardError; end
-
-    class << self
-      def observables
-        @observables ||= {}
-        @observables
-      end
-
-      def fetch(key)
-        # TODO: Log instead per configuration, much better to fail silently sometimes!
-        observables[key] || raise(MissingKeyError, "Observable key '#{key}' not found")
-      end
-
-      def [](key)
-        observables[key] || upsert(key:)
-      end
-
-      def upsert(key:)
-        observables[key] = Observable.new if observables[key].nil?
-        observables[key]
-      end
-
-      def reset
-        @observables = {}
-      end
-    end
-  end
-end