glimmer 2.2.1 → 2.4.1

data/VERSION

@@ -1 +1 @@
-2.2.1
+2.4.1

data/glimmer.gemspec

@@ -2,17 +2,17 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: glimmer 2.2.1 ruby lib
+# stub: glimmer 2.4.1 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "glimmer".freeze
-  s.version = "2.2.1"
+  s.version = "2.4.1"
 
   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-03"
-  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. 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.".freeze
+  s.date = "2021-11-01"
+  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 = [
     "CHANGELOG.md",
@@ -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

@@ -21,6 +21,7 @@
 
 require 'set'
 require 'glimmer/data_binding/observable'
+require 'glimmer/data_binding/observer'
 require 'array_include_methods'
 
 using ArrayIncludeMethods
@@ -29,29 +30,70 @@ module Glimmer
   module DataBinding
     module ObservableArray
       include Observable
+      
+      class Notifier
+        include Observer
+        
+        attr_reader :observable_array
+        
+        def initialize(observable_array)
+          @observable_array = observable_array
+        end
+        
+        def call(new_value=nil, *extra_args)
+          @observable_array.notify_observers
+        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) }
+        if !options.empty? && options[:recursive].is_a?(Integer)
+          options = options.clone
+          options[:recursive] = options[:recursive] - 1
+        end
+        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
+        if element.is_a?(Array) && (options[:recursive] == true || (options[:recursive].is_a?(Integer) && options[:recursive] >= 0))
+          ensure_array_object_observer(element, options)
+        end
+      end
+      
+      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, options)
+        property_observer_list.each do |observer|
+          my_registration = observer.registration_for(self)
+          observer.add_dependent(my_registration => array_observer_registration)
         end
       end
+      
+      def array_object_observer_for(object)
+        @array_object_observers ||= Concurrent::Hash.new
+        @array_object_observers[object] = Notifier.new(self) unless @array_object_observers.has_key?(object)
+        @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)
@@ -76,6 +118,13 @@ module Glimmer
         element_properties_for(observer).each do |property|
           observer.unobserve(element, property)
         end
+        if element.is_a?(ObservableArray)
+          array_object_observer_for(element).unobserve(element)
+          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
       end
 
       def has_observer?(observer)
@@ -204,6 +253,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
 
@@ -237,6 +287,21 @@ module Glimmer
         end
       end
 
+      def filter!(&block)
+        if block_given?
+          old_array = Array.new(self)
+          super(&block).tap do
+            (old_array - self).each do |old_value|
+              unregister_dependent_observers(old_value)
+              remove_element_observers(old_value)
+            end
+            notify_observers
+          end
+        else
+          super
+        end
+      end
+
       def shuffle!(hash = nil)
         (hash.nil? ? super() : super(random: hash[:random])).tap { notify_observers }
       end
@@ -294,6 +359,17 @@ module Glimmer
         end
       end
       
+      def replace(other_array)
+        old_array = Array.new(self)
+        super(other_array).tap do
+          (old_array - self).each do |old_value|
+            unregister_dependent_observers(old_value)
+            remove_element_observers(old_value)
+          end
+          notify_observers
+        end
+      end
+      
       def unregister_dependent_observers(old_value)
         return unless old_value.is_a?(ObservableModel) || old_value.is_a?(ObservableArray)
         property_observer_list.each { |observer| observer.unregister_dependents_with_observable(observer.registration_for(self), old_value) }

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)
@@ -226,6 +233,25 @@ module Glimmer
         end
       end
       
+      def filter!(&block)
+        if block_given?
+          old_hash = self.dup
+          super(&block).tap do |new_hash|
+            deleted_keys = old_hash.keys - new_hash.keys
+            deleted_keys.each do |deleted_key|
+              deleted_value = old_hash[deleted_key]
+              unless deleted_value.nil?
+                unregister_dependent_observers(deleted_key, deleted_value)
+                unregister_dependent_observers(nil, deleted_value)
+                notify_observers(deleted_key)
+              end
+            end
+          end
+        else
+          super
+        end
+      end
+      
       def keep_if(&block)
         if block_given?
           old_hash = self.dup

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)
@@ -143,14 +144,15 @@ module Glimmer
 
       def array_object_observer_for(property_name)
         @array_object_observers ||= Concurrent::Hash.new
-        @array_object_observers[property_name] = ObservableModel::Notifier.new(self, property_name) unless @array_object_observers.has_key?(property_name)
+        @array_object_observers[property_name] = Notifier.new(self, property_name) unless @array_object_observers.has_key?(property_name)
         @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)
@@ -160,7 +162,7 @@ module Glimmer
 
       def hash_object_observer_for(property_name)
         @hash_object_observers ||= Concurrent::Hash.new
-        @hash_object_observers[property_name] = ObservableModel::Notifier.new(self, property_name) unless @hash_object_observers.has_key?(property_name)
+        @hash_object_observers[property_name] = Notifier.new(self, property_name) unless @hash_object_observers.has_key?(property_name)
         @hash_object_observers[property_name]
       end
     end

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.2.1
+  version: 2.4.1
 platform: ruby
 authors:
 - AndyMaleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-03 00:00:00.000000000 Z
+date: 2021-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: array_include_methods
@@ -203,11 +203,12 @@ dependencies:
       - !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. 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 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.
 email: andy.am@gmail.com
 executables: []
 extensions: []
@@ -263,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