glimmer 0.3.5 → 0.4.0

data/lib/glimmer/command_handlers/models/g_widget_listener.rb

@@ -0,0 +1,11 @@
+module Glimmer
+  class GWidgetListener
+
+    attr_reader :listener
+
+    def initialize(listener)
+      @listener = listener
+    end
+
+  end
+end

data/lib/glimmer/command_handlers/models/list_selection_binding.rb

@@ -0,0 +1,47 @@
+require_relative 'observable'
+require_relative 'observer'
+
+module Glimmer
+  # SWT List widget selection binding
+  class ListSelectionBinding
+    include Glimmer
+    include Observable
+    include Observer
+
+    attr_reader :widget
+    @@property_type_updaters = {
+      :string => lambda { |widget, value| widget.widget.select(widget.widget.index_of(value.to_s)) },
+      :array => lambda { |widget, value| widget.widget.selection=((value or []).to_java :string) }
+    }
+    @@property_evaluators = {
+      :string => lambda do |selection_array|
+        return nil if selection_array.empty?
+        selection_array[0]
+      end,
+      :array => lambda do |selection_array|
+        selection_array
+      end
+    }
+    # Initialize with list widget and property_type
+    # property_type :string represents default list single selection
+    # property_type :array represents list multi selection
+    def initialize(widget, property_type)
+      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 call(value)
+      @@property_type_updaters[@property_type].call(@widget, value) unless evaluate_property == value
+    end
+    def evaluate_property
+      selection_array = @widget.widget.send("selection").to_a
+      property_value = @@property_evaluators[@property_type].call(selection_array)
+      return property_value
+    end
+  end
+end

data/lib/glimmer/command_handlers/models/model_binding.rb

@@ -0,0 +1,206 @@
+require_relative 'observable'
+require_relative 'observer'
+
+module Glimmer
+  class ModelBinding
+    include Observable
+    include Observer
+
+    attr_reader :property_type, :binding_options
+    @@property_type_converters = {
+      :undefined => lambda { |value| value },
+      :fixnum => lambda { |value| value.to_i },
+      :array => lambda { |value| value.to_a }
+    }
+    def initialize(base_model, property_name_expression, property_type = :undefined, binding_options = nil)
+      property_type = :undefined if property_type.nil?
+      @base_model = base_model
+      @property_name_expression = property_name_expression
+      @property_type = property_type
+      @binding_options = binding_options || {}
+      if computed?
+        @computed_model_bindings = computed_by.map do |computed_by_property_expression|
+          self.class.new(base_model, computed_by_property_expression, :undefined, computed_binding_options)
+        end
+      end
+    end
+    def model
+      nested_property? ? nested_model : base_model
+    end
+    # e.g. person.address.state returns [person, person.address]
+    def nested_models
+      @nested_models = [base_model]
+      model_property_names.reduce(base_model) do |reduced_model, nested_model_property_name|
+        if reduced_model.nil?
+          nil
+        else
+          invoke_property_reader(reduced_model, nested_model_property_name).tap do |new_reduced_model|
+            @nested_models << new_reduced_model
+          end
+        end
+      end
+      @nested_models
+    end
+    def nested_model
+      nested_models.last
+    end
+    def base_model
+      @base_model
+    end
+    def property_name
+      nested_property? ? nested_property_name : property_name_expression
+    end
+    # All nested property names
+    # e.g. property name expression "address.state" gives ['address', 'state']
+    # If there are any indexed property names, this returns indexes as properties.
+    # e.g. property name expression "addresses[1].state" gives ['addresses', '[1]', 'state']
+    def nested_property_names
+      @nested_property_names ||= property_name_expression.split(".").map {|pne| pne.match(/([^\[]+)(\[[^\]]+\])?/).to_a.drop(1)}.flatten.compact
+    end
+    # Final nested property name
+    # e.g. property name expression "address.state" gives :state
+    def nested_property_name
+      nested_property_names.last
+    end
+    # Model representing nested property names
+    # e.g. property name expression "address.state" gives [:address]
+    def model_property_names
+      nested_property_names[0...-1]
+    end
+    def nested_property?
+      property_name_expression.match(/[.\[]/)
+    end
+    def property_name_expression
+      @property_name_expression
+    end
+    def computed?
+      !!computed_by
+    end
+    def computed_by
+      @binding_options[:computed_by]
+    end
+    def computed_binding_options
+      @binding_options.reject {|k,v| k == :computed_by}
+    end
+    def nested_property_observers_for(observer)
+      @nested_property_observers_collection ||= {}
+      unless @nested_property_observers_collection.has_key?(observer)
+        @nested_property_observers_collection[observer] = nested_property_names.reduce({}) do |output, property_name|
+          output.merge(
+            property_name => Observer.proc do |new_value|
+              # Ensure reattaching observers when a higher level nested property is updated (e.g. person.address changes reattaches person.address.street observer)
+              add_observer(observer)
+              observer.call(evaluate_property)
+            end
+          )
+        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
+        observer.observe(model, property_name)
+        observer.add_dependent([self, nil] => [observer, model, property_name])
+      end
+    end
+    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.delete(observer)
+      elsif nested_property?
+        nested_property_observers_for(observer).clear
+      else
+        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] = Observer.proc do |new_value|
+          observer.call(evaluate_property)
+        end
+      end
+      @computed_observer_collection[observer]
+    end
+    def add_computed_observers(observer)
+      @computed_model_bindings.each do |computed_model_binding|
+        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_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)
+            # TODO figure out a way to deal with this more uniformly
+            nested_property_observer.observe(model)
+            parent_observer.add_dependent([parent_model, parent_property_name] => [nested_property_observer, model, nil])
+          else
+            nested_property_observer.observe(model, property_name)
+            parent_observer.add_dependent([parent_model, parent_property_name] => [nested_property_observer, model, property_name])
+          end
+        end
+      end
+    end
+    def call(value)
+      return if model.nil?
+      converted_value = @@property_type_converters[@property_type].call(value)
+      invoke_property_writer(model, "#{property_name}=", converted_value) unless evaluate_property == converted_value
+    end
+    def evaluate_property
+      invoke_property_reader(model, property_name) unless model.nil?
+    end
+    def evaluate_options_property
+      model.send(options_property_name) unless model.nil?
+    end
+    def options_property_name
+      self.property_name + "_options"
+    end
+    def property_indexed?(property_expression)
+      property_expression.start_with?('[')
+    end
+    def invoke_property_reader(object, property_expression)
+      if property_indexed?(property_expression)
+        property_method = '[]'
+        property_argument = property_expression[1...-1]
+        property_argument = property_argument.to_i if property_argument.match(/\d+/)
+        object.send(property_method, property_argument)
+      else
+        object.send(property_expression)
+      end
+    end
+    def invoke_property_writer(object, property_expression, value)
+      if property_indexed?(property_expression)
+        property_method = '[]='
+        property_argument = property_expression[1...-2]
+        property_argument = property_argument.to_i if property_argument.match(/\d+/)
+        object.send(property_method, property_argument, value)
+      else
+        object.send(property_expression, value)
+      end
+    end
+  end
+end

data/lib/glimmer/command_handlers/models/observable.rb

@@ -0,0 +1,11 @@
+module Glimmer
+  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

data/lib/glimmer/command_handlers/models/observable_array.rb

@@ -0,0 +1,104 @@
+require 'set'
+
+require_relative 'observable'
+
+module Glimmer
+  # 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

data/lib/glimmer/command_handlers/models/observable_model.rb

@@ -0,0 +1,105 @@
+require 'set'
+
+require_relative 'observable'
+require_relative 'observer'
+
+module Glimmer
+  # 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