glimmer-dsl-swt 0.1.0

data/lib/glimmer/data_binding/observable.rb

@@ -0,0 +1,21 @@
+require 'glimmer/error'
+
+module Glimmer
+  module DataBinding
+    module Observable
+      # TODO rename methods to observe/unobserve
+      def add_observer(observer, property_or_properties=nil)
+        raise Error, 'Not implemented!'
+      end
+
+      def remove_observer(observer, property_or_properties=nil)
+        raise Error, 'Not implemented!'
+      end
+ 
+      # Overriding inspect to avoid printing very long observer hierarchies
+      def inspect
+        "#<#{self.class.name}:0x#{self.hash.to_s(16)}>"
+      end
+    end
+  end
+end

data/lib/glimmer/data_binding/observable_array.rb

@@ -0,0 +1,107 @@
+require 'set'
+
+require_relative 'observable'
+
+module Glimmer
+  module DataBinding
+    # 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)
+        # TODO consider alias_method, and define_method instead
+
+        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(observer.registration_for(self), old_value)
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/data_binding/observable_model.rb

@@ -0,0 +1,108 @@
+require 'glimmer'
+
+require_relative 'observable'
+require_relative 'observer'
+
+module Glimmer
+  module DataBinding
+    # 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
+      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
+          # TODO consider alias_method or define_method instead
+          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::Config.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(observer.registration_for(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_observer_registration = array_object_observer.observe(object)
+        property_observer_list(property_name).each do |observer|
+          my_registration = observer.registration_for(self, property_name) # TODO eliminate repetition
+          observer.add_dependent(my_registration => array_observer_registration)
+        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/data_binding/observable_widget.rb

@@ -0,0 +1,17 @@
+module Glimmer
+  module DataBinding
+    module ObservableWidget
+      # TODO see if it is worth it to eliminate duplication of method_missing
+      # from WidgetProxy using a module
+
+      def method_missing(method, *args, &block)
+        method_name = method.to_s
+        if can_handle_observation_request?(method_name)
+          handle_observation_request(method_name, &block)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/data_binding/observer.rb

@@ -0,0 +1,124 @@
+require 'glimmer/error'
+
+module Glimmer
+  module DataBinding
+    # 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 Registration < Struct.new(:observer, :observable, :property, keyword_init: true)
+        def unregister
+          observer.unobserve(observable, property)
+        end
+        alias unobserve unregister
+      end
+
+      class << self
+        def proc(&observer_block)
+          Proc.new(&observer_block)
+        end
+      end
+
+      def registrations
+        @registrations ||= Set.new
+      end
+
+      def registration_for(observable, property = nil)
+        Registration.new(observer: self, observable: observable, property: 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)
+        registration_for(observable, property).tap do |registration|
+          self.registrations << registration
+        end
+      end
+      alias observe register
+
+      def unregister(observable, property = nil)
+        # TODO optimize performance in the future via indexing and/or making a registration official object/class
+        observable.remove_observer(*[self, property].compact)
+        registration = registration_for(observable, property)
+        dependents_for(registration).each do |dependent|
+          dependent.unregister
+          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 |thedependent|
+          thedependent.observable == dependent_observable
+        end
+        thedependents.each do |thedependent|
+          thedependent.unregister
+        end
+      end
+
+      # cleans up all registrations in observables
+      def unregister_all_observables
+        registrations.each do |registration|
+          registration.unregister
+        end
+      end
+      alias unobserve_all_observables unregister_all_observables
+
+      # add dependent observer to unregister when unregistering observer
+      def add_dependent(parent_to_dependent_hash)
+        registration = parent_to_dependent_hash.keys.first
+        dependent = parent_to_dependent_hash.values.first
+        dependents_for(registration) << dependent
+      end
+
+      def remove_dependent(parent_to_dependent_hash)
+        registration = parent_to_dependent_hash.keys.first
+        dependent = parent_to_dependent_hash.values.first
+        dependents_for(registration).delete(dependent)
+      end
+
+      def call(new_value)
+        raise Error, 'Not implemented!'
+      end
+    end
+  end
+end

data/lib/glimmer/data_binding/shine.rb

@@ -0,0 +1,23 @@
+## NOTE: Unsupported in Ruby 2 syntax
+#
+# require File.dirname(__FILE__) + "/glimmer"
+#
+# class Array
+#   include Glimmer
+#
+#   alias original_compare <=>
+#
+#   def <=>(other)
+#     if (self[0].class.name == "WidgetProxy")
+#       content(self[0]) {
+#         if (other.size == 2)
+#           eval("#{self[1]} bind (other[0], other[1])")
+#         elsif (other.size == 3)
+#           eval("#{self[1]} bind (other[0], other[1], other[2])")
+#         end
+#       }
+#     else
+#       original_compare(other)
+#     end
+#   end
+# end

data/lib/glimmer/data_binding/table_items_binding.rb

@@ -0,0 +1,56 @@
+require 'glimmer/data_binding/observable_array'
+require 'glimmer/data_binding/observable_model'
+require 'glimmer/data_binding/observable'
+require 'glimmer/data_binding/observer'
+require 'glimmer/swt/swt_proxy'
+
+module Glimmer
+  module DataBinding
+    class TableItemsBinding
+      include DataBinding::Observable
+      include DataBinding::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
+        if @table.respond_to?(:column_properties=)
+          @table.column_properties = @column_properties
+        else # assume custom widget
+          @table.body_root.column_properties = @column_properties
+        end
+        call(@model_binding.evaluate_property)
+        model = model_binding.base_model
+        observe(model, model_binding.property_name_expression)
+        @table.on_widget_disposed do |dispose_event|
+          unregister_all_observables
+        end
+      end
+
+      def call(new_model_collection=nil)
+        if new_model_collection and new_model_collection.is_a?(Array)
+          observe(new_model_collection, @column_properties)
+          @model_collection = new_model_collection
+        end
+        populate_table(@model_collection, @table, @column_properties)
+      end
+
+      def populate_table(model_collection, parent, column_properties)
+        selected_table_item_models = parent.swt_widget.getSelection.map(&:getData)
+        parent.swt_widget.removeAll
+        model_collection.each do |model|
+          table_item = TableItem.new(parent.swt_widget, SWT::SWTProxy[:none])
+          for index in 0..(column_properties.size-1)
+            table_item.setText(index, model.send(column_properties[index]).to_s)
+          end
+          table_item.setData(model)
+        end
+        selected_table_items = parent.search {|item| selected_table_item_models.include?(item.getData) }
+        selected_table_items = [parent.swt_widget.getItems.first].to_java(TableItem) if selected_table_items.empty? && !parent.swt_widget.getItems.empty?
+        parent.swt_widget.setSelection(selected_table_items) unless selected_table_items.empty?
+      end
+    end
+  end
+end