glimmer 0.8.2 → 0.9.4

data/VERSION

@@ -1 +1 @@
-0.8.2
+0.9.4

data/lib/glimmer.rb

@@ -2,14 +2,12 @@
 # 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.
-require 'facets'
-require 'super_module'
 require 'logger'
-require 'java'
 require 'set'
-require 'nested_inherited_jruby_include_package'
-require 'fileutils'
-require 'os'
+
+$LOAD_PATH.unshift(File.expand_path('..', __FILE__))
+
+require 'glimmer/config'
 
 # Glimmer provides a JRuby Desktop UI DSL + Data-Binding functionality
 #
@@ -20,24 +18,45 @@ require 'os'
 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
-    def included(klass)
-      if Config.import_swt_packages
-        klass.include(SWT::Packages)
-        klass.extend(SWT::Packages)
-        klass.extend(Glimmer)
-      end
+    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
@@ -47,12 +66,7 @@ module Glimmer
   end
 end
 
-$LOAD_PATH.unshift(File.expand_path('..', __FILE__))
-
-require 'glimmer/config'
-require 'glimmer/swt/packages'
-require 'glimmer/dsl/swt/dsl'
-require 'glimmer/dsl/xml/dsl'
-require 'glimmer/dsl/css/dsl'
 require 'glimmer/error'
+require 'glimmer/excluded_keyword_error'
 require 'glimmer/invalid_keyword_error'
+require 'glimmer/dsl/engine'

data/lib/glimmer/config.rb

@@ -1,19 +1,14 @@
 module Glimmer
   module Config
     class << self
-      # Tells Glimmer to import SWT packages into including class (default: true)
-      def import_swt_packages=(value)
-        @@import_swt_packages = !!value
+      LOOP_MAX_COUNT_DEFAULT = 100
+      
+      attr_writer :loop_max_count
+      
+      def loop_max_count
+        @loop_max_count ||= LOOP_MAX_COUNT_DEFAULT
       end
-  
-      # Returns whether Glimmer will import SWT packages into including class
-      def import_swt_packages
-        unless defined? @@import_swt_packages
-          @@import_swt_packages = true
-        end
-        @@import_swt_packages
-      end
-  
+      
       # Returns Glimmer logger (standard Ruby logger)
       def logger
         # unless defined? @@logger

data/lib/glimmer/data_binding/observable_array.rb

@@ -1,6 +1,6 @@
 require 'set'
 
-require_relative 'observable'
+require 'glimmer/data_binding/observable'
 
 module Glimmer
   module DataBinding
@@ -40,61 +40,40 @@ module Glimmer
       def notify_observers
         property_observer_list.each {|observer| observer.call}
       end
-
-      def self.extend_object(array)
-        # TODO consider alias_method, and define_method instead
-
-        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]
+      
+      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)
-          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
+        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)

data/lib/glimmer/data_binding/observable_model.rb

@@ -1,7 +1,5 @@
-require 'glimmer'
-
-require_relative 'observable'
-require_relative 'observer'
+require 'glimmer/data_binding/observable'
+require 'glimmer/data_binding/observer'
 
 module Glimmer
   module DataBinding
@@ -58,22 +56,20 @@ module Glimmer
         method(property_writer_name)
         ensure_array_object_observer(property_name, send(property_name))
         begin
-          method("__original_#{property_writer_name}")
+          singleton_method("__original_#{property_writer_name}")
         rescue
-          # TODO consider alias_method or define_method instead
-          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)
+          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_eval
         end
       rescue => e
-        # ignore writing if no property writer exists
+        #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
 

data/lib/glimmer/data_binding/observer.rb

@@ -122,3 +122,6 @@ module Glimmer
     end
   end
 end
+
+require 'glimmer/data_binding/observable_model'
+require 'glimmer/data_binding/observable_array'

data/lib/glimmer/dsl/engine.rb

@@ -1,4 +1,5 @@
-require 'glimmer'
+require 'facets/string/camelcase'
+
 require 'glimmer/dsl/expression_handler'
 
 module Glimmer
@@ -10,6 +11,8 @@ module Glimmer
     # When DSL engine interprets an expression, it attempts to handle
     # with ordered expression array specified via `.expressions=` method.
     class Engine
+      MESSAGE_NO_DSLS = "Glimmer has no DSLs configured. Add glimmer-dsl-swt gem or visit https://github.com/AndyObtiva/glimmer#multi-dsl-support for more details.\n"
+      
       class << self
         def dsl=(dsl_name)
           dsl_name = dsl_name&.to_sym
@@ -55,6 +58,10 @@ module Glimmer
           dsl_stack.clear
           disabled_dsls.clear
         end
+        
+        def no_dsls?
+          static_expressions.empty? && dynamic_expression_chains_of_responsibility.empty?
+        end
 
         # Dynamic expression chains of responsibility indexed by dsl
         def dynamic_expression_chains_of_responsibility
@@ -64,6 +71,16 @@ module Glimmer
         # Static expressions indexed by keyword and dsl
         def static_expressions
           @static_expressions ||= {}
+        end        
+
+        # Sets dynamic expression chains of responsibility. Useful for internal testing
+        def dynamic_expression_chains_of_responsibility=(chains)
+          @dynamic_expression_chains_of_responsibility = chains
+        end
+
+        # Sets static expressions. Useful for internal testing
+        def static_expressions=(expressions)
+          @static_expressions = expressions
         end
 
         # Sets an ordered array of DSL expressions to support
@@ -73,8 +90,9 @@ module Glimmer
         #
         # They are used in order following the Chain of Responsibility Design
         # Pattern when interpretting a DSL expression
-        def add_dynamic_expressions(dsl_namespace, expression_names)
-          dsl = dsl_namespace.name.split("::").last.downcase.to_sym
+        def add_dynamic_expressions(dsl_namespace, *expression_names)
+          expression_names = expression_names.flatten
+          dsl = dsl_namespace.name.split("::").last.downcase.to_sym          
           dynamic_expression_chains_of_responsibility[dsl] = expression_names.reverse.map do |expression_name|
             expression_class(dsl_namespace, expression_name).new
           end.reduce(nil) do |last_expresion_handler, expression|
@@ -82,7 +100,7 @@ module Glimmer
             expression_handler = ExpressionHandler.new(expression)
             expression_handler.next = last_expresion_handler if last_expresion_handler
             expression_handler
-          end
+          end                   
         end
 
         def add_static_expression(static_expression)
@@ -91,31 +109,40 @@ module Glimmer
           static_expression_dsl = static_expression.class.dsl
           static_expressions[keyword] ||= {}
           static_expressions[keyword][static_expression_dsl] = static_expression
-          Glimmer.define_method(keyword) do |*args, &block|
+          Glimmer.send(:define_method, keyword) do |*args, &block|
             begin
-              retrieved_static_expression = Glimmer::DSL::Engine.static_expressions[keyword][Glimmer::DSL::Engine.dsl]            
-              static_expression_dsl = (Glimmer::DSL::Engine.static_expressions[keyword].keys - Glimmer::DSL::Engine.disabled_dsls).first if retrieved_static_expression.nil?
-              if retrieved_static_expression.nil? && Glimmer::DSL::Engine.dsl && (static_expression_dsl.nil? || !Glimmer::DSL::Engine.static_expressions[keyword][static_expression_dsl].is_a?(TopLevelExpression))
-                begin
-                  return Glimmer::DSL::Engine.interpret(keyword, *args, &block)
-                rescue => e
-                  Glimmer::DSL::Engine.reset
-                  raise e if static_expression_dsl.nil? || !Glimmer::DSL::Engine.static_expressions[keyword][static_expression_dsl].is_a?(TopLevelExpression)
-                end
-              end
-              raise Glimmer::Error, "Unsupported keyword: #{keyword}" unless static_expression_dsl || retrieved_static_expression
-              Glimmer::DSL::Engine.dsl_stack.push(static_expression_dsl || Glimmer::DSL::Engine.dsl)
-              static_expression = Glimmer::DSL::Engine.static_expressions[keyword][Glimmer::DSL::Engine.dsl]
-              if !static_expression.can_interpret?(Glimmer::DSL::Engine.parent, keyword, *args, &block)
-                raise Error, "Invalid use of Glimmer keyword #{keyword} with args #{args} under parent #{Glimmer::DSL::Engine.parent}"
+              if Glimmer::DSL::Engine.no_dsls?
+                puts Glimmer::DSL::Engine::MESSAGE_NO_DSLS
               else
-                Glimmer::Config.logger&.debug "#{static_expression.class.name} will handle expression keyword #{keyword}"
-                return static_expression.interpret(Glimmer::DSL::Engine.parent, keyword, *args, &block).tap do |ui_object|
-                  Glimmer::DSL::Engine.add_content(ui_object, static_expression, &block) unless block.nil?
-                  Glimmer::DSL::Engine.dsl_stack.pop
+                retrieved_static_expression = Glimmer::DSL::Engine.static_expressions[keyword][Glimmer::DSL::Engine.dsl]
+                static_expression_dsl = (Glimmer::DSL::Engine.static_expressions[keyword].keys - Glimmer::DSL::Engine.disabled_dsls).first if retrieved_static_expression.nil?
+                interpretation = nil
+                if retrieved_static_expression.nil? && Glimmer::DSL::Engine.dsl && (static_expression_dsl.nil? || !Glimmer::DSL::Engine.static_expressions[keyword][static_expression_dsl].is_a?(TopLevelExpression))
+                  begin
+                    interpretation = Glimmer::DSL::Engine.interpret(keyword, *args, &block)
+                  rescue => e
+                    Glimmer::DSL::Engine.reset
+                    raise e if static_expression_dsl.nil? || !Glimmer::DSL::Engine.static_expressions[keyword][static_expression_dsl].is_a?(TopLevelExpression)
+                  end
                 end
-              end
-            rescue => e
+                if interpretation
+                  interpretation
+                else              
+                  raise Glimmer::Error, "Unsupported keyword: #{keyword}" unless static_expression_dsl || retrieved_static_expression
+                  Glimmer::DSL::Engine.dsl_stack.push(static_expression_dsl || Glimmer::DSL::Engine.dsl)
+                  static_expression = Glimmer::DSL::Engine.static_expressions[keyword][Glimmer::DSL::Engine.dsl]
+                  if !static_expression.can_interpret?(Glimmer::DSL::Engine.parent, keyword, *args, &block)
+                    raise Error, "Invalid use of Glimmer keyword #{keyword} with args #{args} under parent #{Glimmer::DSL::Engine.parent}"
+                  else
+                    Glimmer::Config.logger&.debug "#{static_expression.class.name} will handle expression keyword #{keyword}"
+                    static_expression.interpret(Glimmer::DSL::Engine.parent, keyword, *args, &block).tap do |ui_object|
+                      Glimmer::DSL::Engine.add_content(ui_object, static_expression, &block) unless block.nil?
+                      Glimmer::DSL::Engine.dsl_stack.pop
+                    end
+                  end
+                end
+              end              
+            rescue StandardError => e
 #               Glimmer::DSL::Engine.dsl_stack.pop
                 Glimmer::DSL::Engine.reset
               raise e
@@ -133,6 +160,10 @@ module Glimmer
 
         # Interprets Glimmer dynamic DSL expression consisting of keyword, args, and block (e.g. shell(:no_resize) { ... })
         def interpret(keyword, *args, &block)
+          if no_dsls?
+            puts MESSAGE_NO_DSLS
+            return
+          end
           keyword = keyword.to_s
           dynamic_expression_dsl = (dynamic_expression_chains_of_responsibility.keys - disabled_dsls).first if dsl.nil?
           dsl_stack.push(dynamic_expression_dsl || dsl)
@@ -141,7 +172,7 @@ module Glimmer
             add_content(ui_object, expression, &block)
             dsl_stack.pop
           end
-        rescue => e
+        rescue StandardError => e
 #           dsl_stack.pop
           reset
           raise e

data/lib/glimmer/dsl/expression.rb

@@ -1,6 +1,4 @@
 require 'glimmer/error'
-require 'glimmer/swt/widget_proxy'
-require 'glimmer/ui/custom_widget'
 
 module Glimmer
   module DSL
@@ -35,11 +33,6 @@ module Glimmer
         # No Op by default
       end
 
-      # Checks if parent object is a widget
-      def widget?(parent)
-        parent.is_a?(Glimmer::SWT::WidgetProxy) or parent.is_a?(Glimmer::UI::CustomWidget)
-      end
-
       # Checks if object is a Symbol or a String
       def textual?(object)
         object.is_a?(Symbol) or object.is_a?(String)

data/lib/glimmer/dsl/static_expression.rb

@@ -1,8 +1,8 @@
+require 'facets/string/underscore'
+
 require 'glimmer/error'
 require 'glimmer/dsl/engine'
 require 'glimmer/dsl/expression'
-require 'glimmer/swt/widget_proxy'
-require 'glimmer/ui/custom_widget'
 
 module Glimmer
   module DSL

data/lib/glimmer/excluded_keyword_error.rb

@@ -0,0 +1,5 @@
+module Glimmer
+  # Represents Glimmer errors that occur due to excluded keywords passing through method_missing
+  class ExcludedKeywordError < RuntimeError
+  end
+end