glimmer 0.8.2 → 0.9.0

data/lib/glimmer/data_binding/list_selection_binding.rb

@@ -1,52 +0,0 @@
-require 'glimmer'
-require 'glimmer/data_binding/observable'
-require 'glimmer/data_binding/observer'
-
-module Glimmer
-  module DataBinding
-    # SWT List widget selection binding
-    class ListSelectionBinding
-      include Glimmer
-      include Observable
-      include Observer
-
-      attr_reader :widget_proxy
-
-      PROPERTY_TYPE_UPDATERS = {
-        :string => lambda { |widget_proxy, value| widget_proxy.swt_widget.select(widget_proxy.swt_widget.index_of(value.to_s)) },
-        :array => lambda { |widget_proxy, value| widget_proxy.swt_widget.selection=(value || []).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_proxy, property_type)
-        property_type = :string if property_type.nil? or property_type == :undefined
-        @widget_proxy = widget_proxy
-        @property_type = property_type
-        @widget_proxy.on_widget_disposed do |dispose_event|
-          unregister_all_observables
-        end
-      end
-
-      def call(value)
-        PROPERTY_TYPE_UPDATERS[@property_type].call(@widget_proxy, value) unless evaluate_property == value
-      end
-
-      def evaluate_property
-        selection_array = @widget_proxy.swt_widget.send('selection').to_a #TODO refactor send('selection') into proper method invocation
-        PROPERTY_EVALUATORS[@property_type].call(selection_array)
-      end
-    end
-  end
-end

data/lib/glimmer/data_binding/model_binding.rb

@@ -1,248 +0,0 @@
-require 'glimmer/data_binding/observable'
-require 'glimmer/data_binding/observer'
-
-module Glimmer
-  module DataBinding
-    class ModelBinding
-      include Observable
-      include Observer
-
-      attr_reader :binding_options
-
-      def initialize(base_model, property_name_expression, binding_options = nil)
-        @base_model = base_model
-        @property_name_expression = property_name_expression
-        @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)
-          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
-
-      def convert_on_read(value)
-        apply_converter(@binding_options[:on_read], value)
-      end
-
-      def convert_on_write(value)
-        apply_converter(@binding_options[:on_write], value)
-      end
-
-      def apply_converter(converter, value)
-        if converter.nil?
-          value
-        elsif converter.is_a?(String) || converter.is_a?(Symbol)
-          if value.respond_to?(converter)
-            value.send(converter)
-          else
-            raise Glimmer::Error, "Unsupported bind converter: #{converter.inspect}"
-          end
-        elsif converter.respond_to?(:call, value)
-          converter.call(value)
-        else
-          raise Glimmer::Error, "Unsupported bind converter: #{converter.inspect}"
-        end
-      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.empty?
-      end
-
-      def computed_by
-        [@binding_options[:computed_by]].flatten.compact
-      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]
-      end
-
-      def add_observer(observer)
-        if computed?
-          add_computed_observers(observer)
-        elsif nested_property?
-          add_nested_observers(observer)
-        else
-          model_binding_observer = Observer.proc do |new_value|
-            observer.call(evaluate_property)
-          end
-          observer_registration = model_binding_observer.observe(model, property_name)
-          my_registration = observer.registration_for(self)
-          observer.add_dependent(my_registration => observer_registration)
-        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|
-          observer_registration = computed_observer_for(observer).observe(computed_model_binding)
-          my_registration = observer.registration_for(self)
-          observer.add_dependent(my_registration => observer_registration)
-        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
-              observer_registration = nested_property_observer.observe(model)
-            else
-              observer_registration = nested_property_observer.observe(model, property_name)
-            end
-            parent_registration = parent_observer.registration_for(parent_model, parent_property_name)
-            parent_observer.add_dependent(parent_registration => observer_registration)
-          end
-        end
-      end
-
-      def call(value)
-        return if model.nil?
-        converted_value = value
-        invoke_property_writer(model, "#{property_name}=", converted_value) unless evaluate_property == converted_value
-      end
-
-      def evaluate_property
-        value = nil        
-        value = invoke_property_reader(model, property_name) unless model.nil?
-        convert_on_read(value)
-      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.to_s.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)
-        return if @binding_options[:read_only]
-        value = convert_on_write(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
-end

data/lib/glimmer/data_binding/observable.rb

@@ -1,21 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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

@@ -1,108 +0,0 @@
-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