glimmer 0.2.5 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea0f249121119690fd3553adc211844541485690b633198bf5a186ea227e878b
-  data.tar.gz: b598dc0df0a28745eadfdc917cda0dda117f773c2b507e7563915c87fc4a3bb6
+  metadata.gz: cc35b055fcf86d7c93b264b409424039c63c0361f0a7b587e9db0f2071e7809e
+  data.tar.gz: 3ab0eec08e13367c717ee74a984fea0ee49bbd309fd2fd3348fb40e70b156b2c
 SHA512:
-  metadata.gz: 9282de0acba5317c726d5ccb93f1bd3261ff3a8a4937eb0d12bb9dd96d656a887968f661530111ef661a060aed06a18de44dd8f42831c11ae73c0760d61d7ca2
-  data.tar.gz: 93095774ad6692645730284c959742eb7399b2504671d5160856694f7592f694712b68e32540dc86aa9af786dbdf21d8b0d6ac7f93ed3ec475df32c35e249bd7
+  metadata.gz: '059e99839505e645cc41cd13d0adc2f04680643dd7d45d6b6ecb0e9e2fec7823f330f0962756f745ba9ca564c945fb97480e988d21efd732fb3ec36185c8dc89'
+  data.tar.gz: eb9f191f5aa31e9d716b787bb1b54d0792fb2aaaf080f8f37b7dd17e0ada300192986910b8fe3bcf777a1da7382cf5bd8dd3c6d59bccf63703fbcb95b3fa7bc9

data/README.markdown

@@ -66,14 +66,14 @@ Please follow these instructions to make the `glimmer` command available on your
 
 Run this command to install directly:
 ```
-jgem install glimmer -v 0.2.5
+jgem install glimmer -v 0.3.1
 ```
 
 ### Option 2: Bundler
 
 Add the following to `Gemfile`:
 ```
-gem 'glimmer', '~> 0.2.5'
+gem 'glimmer', '~> 0.3.1'
 ```
 
 And, then run:

data/lib/command_handlers/combo_selection_data_binding_command_handler.rb

@@ -22,12 +22,12 @@ class ComboSelectionDataBindingCommandHandler
     widget_binding = WidgetBinding.new(parent, "items")
     widget_binding.update(model_binding.evaluate_options_property)
     model = model_binding.base_model
-    model.extend ObservableModel unless model.is_a?(ObservableModel)
-    model.add_observer(model_binding.options_property_name, widget_binding)
+    model.extend(ObservableModel) unless model.is_a?(ObservableModel)
+    widget_binding.observe(model, model_binding.options_property_name)
 
     widget_binding = WidgetBinding.new(parent, "text")
     widget_binding.update(model_binding.evaluate_property)
-    model.add_observer(model_binding.property_name_expression, widget_binding)
+    widget_binding.observe(model, model_binding.property_name_expression)
 
     add_contents(parent) {
       on_widget_selected {

data/lib/command_handlers/data_binding_command_handler.rb

@@ -58,7 +58,7 @@ class DataBindingCommandHandler
       widget_binding_parameters = [parent, command_symbol.to_s]
       widget_binding = WidgetBinding.new(*widget_binding_parameters)
       widget_binding.update(model_binding.evaluate_property)
-      model_binding.add_observer(widget_binding)
+      widget_binding.observe(model_binding)
       widget_data_binder_map = @@widget_data_binders[parent.widget.class]
       widget_data_binder = widget_data_binder_map[command_symbol.to_s.to_sym] if widget_data_binder_map
       widget_data_binder.call(parent, model_binding) if widget_data_binder

data/lib/command_handlers/list_selection_data_binding_command_handler.rb

@@ -23,14 +23,16 @@ class ListSelectionDataBindingCommandHandler
     widget_binding = WidgetBinding.new(parent, "items")
     widget_binding.update(model_binding.evaluate_options_property)
     model = model_binding.base_model
-    model.extend ObservableModel unless model.is_a?(ObservableModel)
-    model.add_observer(model_binding.options_property_name, widget_binding)
+    model.extend(ObservableModel) unless model.is_a?(ObservableModel)
+    #TODO make this options observer dependent and all similar observers in widget specific data binding handlers
+    widget_binding.observe(model, model_binding.options_property_name)
 
     property_type = :string
     property_type = :array if parent.has_style?(:multi)
     list_selection_binding = ListSelectionBinding.new(parent, property_type)
     list_selection_binding.update(model_binding.evaluate_property)
-    model.add_observer(model_binding.property_name_expression, list_selection_binding)
+    #TODO check if nested data binding works for list widget and other widgets that need custom data binding
+    list_selection_binding.observe(model, model_binding.property_name_expression)
 
     add_contents(parent) {
       on_widget_selected {

data/lib/command_handlers/models/block_observer.rb

@@ -1,5 +1,6 @@
-# Observer that takes an updater block to process updates
+require_relative 'observer'
 
+# Observer that takes an updater block to process updates
 class BlockObserver
   include Observer
 

data/lib/command_handlers/models/list_selection_binding.rb

@@ -2,6 +2,7 @@ require File.dirname(__FILE__) + "/observer"
 
 # SWT List widget selection binding
 class ListSelectionBinding
+  include Glimmer
   include Observer
 
   attr_reader :widget
@@ -25,6 +26,11 @@ class ListSelectionBinding
     property_type = :string if property_type.nil? or property_type == :undefined
     @widget = widget
     @property_type = property_type
+    add_contents(@widget) {
+      on_widget_disposed { |dispose_event|
+        unregister_all_observables
+      }
+    }
   end
   def update(value)
     @@property_type_updaters[@property_type].call(@widget, value) unless evaluate_property == value

data/lib/command_handlers/models/model_binding.rb

@@ -1,4 +1,5 @@
-require File.dirname(__FILE__) + "/observer"
+require_relative 'observer'
+require_relative 'block_observer'
 
 class ModelBinding
   include Observer
@@ -92,40 +93,77 @@ class ModelBinding
         )
       end
     end
+    # @nested_property_observers_collection[observer].keys.each_with_index do |property_name, i|
+    #   previous_property_name = nested_property_names[i-1]
+    #   previous_observer = @nested_property_observers_collection[observer][previous_property_name]
+    #   nested_property_observer = @nested_property_observers_collection[observer][property_name]
+    #   previous_observer.add_dependent(nested_property_observer) unless previous_observer.nil?
+    # end
+    # TODO remove this brainstorming
+    # person.addresses[1].streets[2].number
+    # person.addresses[1] = ...
     @nested_property_observers_collection[observer]
   end
   def add_observer(observer)
     if computed?
       add_computed_observers(observer)
+    elsif nested_property?
+      add_nested_observers(observer)
     else
-      add_direct_observer(observer)
+      model.extend(ObservableModel) unless model.is_a?(ObservableModel)
+      observer.observe(model, property_name)
+      observer.add_dependent([self, nil] => [observer, model, property_name])
     end
   end
-  def add_computed_observers(observer)
-    computed_observer = BlockObserver.new do |changed_value|
-      observer.update(evaluate_property)
+  def remove_observer(observer)
+    if computed?
+      @computed_model_bindings.each do |computed_model_binding|
+        computed_observer_for(observer).unobserve(computed_model_binding)
+      end
+      @computed_observer_collection[observer] = nil
+    elsif nested_property?
+      nested_property_observers_for(observer).clear
+    else
+      model.extend(ObservableModel) unless model.is_a?(ObservableModel)
+      observer.unobserve(model, property_name)
     end
+  end
+  def computed_observer_for(observer)
+    @computed_observer_collection ||= {}
+    unless @computed_observer_collection.has_key?(observer)
+      @computed_observer_collection[observer] = BlockObserver.new do |changed_value|
+        observer.update(evaluate_property)
+      end
+    end
+    @computed_observer_collection[observer]
+  end
+  def add_computed_observers(observer)
     @computed_model_bindings.each do |computed_model_binding|
-      computed_model_binding.add_observer(computed_observer)
+      computed_observer_for(observer).observe(computed_model_binding)
+      observer.add_dependent([self, nil] => [computed_observer_for(observer), computed_model_binding, nil])
     end
   end
-  def add_direct_observer(observer)
-    if nested_property?
-      nested_property_observers = nested_property_observers_for(observer)
-      nested_models.zip(nested_property_names).each do |model, property_name|
-        unless model.nil?
-          if property_indexed?(property_name)
-            model.extend ObservableArray unless model.is_a?(ObservableArray)
-            model.add_array_observer(nested_property_observers[property_name]) unless model.has_array_observer?(nested_property_observers[property_name])
-          else
-            model.extend ObservableModel unless model.is_a?(ObservableModel)
-            model.add_observer(property_name, nested_property_observers[property_name]) unless model.has_observer?(property_name, nested_property_observers[property_name])
-          end
+  def add_nested_observers(observer)
+    nested_property_observers = nested_property_observers_for(observer)
+    nested_models.zip(nested_property_names).each_with_index do |zip, i|
+      model, property_name = zip
+      nested_property_observer = nested_property_observers[property_name]
+      previous_index = i - 1
+      parent_model = previous_index.negative? ? self : nested_models[previous_index]
+      parent_property_name = previous_index.negative? ? nil : nested_property_names[previous_index]
+      parent_observer = previous_index.negative? ? observer : nested_property_observers[parent_property_name]
+      parent_property_name = nil if parent_property_name.to_s.start_with?('[')
+      unless model.nil?
+        if property_indexed?(property_name)
+          model.extend(ObservableArray) unless model.is_a?(ObservableArray)
+          nested_property_observer.observe(model) unless model.has_observer?(nested_property_observer)
+          parent_observer.add_dependent([parent_model, parent_property_name] => [nested_property_observer, model, nil])
+        else
+          model.extend(ObservableModel) unless model.is_a?(ObservableModel)
+          nested_property_observer.observe(model, property_name) unless model.has_observer?(nested_property_observer, property_name)
+          parent_observer.add_dependent([parent_model, parent_property_name] => [nested_property_observer, model, property_name])
         end
       end
-    else
-      model.extend ObservableModel unless model.is_a?(ObservableModel)
-      model.add_observer(property_name, observer)
     end
   end
   def update(value)
@@ -137,7 +175,7 @@ class ModelBinding
     invoke_property_reader(model, property_name) unless model.nil?
   end
   def evaluate_options_property
-    model.send(property_name + "_options") unless model.nil?
+    model.send(options_property_name) unless model.nil?
   end
   def options_property_name
     self.property_name + "_options"

data/lib/command_handlers/models/observable.rb

@@ -0,0 +1,9 @@
+module Observable
+  def add_observer(observer, property_or_properties=nil)
+    raise 'Not implemented!'
+  end
+
+  def remove_observer(observer, property_or_properties=nil)
+    raise 'Not implemented!'
+  end
+end

data/lib/command_handlers/models/observable_array.rb

@@ -1,27 +1,39 @@
 require 'set'
+
+require_relative 'observable'
+
+# TODO prefix utility methods with double-underscore
 module ObservableArray
+  include Observable
 
-  def add_observer(element_properties, observer)
+  def add_observer(observer, element_properties=nil)
     property_observer_list << observer
-    each do |element|
-      [element_properties].flatten.each do |property|
+    [element_properties].flatten.compact.each do |property|
+      each do |element|
         element.extend(ObservableModel) unless element.is_a?(ObservableModel)
-        element.add_observer(property, observer)
+        observer.observe(element, property)
       end
     end
+    observer
   end
 
-  def add_array_observer(observer)
-    property_observer_list << observer
+  def remove_observer(observer, element_properties=nil)
+    property_observer_list.delete(observer)
+    [element_properties].flatten.compact.each do |property|
+      each do |element|
+        element.extend(ObservableModel) unless element.is_a?(ObservableModel)
+        observer.unobserve(element, property)
+      end
+    end
+    observer
   end
 
-  def has_array_observer?(observer)
+  def has_observer?(observer)
     property_observer_list.include?(observer)
   end
 
   def property_observer_list
-    @property_observer_list = Set.new unless @property_observer_list
-    @property_observer_list
+    @property_observer_list ||= Set.new
   end
 
   def notify_observers
@@ -29,37 +41,63 @@ module ObservableArray
   end
 
   def self.extend_object(array)
-    array.instance_eval("alias __original_add__ <<")
+    array.instance_eval("alias __original_add <<")
     array.instance_eval <<-end_eval, __FILE__, __LINE__
       def <<(value)
-        self.__original_add__(value)
+        self.__original_add(value)
         notify_observers
       end
     end_eval
 
-    array.instance_eval("alias __original_set_value__ []=")
+    array.instance_eval("alias __original_set_value []=")
     array.instance_eval <<-end_eval, __FILE__, __LINE__
       def []=(index, value)
-        self.__original_set_value__(index, value)
+        old_value = self[index]
+        unregister_dependent_observers(old_value)
+        self.__original_set_value(index, value)
         notify_observers
       end
     end_eval
 
-    notify_observers_on_invokation(array, "delete")
-    notify_observers_on_invokation(array, "delete_at")
-    notify_observers_on_invokation(array, "clear")
+    array.instance_eval("alias __original_delete delete")
+    array.instance_eval <<-end_eval, __FILE__, __LINE__
+      def delete(value)
+        unregister_dependent_observers(value)
+        self.__original_delete(value)
+        notify_observers
+      end
+    end_eval
 
-    super
-  end
+    array.instance_eval("alias __original_delete_at delete_at")
+    array.instance_eval <<-end_eval, __FILE__, __LINE__
+      def delete_at(index)
+        old_value = self[index]
+        unregister_dependent_observers(old_value)
+        self.__original_delete_at(index)
+        notify_observers
+      end
+    end_eval
 
-  def self.notify_observers_on_invokation(model, method)
-    model.instance_eval "alias __original_#{method}__ #{method}\n"
-    model.instance_eval <<-end_eval, __FILE__, __LINE__
-      def #{method}(*args, &block)
-        self.__original_#{method}__(*args, &block)
+    array.instance_eval("alias __original_clear clear")
+    array.instance_eval <<-end_eval, __FILE__, __LINE__
+      def clear
+        each do |old_value|
+          unregister_dependent_observers(old_value)
+        end
+        self.__original_clear
         notify_observers
       end
     end_eval
+
+    super
+  end
+
+  def unregister_dependent_observers(old_value)
+    # TODO look into optimizing this
+    return unless old_value.is_a?(ObservableModel) || old_value.is_a?(ObservableArray)
+    property_observer_list.each do |observer|
+      observer.unregister_dependents_with_observable([self, nil], old_value)
+    end
   end
 
 end

data/lib/command_handlers/models/observable_model.rb

@@ -1,19 +1,42 @@
 require 'set'
 
-require File.dirname(__FILE__) + "/block_observer"
+require_relative 'observable'
+require_relative 'observer'
 
+# TODO prefix utility methods with double-underscore
 module ObservableModel
+  include Observable
 
-  # Takes observer as an object or a block updater
-  def add_observer(property_name, observer = nil, &updater)
-    observer ||= BlockObserver.new(&updater)
+  class Updater
+    include Observer
+    def initialize(observable_model, property_name)
+      @observable_model = observable_model
+      @property_name = property_name
+    end
+    def update(changed_value=nil)
+      @observable_model.notify_observers(@property_name)
+    end
+  end
+
+  def add_observer(observer, property_name)
+    return observer if has_observer?(observer, property_name)
     property_observer_list(property_name) << observer
+    add_property_writer_observers(property_name)
+    observer
   end
 
-  def has_observer?(property_name, observer)
+  def remove_observer(observer, property_name)
+    property_observer_list(property_name).delete(observer)
+  end
+
+  def has_observer?(observer, property_name)
     property_observer_list(property_name).include?(observer)
   end
 
+  def has_observer_for_any_property?(observer)
+    property_observer_hash.values.map(&:to_a).sum.include?(observer)
+  end
+
   def property_observer_hash
     @property_observers = Hash.new unless @property_observers
     @property_observers
@@ -27,45 +50,51 @@ module ObservableModel
   def notify_observers(property_name)
     property_observer_list(property_name).each {|observer| observer.update(send(property_name))}
   end
+  #TODO upon updating values, make sure dependent observers are cleared (not added as dependents here)
 
-  class Updater
-    def initialize(property_name, observable_model)
-      @property_name = property_name
-      @observable_model = observable_model
+  def add_property_writer_observers(property_name)
+    property_writer_name = "#{property_name}="
+    ensure_array_object_observer(property_name, send(property_name))
+    begin
+      method("__original_#{property_writer_name}")
+    rescue
+      instance_eval "alias __original_#{property_writer_name} #{property_writer_name}"
+      instance_eval <<-end_eval, __FILE__, __LINE__
+        def #{property_writer_name}(value)
+          old_value = self.#{property_name}
+          unregister_dependent_observers('#{property_name}', old_value)
+          self.__original_#{property_writer_name}(value)
+          notify_observers('#{property_name}')
+          ensure_array_object_observer('#{property_name}', value, old_value)
+        end
+      end_eval
     end
-    def update
-      @observable_model.notify_observers(@property_name)
+  end
+
+  def unregister_dependent_observers(property_name, old_value)
+    # TODO look into optimizing this
+    return unless old_value.is_a?(ObservableModel) || old_value.is_a?(ObservableArray)
+    property_observer_list(property_name).each do |observer|
+      observer.unregister_dependents_with_observable([self, property_name], old_value)
     end
   end
 
-  def self.extend_object(model)
-    super
-    model.methods.each do |method|
-      self.add_method_observers(model, method)
+  def ensure_array_object_observer(property_name, object, old_object = nil)
+    return unless object.is_a?(Array)
+    object.extend(ObservableArray) unless object.is_a?(ObservableArray)
+    array_object_observer = array_object_observer_for(property_name)
+    array_object_observer.observe(object)
+    property_observer_list(property_name).each do |observer|
+      observer.add_dependent([self, property_name] => [array_object_observer, object, nil])
     end
+    array_object_observer_for(property_name).unregister(old_object) if old_object.is_a?(ObservableArray)
   end
 
-  def self.add_method_observers(model, method)
-    setter_method_pattern = /^(\w+=)$/
-    if (method.match(setter_method_pattern))
-      getter_method = method[0, method.length - 1]
-      getter_value = model.send(getter_method)
-      if (getter_value.is_a?(Array) and
-          !getter_value.is_a?(ObservableArray))
-        getter_value.extend(ObservableArray)
-        getter_value.add_observer([], Updater.new(getter_method, model))
-      end
-      model.instance_eval "alias original_#{method} #{method}\n"
-      model.instance_eval <<-end_eval, __FILE__, __LINE__
-        def #{method}(value)
-          self.original_#{method}(value)
-          notify_observers('#{getter_method}')
-          if (value.is_a?(Array) and !value.is_a?(ObservableArray))
-            value.extend(ObservableArray)
-            value.add_observer([], ObservableModel::Updater.new('#{getter_method}', self))
-          end
-        end
-      end_eval
+  def array_object_observer_for(property_name)
+    @array_object_observers ||= {}
+    unless @array_object_observers.has_key?(property_name)
+      @array_object_observers[property_name] = ObservableModel::Updater.new(self, property_name)
     end
+    @array_object_observers[property_name]
   end
 end

data/lib/command_handlers/models/observer.rb

@@ -1,8 +1,79 @@
+require 'set'
+
 # Mixin representing Observer trait from Observer Design Pattern
 # Allows classes to include without interfering with their
 # inheritance hierarchy.
-
 module Observer
+  def registrations
+    @registrations ||= Set.new
+  end
+
+  def registrations_for(observable, property = nil)
+    registrations.select {|o, p| o == observable && p == property}
+  end
+
+  # mapping of registrations to dependents
+  # {[observable, property] => [[dependent, dependent_observable, dependent_property], ...]}
+  def dependents
+    @dependents ||= Hash.new
+  end
+
+  def dependents_for(registration)
+    dependents[registration] ||= Set.new
+  end
+
+  # registers observer in an observable on a property (optional)
+  # observer maintains registration list to unregister later
+  def register(observable, property = nil)
+    observable.add_observer(*[self, property].compact)
+    [observable, property].tap do |registration|
+      self.registrations << registration
+    end
+  end
+  alias observe register
+
+  def unregister(observable, property = nil)
+    observable.remove_observer(*[self, property].compact)
+    registration = [observable, property]
+    dependents_for(registration).each do |dependent|
+      dependent_observer, dependent_observable, dependent_property = dependent
+      dependent_observer.unregister(dependent_observable, dependent_property)
+      remove_dependent(registration => dependent)
+    end
+    registrations.delete(registration)
+  end
+  alias unobserve unregister
+
+  def unregister_dependents_with_observable(registration, dependent_observable)
+    thedependents = dependents_for(registration).select do |d_observer, d_observable, d_property|
+      d_observable == dependent_observable
+    end
+    thedependents.each do |d_observer, d_observable, d_property|
+      d_observer.unregister(d_observable, d_property)
+    end
+  end
+
+  # cleans up all registrations in observables
+  def unregister_all_observables
+    registrations.each do |observable, property|
+      unregister(observable, property)
+    end
+  end
+  alias unobserve_all_observables unregister_all_observables
+
+  # add dependent observer to unregister when unregistering observer
+  def add_dependent(parent_to_dependent_hash)
+    observable, property = registration = parent_to_dependent_hash.keys.first
+    dependent_observer, dependent_observable, dependent_property = dependent = parent_to_dependent_hash.values.first
+    dependents_for(registration) << dependent
+  end
+
+  def remove_dependent(parent_to_dependent_hash)
+    observable, property = registration = parent_to_dependent_hash.keys.first
+    dependent_observer, dependent_observable, dependent_property = dependent = parent_to_dependent_hash.values.first
+    dependents_for(registration).delete(dependent)
+  end
+
   def update(changed_value)
     raise 'Not implemented!'
   end

data/lib/command_handlers/models/r_widget.rb

@@ -5,9 +5,9 @@ class RWidget
   require File.dirname(__FILE__) + "/r_widget_packages"
 
   include Parent
-  
+
   attr_reader :widget
-  
+
   #TODO externalize
   @@default_styles = {
     "text" => SWT::BORDER,
@@ -16,11 +16,11 @@ class RWidget
     "list" => SWT::BORDER | SWT::V_SCROLL,
     "button" => SWT::PUSH,
   }
-  
+
   #TODO externalize
   @@default_initializers = {
     "composite" => Proc.new {|composite| composite.setLayout(GridLayout.new) },
-    "table" => Proc.new do |table| 
+    "table" => Proc.new do |table|
       table.setHeaderVisible(true)
       table.setLinesVisible(true)
     end,
@@ -33,7 +33,7 @@ class RWidget
     @widget = underscored_widget_name.swt_widget.new(parent, style(underscored_widget_name, styles))
     @@default_initializers[underscored_widget_name].call(@widget) if @@default_initializers[underscored_widget_name]
   end
-  
+
   def has_attribute?(attribute_name, *args)
     @widget.respond_to?(attribute_setter(attribute_name), args)
   end
@@ -66,10 +66,10 @@ class RWidget
     end
     return false
   end
-  
+
   def can_add_listener?(underscored_listener_name)
     listener_method_name = underscored_listener_name.camelcase(:lower)
-    @widget.getClass.getMethods.each do |widget_method| 
+    @widget.getClass.getMethods.each do |widget_method|
       if widget_method.getName.match(/add.*Listener/)
         widget_method.getParameterTypes.each do |listener_type|
           listener_type.getMethods.each do |listener_method|
@@ -82,10 +82,10 @@ class RWidget
     end
     return false
   end
-  
-  def add_listener(underscored_listener_name, &block) 
+
+  def add_listener(underscored_listener_name, &block)
     listener_method_name = underscored_listener_name.camelcase(:lower)
-    @widget.getClass.getMethods.each do |widget_method| 
+    @widget.getClass.getMethods.each do |widget_method|
       if widget_method.getName.match(/add.*Listener/)
         widget_method.getParameterTypes.each do |listener_type|
           listener_type.getMethods.each do |listener_method|
@@ -109,11 +109,11 @@ class RWidget
       end
     end
   end
-  
+
   def process_block(block)
     block.call(@widget)
   end
-  
+
   def async_exec(&block)
     @widget.getDisplay.asyncExec(RRunnable.new(&block))
   end
@@ -121,7 +121,7 @@ class RWidget
   def sync_exec(&block)
     @widget.getDisplay.syncExec(RRunnable.new(&block))
   end
-  
+
   def has_style?(style)
     (widget.style & style.swt_constant) == style.swt_constant
   end
@@ -144,10 +144,10 @@ class RWidget
 
   def swt_styles(styles)
     styles.map(&:swt_constant)
-  end  
-  
+  end
+
   def attribute_setter(attribute_name)
     "set#{attribute_name.to_s.camelcase(:upper)}"
   end
 
-end
+end

data/lib/command_handlers/models/table_items_binding.rb

@@ -3,6 +3,7 @@ require File.dirname(__FILE__) + "/observable_model"
 require File.dirname(__FILE__) + "/observer"
 
 class TableItemsBinding
+  include Glimmer
   include Observer
   include_package 'org.eclipse.swt'
   include_package 'org.eclipse.swt.widgets'
@@ -14,12 +15,17 @@ class TableItemsBinding
     update(@model_binding.evaluate_property)
     model = model_binding.base_model
     model.extend(ObservableModel) unless model.is_a?(ObservableModel)
-    model.add_observer(model_binding.property_name_expression, self)
+    observe(model, model_binding.property_name_expression)
+    add_contents(@table) {
+      on_widget_disposed { |dispose_event|
+        unregister_all_observables
+      }
+    }
   end
   def update(model_collection=nil)
     if model_collection and model_collection.is_a?(Array)
       model_collection.extend(ObservableArray) unless model_collection.is_a?(ObservableArray)
-      model_collection.add_observer(@column_properties, self)
+      observe(model_collection, @column_properties)
       @model_collection = model_collection
     end
     populate_table(@model_collection, @table, @column_properties)

data/lib/command_handlers/models/tree_items_binding.rb

@@ -3,6 +3,7 @@ require File.dirname(__FILE__) + "/observable_model"
 require File.dirname(__FILE__) + "/observer"
 
 class TreeItemsBinding
+  include Glimmer
   include Observer
   include_package 'org.eclipse.swt'
   include_package 'org.eclipse.swt.widgets'
@@ -14,13 +15,18 @@ class TreeItemsBinding
     update(@model_binding.evaluate_property)
     model = model_binding.base_model
     model.extend(ObservableModel) unless model.is_a?(ObservableModel)
-    model.add_observer(model_binding.property_name_expression, self)
+    observe(model, model_binding.property_name_expression)
+    add_contents(@tree) {
+      on_widget_disposed { |dispose_event|
+        unregister_all_observables
+      }
+    }
   end
   def update(model_tree_root_node=nil)
     if model_tree_root_node and model_tree_root_node.respond_to?(@tree_properties[:children])
       model_tree_root_node.extend(ObservableModel) unless model_tree_root_node.is_a?(ObservableModel)
-      model_tree_root_node.add_observer(@tree_properties[:text], self)
-      model_tree_root_node.add_observer(@tree_properties[:children], self)
+      observe(model_tree_root_node, @tree_properties[:text])
+      observe(model_tree_root_node, @tree_properties[:children])
       @model_tree_root_node = model_tree_root_node
     end
     populate_tree(@model_tree_root_node, @tree, @tree_properties)
@@ -34,7 +40,7 @@ class TreeItemsBinding
     table_item.setText((model_tree_node && model_tree_node.send(tree_properties[:text])).to_s)
       [model_tree_node && model_tree_node.send(tree_properties[:children])].flatten.to_a.compact.each do |child|
       child.extend(ObservableModel) unless child.is_a?(ObservableModel)
-      child.add_observer(@tree_properties[:text], self)
+      observe(child, @tree_properties[:text])
       populate_tree_node(child, table_item, tree_properties)
     end
   end

data/lib/command_handlers/models/widget_binding.rb

@@ -1,6 +1,7 @@
 require File.dirname(__FILE__) + "/observer"
 
 class WidgetBinding
+  include Glimmer
   include Observer
 
   attr_reader :widget, :property
@@ -13,6 +14,11 @@ class WidgetBinding
     @widget = model
     @property = property
     @translator = translator || proc {|value| value}
+    add_contents(@widget) {
+      on_widget_disposed { |dispose_event|
+        unregister_all_observables
+      }
+    }
   end
   def update(value)
     converted_value = translated_value = @translator.call(value)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: glimmer
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.3.1
 platform: ruby
 authors:
 - AndyMaleh
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-03-08 00:00:00.000000000 Z
+date: 2020-03-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   requirement: !ruby/object:Gem::Requirement
@@ -162,6 +162,7 @@ files:
 - lib/command_handlers/models/block_observer.rb
 - lib/command_handlers/models/list_selection_binding.rb
 - lib/command_handlers/models/model_binding.rb
+- lib/command_handlers/models/observable.rb
 - lib/command_handlers/models/observable_array.rb
 - lib/command_handlers/models/observable_model.rb
 - lib/command_handlers/models/observer.rb