glimmer 0.10.0 → 1.0.0

data/VERSION

@@ -1 +1 @@
-0.10.0
+1.0.0

data/lib/glimmer.rb

@@ -1,9 +1,27 @@
-# Glimmer - a JRuby DSL that enables easy and efficient authoring of user
-# interfaces using the robust platform-independent Eclipse SWT library. Glimmer
-# comes with built-in data-binding support to greatly facilitate synchronizing
-# UI with domain models.
+# Copyright (c) 2007-2020 Andy Maleh
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
 require 'logger'
 require 'set'
+require 'array_include_methods'
 
 $LOAD_PATH.unshift(File.expand_path('..', __FILE__))
 
@@ -17,7 +35,6 @@ require 'glimmer/config'
 # Glimmer DSL dynamic keywords (e.g. label, combo, etc...) are available via method_missing
 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
@@ -41,32 +58,26 @@ module Glimmer
     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
+      raise "Glimmer looped #{Config.loop_max_count} times with keyword '#{new_loop_data[0]}'! Check code for errors." if Glimmer.loop == Config.loop_max_count
     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 ExcludedKeywordError, "Glimmer excluded keyword: #{method_symbol}"
+    is_excluded = Config.excluded_keyword_checkers.reduce(false) {|result, checker| result || instance_exec(method_symbol, *args, &checker) }
+    if is_excluded
+      Glimmer::Config.logger.debug "Glimmer excluded keyword: #{method_symbol}" if Glimmer::Config.log_excluded_keywords?
+      super(method_symbol, *args, &block)
     end
-    Glimmer::Config.logger.debug {"Interpreting keyword: #{method_symbol}"}
+    Glimmer::Config.logger.info {"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}
-    end
-    Glimmer::Config.logger.debug {"#{e.message}\n#{e.backtrace.join("\n")}"}
+    Glimmer::Config.logger.error {"Encountered an invalid keyword at this object: #{self}"}
+    Glimmer::Config.logger.error {e.full_message}
     super(method_symbol, *args, &block)
   end
 end
 
 require 'glimmer/error'
-require 'glimmer/excluded_keyword_error'
 require 'glimmer/invalid_keyword_error'
 require 'glimmer/dsl/engine'

data/lib/glimmer/config.rb

@@ -1,16 +1,52 @@
+# Copyright (c) 2007-2020 Andy Maleh
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
 module Glimmer
   module Config
     class << self
       LOOP_MAX_COUNT_DEFAULT = 100
+      REGEX_METHODS_EXCLUDED = /^(to_|\[)/
       
       attr_writer :loop_max_count
+      attr_accessor :log_excluded_keywords
+      alias log_excluded_keywords? log_excluded_keywords
+      
+      def excluded_keyword_checkers
+        @excluded_keyword_checkers ||= reset_excluded_keyword_checkers!
+      end
+      
+      def excluded_keyword_checkers=(checkers)
+        @excluded_keyword_checkers = checkers
+      end
+      
+      def reset_excluded_keyword_checkers!
+        @excluded_keyword_checkers = [ lambda { |method_symbol, *args| method_symbol.to_s.match(REGEX_METHODS_EXCLUDED) } ]
+      end
       
       def loop_max_count
         @loop_max_count ||= LOOP_MAX_COUNT_DEFAULT
       end
       
       # Returns Glimmer logger (standard Ruby logger)
-      def logger
+      def logger      
         reset_logger! unless defined? @@logger
         @@logger
       end
@@ -22,12 +58,13 @@ module Glimmer
       def reset_logger!
         self.logger = Logger.new(STDOUT).tap do |logger| 
           logger.level = Logger::ERROR
+          begin
+            logger.level = ENV['GLIMMER_LOGGER_LEVEL'].strip.downcase if ENV['GLIMMER_LOGGER_LEVEL']
+          rescue => e
+            puts e.message
+          end
         end
       end
     end
   end
 end
-
-if ENV['GLIMMER_LOGGER_LEVEL']
-  Glimmer::Config.logger.level = ENV['GLIMMER_LOGGER_LEVEL'].downcase
-end

data/lib/glimmer/data_binding/model_binding.rb

@@ -1,3 +1,24 @@
+# Copyright (c) 2007-2020 Andy Maleh
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
 require 'glimmer/data_binding/observable'
 require 'glimmer/data_binding/observer'
 
@@ -7,7 +28,7 @@ module Glimmer
       include Observable
       include Observer
 
-      attr_reader :binding_options
+      attr_reader :binding_options, :property_name_expression
 
       def initialize(base_model, property_name_expression, binding_options = nil)
         @base_model = base_model
@@ -60,19 +81,10 @@ module Glimmer
       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
+        return value if converter.nil?          
+        return value.send(converter) if (converter.is_a?(String) || converter.is_a?(Symbol)) && value.respond_to?(converter)          
+        return converter.call(value) if converter.respond_to?(:call, value)          
+        raise Glimmer::Error, "Unsupported bind converter: #{converter.inspect}"
       end
 
       # All nested property names
@@ -99,10 +111,6 @@ module Glimmer
         property_name_expression.match(/[.\[]/)
       end
 
-      def property_name_expression
-        @property_name_expression
-      end
-
       def computed?
         !computed_by.empty?
       end
@@ -179,17 +187,19 @@ module Glimmer
           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]
+          if previous_index.negative?
+            parent_model = self
+            parent_property_name = nil
+            parent_observer = observer
+          else
+            parent_model = nested_models[previous_index]
+            parent_property_name = nested_property_names[previous_index]
+            parent_observer = nested_property_observers[parent_property_name]
+          end
           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
+            # TODO figure out a way to deal with this more uniformly
+            observer_registration = property_indexed?(property_name) ? nested_property_observer.observe(model) : nested_property_observer.observe(model, property_name)
             parent_registration = parent_observer.registration_for(parent_model, parent_property_name)
             parent_observer.add_dependent(parent_registration => observer_registration)
           end

data/lib/glimmer/data_binding/observable.rb

@@ -1,3 +1,24 @@
+# Copyright (c) 2007-2020 Andy Maleh
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
 require 'glimmer/error'
 
 module Glimmer

data/lib/glimmer/data_binding/observable_array.rb

@@ -1,85 +1,284 @@
-require 'set'
+# Copyright (c) 2007-2020 Andy Maleh
+# 
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+# 
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+# 
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
+require 'set'
 require 'glimmer/data_binding/observable'
+require 'array_include_methods'
+
+using ArrayIncludeMethods
 
 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?
+      def add_observer(observer, *element_properties)
+        element_properties = element_properties.flatten.compact.uniq
+        return observer if has_observer?(observer) && has_observer_element_properties?(observer, element_properties)
         property_observer_list << observer
-        [element_properties].flatten.compact.each do |property|
-          each do |element|
-            observer.observe(element, property)
-          end
-        end
+        observer_element_properties[observer] = element_properties_for(observer) + Set.new(element_properties)
+        each { |element| add_element_observer(element, observer) }
         observer
       end
+      
+      def add_element_observers(element)
+        property_observer_list.each do |observer|
+          add_element_observer(element, observer)
+        end
+      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
+      def add_element_observer(element, observer)
+        element_properties_for(observer).each do |property|
+          observer.observe(element, property)
+        end      
+      end
+
+      def remove_observer(observer, *element_properties)
+        element_properties = element_properties.flatten.compact.uniq
+        if !element_properties.empty?
+          old_element_properties = element_properties_for(observer)
+          observer_element_properties[observer] = element_properties_for(observer) - Set.new(element_properties)
+          each { |element| element_properties.each { |property| observer.unobserve(element, property) } }
         end
+        if element_properties_for(observer).empty?
+          property_observer_list.delete(observer)
+          observer_element_properties.delete(observer)
+          each { |element| remove_element_observer(element, observer) }
+        end        
         observer
       end
 
+      def remove_element_observers(element)
+        property_observer_list.each do |observer|
+          remove_element_observer(element, observer)
+        end      
+      end
+
+      def remove_element_observer(element, observer)
+        element_properties_for(observer).each do |property|
+          observer.unobserve(element, property)
+        end      
+      end
+
       def has_observer?(observer)
         property_observer_list.include?(observer)
       end
+      
+      def has_observer_element_properties?(observer, element_properties)
+        element_properties_for(observer).to_a.include_all?(element_properties)
+      end
 
       def property_observer_list
         @property_observer_list ||= Set.new
       end
 
+      def observer_element_properties
+        @observer_element_properties ||= {}
+      end
+
+      def element_properties_for(observer)
+        observer_element_properties[observer] ||= Set.new
+      end
+
       def notify_observers
-        property_observer_list.each {|observer| observer.call}
+        property_observer_list.to_a.each(&:call)
       end
       
       def <<(element)
-        super(element)
-        notify_observers
+        super(element).tap do
+          add_element_observers(element)        
+          notify_observers
+        end
       end
+      alias push <<
       
       def []=(index, value)
         old_value = self[index]
         unregister_dependent_observers(old_value)
-        super(index, value)
-        notify_observers
+        remove_element_observers(old_value)
+        add_element_observers(value)    
+        super(index, value).tap do
+          notify_observers
+        end
+      end
+      
+      def pop
+        popped_element = last
+        unregister_dependent_observers(popped_element)
+        remove_element_observers(popped_element)
+        super.tap do
+          notify_observers
+        end
       end
       
       def delete(element)
         unregister_dependent_observers(element)
-        super(element)
-        notify_observers
+        remove_element_observers(element)
+        super(element).tap do
+          notify_observers
+        end
       end
       
       def delete_at(index)
         old_value = self[index]
         unregister_dependent_observers(old_value)
-        super(index)
-        notify_observers
+        remove_element_observers(old_value)
+        super(index).tap do
+          notify_observers
+        end
+      end
+      
+      def delete_if(&block)
+        if block_given?
+          old_array = Array.new(self)
+          super(&block).tap do |new_array|
+            (old_array - new_array).each do |element| 
+              unregister_dependent_observers(element)
+              remove_element_observers(element)
+            end
+            notify_observers
+          end
+        else
+          super
+        end
       end
       
       def clear
         each do |old_value|
           unregister_dependent_observers(old_value)
+          remove_element_observers(old_value)
+        end
+        super.tap do
+          notify_observers
+        end
+      end
+      
+      def reverse!
+        super.tap do
+          notify_observers
+        end
+      end
+
+      def collect!(&block)
+        if block_given?
+          each do |old_value|
+            unregister_dependent_observers(old_value)
+            remove_element_observers(old_value)
+          end
+          super(&block).tap do
+            each { |element| add_element_observers(element) }
+            notify_observers
+          end
+        else
+          super
+        end
+      end
+      alias map! collect!
+
+      def compact!
+        super.tap { notify_observers }
+      end
+
+      def flatten!(level=nil)
+        each do |old_value|
+          unregister_dependent_observers(old_value)
+          remove_element_observers(old_value)
+        end
+        (level.nil? ? super() : super(level)).tap do
+          each { |element| add_element_observers(element) }
+          notify_observers
+        end
+      end
+
+      def rotate!(count=1)
+        super(count).tap { notify_observers }
+      end
+
+      def select!(&block)
+        if block_given?
+          old_array = Array.new(self)
+          super(&block).tap do
+            (old_array - self).each do |old_value|
+              unregister_dependent_observers(old_value)
+              remove_element_observers(old_value)
+            end
+            notify_observers
+          end
+        else
+          super
+        end
+      end
+
+      def shuffle!(hash = nil)
+        (hash.nil? ? super() : super(random: hash[:random])).tap { notify_observers }
+      end
+
+      def slice!(arg1, arg2=nil)
+        old_array = Array.new(self)
+        (arg2.nil? ? super(arg1) : super(arg1, arg2)).tap do
+          (old_array - self).each do |old_value|
+            unregister_dependent_observers(old_value)
+            remove_element_observers(old_value)
+          end
+          notify_observers
+        end
+      end
+
+      def sort!(&block)
+        (block.nil? ? super() : super(&block)).tap { notify_observers }
+      end
+
+      def sort_by!(&block)
+        (block.nil? ? super() : super(&block)).tap { notify_observers }
+      end
+
+      def uniq!(&block)
+        each do |old_value|
+          unregister_dependent_observers(old_value)
+          remove_element_observers(old_value)
+        end
+        (block.nil? ? super() : super(&block)).tap do
+          each { |element| add_element_observers(element) }
+          notify_observers
+        end
+      end
+
+      def reject!(&block)
+        if block.nil?
+          super
+        else
+          old_array = Array.new(self)
+          super(&block).tap do
+            (old_array - self).each do |old_value|
+              unregister_dependent_observers(old_value)
+              remove_element_observers(old_value)
+            end
+            notify_observers
+          end
         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
+        property_observer_list.each { |observer| observer.unregister_dependents_with_observable(observer.registration_for(self), old_value) }
       end
     end
   end