glimmer 2.2.2 → 2.5.0

data/lib/glimmer/data_binding/observer.rb

@@ -46,12 +46,12 @@ module Glimmer
         end
       end
 
-      class Registration < Struct.new(:observer, :observable, :property, keyword_init: true)
-        def unregister
-          observer.unobserve(observable, property)
+      class Registration < Struct.new(:observer, :observable, :args, keyword_init: true)
+        def deregister
+          observer.unobserve(observable, *args)
         end
-        alias unobserve unregister
-        alias deregister unregister
+        alias unregister deregister
+        alias unobserve deregister
       end
 
       class << self
@@ -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 observe(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,43 +94,46 @@ 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
+      alias register observe
 
-      def unregister(observable, property = nil)
+      def unobserve(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
-      alias deregister unregister
+      alias unregister unobserve
+      alias deregister unobserve
 
-      def unregister_dependents_with_observable(registration, dependent_observable)
+      def unobserve_dependents_with_observable(registration, dependent_observable)
         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
+      alias unregister_dependents_with_observable unobserve_dependents_with_observable
+      alias deregister_dependents_with_observable unobserve_dependents_with_observable
 
       # cleans up all registrations in observables
-      def unregister_all_observables
-        registrations.each(&:unregister)
+      def unobserve_all_observables
+        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
+      alias unregister_all_observables unobserve_all_observables
+      alias deregister_all_observables unobserve_all_observables
 
       # add dependent observer to unregister when unregistering observer
       def add_dependent(parent_to_dependent_hash)
@@ -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.2.2
+  version: 2.5.0
 platform: ruby
 authors:
 - AndyMaleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-03 00:00:00.000000000 Z
+date: 2021-11-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: array_include_methods
@@ -192,22 +192,24 @@ dependencies:
   name: rake-tui
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - ">"
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - ">"
       - !ruby/object:Gem::Version
         version: '0'
 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 ObservableModel,
-  ObservableArray, and ObservableHash). Used in the Glimmer DSL for SWT (JRuby Desktop
-  Development GUI Framework), the Glimmer DSL for Tk (Ruby Desktop Development GUI
-  Library), the Glimmer DSL for Opal (Pure Ruby Web GUI and Auto-Webifier of Desktop
-  Apps), the Glimmer DSL for XML (& HTML), and the Glimmer DSL for CSS.
+  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 Opal (Pure Ruby Web GUI and
+  Auto-Webifier of Desktop Apps), Glimmer DSL for Tk (Ruby Desktop Development GUI
+  Library), Glimmer DSL for LibUI (Prerequisite-Free Ruby Desktop Development GUI
+  Library), Glimmer DSL for GTK (Ruby-GNOME Desktop Development GUI Library), Glimmer
+  DSL for XML (& HTML), and Glimmer DSL for CSS.
 email: andy.am@gmail.com
 executables: []
 extensions: []
@@ -229,6 +231,7 @@ files:
 - lib/glimmer/data_binding/observable.rb
 - lib/glimmer/data_binding/observable_array.rb
 - lib/glimmer/data_binding/observable_hash.rb
+- lib/glimmer/data_binding/observable_hashable.rb
 - lib/glimmer/data_binding/observable_model.rb
 - lib/glimmer/data_binding/observer.rb
 - lib/glimmer/data_binding/shine.rb
@@ -263,7 +266,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.28
+rubygems_version: 3.2.31
 signing_key:
 specification_version: 4
 summary: Glimmer - DSL Engine for Ruby GUI and More