glimmer 0.9.5 → 0.10.4

data/VERSION

@@ -1 +1 @@
-0.9.5
+0.10.4

data/lib/glimmer.rb

@@ -4,6 +4,7 @@
 # UI with domain models.
 require 'logger'
 require 'set'
+require 'array_include_methods'
 
 $LOAD_PATH.unshift(File.expand_path('..', __FILE__))
 
@@ -17,7 +18,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,27 +41,22 @@ 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

data/lib/glimmer/config.rb

@@ -2,29 +2,48 @@ 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
-        # unless defined? @@logger
-        #   @@logger = Logger.new(STDOUT).tap {|logger| logger.level = Logger::WARN}
-        # end
-        @@logger if defined? @@logger
+      def logger      
+        reset_logger! unless defined? @@logger
+        @@logger
+      end
+      
+      def logger=(custom_logger)
+        @@logger = custom_logger
       end
   
-      def enable_logging
-        @@logger = Logger.new(STDOUT).tap {|logger| logger.level = Logger::WARN}
+      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.enable_logging
-  Glimmer::Config.logger.level = ENV['GLIMMER_LOGGER_LEVEL'].downcase
-end

data/lib/glimmer/data_binding/observable_array.rb

@@ -1,77 +1,280 @@
 require 'set'
+require 'array_include_methods'
 
 require 'glimmer/data_binding/observable'
 
+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|
+      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 do |element|
-            observer.unobserve(element, property)
+            element_properties.each do |property|
+              observer.unobserve(element, property)
+            end
           end
         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 do |element|
+              add_element_observers(element)
+            end
+            notify_observers
+          end
+        else
+          super
+        end
+      end
+      alias map! collect!
+
+      def compact!
+        super.tap do
+          notify_observers
+        end
+      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 do |element|
+            add_element_observers(element)
+          end
+          notify_observers
+        end
+      end
+
+      def rotate!(count=1)
+        super(count).tap do
+          notify_observers
+        end
+      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 do
+          notify_observers
+        end
+      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 do
+          notify_observers
+        end
+      end
+
+      def sort_by!(&block)
+        (block.nil? ? super() : super(&block)).tap do
+          notify_observers
+        end
+      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 do |element|
+            add_element_observers(element)
+          end
+          notify_observers
+        end
+      end
+
+      def reject!(&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
-        super()
-        notify_observers
       end
       
       def unregister_dependent_observers(old_value)

data/lib/glimmer/data_binding/observable_model.rb

@@ -34,7 +34,7 @@ module Glimmer
       end
 
       def has_observer_for_any_property?(observer)
-        property_observer_hash.values.map(&:to_a).sum.include?(observer)
+        property_observer_hash.values.map(&:to_a).reduce(:+).include?(observer)
       end
 
       def property_observer_hash
@@ -47,7 +47,9 @@ module Glimmer
       end
 
       def notify_observers(property_name)
-        property_observer_list(property_name).each {|observer| observer.call(send(property_name))}
+        property_observer_list(property_name).to_a.each do |observer|
+          observer.call(send(property_name))
+        end
       end
       #TODO upon updating values, make sure dependent observers are cleared (not added as dependents here)
 
@@ -70,7 +72,7 @@ module Glimmer
         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")}"
+        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)

data/lib/glimmer/data_binding/observer.rb

@@ -59,6 +59,7 @@ module Glimmer
       # registers observer in an observable on a property (optional)
       # observer maintains registration list to unregister later
       def register(observable, property = nil)
+        return if observable.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)
@@ -75,6 +76,7 @@ module Glimmer
       alias observe register
 
       def unregister(observable, property = nil)
+        return unless observable.is_a?(Observable)
         # 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)
@@ -90,16 +92,12 @@ module Glimmer
         thedependents = dependents_for(registration).select do |thedependent|
           thedependent.observable == dependent_observable
         end
-        thedependents.each do |thedependent|
-          thedependent.unregister
-        end
+        thedependents.each(&:unregister)
       end
 
       # cleans up all registrations in observables
       def unregister_all_observables
-        registrations.each do |registration|
-          registration.unregister
-        end
+        registrations.each(&:unregister)
       end
       alias unobserve_all_observables unregister_all_observables