glimmer 2.3.0 → 2.5.1

data/lib/glimmer/data_binding/model_binding.rb

@@ -30,9 +30,9 @@ module Glimmer
 
       attr_reader :binding_options, :property_name_expression
 
-      def initialize(base_model, property_name_expression, binding_options = nil)
-        @base_model = base_model
-        @property_name_expression = property_name_expression
+      def initialize(*args)
+        binding_options = args.pop if args.size > 1 && args.last.is_a?(Hash)
+        @base_model, @property_name_expression = args
         @binding_options = binding_options || Concurrent::Hash.new
         if computed?
           @computed_model_bindings = Concurrent::Array.new(computed_by.map do |computed_by_property_expression|
@@ -91,7 +91,7 @@ module Glimmer
       end
 
       def nested_property?
-        property_name_expression.match(/[.\[]/)
+        property_name_expression.to_s.match(/[.\[]/)
       end
 
       def computed?
@@ -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].compact)
           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,17 +196,17 @@ 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
-        invoke_property_writer(model, "#{property_name}=", converted_value) unless converted_value == evaluate_property
+        invoke_property_writer(model, model.is_a?(Hash) ? property_name : "#{property_name}=", converted_value) unless converted_value == evaluate_property || property_name.nil?
       end
 
       def evaluate_property
@@ -258,11 +263,18 @@ module Glimmer
           property_argument = property_argument.to_i if property_argument.match(/\d+/)
           object.send(property_method, property_argument)
         else
-          object.send(property_expression)
+          if property_expression.nil?
+            object
+          elsif object.is_a?(Hash)
+            object[property_expression]
+          else
+            object.send(property_expression)
+          end
         end
       end
 
       def invoke_property_writer(object, property_expression, value)
+        return if property_expression.nil?
         raise "Cannot invoke `#{property_expression}` because ModelBinding#binding_options[:read_only]=true" if @binding_options[:read_only]
         apply_processor(@binding_options[:before_write], value)
         converted_value = convert_on_write(value)
@@ -272,7 +284,11 @@ module Glimmer
           property_argument = property_argument.to_i if property_argument.match(/\d+/)
           object.send(property_method, property_argument, converted_value)
         else
-          object.send(property_expression, converted_value)
+          if object.is_a?(Hash)
+            object[property_expression] = converted_value
+          else
+            object.send(property_expression, converted_value)
+          end
         end
         apply_processor(@binding_options[:after_write], converted_value)
       end

data/lib/glimmer/data_binding/observable_array.rb

@@ -45,33 +45,41 @@ 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
+        property_observer_list[observer] = options
         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)
-        property_observer_list.each do |observer|
-          add_element_observer(element, observer)
+      def add_element_observers(element, general_options = {})
+        property_observer_list.each do |observer, options|
+          add_element_observer(element, observer, options.merge(general_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
-        ensure_array_object_observer(element) if 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)
-        property_observer_list.each do |observer|
+        array_observer_registration = array_object_observer.observe(object, options)
+        property_observer_list.each do |observer, options|
           my_registration = observer.registration_for(self)
           observer.add_dependent(my_registration => array_observer_registration)
         end
@@ -83,7 +91,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)
@@ -99,7 +109,7 @@ module Glimmer
       end
 
       def remove_element_observers(element)
-        property_observer_list.each do |observer|
+        property_observer_list.each do |observer, options|
           remove_element_observer(element, observer)
         end
       end
@@ -110,17 +120,15 @@ 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 {|obs, opt| obs.respond_to?(:observable_array) && obs.observable_array == self}.each do |o|
+            o.deregister_all_observables if o.respond_to?(:deregister_all_observables)
             @array_object_observers.reject! {|k, v| v == o}
           end
         end
       end
 
       def has_observer?(observer)
-        property_observer_list.include?(observer)
+        property_observer_list.keys.include?(observer)
       end
       
       def has_observer_element_properties?(observer, element_properties)
@@ -128,7 +136,7 @@ module Glimmer
       end
 
       def property_observer_list
-        @property_observer_list ||= Concurrent::Set.new
+        @property_observer_list ||= Concurrent::Hash.new
       end
 
       def observer_element_properties
@@ -140,7 +148,7 @@ module Glimmer
       end
 
       def notify_observers
-        property_observer_list.to_a.each { |o| o.call(self) }
+        property_observer_list.to_a.each { |obs, opt| obs.call(self) }
       end
       
       def <<(element)
@@ -245,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
 
@@ -363,7 +372,7 @@ module Glimmer
       
       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) }
+        property_observer_list.each { |observer, options| observer.unregister_dependents_with_observable(observer.registration_for(self), old_value) }
       end
       alias deregister_dependent_observers unregister_dependent_observers
     end

data/lib/glimmer/data_binding/observable_hash.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 ObservableHash
-      include Observable
+      include ObservableHashable
 
       class Notifier
         include Observer
@@ -40,36 +40,19 @@ module Glimmer
         end
       end
       
-      OBSERVED_STORE_METHOD = lambda do |key, value|
-        if key_observer_list(key).empty?
-          if all_key_observer_list.empty?
-            self.send('__original__store', key, value)
-          else
-            old_value = self[key]
-            unregister_dependent_observers(nil, old_value) # remove dependent observers previously installed in ensure_array_object_observer and ensure_hash_object_observer
-            self.send('__original__store', key, value)
-            notify_observers(key)
-            ensure_array_object_observer(nil, value, old_value)
-            ensure_hash_object_observer(nil, value, old_value)
-          end
-        else
-          old_value = self[key]
-          unregister_dependent_observers(key, old_value) # remove dependent observers previously installed in ensure_array_object_observer and ensure_hash_object_observer
-          self.send('__original__store', key, value)
-          notify_observers(key)
-          ensure_array_object_observer(key, value, old_value)
-          ensure_hash_object_observer(key, value, old_value)
+      def add_observer(observer, key = nil, options = {})
+        if key.is_a?(Hash)
+          options = key
+          key = nil
         end
-      end
-
-      def add_observer(observer, key = nil)
         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,24 +101,6 @@ 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])
-        begin
-          method('__original__store')
-        rescue
-          define_singleton_method('__original__store', store_method)
-          define_singleton_method('[]=', &OBSERVED_STORE_METHOD)
-        end
-      rescue => e
-        #ignore writing if no key writer exists
-        Glimmer::Config.logger.debug {"No need to observe store method: '[]='\n#{e.message}\n#{e.backtrace.join("\n")}"}
-      end
-      
-      def store_method
-        self.class.instance_method('[]=') rescue self.method('[]=')
-      end
-
       def unregister_dependent_observers(key, old_value)
         # TODO look into optimizing this
         return unless old_value.is_a?(ObservableModel) || old_value.is_a?(ObservableArray) || old_value.is_a?(ObservableHash)
@@ -143,10 +108,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,23 +126,6 @@ module Glimmer
         @array_object_observers[key]
       end
       
-      def ensure_hash_object_observer(key, object, old_object = nil)
-        return unless object&.is_a?(Hash)
-        hash_object_observer = hash_object_observer_for(key)
-        hash_observer_registration = hash_object_observer.observe(object)
-        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)
-        end
-        hash_object_observer_for(key).unregister(old_object) if old_object.is_a?(ObservableHash)
-      end
-
-      def hash_object_observer_for(key)
-        @hash_object_observers ||= Concurrent::Hash.new
-        @hash_object_observers[key] = ObservableModel::Notifier.new(self, key) unless @hash_object_observers.has_key?(key)
-        @hash_object_observers[key]
-      end
-      
       def delete(key, &block)
         old_value = self[key]
         unless old_value.nil?

data/lib/glimmer/data_binding/observable_hashable.rb

@@ -0,0 +1,75 @@
+# Copyright (c) 2007-2021 Andy Maleh
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# 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'
+
+module Glimmer
+  module DataBinding
+    # Represents a Hash-like object with attributes writable via :[]= store method like Hash, Struct, and OpenStruct
+    # Expects including class to have the following methods:
+    # - key_observer_list
+    # - all_key_observer_list
+    # - unregister_dependent_observer
+    # - ensure_array_object_observer
+    module ObservableHashable
+      include Observable
+      
+      OBSERVED_STORE_METHOD = lambda do |options|
+        lambda do |key, value|
+          if key_observer_list(key).empty?
+            if all_key_observer_list.empty?
+              self.send('__original__store', key, value)
+            else
+              old_value = self[key]
+              unregister_dependent_observers(nil, old_value) # remove dependent observers previously installed in ensure_array_object_observer
+              self.send('__original__store', key, value)
+              notify_observers(key)
+              ensure_array_object_observer(nil, value, old_value, options)
+            end
+          else
+            old_value = self[key]
+            unregister_dependent_observers(key, old_value) # remove dependent observers previously installed in ensure_array_object_observer
+            self.send('__original__store', key, value)
+            notify_observers(key)
+            ensure_array_object_observer(key, value, old_value, options)
+          end
+        end
+      end
+
+      def add_key_writer_observer(key = nil, options)
+        ensure_array_object_observer(key, self[key], nil, options)
+        begin
+          method('__original__store')
+        rescue
+          define_singleton_method('__original__store', store_method)
+          define_singleton_method('[]=', &OBSERVED_STORE_METHOD.call(options))
+        end
+      rescue => e
+        #ignore writing if no key writer exists
+        Glimmer::Config.logger.debug {"No need to observe store method: '[]='\n#{e.message}\n#{e.backtrace.join("\n")}"}
+      end
+      
+      def store_method
+        self.class.instance_method('[]=') rescue self.method('[]=')
+      end
+    end
+  end
+end

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,26 +40,27 @@ 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)
+      
+      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)
+        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)
+      
+      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)
@@ -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
@@ -95,24 +97,32 @@ module Glimmer
       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)
+      
+      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)
         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,10 +140,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 = nil)
+        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)
@@ -146,23 +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)
-        return unless object&.is_a?(Hash)
-        hash_object_observer = hash_object_observer_for(property_name)
-        hash_observer_registration = hash_object_observer.observe(object)
-        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