glimmer 0.4.3 → 0.4.4

data/lib/glimmer/swt/observable.rb

@@ -0,0 +1,13 @@
+module Glimmer
+  module SWT
+    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
+  end
+end

data/lib/glimmer/swt/observable_array.rb

@@ -0,0 +1,105 @@
+require 'set'
+
+require_relative 'observable'
+
+module Glimmer
+  module SWT
+    # TODO prefix utility methods with double-underscore
+    module ObservableArray
+      include Observable
+
+      def add_observer(observer, element_properties=nil)
+        return observer if has_observer?(observer) && element_properties.nil?
+        property_observer_list << observer
+        [element_properties].flatten.compact.each do |property|
+          each do |element|
+            observer.observe(element, property)
+          end
+        end
+        observer
+      end
+
+      def remove_observer(observer, element_properties=nil)
+        property_observer_list.delete(observer)
+        [element_properties].flatten.compact.each do |property|
+          each do |element|
+            observer.unobserve(element, property)
+          end
+        end
+        observer
+      end
+      
+      def has_observer?(observer)
+        property_observer_list.include?(observer)
+      end
+
+      def property_observer_list
+        @property_observer_list ||= Set.new
+      end
+
+      def notify_observers
+        property_observer_list.each {|observer| observer.call}
+      end
+
+      def self.extend_object(array)
+        array.instance_eval("alias __original_add <<")
+        array.instance_eval <<-end_eval, __FILE__, __LINE__
+        def <<(value)
+          self.__original_add(value)
+          notify_observers
+        end
+        end_eval
+
+        array.instance_eval("alias __original_set_value []=")
+        array.instance_eval <<-end_eval, __FILE__, __LINE__
+        def []=(index, value)
+          old_value = self[index]
+          unregister_dependent_observers(old_value)
+          self.__original_set_value(index, value)
+          notify_observers
+        end
+        end_eval
+
+        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
+
+        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
+
+        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
+  end
+end

data/lib/glimmer/swt/observable_model.rb

@@ -0,0 +1,107 @@
+require 'set'
+
+require_relative 'observable'
+require_relative 'observer'
+
+module Glimmer
+  module SWT
+    # TODO prefix utility methods with double-underscore
+    module ObservableModel
+      include Observable
+
+      class Notifier
+        include Observer
+        def initialize(observable_model, property_name)
+          @observable_model = observable_model
+          @property_name = property_name
+        end
+        def call(new_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 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
+      end
+
+      def property_observer_list(property_name)
+        property_observer_hash[property_name.to_sym] = Set.new unless property_observer_hash[property_name.to_sym]
+        property_observer_hash[property_name.to_sym]
+      end
+
+      def notify_observers(property_name)
+        property_observer_list(property_name).each {|observer| observer.call(send(property_name))}
+      end
+      #TODO upon updating values, make sure dependent observers are cleared (not added as dependents here)
+
+      def add_property_writer_observers(property_name)
+        property_writer_name = "#{property_name}="
+        method(property_writer_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
+      rescue => e
+        # ignore writing if no property writer exists
+        Glimmer.logger.debug "No need to observe property writer: #{property_writer_name}\n#{e.message}\n#{e.backtrace.join("\n")}"
+      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 ensure_array_object_observer(property_name, object, old_object = nil)
+        return unless object.is_a?(Array)
+        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 array_object_observer_for(property_name)
+        @array_object_observers ||= {}
+        unless @array_object_observers.has_key?(property_name)
+          @array_object_observers[property_name] = ObservableModel::Notifier.new(self, property_name)
+        end
+        @array_object_observers[property_name]
+      end
+    end
+  end
+end

data/lib/glimmer/swt/observer.rb

@@ -0,0 +1,117 @@
+require 'set'
+
+module Glimmer
+  module SWT
+    # Mixin representing Observer trait from Observer Design Pattern
+    # Allows classes to include without interfering with their
+    # inheritance hierarchy.
+    #
+    # Includes a default implementation that can receive an observer block
+    # Example: Observer.proc {|new_value| puts new_value}
+    # Subclasses may override
+    module Observer
+      # Observer Proc default implementation that takes an observer block to process updates
+      # via call method
+      class Proc
+        include Observer
+
+        def initialize(&observer_block)
+          @observer_block = observer_block
+        end
+
+        # Called by observables once updates occur sending in the new_value if any
+        def call(new_value=nil)
+          @observer_block.call(new_value)
+        end
+      end
+
+      class << self
+        def proc(&observer_block)
+          Proc.new(&observer_block)
+        end
+      end
+
+      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)
+        unless observable.is_a?(Observable)
+          # TODO refactor code to be more smart/polymorphic/automated and honor open/closed principle
+          if observable.is_a?(Array)
+            observable.extend(ObservableArray)
+          else
+            observable.extend(ObservableModel)
+          end
+        end
+        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 call(new_value)
+        raise 'Not implemented!'
+      end
+    end
+  end
+end

data/lib/glimmer/swt/proc_tracker.rb

@@ -0,0 +1,16 @@
+module Glimmer
+  module SWT
+    class ProcTracker < DelegateClass(Proc)
+      def initialize(proc)
+        super(proc)
+      end
+      def call(*args)
+        __getobj__.call(*args)
+        @called = true
+      end
+      def called?
+        !!@called
+      end
+    end
+  end
+end

data/lib/glimmer/swt/table_items_binding.rb

@@ -0,0 +1,47 @@
+require_relative 'observable_array'
+require_relative 'observable_model'
+require_relative 'observable'
+require_relative 'observer'
+
+module Glimmer
+  module SWT
+    class TableItemsBinding
+      include Glimmer
+      include Observable
+      include Observer
+      include_package 'org.eclipse.swt'
+      include_package 'org.eclipse.swt.widgets'
+
+      def initialize(parent, model_binding, column_properties)
+        @table = parent
+        @model_binding = model_binding
+        @column_properties = column_properties
+        call(@model_binding.evaluate_property)
+        model = model_binding.base_model
+        observe(model, model_binding.property_name_expression)
+        add_contents(@table) {
+          on_widget_disposed { |dispose_event|
+            unregister_all_observables
+          }
+        }
+      end
+      def call(model_collection=nil)
+        if model_collection and model_collection.is_a?(Array)
+          observe(model_collection, @column_properties)
+          @model_collection = model_collection
+        end
+        populate_table(@model_collection, @table, @column_properties)
+      end
+      def populate_table(model_collection, parent, column_properties)
+        parent.widget.removeAll
+        model_collection.each do |model|
+          table_item = TableItem.new(parent.widget, GSWT[:none])
+          for index in 0..(column_properties.size-1)
+            table_item.setText(index, model.send(column_properties[index]).to_s)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/glimmer/swt/tree_items_binding.rb

@@ -0,0 +1,51 @@
+require_relative 'observable_array'
+require_relative 'observable_model'
+require_relative 'observable'
+require_relative 'observer'
+
+module Glimmer
+  module SWT
+    class TreeItemsBinding
+      include Glimmer
+      include Observable
+      include Observer
+      include_package 'org.eclipse.swt'
+      include_package 'org.eclipse.swt.widgets'
+
+      def initialize(parent, model_binding, tree_properties)
+        @tree = parent
+        @model_binding = model_binding
+        @tree_properties = [tree_properties].flatten.first.to_h
+        call(@model_binding.evaluate_property)
+        model = model_binding.base_model
+        observe(model, model_binding.property_name_expression)
+        add_contents(@tree) {
+          on_widget_disposed { |dispose_event|
+            unregister_all_observables
+          }
+        }
+      end
+      def call(model_tree_root_node=nil)
+        if model_tree_root_node and model_tree_root_node.respond_to?(@tree_properties[:children])
+          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)
+      end
+      def populate_tree(model_tree_root_node, parent, tree_properties)
+        parent.widget.removeAll
+        populate_tree_node(model_tree_root_node, parent.widget, tree_properties)
+      end
+      def populate_tree_node(model_tree_node, parent, tree_properties)
+        table_item = TreeItem.new(parent, GSWT[:none])
+        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|
+          observe(child, @tree_properties[:text])
+          populate_tree_node(child, table_item, tree_properties)
+        end
+      end
+
+    end
+  end
+end