glimmer 0.9.0 → 0.9.5

data/VERSION

@@ -1 +1 @@
-0.9.0
+0.9.5

data/lib/glimmer.rb

@@ -5,6 +5,10 @@
 require 'logger'
 require 'set'
 
+$LOAD_PATH.unshift(File.expand_path('..', __FILE__))
+
+require 'glimmer/config'
+
 # Glimmer provides a JRuby Desktop UI DSL + Data-Binding functionality
 #
 # A desktop UI application class must include Glimmer to gain access to Glimmer DSL
@@ -14,14 +18,45 @@ require 'set'
 module Glimmer
   #TODO make it configurable to include or not include perhaps reverting to using included
   REGEX_METHODS_EXCLUDED = /^(to_|\[)/
+  
+  # TODO add loop detection support to avoid infinite loops (perhaps breaks after 3 repetitions and provides an option to allow it if intentional)
+  class << self
+    attr_accessor :loop_last_data
+    
+    def loop_reset!(including_loop_last_data = false)
+      @loop_last_data = nil if including_loop_last_data
+      @loop = 1
+    end
+    
+    def loop
+      @loop ||= loop_reset!
+    end
+    
+    def loop_increment!
+      @loop = loop + 1
+    end
+  end
 
   def method_missing(method_symbol, *args, &block)
+    new_loop_data = [method_symbol, args, block]
+    if new_loop_data == Glimmer.loop_last_data
+      Glimmer.loop_increment!
+      if Glimmer.loop == Config.loop_max_count
+        raise "Glimmer looped #{Config.loop_max_count} times with keyword '#{new_loop_data[0]}'! Check code for errors."
+      end
+    else
+      Glimmer.loop_reset!
+    end
+    Glimmer.loop_last_data = new_loop_data
     # This if statement speeds up Glimmer in girb or whenever directly including on main object
     if method_symbol.to_s.match(REGEX_METHODS_EXCLUDED)
-      raise InvalidKeywordError, "Glimmer excluded keyword: #{method_symbol}"
+      raise ExcludedKeywordError, "Glimmer excluded keyword: #{method_symbol}"
     end
     Glimmer::Config.logger&.debug "Interpreting keyword: #{method_symbol}"
     Glimmer::DSL::Engine.interpret(method_symbol, *args, &block)
+  rescue ExcludedKeywordError => e
+    # TODO add a feature to show excluded keywords optionally for debugging purposes
+    super(method_symbol, *args, &block)
   rescue InvalidKeywordError => e
     if !method_symbol.to_s.match(REGEX_METHODS_EXCLUDED)
       Glimmer::Config.logger&.error e.message
@@ -31,8 +66,7 @@ module Glimmer
   end
 end
 
-$LOAD_PATH.unshift(File.expand_path('..', __FILE__))
-
-require 'glimmer/config'
 require 'glimmer/error'
+require 'glimmer/excluded_keyword_error'
 require 'glimmer/invalid_keyword_error'
+require 'glimmer/dsl/engine'

data/lib/glimmer/config.rb

@@ -1,6 +1,14 @@
 module Glimmer
   module Config
     class << self
+      LOOP_MAX_COUNT_DEFAULT = 100
+      
+      attr_writer :loop_max_count
+      
+      def loop_max_count
+        @loop_max_count ||= LOOP_MAX_COUNT_DEFAULT
+      end
+      
       # Returns Glimmer logger (standard Ruby logger)
       def logger
         # unless defined? @@logger

data/lib/glimmer/data_binding/model_binding.rb

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

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

@@ -0,0 +1,86 @@
+require 'set'
+
+require 'glimmer/data_binding/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 <<(element)
+        super(element)
+        notify_observers
+      end
+      
+      def []=(index, value)
+        old_value = self[index]
+        unregister_dependent_observers(old_value)
+        super(index, value)
+        notify_observers
+      end
+      
+      def delete(element)
+        unregister_dependent_observers(element)
+        super(element)
+        notify_observers
+      end
+      
+      def delete_at(index)
+        old_value = self[index]
+        unregister_dependent_observers(old_value)
+        super(index)
+        notify_observers
+      end
+      
+      def clear
+        each do |old_value|
+          unregister_dependent_observers(old_value)
+        end
+        super()
+        notify_observers
+      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

@@ -0,0 +1,104 @@
+require 'glimmer/data_binding/observable'
+require 'glimmer/data_binding/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
+          singleton_method("__original_#{property_writer_name}")
+        rescue
+          old_method = self.class.instance_method(property_writer_name) rescue self.method(property_writer_name)
+          define_singleton_method("__original_#{property_writer_name}", old_method)
+          define_singleton_method(property_writer_name) do |value|
+            old_value = self.send(property_name)
+            unregister_dependent_observers(property_name, old_value)
+            self.send("__original_#{property_writer_name}", value)
+            notify_observers(property_name)
+            ensure_array_object_observer(property_name, value, old_value)
+          end
+        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