glimmer 2.4.1 → 2.5.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 374a048642d7ade3614c400b3ffefa627d3c40ca6976acf1a7969592865ecef8
-  data.tar.gz: 5653e8de7ff5ebe9258d872cb72a4067118217e06e698615c9276b95016fb233
+  metadata.gz: 8767081e5092e2238c10506725c9b552975128f7b463ec8d6d522a7b763cfcf9
+  data.tar.gz: df300e488e8094dc16293e3ab45a06b58a51e6620d3d744040dec2da4bdf09e7
 SHA512:
-  metadata.gz: 723e1b9231125f0d3f6507f5312b8a4a12c7bb7e4e3af35cf1f682da317c3a6374d814d0a28e5c2cd37d48255dc3cd7f8e70072b4c0f30bba751ce6730566f45
-  data.tar.gz: 2449d3783dc09bd4154c62df7ae1d954b0c8c411c98276bfa8ceb4f9d4ac0d1504618614fa33d88afa33b056ba1f04ce8b57050b526aa31ecac36b8954507461
+  metadata.gz: 7b9aea718ba6d0e39860bbcf3f24f428dff3e0138ec26244676c9fab419a08a28fc39d4cd9db912b4a224a97016133d79efbf3e8321c4828f5fd66a36ad4b436
+  data.tar.gz: 8aa24fa09f117a33b276174c6631d7aecc940ff63346204c65711e2a5e4a064550bd7417d8c9aee4a539b26707c046b4afe7b9f989dea7bf372bb199328539bc

data/CHANGELOG.md

@@ -3,6 +3,29 @@
 Related Change Logs:
 - [glimmer-dsl-swt/CHANGELOG.md](https://github.com/AndyObtiva/glimmer-dsl-swt/blob/master/CHANGELOG.md)
 
+### 2.5.4
+
+- `Glimmer::DataBinding::ObservableModel` support for observing model attributes with specified `:attribute_writer_type` option (default: `:attribute=`), which can be a single symbol or an array (e.g. `attribute_writer_type: [:attribute=, :set_attribute]`). Glimmer automatches attribute name and automatically generates observer notification attribute writer methods.
+
+### 2.5.3
+
+- Provide `Observer#observe` option to tolerate not being able to extend an object for observation by silently not observing such object
+- Use `Concurrent::Hash` for `ObservableModel#property_observer_hash`
+- Use `Concurrent::Hash` for `ObservableHash#key_observer_hash`
+
+### 2.5.1
+
+- Fix issue with referencing `OpenStruct` without 'ostruct' library being required (it now checks if `OpenStruct` is loaded first and avoids referencing otherwise).
+
+### 2.5.0
+
+- Support observing `Struct`/`OpenStruct` changes via `:[]=` method in addition to attribute writers.
+- Support read-only direct observation of `Hash` object without key via `ModelBinding` (e.g. `ModelBinding.new(some_hash)`)
+- Support read-only direct observation of `Array` object without index via `ModelBinding` (e.g. `ModelBinding.new(some_array)`)
+- Support observing `Hash` attribute with `ModelBinding` (all keys or a single key)
+- Disable `#ensure_hash_object_observer` in ObservableModel/ObservableHash/ObservableArray since it has performance implications and is not necessary
+- Fix issue with `#ensure_array_object_observer` not receiving `recursive: true` option when updating value of an attribute in `ObservableArray`, `ObservableModel`, and `ObservableHash`
+
 ### 2.4.1
 
 - Support `recursive: [integer]` option for ObservableArray#add_observer for finite recursion

data/README.md

@@ -34,6 +34,7 @@ Start by checking out Glimmer's original GUI DSL, which got extracted into its o
 - [glimmer-dsl-opal](https://github.com/AndyObtiva/glimmer-dsl-opal): Glimmer DSL for Opal (Pure Ruby Web GUI and Auto-Webifier of Desktop Apps)
 - [glimmer-dsl-tk](https://github.com/AndyObtiva/glimmer-dsl-tk): Glimmer DSL for Tk (MRI Ruby Desktop Development GUI Library)
 - [glimmer-dsl-libui](https://github.com/AndyObtiva/glimmer-dsl-libui): Glimmer DSL for LibUI (Prerequisite-Free Ruby Desktop Development GUI Library)
+- [glimmer-dsl-gtk](https://github.com/AndyObtiva/glimmer-dsl-gtk): Glimmer DSL for GTK (Ruby-GNOME Desktop Development GUI Library)
 - [glimmer-dsl-xml](https://github.com/AndyObtiva/glimmer-dsl-xml): Glimmer DSL for XML (& HTML)
 - [glimmer-dsl-css](https://github.com/AndyObtiva/glimmer-dsl-css): Glimmer DSL for CSS
 
@@ -229,7 +230,7 @@ end
 ### Setup
 
 Follow these steps to author a [Glimmer](https://rubygems.org/gems/glimmer) DSL:
-- Add `gem 'glimmer', '~> 2.4.1'` to `Gemfile` and run `bundle` or run `gem install glimmer -v2.4.1` and add `require 'glimmer'`
+- Add `gem 'glimmer', '~> 2.5.4'` to `Gemfile` and run `bundle` or run `gem install glimmer -v2.5.4` 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
 
@@ -1184,11 +1185,11 @@ Glimmer enhances observed models automatically (including array operations like
 This relies mainly on the Observer Design Pattern and the MVP (Model-View-Presenter) Architectural Pattern (a variation on MVC)
 
 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::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`). Passing the option `ignore_frozen: true` at the end of the args of `register` (alias: `observe`) method results in silently ignoring any passed frozen observable without raising an error (it raises an error otherwise for frozen/immutable objects).
 - `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::ObservableModel`: Mixin module for any observable model (`Object`, `Struct` or `OpenStruct`) with observable attributes (observes attribute writers and `Struct`/`OpenStruct` `:[]=` method). 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. `:attribute_writer_type` option can be specified (default: `:attribute=`) to observe different attribute styles (e.g. `attribute_writer_type: [:attribute=, :set_attribute]`).
 - `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. Alternatively, pass `recursive: [integer]` to limit recursion in `Array` observation to a specific number of levels beyond the first level (which is always included).
-- `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::ObservableHash`: Mixin module for any observable hash that automatically handles notifying observers upon performing hash mutation operations (e.g. `hash[key]=value`, `select!`, `merge!`).  Also, it automatically handles observing array values using `ObservableArray` appropriately so they would notify observers upon array mutation changes.
 - `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 `<=`
 
@@ -1254,7 +1255,7 @@ end
 
 Note that if an observed model attribute or hash key is an array, it is automatically observed for array changes, not just attribute/key-value changes.
 
-All of the features above make Glimmer's data-binding library one of the most sophisticated and advanced in the industry since they automate everything instead of requiring endless manual configuration, thus resulting in some of the tersest most declarative syntax for using observers and data-binding.
+All of the features above make Glimmer's data-binding library one of the most sophisticated and advanced in the industry since it automates everything instead of requiring endless manual configuration, thus resulting in some of the tersest most declarative syntax for using observers and data-binding.
 
 You may learn more by looking into [data-binding specs](/Users/andy/code/glimmer/spec/lib/glimmer/data_binding) as well as [Data-Binding](https://github.com/AndyObtiva/glimmer-dsl-swt/blob/master/docs/reference/GLIMMER_GUI_DSL_SYNTAX.md#data-binding) and [Observer](https://github.com/AndyObtiva/glimmer-dsl-swt/blob/master/docs/reference/GLIMMER_GUI_DSL_SYNTAX.md#observer) usage in [Glimmer DSL for SWT](https://github.com/AndyObtiva/glimmer-dsl-swt)
 

data/VERSION

@@ -1 +1 @@
-2.4.1
+2.5.4

data/glimmer.gemspec

@@ -1,89 +1,90 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
-# stub: glimmer 2.4.1 ruby lib
-
-Gem::Specification.new do |s|
-  s.name = "glimmer".freeze
-  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-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",
-    "LICENSE.txt",
-    "README.md"
-  ]
-  s.files = [
-    "CHANGELOG.md",
-    "CONTRIBUTING.md",
-    "LICENSE.txt",
-    "PROCESS.md",
-    "README.md",
-    "VERSION",
-    "glimmer.gemspec",
-    "lib/glimmer.rb",
-    "lib/glimmer/config.rb",
-    "lib/glimmer/data_binding/model_binding.rb",
-    "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_model.rb",
-    "lib/glimmer/data_binding/observer.rb",
-    "lib/glimmer/data_binding/shine.rb",
-    "lib/glimmer/dsl/bind_expression.rb",
-    "lib/glimmer/dsl/engine.rb",
-    "lib/glimmer/dsl/expression.rb",
-    "lib/glimmer/dsl/expression_handler.rb",
-    "lib/glimmer/dsl/observe_expression.rb",
-    "lib/glimmer/dsl/parent_expression.rb",
-    "lib/glimmer/dsl/static_expression.rb",
-    "lib/glimmer/dsl/top_level_expression.rb",
-    "lib/glimmer/error.rb",
-    "lib/glimmer/ext/module.rb",
-    "lib/glimmer/invalid_keyword_error.rb",
-    "lib/glimmer/shim/concurrent.rb"
-  ]
-  s.homepage = "http://github.com/AndyObtiva/glimmer".freeze
-  s.licenses = ["MIT".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
-    s.specification_version = 4
-  end
-
-  if s.respond_to? :add_runtime_dependency then
-    s.add_runtime_dependency(%q<array_include_methods>.freeze, ["~> 1.4.0"])
-    s.add_runtime_dependency(%q<facets>.freeze, [">= 3.1.0", "< 4.0.0"])
-    s.add_development_dependency(%q<rspec-mocks>.freeze, ["~> 3.5.0"])
-    s.add_development_dependency(%q<rspec>.freeze, ["~> 3.5.0"])
-    s.add_development_dependency(%q<puts_debuggerer>.freeze, ["~> 0.13"])
-    s.add_development_dependency(%q<rake>.freeze, [">= 10.1.0", "< 14.0.0"])
-    s.add_development_dependency(%q<jeweler>.freeze, [">= 2.0.0", "< 3.0.0"])
-    s.add_development_dependency(%q<rdoc>.freeze, [">= 6.2.1", "< 7.0.0"])
-    s.add_development_dependency(%q<coveralls>.freeze, [">= 0"])
-    s.add_development_dependency(%q<simplecov>.freeze, ["~> 0.16.1"])
-    s.add_development_dependency(%q<simplecov-lcov>.freeze, ["~> 0.7.0"])
-    s.add_development_dependency(%q<rake-tui>.freeze, [">= 0"])
-  else
-    s.add_dependency(%q<array_include_methods>.freeze, ["~> 1.4.0"])
-    s.add_dependency(%q<facets>.freeze, [">= 3.1.0", "< 4.0.0"])
-    s.add_dependency(%q<rspec-mocks>.freeze, ["~> 3.5.0"])
-    s.add_dependency(%q<rspec>.freeze, ["~> 3.5.0"])
-    s.add_dependency(%q<puts_debuggerer>.freeze, ["~> 0.13"])
-    s.add_dependency(%q<rake>.freeze, [">= 10.1.0", "< 14.0.0"])
-    s.add_dependency(%q<jeweler>.freeze, [">= 2.0.0", "< 3.0.0"])
-    s.add_dependency(%q<rdoc>.freeze, [">= 6.2.1", "< 7.0.0"])
-    s.add_dependency(%q<coveralls>.freeze, [">= 0"])
-    s.add_dependency(%q<simplecov>.freeze, ["~> 0.16.1"])
-    s.add_dependency(%q<simplecov-lcov>.freeze, ["~> 0.7.0"])
-    s.add_dependency(%q<rake-tui>.freeze, [">= 0"])
-  end
-end
-
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+# stub: glimmer 2.5.4 ruby lib
+
+Gem::Specification.new do |s|
+  s.name = "glimmer".freeze
+  s.version = "2.5.4"
+
+  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-12-08"
+  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 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.".freeze
+  s.email = "andy.am@gmail.com".freeze
+  s.extra_rdoc_files = [
+    "CHANGELOG.md",
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    "CHANGELOG.md",
+    "CONTRIBUTING.md",
+    "LICENSE.txt",
+    "PROCESS.md",
+    "README.md",
+    "VERSION",
+    "glimmer.gemspec",
+    "lib/glimmer.rb",
+    "lib/glimmer/config.rb",
+    "lib/glimmer/data_binding/model_binding.rb",
+    "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",
+    "lib/glimmer/dsl/bind_expression.rb",
+    "lib/glimmer/dsl/engine.rb",
+    "lib/glimmer/dsl/expression.rb",
+    "lib/glimmer/dsl/expression_handler.rb",
+    "lib/glimmer/dsl/observe_expression.rb",
+    "lib/glimmer/dsl/parent_expression.rb",
+    "lib/glimmer/dsl/static_expression.rb",
+    "lib/glimmer/dsl/top_level_expression.rb",
+    "lib/glimmer/error.rb",
+    "lib/glimmer/ext/module.rb",
+    "lib/glimmer/invalid_keyword_error.rb",
+    "lib/glimmer/shim/concurrent.rb"
+  ]
+  s.homepage = "http://github.com/AndyObtiva/glimmer".freeze
+  s.licenses = ["MIT".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
+    s.specification_version = 4
+  end
+
+  if s.respond_to? :add_runtime_dependency then
+    s.add_runtime_dependency(%q<array_include_methods>.freeze, ["~> 1.4.0"])
+    s.add_runtime_dependency(%q<facets>.freeze, [">= 3.1.0", "< 4.0.0"])
+    s.add_development_dependency(%q<rspec-mocks>.freeze, ["~> 3.5.0"])
+    s.add_development_dependency(%q<rspec>.freeze, ["~> 3.5.0"])
+    s.add_development_dependency(%q<puts_debuggerer>.freeze, ["~> 0.13"])
+    s.add_development_dependency(%q<rake>.freeze, [">= 10.1.0", "< 14.0.0"])
+    s.add_development_dependency(%q<jeweler>.freeze, [">= 2.0.0", "< 3.0.0"])
+    s.add_development_dependency(%q<rdoc>.freeze, [">= 6.2.1", "< 7.0.0"])
+    s.add_development_dependency(%q<coveralls>.freeze, [">= 0"])
+    s.add_development_dependency(%q<simplecov>.freeze, ["~> 0.16.1"])
+    s.add_development_dependency(%q<simplecov-lcov>.freeze, ["~> 0.7.0"])
+    s.add_development_dependency(%q<rake-tui>.freeze, ["> 0"])
+  else
+    s.add_dependency(%q<array_include_methods>.freeze, ["~> 1.4.0"])
+    s.add_dependency(%q<facets>.freeze, [">= 3.1.0", "< 4.0.0"])
+    s.add_dependency(%q<rspec-mocks>.freeze, ["~> 3.5.0"])
+    s.add_dependency(%q<rspec>.freeze, ["~> 3.5.0"])
+    s.add_dependency(%q<puts_debuggerer>.freeze, ["~> 0.13"])
+    s.add_dependency(%q<rake>.freeze, [">= 10.1.0", "< 14.0.0"])
+    s.add_dependency(%q<jeweler>.freeze, [">= 2.0.0", "< 3.0.0"])
+    s.add_dependency(%q<rdoc>.freeze, [">= 6.2.1", "< 7.0.0"])
+    s.add_dependency(%q<coveralls>.freeze, [">= 0"])
+    s.add_dependency(%q<simplecov>.freeze, ["~> 0.16.1"])
+    s.add_dependency(%q<simplecov-lcov>.freeze, ["~> 0.7.0"])
+    s.add_dependency(%q<rake-tui>.freeze, ["> 0"])
+  end
+end
+

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?
@@ -137,7 +137,7 @@ module Glimmer
               apply_processor(@binding_options[:after_read], converted_value)
             end
           end
-          observer_registration = model_binding_observer.observe(model, property_name, observation_options)
+          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
@@ -206,7 +206,7 @@ module Glimmer
       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
@@ -263,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)
@@ -277,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

@@ -50,8 +50,8 @@ module Glimmer
         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)
+        property_observer_list[observer] = options
+        observer_element_properties[observer] = Concurrent::Set.new(Concurrent::Array.new(element_properties_for(observer).to_a) + Concurrent::Array.new(element_properties)) # converting to Array as a workaround to jruby-9.3.2.0 issue TODO remove this workaround when no longer needed
         if !options.empty? && options[:recursive].is_a?(Integer)
           options = options.clone
           options[:recursive] = options[:recursive] - 1
@@ -60,9 +60,9 @@ module Glimmer
         observer
       end
       
-      def add_element_observers(element, options = {})
-        property_observer_list.each do |observer|
-          add_element_observer(element, observer, options)
+      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
 
@@ -79,7 +79,7 @@ module Glimmer
         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|
+        property_observer_list.each do |observer, options|
           my_registration = observer.registration_for(self)
           observer.add_dependent(my_registration => array_observer_registration)
         end
@@ -97,7 +97,7 @@ module Glimmer
         element_properties = element_properties.flatten.compact.uniq
         if !element_properties.empty?
           old_element_properties = element_properties_for(observer)
-          observer_element_properties[observer] = element_properties_for(observer) - Concurrent::Set.new(element_properties)
+          observer_element_properties[observer] = Concurrent::Set.new(Concurrent::Array.new(element_properties_for(observer).to_a) - Concurrent::Array.new(element_properties)) # TODO remove this workaround when no longer needed (it is for jruby-9.3.2.0 issue)
           each { |element| element_properties.each { |property| observer.unobserve(element, property) } }
         end
         if element_properties_for(observer).empty?
@@ -109,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
@@ -120,15 +120,15 @@ module Glimmer
         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
+          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)
@@ -136,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
@@ -148,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)
@@ -372,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,28 +40,6 @@ 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)
-        end
-      end
-
       def add_observer(observer, key = nil, options = {})
         if key.is_a?(Hash)
           options = key
@@ -106,7 +84,7 @@ module Glimmer
       end
 
       def key_observer_hash
-        @key_observers ||= Hash.new
+        @key_observers ||= Concurrent::Hash.new
       end
 
       def key_observer_list(key)
@@ -123,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, options)
-        ensure_array_object_observer(key, self[key], nil, options)
-        ensure_hash_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)
-        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)
@@ -166,24 +126,6 @@ module Glimmer
         @array_object_observers[key]
       end
       
-      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, 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)
-        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,25 +40,26 @@ module Glimmer
         end
       end
       
-      PROPERTY_WRITER_FACTORY = lambda do |property_name|
-        property_writer_name = "#{property_name}="
+      PROPERTY_WRITER_FACTORY = lambda do |property_name, property_writer_name, options|
         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 = {})
+        initialize_observer_options(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,32 +93,44 @@ 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))
+        options[:attribute_writer_type].each do |attribute_writer_type|
+          begin
+            property_writer_name = attribute_writer_type.to_s.gsub('attribute', property_name.to_s)
+            method(property_writer_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))
+              # 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, property_writer_name, options))
+            end
+          rescue => e
+            #ignore writing if no property writer exists
+            Glimmer::Config.logger.debug {"No need to observe property writer: #{property_writer_name}\n#{e.message}\n#{e.backtrace.join("\n")}"}
+          end
         end
-      rescue => e
-        #ignore writing if no property writer exists
-        Glimmer::Config.logger.debug {"No need to observe property writer: #{property_writer_name}\n#{e.message}\n#{e.backtrace.join("\n")}"}
       end
       
       def property_writer_method(property_writer_name)
@@ -130,7 +144,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,23 +161,10 @@ 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]
+      def initialize_observer_options(options)
+        options[:attribute_writer_type] ||= [:attribute=]
+        options[:attribute_writer_type] = [options[:attribute_writer_type]] if !options[:attribute_writer_type].is_a?(Array)
       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.1
+  version: 2.5.4
 platform: ruby
 authors:
 - AndyMaleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-01 00:00:00.000000000 Z
+date: 2021-12-08 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