glimmer 0.7.7 → 0.9.0

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

data/lib/glimmer/data_binding/observable_widget.rb

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

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

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

@@ -1,47 +0,0 @@
-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
-        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(model_collection=nil)
-        if model_collection and model_collection.is_a?(Array)
-          # TODO clean observer registrations 
-          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.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
-        end
-      end
-    end
-  end
-end

data/lib/glimmer/data_binding/tree_items_binding.rb

@@ -1,71 +0,0 @@
-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 TreeItemsBinding
-      include DataBinding::Observable
-      include DataBinding::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
-        if @tree.respond_to?(:tree_properties=)
-          @tree.tree_properties = @tree_properties
-        else # assume custom widget
-          @tree.body_root.tree_properties = @tree_properties
-        end
-        call
-        model = model_binding.base_model
-        observe(model, model_binding.property_name_expression)
-        @tree.on_widget_disposed do |dispose_event|
-          unregister_all_observables
-        end
-      end
-
-      def call(new_value=nil)
-        @model_tree_root_node = @model_binding.evaluate_property
-        populate_tree(@model_tree_root_node, @tree, @tree_properties)
-      end
-
-      def populate_tree(model_tree_root_node, parent, tree_properties)
-        # TODO make it change things by delta instead of removing all
-        selected_tree_item_model = parent.swt_widget.getSelection.map(&:getData).first
-        old_tree_items = parent.all_tree_items
-        old_tree_item_expansion_by_data = old_tree_items.reduce({}) {|hash, ti| hash.merge(ti.getData => ti.getExpanded)}
-        old_tree_items.each do |tree_item|
-          tree_item.getData('observer_registrations').each do |key, observer_registration|
-            observer_registration.unregister
-          end          
-        end        
-        parent.swt_widget.removeAll
-        populate_tree_node(model_tree_root_node, parent.swt_widget, tree_properties)
-        parent.all_tree_items.each { |ti| ti.setExpanded(!!old_tree_item_expansion_by_data[ti.getData]) }
-        tree_item_to_select = parent.depth_first_search {|ti| ti.getData == selected_tree_item_model}
-        parent.swt_widget.setSelection(tree_item_to_select)
-      end
-
-      def populate_tree_node(model_tree_node, parent, tree_properties)
-        return if model_tree_node.nil?
-        # TODO anticipate default tree properties if none were passed (like literal values text and children)
-        tree_item = TreeItem.new(parent, SWT::SWTProxy[:none])
-        observer_registrations = @tree_properties.reduce({}) do |hash, key_value_pair|
-          hash.merge(key_value_pair.first => observe(model_tree_node, key_value_pair.last))
-        end
-        tree_item.setData('observer_registrations', observer_registrations)
-        tree_item.setData(model_tree_node)
-        tree_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|
-          populate_tree_node(child, tree_item, tree_properties)
-        end
-      end
-    end
-  end
-end

data/lib/glimmer/data_binding/widget_binding.rb

@@ -1,33 +0,0 @@
-require 'glimmer'
-require_relative 'observable'
-require_relative 'observer'
-
-module Glimmer
-  module DataBinding
-    class WidgetBinding
-      include Glimmer
-      include Observable
-      include Observer
-
-      attr_reader :widget, :property
-      def initialize(model, property, translator = nil)
-        @widget = model
-        @property = property
-        @translator = translator || proc {|value| value}
-
-        if @widget.respond_to?(:dispose)
-          @widget.on_widget_disposed do |dispose_event|
-            unregister_all_observables
-          end
-        end
-      end
-      def call(value)
-        converted_value = translated_value = @translator.call(value)
-        @widget.set_attribute(@property, converted_value) unless evaluate_property == converted_value
-      end
-      def evaluate_property
-        @widget.get_attribute(@property)
-      end
-    end
-  end
-end

data/lib/glimmer/dsl/css/css_expression.rb

@@ -1,21 +0,0 @@
-require 'glimmer/dsl/static_expression'
-require 'glimmer/dsl/top_level_expression'
-require 'glimmer/dsl/parent_expression'
-require 'glimmer/css/style_sheet'
-
-module Glimmer
-  module DSL
-    module CSS
-      # This static html expression flips the DSL switch on for 
-      # XML DSL in Glimmer
-      class CssExpression < StaticExpression
-        include TopLevelExpression
-        include ParentExpression
-
-        def interpret(parent, keyword, *args, &block)
-          Glimmer::CSS::StyleSheet.new
-        end
-      end
-    end
-  end
-end