glimmer 2.3.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 04a3036ea66bf774c6c27cf8b248e5658df35ccc3a69998159e43a013d3489e0
-  data.tar.gz: 4241bfc406e54c13bbc4357918bf2bfed5a353f63f5200eea6ed60e0f7c84281
+  metadata.gz: f6a8921b091e770dd1acb0528bdf8dad0a63e79290ffb457325abf261b4ac8ca
+  data.tar.gz: 4d530d648577640a25943fb55f61918d352f30e2007f7426b739b877cd6a44a0
 SHA512:
-  metadata.gz: ff74a70f8137ce7967d36e47a191ebdf8efbd67e15724449dd9c5b3a9db04d526a3ab00f4ba484d89af71430ed0543217ac7a0722427b47d735baf3ca4adc524
-  data.tar.gz: f854ebfc523130f308b289fcf575d782776057f4f2d212332d38eeb719444e0d8d7790d0f7e2824059a9bccea1f22be532e1bd55619ba2e66dd585930d4574f5
+  metadata.gz: 68f5e3c05e2381a6f4855cec0832cc983fc74d0dcf27649efaf9e92dd8cf7aa69f9e171494ee1ab17a6a8d68ce0d71cb9ef61521290d999eaa70ad3915b989f2
+  data.tar.gz: 6b3af9b3d411bed16cc9c9f2f227394675fd255098d64729424e31dfdbf1b7e75d8e3aac102016f31c8b729978e33b44fbca1b0dbecec1d1acffea3651dbc468

data/CHANGELOG.md

@@ -3,6 +3,13 @@
 Related Change Logs:
 - [glimmer-dsl-swt/CHANGELOG.md](https://github.com/AndyObtiva/glimmer-dsl-swt/blob/master/CHANGELOG.md)
 
+### 2.4.0
+
+- Support passing arbitrary options to `Observer` `#observe` (`#register`) method (not just properties, like `recursive: true` for example)
+- Make observing nested arrays within an array optional with `recursive: true` option
+- Make `Observer` `dependents` collection rely on Concurrent::Hash when available
+- Fix `Observer` cleanup of registrations and dependents on `#deregister` (was not cleaning up everything because observables were changing `#hash` value on content change and slipping through the cracks as a result)
+
 ### 2.3.0
 
 - Have observing `ObservableArray` automatically notice if any values are nested arrays and observe them for micro-changes (recursively all the way down)

data/README.md

@@ -210,7 +210,7 @@ end
 ### Setup
 
 Follow these steps to author a [Glimmer](https://rubygems.org/gems/glimmer) DSL:
-- Add `gem 'glimmer', '~> 2.3.0'` to `Gemfile` and run `bundle` or run `gem install glimmer -v2.3.0` and add `require 'glimmer'`
+- Add `gem 'glimmer', '~> 2.4.0'` to `Gemfile` and run `bundle` or run `gem install glimmer -v2.4.0` and add `require 'glimmer'`
 - Create `glimmer/dsl/[dsl_name]/dsl.rb`, which requires and adds all dynamic expressions for the [dsl_name] Glimmer DSL module as per the code shown in the previous section (or [Official DSLs](#official-dsls) as examples)
 - Create `glimmer/dsl/[dsl_name]/[expresion_name]_expresion.rb` for every [expresion_name] expression needed, whether dynamic or static
 
@@ -856,7 +856,7 @@ Glimmer app:
 
 ![glimmer dsl tk screenshot sample hello world](https://raw.githubusercontent.com/AndyObtiva/glimmer-dsl-tk/master/images/glimmer-dsl-tk-screenshot-sample-hello-world.png)
 
-###### Hello, Tab!
+###### Hello, Notebook!
 
 Glimmer code (from [samples/hello/hello_tab.rb](https://github.com/AndyObtiva/glimmer-dsl-tk/blob/master/samples/hello/hello_tab.rb)):
 
@@ -864,7 +864,7 @@ Glimmer code (from [samples/hello/hello_tab.rb](https://github.com/AndyObtiva/gl
 include Glimmer
 
 root {
-  title 'Hello, Tab!'
+  title 'Hello, Notebook!'
    
   notebook {
     frame(text: 'English') {
@@ -885,13 +885,13 @@ root {
 Run (with the [glimmer-dsl-tk](https://rubygems.org/gems/glimmer-dsl-tk) gem installed):
 
 ```
-ruby -r glimmer-dsl-tk -e "require '../samples/hello/hello_tab.rb'"
+ruby -r glimmer-dsl-tk -e "require '../samples/hello/hello_notebook.rb'"
 ```
 
 Glimmer app:
 
-![glimmer dsl tk screenshot sample hello tab English](https://raw.githubusercontent.com/AndyObtiva/glimmer-dsl-tk/master/images/glimmer-dsl-tk-screenshot-sample-hello-tab-english.png)
-![glimmer dsl tk screenshot sample hello tab French](https://raw.githubusercontent.com/AndyObtiva/glimmer-dsl-tk/master/images/glimmer-dsl-tk-screenshot-sample-hello-tab-french.png)
+![glimmer dsl tk screenshot sample hello notebook English](https://raw.githubusercontent.com/AndyObtiva/glimmer-dsl-tk/master/images/glimmer-dsl-tk-screenshot-sample-hello-notebook-english.png)
+![glimmer dsl tk screenshot sample hello notebook French](https://raw.githubusercontent.com/AndyObtiva/glimmer-dsl-tk/master/images/glimmer-dsl-tk-screenshot-sample-hello-notebook-french.png)
 
 ###### Hello, Combo!
 
@@ -900,7 +900,7 @@ Glimmer code (from [samples/hello/hello_combo.rb](https://github.com/AndyObtiva/
 ```ruby
 # ... more code precedes
 root {
-  title 'Hello, Combo!'
+  title 'Hello, Combobox!'
   
   combobox { |proxy|
     state 'readonly'
@@ -920,13 +920,13 @@ root {
 Run (with the [glimmer-dsl-tk](https://rubygems.org/gems/glimmer-dsl-tk) gem installed):
 
 ```
-ruby -r glimmer-dsl-tk -e "require '../samples/hello/hello_combo.rb'"
+ruby -r glimmer-dsl-tk -e "require '../samples/hello/hello_combobox.rb'"
 ```
 
 Glimmer app:
 
-![glimmer dsl tk screenshot sample hello combo](https://raw.githubusercontent.com/AndyObtiva/glimmer-dsl-tk/master/images/glimmer-dsl-tk-screenshot-sample-hello-combo.png)
-![glimmer dsl tk screenshot sample hello combo dropdown](https://raw.githubusercontent.com/AndyObtiva/glimmer-dsl-tk/master/images/glimmer-dsl-tk-screenshot-sample-hello-combo-dropdown.png)
+![glimmer dsl tk screenshot sample hello combo](https://raw.githubusercontent.com/AndyObtiva/glimmer-dsl-tk/master/images/glimmer-dsl-tk-screenshot-sample-hello-combobox.png)
+![glimmer dsl tk screenshot sample hello combo dropdown](https://raw.githubusercontent.com/AndyObtiva/glimmer-dsl-tk/master/images/glimmer-dsl-tk-screenshot-sample-hello-combobox-dropdown.png)
 
 #### Glimmer DSL for LibUI (Prerequisite-Free Ruby Desktop Development GUI Library)
 
@@ -1163,7 +1163,7 @@ These are the main classes concerning data-binding:
 - `Glimmer::DataBinding::Observer`: Provides general observer support including unique registration and deregistration for cleanup and prevention of memory leaks. Main methods concerned are: `call`, `register` (alias: `observe`), and `unregister` (alias: `unobserve` or `deregister`)
 - `Glimmer::DataBinding::Observable`: General super-module for all observables. Main methods concerned are: `add_observer` and `remove_observer`
 - `Glimmer::DataBinding::ObservableModel`: Mixin module for any observable model with observable attributes. In addition to `Observable` methods, it has a `notify_observers` method to be called when changes occur. It automatically enhances all attribute setters (ending with `=`) to notify observers on changes. Also, it automatically handles observing array attributes using `ObservableArray` appropriately so they would notify observers upon array mutation changes.
-- `Glimmer::DataBinding::ObservableArray`: Mixin module for any observable array collection that automatically handles notifying observers upon performing array mutation operations (e.g. `push`, `select!`, or `delete`) recursively (meaning if an array contained arrays and they changed, observers are notified)
+- `Glimmer::DataBinding::ObservableArray`: Mixin module for any observable array collection that automatically handles notifying observers upon performing array mutation operations (e.g. `push`, `select!`, or `delete`) recursively (meaning if an array contained arrays and they changed, observers are notified). Accepts `recursive: true` option in `add_observer` method to recursively observe nested arrays all the way down.
 - `Glimmer::DataBinding::ObservableHash`: Mixin module for any observable hash that automatically handles notifying observers upon performing hash mutation operations (e.g. `hash[key]=value`, `select!`, `merge!`)
 - `Glimmer::DataBinding::ModelBinding`: a higher-level abstraction that relies on all the other observer/observable classes to support basic data-binding, nested data-binding, and computed data-binding
 - `Glimmer::DataBinding::Shine`: enables highly intuitive and visually expressive syntax to perform bidirectional (two-way) data-binding with `<=>` and unidirectional (one-way) data-binding with `<=`

data/VERSION

@@ -1 +1 @@
-2.3.0
+2.4.0

data/glimmer.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: glimmer 2.3.0 ruby lib
+# stub: glimmer 2.4.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "glimmer".freeze
-  s.version = "2.3.0"
+  s.version = "2.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["AndyMaleh".freeze]
-  s.date = "2021-10-07"
+  s.date = "2021-10-15"
   s.description = "Glimmer is a Ruby DSL Framework for Ruby GUI and More, consisting of a DSL Engine and an Observable / Observer / Data-Binding Library (including Observable Model, Observable Array, and Observable Hash). Used in Glimmer DSL for SWT (JRuby Desktop Development GUI Framework), Glimmer DSL for Tk (Ruby Desktop Development GUI Library), Glimmer DSL for LibUI (Prerequisite-Free Ruby Desktop Development GUI Library), Glimmer DSL for Opal (Pure Ruby Web GUI and Auto-Webifier of Desktop Apps), Glimmer DSL for XML (& HTML), and Glimmer DSL for CSS.".freeze
   s.email = "andy.am@gmail.com".freeze
   s.extra_rdoc_files = [
@@ -51,7 +51,7 @@ Gem::Specification.new do |s|
   ]
   s.homepage = "http://github.com/AndyObtiva/glimmer".freeze
   s.licenses = ["MIT".freeze]
-  s.rubygems_version = "3.2.28".freeze
+  s.rubygems_version = "3.2.22".freeze
   s.summary = "Glimmer - DSL Engine for Ruby GUI and More".freeze
 
   if s.respond_to? :specification_version then

data/lib/glimmer/data_binding/model_binding.rb

@@ -101,6 +101,10 @@ module Glimmer
       def computed_by
         Concurrent::Array.new([@binding_options[:computed_by]].flatten.compact)
       end
+      
+      def observation_options
+        @binding_options.slice(:recursive)
+      end
 
       def nested_property_observers_for(observer)
         @nested_property_observers_collection ||= Concurrent::Hash.new
@@ -121,7 +125,7 @@ module Glimmer
         @nested_property_observers_collection[observer]
       end
 
-      def add_observer(observer)
+      def add_observer(observer, extra_options = {})
         if computed?
           add_computed_observers(observer)
         elsif nested_property?
@@ -133,19 +137,20 @@ module Glimmer
               apply_processor(@binding_options[:after_read], converted_value)
             end
           end
-          observer_registration = model_binding_observer.observe(model, property_name)
+          observer_registration = model_binding_observer.observe(model, property_name, observation_options)
           my_registration = observer.registration_for(self)
           observer.add_dependent(my_registration => observer_registration)
         end
       end
 
-      def remove_observer(observer)
+      def remove_observer(observer, extra_options = {})
         if computed?
           @computed_model_bindings.each do |computed_model_binding|
             computed_observer_for(observer).unobserve(computed_model_binding)
           end
           @computed_observer_collection.delete(observer)
         elsif nested_property?
+          # No need to call remove_nested_observers(observer) (cleanup happens automatically indirectly when invoked through observer.unobserve(model_binding))
           nested_property_observers_for(observer).clear
         else
           observer.unobserve(model, property_name)
@@ -167,7 +172,7 @@ module Glimmer
 
       def add_computed_observers(observer)
         @computed_model_bindings.each do |computed_model_binding|
-          observer_registration = computed_observer_for(observer).observe(computed_model_binding)
+          observer_registration = computed_observer_for(observer).observe(computed_model_binding, observation_options)
           my_registration = observer.registration_for(self)
           observer.add_dependent(my_registration => observer_registration)
         end
@@ -191,13 +196,13 @@ module Glimmer
           parent_property_name = nil if parent_property_name.to_s.start_with?('[')
           unless model.nil?
             # TODO figure out a way to deal with this more uniformly
-            observer_registration = property_indexed?(property_name) ? nested_property_observer.observe(model) : nested_property_observer.observe(model, property_name)
-            parent_registration = parent_observer.registration_for(parent_model, parent_property_name)
+            observer_registration = property_indexed?(property_name) ? nested_property_observer.observe(model, observation_options) : nested_property_observer.observe(model, property_name, observation_options)
+            parent_registration = parent_observer.registration_for(parent_model, *[parent_property_name].compact)
             parent_observer.add_dependent(parent_registration => observer_registration)
           end
         end
       end
-
+      
       def call(value, *extra_args)
         return if model.nil?
         converted_value = value

data/lib/glimmer/data_binding/observable_array.rb

@@ -45,32 +45,34 @@ module Glimmer
         end
       end
 
-      def add_observer(observer, *element_properties)
+      def add_observer(observer, *args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        element_properties = args
         element_properties = element_properties.flatten.compact.uniq
         return observer if has_observer?(observer) && has_observer_element_properties?(observer, element_properties)
         property_observer_list << observer
         observer_element_properties[observer] = element_properties_for(observer) + Concurrent::Set.new(element_properties)
-        each { |element| add_element_observer(element, observer) }
+        each { |element| add_element_observer(element, observer, options) }
         observer
       end
       
-      def add_element_observers(element)
+      def add_element_observers(element, options = {})
         property_observer_list.each do |observer|
-          add_element_observer(element, observer)
+          add_element_observer(element, observer, options)
         end
       end
 
-      def add_element_observer(element, observer)
+      def add_element_observer(element, observer, options = {})
         element_properties_for(observer).each do |property|
-          observer.observe(element, property)
+          observer.observe(element, property, options)
         end
-        ensure_array_object_observer(element) if element.is_a?(Array)
+        ensure_array_object_observer(element, options) if options[:recursive] && element.is_a?(Array)
       end
       
-      def ensure_array_object_observer(object)
+      def ensure_array_object_observer(object, options)
         return unless object&.is_a?(Array)
         array_object_observer = array_object_observer_for(object)
-        array_observer_registration = array_object_observer.observe(object)
+        array_observer_registration = array_object_observer.observe(object, options)
         property_observer_list.each do |observer|
           my_registration = observer.registration_for(self)
           observer.add_dependent(my_registration => array_observer_registration)
@@ -83,7 +85,9 @@ module Glimmer
         @array_object_observers[object]
       end
 
-      def remove_observer(observer, *element_properties)
+      def remove_observer(observer, *args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        element_properties = args
         element_properties = element_properties.flatten.compact.uniq
         if !element_properties.empty?
           old_element_properties = element_properties_for(observer)
@@ -110,10 +114,8 @@ module Glimmer
         end
         if element.is_a?(ObservableArray)
           array_object_observer_for(element).unobserve(element)
-          element.property_observer_list.select {|o| o.observable_array == self}.each do |o|
-            o.registrations.each do |registration|
-              registration.deregister
-            end
+          element.property_observer_list.select {|o| o.respond_to?(:observable_array) && o.observable_array == self}.each do |o|
+            o.deregister_all_observables
             @array_object_observers.reject! {|k, v| v == o}
           end
         end
@@ -245,6 +247,7 @@ module Glimmer
       alias map! collect!
 
       def compact!
+        # TODO consider checking which exact indices changed and only notifying if there is a change
         super.tap { notify_observers }
       end
 

data/lib/glimmer/data_binding/observable_hash.rb

@@ -62,14 +62,19 @@ module Glimmer
         end
       end
 
-      def add_observer(observer, key = nil)
+      def add_observer(observer, key = nil, options = {})
+        if key.is_a?(Hash)
+          options = key
+          key = nil
+        end
         return observer if has_observer?(observer, key)
         key_observer_list(key) << observer
-        add_key_writer_observer(key)
+        add_key_writer_observer(key, options)
         observer
       end
 
-      def remove_observer(observer, key = nil)
+      def remove_observer(observer, key = nil, options = {})
+        old_value = self[key]
         if has_observer?(observer, key)
           key_observer_list(key).delete(observer)
           observer.unobserve(self, key)
@@ -118,9 +123,9 @@ module Glimmer
         (key_observer_list(key).to_a - all_key_observer_list.to_a).each { |observer| observer.call(self[key], key) }
       end
 
-      def add_key_writer_observer(key = nil)
-        ensure_array_object_observer(key, self[key])
-        ensure_hash_object_observer(key, self[key])
+      def add_key_writer_observer(key = nil, options)
+        ensure_array_object_observer(key, self[key], nil, options)
+        ensure_hash_object_observer(key, self[key], nil, options)
         begin
           method('__original__store')
         rescue
@@ -143,10 +148,11 @@ module Glimmer
       end
       alias deregister_dependent_observers unregister_dependent_observers
 
-      def ensure_array_object_observer(key, object, old_object = nil)
+      def ensure_array_object_observer(key, object, old_object = nil, options = {})
+        options ||= {}
         return unless object&.is_a?(Array)
         array_object_observer = array_object_observer_for(key)
-        array_observer_registration = array_object_observer.observe(object)
+        array_observer_registration = array_object_observer.observe(object, options)
         key_observer_list(key).each do |observer|
           my_registration = observer.registration_for(self, key) # TODO eliminate repetition
           observer.add_dependent(my_registration => array_observer_registration)
@@ -160,10 +166,11 @@ module Glimmer
         @array_object_observers[key]
       end
       
-      def ensure_hash_object_observer(key, object, old_object = nil)
+      def ensure_hash_object_observer(key, object, old_object = nil, options = {})
+        options ||= {}
         return unless object&.is_a?(Hash)
         hash_object_observer = hash_object_observer_for(key)
-        hash_observer_registration = hash_object_observer.observe(object)
+        hash_observer_registration = hash_object_observer.observe(object, options)
         key_observer_list(key).each do |observer|
           my_registration = observer.registration_for(self, key) # TODO eliminate repetition
           observer.add_dependent(my_registration => hash_observer_registration)

data/lib/glimmer/data_binding/observable_model.rb

@@ -52,14 +52,14 @@ module Glimmer
         end
       end
 
-      def add_observer(observer, property_name)
+      def add_observer(observer, property_name, options = {})
         return observer if has_observer?(observer, property_name)
         property_observer_list(property_name) << observer
-        add_property_writer_observers(property_name)
+        add_property_writer_observers(property_name, options)
         observer
       end
 
-      def remove_observer(observer, property_name)
+      def remove_observer(observer, property_name, options = {})
         if has_observer?(observer, property_name)
           property_observer_list(property_name).delete(observer)
           observer.unobserve(self, property_name)
@@ -103,11 +103,11 @@ module Glimmer
         property_observer_list(property_name).to_a.each { |observer| observer.call(send(property_name)) }
       end
 
-      def add_property_writer_observers(property_name)
+      def add_property_writer_observers(property_name, options)
         property_writer_name = "#{property_name}="
         method(property_writer_name)
-        ensure_array_object_observer(property_name, send(property_name))
-        ensure_hash_object_observer(property_name, send(property_name))
+        ensure_array_object_observer(property_name, send(property_name), nil, options)
+        ensure_hash_object_observer(property_name, send(property_name), nil, options)
         begin
           method("__original__#{property_writer_name}")
         rescue
@@ -130,10 +130,11 @@ module Glimmer
       end
       alias deregister_dependent_observers unregister_dependent_observers
 
-      def ensure_array_object_observer(property_name, object, old_object = nil)
+      def ensure_array_object_observer(property_name, object, old_object = nil, options = {})
+        options ||= {}
         return unless object&.is_a?(Array)
         array_object_observer = array_object_observer_for(property_name)
-        array_observer_registration = array_object_observer.observe(object)
+        array_observer_registration = array_object_observer.observe(object, options)
         property_observer_list(property_name).each do |observer|
           my_registration = observer.registration_for(self, property_name) # TODO eliminate repetition
           observer.add_dependent(my_registration => array_observer_registration)
@@ -147,10 +148,11 @@ module Glimmer
         @array_object_observers[property_name]
       end
       
-      def ensure_hash_object_observer(property_name, object, old_object = nil)
+      def ensure_hash_object_observer(property_name, object, old_object = nil, options)
+        options ||= {}
         return unless object&.is_a?(Hash)
         hash_object_observer = hash_object_observer_for(property_name)
-        hash_observer_registration = hash_object_observer.observe(object)
+        hash_observer_registration = hash_object_observer.observe(object, options)
         property_observer_list(property_name).each do |observer|
           my_registration = observer.registration_for(self, property_name) # TODO eliminate repetition
           observer.add_dependent(my_registration => hash_observer_registration)

data/lib/glimmer/data_binding/observer.rb

@@ -46,9 +46,9 @@ module Glimmer
         end
       end
 
-      class Registration < Struct.new(:observer, :observable, :property, keyword_init: true)
+      class Registration < Struct.new(:observer, :observable, :args, keyword_init: true)
         def unregister
-          observer.unobserve(observable, property)
+          observer.unobserve(observable, *args)
         end
         alias unobserve unregister
         alias deregister unregister
@@ -61,29 +61,31 @@ module Glimmer
       end
 
       def registrations
-        @registrations ||= Concurrent::Set.new
+        @registrations ||= Concurrent::Hash.new
       end
 
-      def registration_for(observable, property = nil)
-        Registration.new(observer: self, observable: observable, property: property)
+      def registration_for(observable, *args)
+        args = compact_args(args)
+        registrations[[observable.object_id, args]] ||= Registration.new(observer: self, observable: observable, args: args)
       end
+      alias ensure_registration_for! registration_for
 
       # mapping of registrations to dependents
       # {[observable, property] => [[dependent, dependent_observable, dependent_property], ...]}
       def dependents
-        @dependents ||= Hash.new
+        @dependents ||= Concurrent::Hash.new
       end
 
       def dependents_for(registration)
-        dependents[registration] ||= Concurrent::Set.new
+        dependents[registration.object_id] ||= Concurrent::Set.new
       end
 
-      # registers observer in an observable on a property (optional)
+      # registers observer in an observable on args usually containing a property and options (optional)
       # observer maintains registration list to unregister later
-      def register(observable, property = nil)
+      def register(observable, *args)
         return if observable.nil?
         unless observable.is_a?(Observable)
-          # TODO refactor code to be more smart/polymorphic/automated and honor open/closed principle
+          # TODO refactor code to be more smart/polymorphic/automated and honor open/closed principle (e.g. for SomeClass, search if there is ObservableSomeClass)
           if observable.is_a?(Array)
             observable.extend(ObservableArray)
           elsif observable.is_a?(Hash)
@@ -92,23 +94,23 @@ module Glimmer
             observable.extend(ObservableModel)
           end
         end
-        observable.add_observer(*[self, property].compact)
-        registration_for(observable, property).tap do |registration|
-          self.registrations << registration
-        end
+        args = compact_args(args)
+        observable.add_observer(self, *args)
+        ensure_registration_for!(observable, *args)
       end
       alias observe register
 
-      def unregister(observable, property = nil)
+      def unregister(observable, *args)
         return unless observable.is_a?(Observable)
-        # TODO optimize performance in the future via indexing and/or making a registration official object/class
-        registration = registration_for(observable, property)
-        dependents_for(registration).each do |dependent|
-          dependent.unregister
-          remove_dependent(registration => dependent)
-        end
-        registrations.delete(registration).tap do |registration|
-          observable.remove_observer(*[self, property].compact)
+        args = compact_args(args)
+        registration = registration_for(observable, *args)
+        registrations.delete([observable.object_id, args])
+        registration.tap do |registration|
+          dependents_for(registration).each do |dependent|
+            remove_dependent(registration => dependent)
+            dependent.deregister if dependent != registration
+          end
+          observable.remove_observer(self, *args)
         end
       end
       alias unobserve unregister
@@ -118,14 +120,17 @@ module Glimmer
         thedependents = dependents_for(registration).select do |thedependent|
           thedependent.observable == dependent_observable
         end
-        thedependents.each(&:unregister)
+        thedependents.each(&:deregister)
       end
       alias unobserve_dependents_with_observable unregister_dependents_with_observable
       alias deregister_dependents_with_observable unregister_dependents_with_observable
 
       # cleans up all registrations in observables
       def unregister_all_observables
-        registrations.each(&:unregister)
+        registrations.values.dup.each do |registration|
+          registration.deregister
+          registrations.delete([registration.observable.object_id, registration.args])
+        end
       end
       alias unobserve_all_observables unregister_all_observables
       alias deregister_all_observables unregister_all_observables
@@ -140,12 +145,20 @@ module Glimmer
       def remove_dependent(parent_to_dependent_hash)
         registration = parent_to_dependent_hash.keys.first
         dependent = parent_to_dependent_hash.values.first
-        dependents_for(registration).delete(dependent)
+        dependents_for(registration).delete(dependent).tap do
+          dependents.delete([registration.object_id]) if dependents_for(registration).empty?
+        end
       end
 
       def call(new_value = nil, *extra_args)
         raise Error, 'Not implemented!'
       end
+      
+      def compact_args(args)
+        args = args[0...-1] if args.last == {}
+        args = args[0...-1] if args.last == []
+        args.compact
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glimmer
 version: !ruby/object:Gem::Version
-  version: 2.3.0
+  version: 2.4.0
 platform: ruby
 authors:
 - AndyMaleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-07 00:00:00.000000000 Z
+date: 2021-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: array_include_methods
@@ -264,7 +264,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.28
+rubygems_version: 3.2.22
 signing_key:
 specification_version: 4
 summary: Glimmer - DSL Engine for Ruby GUI and More