glimmer 2.4.0 → 2.5.3

data/lib/glimmer/data_binding/observable_model.rb

@@ -19,13 +19,13 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-require 'glimmer/data_binding/observable'
+require 'glimmer/data_binding/observable_hashable'
 require 'glimmer/data_binding/observer'
 
 module Glimmer
   module DataBinding
     module ObservableModel
-      include Observable
+      include ObservableHashable
 
       class Notifier
         include Observer
@@ -40,25 +40,26 @@ module Glimmer
         end
       end
       
-      PROPERTY_WRITER_FACTORY = lambda do |property_name|
+      PROPERTY_WRITER_FACTORY = lambda do |property_name, options|
         property_writer_name = "#{property_name}="
         lambda do |value|
           old_value = self.send(property_name)
-          unregister_dependent_observers(property_name, old_value) # remove dependent observers previously installed in ensure_array_object_observer and ensure_hash_object_observer
+          unregister_dependent_observers(property_name, old_value) # remove dependent observers previously installed in ensure_array_object_observer
           self.send("__original__#{property_writer_name}", value)
           notify_observers(property_name)
-          ensure_array_object_observer(property_name, value, old_value)
-          ensure_hash_object_observer(property_name, value, old_value)
+          ensure_array_object_observer(property_name, value, old_value, options)
         end
       end
-
+      
       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, options)
+        open_struct_loaded = !!::OpenStruct rescue false
+        add_key_writer_observer(property_name, options) if is_a?(Struct) || (open_struct_loaded && is_a?(OpenStruct))
         observer
       end
-
+      
       def remove_observer(observer, property_name, options = {})
         if has_observer?(observer, property_name)
           property_observer_list(property_name).delete(observer)
@@ -67,10 +68,11 @@ module Glimmer
       end
 
       def remove_observers(property_name)
-        property_observer_hash[property_name.to_sym].each do |observer|
+        property_key = property_name&.to_sym
+        property_observer_hash[property_key].each do |observer|
           remove_observer(observer, property_name)
         end
-        property_observer_hash.delete(property_name.to_sym)
+        property_observer_hash.delete(property_key)
       end
 
       def remove_all_observers
@@ -91,28 +93,36 @@ module Glimmer
       end
 
       def property_observer_hash
-        @property_observers ||= Hash.new
+        @property_observers ||= Concurrent::Hash.new
       end
 
       def property_observer_list(property_name)
-        property_observer_hash[property_name.to_sym] = Concurrent::Set.new unless property_observer_hash[property_name.to_sym]
-        property_observer_hash[property_name.to_sym]
+        property_key = property_name&.to_sym
+        property_observer_hash[property_key] = Concurrent::Set.new unless property_observer_hash[property_key]
+        property_observer_hash[property_key]
       end
+      alias key_observer_list property_observer_list
+      
+      def all_property_observer_list
+        property_observer_list(nil)
+      end
+      alias all_key_observer_list all_property_observer_list
 
       def notify_observers(property_name)
         property_observer_list(property_name).to_a.each { |observer| observer.call(send(property_name)) }
       end
-
+      
       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), nil, options)
-        ensure_hash_object_observer(property_name, send(property_name), nil, options)
         begin
           method("__original__#{property_writer_name}")
         rescue
           define_singleton_method("__original__#{property_writer_name}", property_writer_method(property_writer_name))
-          define_singleton_method(property_writer_name, &PROPERTY_WRITER_FACTORY.call(property_name))
+          # Note the limitation that the first observe call options apply to all subsequent observations meaning even if unobserve was called, options do not change from initial ones
+          # It is good enough for now. If there is a need to address this in the future, this is where to start the work
+          define_singleton_method(property_writer_name, &PROPERTY_WRITER_FACTORY.call(property_name, options))
         end
       rescue => e
         #ignore writing if no property writer exists
@@ -130,7 +140,7 @@ module Glimmer
       end
       alias deregister_dependent_observers unregister_dependent_observers
 
-      def ensure_array_object_observer(property_name, object, old_object = nil, options = {})
+      def ensure_array_object_observer(property_name, object, old_object = nil, options = nil)
         options ||= {}
         return unless object&.is_a?(Array)
         array_object_observer = array_object_observer_for(property_name)
@@ -147,24 +157,6 @@ module Glimmer
         @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, 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, 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)
-        end
-        hash_object_observer_for(property_name).unregister(old_object) if old_object.is_a?(ObservableHash)
-      end
-
-      def hash_object_observer_for(property_name)
-        @hash_object_observers ||= Concurrent::Hash.new
-        @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
   end
 end

data/lib/glimmer/data_binding/observer.rb

@@ -47,11 +47,11 @@ module Glimmer
       end
 
       class Registration < Struct.new(:observer, :observable, :args, keyword_init: true)
-        def unregister
+        def deregister
           observer.unobserve(observable, *args)
         end
-        alias unobserve unregister
-        alias deregister unregister
+        alias unregister deregister
+        alias unobserve deregister
       end
 
       class << self
@@ -82,8 +82,10 @@ module Glimmer
 
       # registers observer in an observable on args usually containing a property and options (optional)
       # observer maintains registration list to unregister later
-      def register(observable, *args)
+      def observe(observable, *args)
+        options = args.last.is_a?(Hash) ? args.last : {}
         return if observable.nil?
+        return if options[:ignore_frozen] && observable.frozen?
         unless observable.is_a?(Observable)
           # 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)
@@ -98,9 +100,9 @@ module Glimmer
         observable.add_observer(self, *args)
         ensure_registration_for!(observable, *args)
       end
-      alias observe register
+      alias register observe
 
-      def unregister(observable, *args)
+      def unobserve(observable, *args)
         return unless observable.is_a?(Observable)
         args = compact_args(args)
         registration = registration_for(observable, *args)
@@ -113,27 +115,27 @@ module Glimmer
           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(&: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
+      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)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glimmer
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 2.5.3
 platform: ruby
 authors:
 - AndyMaleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-15 00:00:00.000000000 Z
+date: 2021-12-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: array_include_methods
@@ -192,23 +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 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.
+  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: []
@@ -230,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