glimmer 0.3.5 → 0.4.0

data/lib/command_handlers/models/observable.rb

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

data/lib/command_handlers/models/observable_array.rb

@@ -1,102 +0,0 @@
-require 'set'
-
-require_relative 'observable'
-
-# 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.update}
-  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

data/lib/command_handlers/models/observable_model.rb

@@ -1,103 +0,0 @@
-require 'set'
-
-require_relative 'observable'
-require_relative 'observer'
-
-# TODO prefix utility methods with double-underscore
-module ObservableModel
-  include Observable
-
-  class Updater
-    include Observer
-    def initialize(observable_model, property_name)
-      @observable_model = observable_model
-      @property_name = property_name
-    end
-    def update(changed_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.update(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::Updater.new(self, property_name)
-    end
-    @array_object_observers[property_name]
-  end
-end

data/lib/command_handlers/models/observer.rb

@@ -1,88 +0,0 @@
-require 'set'
-
-# Mixin representing Observer trait from Observer Design Pattern
-# Allows classes to include without interfering with their
-# inheritance hierarchy.
-module Observer
-  def registrations
-    @registrations ||= Set.new
-  end
-
-  def registrations_for(observable, property = nil)
-    registrations.select {|o, p| o == observable && p == 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)
-    [observable, property].tap do |registration|
-      self.registrations << registration
-    end
-  end
-  alias observe register
-
-  def unregister(observable, property = nil)
-    observable.remove_observer(*[self, property].compact)
-    registration = [observable, property]
-    dependents_for(registration).each do |dependent|
-      dependent_observer, dependent_observable, dependent_property = dependent
-      dependent_observer.unregister(dependent_observable, dependent_property)
-      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 |d_observer, d_observable, d_property|
-      d_observable == dependent_observable
-    end
-    thedependents.each do |d_observer, d_observable, d_property|
-      d_observer.unregister(d_observable, d_property)
-    end
-  end
-
-  # cleans up all registrations in observables
-  def unregister_all_observables
-    registrations.each do |observable, property|
-      unregister(observable, property)
-    end
-  end
-  alias unobserve_all_observables unregister_all_observables
-
-  # add dependent observer to unregister when unregistering observer
-  def add_dependent(parent_to_dependent_hash)
-    observable, property = registration = parent_to_dependent_hash.keys.first
-    dependent_observer, dependent_observable, dependent_property = dependent = parent_to_dependent_hash.values.first
-    dependents_for(registration) << dependent
-  end
-
-  def remove_dependent(parent_to_dependent_hash)
-    observable, property = registration = parent_to_dependent_hash.keys.first
-    dependent_observer, dependent_observable, dependent_property = dependent = parent_to_dependent_hash.values.first
-    dependents_for(registration).delete(dependent)
-  end
-
-  def update(changed_value)
-    raise 'Not implemented!'
-  end
-end

data/lib/command_handlers/models/r_color.rb

@@ -1,32 +0,0 @@
-require_relative 'r_swt'
-
-class RColor
-  attr_reader :display, :red, :green, :blue, :alpha
-
-  include_package 'org.eclipse.swt.graphics'
-
-  class << self
-    include_package 'org.eclipse.swt'
-
-    def for(display, standard_color)
-      display.getSystemColor(RSwt[standard_color])
-    end
-  end
-
-  def initialize(display, red, green, blue, alpha = nil)
-    @display = display
-    @red = red
-    @green = green
-    @blue = blue
-    @alpha = alpha
-  end
-
-  def color
-    @color ||= Color.new(@display, *[@red, @green, @blue, @alpha].compact)
-  end
-
-  def display=(a_display)
-    @display = a_display
-    @color = nil
-  end
-end

data/lib/command_handlers/models/r_font.rb

@@ -1,60 +0,0 @@
-require_relative 'r_swt'
-
-class RFont
-  include_package 'org.eclipse.swt.graphics'
-
-  extend Glimmer
-
-  attr_reader :r_widget
-  attr_accessor :display
-
-  class << self
-    def for(r_widget)
-      @instances ||= {}
-      unless @instances[r_widget]
-        @instances[r_widget] = new(r_widget)
-        add_contents(r_widget) {
-          on_widget_disposed { |dispose_event|
-            @instances.delete(r_widget)
-          }
-        }
-      end
-      @instances[r_widget]
-    end
-  end
-
-  def initialize(r_widget, display = nil)
-    @r_widget = r_widget
-    @display = display || @r_widget.widget.display
-  end
-
-  def r_widget=(a_widget)
-    @r_widget = a_widget
-    @font_datum = nil
-  end
-
-  def font_datum
-    @font_datum ||= @r_widget.widget.getFont.getFontData[0]
-  end
-
-  def name
-    font_datum.getName
-  end
-
-  def height
-    font_datum.getHeight
-  end
-
-  def style
-    font_datum.getStyle
-  end
-
-  def font(font_properties)
-    font_properties[:style] = RSwt[*font_properties[:style]]
-    font_data_args = [:name, :height, :style].map do |font_property_name|
-      font_properties[font_property_name] || send(font_property_name)
-    end
-    font_datum = FontData.new(*font_data_args)
-    Font.new(@display, font_datum)
-  end
-end

data/lib/command_handlers/models/r_runnable.rb

@@ -1,11 +0,0 @@
-class RRunnable
-  include java.lang.Runnable
-  
-  def initialize(&block)
-    @block = block
-  end
-  
-  def run
-    @block.call
-  end
-end

data/lib/command_handlers/models/r_shell.rb

@@ -1,24 +0,0 @@
-require_relative 'r_widget'
-
-class RShell < RWidget
-  include_package 'org.eclipse.swt.layout'
-  include_package 'org.eclipse.swt.widgets'
-
-  attr_reader :display
-
-  def initialize(display = Display.new)
-    @display = display
-    @widget = Shell.new(@display)
-    @widget.setLayout(FillLayout.new)
-  end
-
-  def open
-    @widget.pack
-    @widget.open
-    until @widget.isDisposed
-      @display.sleep unless @display.readAndDispatch
-    end
-    @display.dispose
-  end
-
-end

data/lib/command_handlers/models/r_swt.rb

@@ -1,18 +0,0 @@
-class RSwt
-  class << self
-    # Gets SWT constants as if calling SWT::CONSTANT where constant is
-    # passed in as a lower case symbol
-    def [](*symbols)
-      symbols.compact.reduce(0) { |output, symbol| output | constant(symbol) }
-    end
-
-    def constant(symbol)
-      return symbol if symbol.is_a?(Integer)
-      swt_constant_symbol = symbol.to_s.upcase.to_sym
-      org.eclipse.swt.SWT.const_get(swt_constant_symbol)
-    rescue
-      swt_constant_symbol = org.eclipse.swt.SWT.constants.find {|c| c.to_s.upcase == swt_constant_symbol.to_s}
-      org.eclipse.swt.SWT.const_get(swt_constant_symbol)
-    end
-  end
-end