glimmer 0.8.2 → 0.9.0

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,56 +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
-        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

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

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

@@ -1,10 +0,0 @@
-require 'glimmer/dsl/engine'
-Dir[File.expand_path('../*_expression.rb', __FILE__)].each {|f| require f}
-
-Glimmer::DSL::Engine.add_dynamic_expressions(
-  Glimmer::DSL::CSS,
-  %w[
-    rule
-    dynamic_property
-  ]
-)

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

@@ -1,12 +0,0 @@
-require 'glimmer/dsl/expression'
-require 'glimmer/dsl/css/property_expression'
-
-module Glimmer
-  module DSL
-    module CSS
-      class DynamicPropertyExpression < Expression
-        include PropertyExpression
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-require 'glimmer/dsl/expression'
-require 'glimmer/css/rule'
-
-module Glimmer
-  module DSL
-    module CSS
-      module PropertyExpression
-        include ParentExpression
-
-        def can_interpret?(parent, keyword, *args, &block)
-          parent.is_a?(Glimmer::CSS::Rule) and
-            !block_given? and
-            !args.empty?
-        end
-
-        def interpret(parent, keyword, *args, &block)
-          parent.add_property(keyword, *args)
-        end
-      end
-    end
-  end
-end

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

@@ -1,17 +0,0 @@
-require 'glimmer/dsl/static_expression'
-require 'glimmer/dsl/css/property_expression'
-
-module Glimmer
-  module DSL
-    module CSS
-      # Static keyword 'pv' version of CSS DSL dynamic property expression
-      class PVExpression < StaticExpression
-        include PropertyExpression
-
-        def interpret(parent, keyword, *args, &block)
-          parent.add_property(args[0], args[1])
-        end
-      end
-    end
-  end
-end

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

@@ -1,25 +0,0 @@
-require 'glimmer/dsl/expression'
-require 'glimmer/css/style_sheet'
-require 'glimmer/css/rule'
-
-module Glimmer
-  module DSL
-    module CSS
-      class RuleExpression < Expression
-        include ParentExpression
-
-        def can_interpret?(parent, keyword, *args, &block)
-          parent.is_a?(Glimmer::CSS::StyleSheet) and
-            block_given? and
-            args.empty?
-        end
-
-        def interpret(parent, keyword, *args, &block)
-          Glimmer::CSS::Rule.new(keyword.to_s.downcase).tap do |rule|
-            parent.rules << rule
-          end
-        end
-      end
-    end
-  end
-end