glimmer-dsl-opal 0.0.7 → 0.3.0

data/lib/glimmer/config.rb

@@ -1,22 +0,0 @@
-module Glimmer
-  module Config
-    class << self
-      # 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
-      end
-  
-      def enable_logging
-        @@logger = Logger.new(STDOUT).tap {|logger| logger.level = Logger::WARN}
-      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/dsl/engine.rb

@@ -1,193 +0,0 @@
-require 'glimmer'
-require 'glimmer/dsl/expression_handler'
-
-module Glimmer
-  module DSL
-    # Glimmer DSL Engine
-    #
-    # Follows Interpreter and Chain of Responsibility Design Patterns
-    #
-    # When DSL engine interprets an expression, it attempts to handle
-    # with ordered expression array specified via `.expressions=` method.
-    class Engine
-      class << self
-        def dsl=(dsl_name)
-          dsl_name = dsl_name&.to_sym
-          if dsl_name
-            dsl_stack.push(dsl_name)
-          else
-            dsl_stack.clear
-          end
-        end
-        
-        def dsl
-          dsl_stack.last
-        end
-
-        def dsls
-          static_expressions.values.map(&:keys).flatten.uniq
-        end
-
-        def disable_dsl(dsl_name)
-          dsl_name = dsl_name.to_sym
-          disabled_dsls << dsl_name
-        end
-
-        def enable_dsl(dsl_name)
-          dsl_name = dsl_name.to_sym
-          disabled_dsls.delete(dsl_name)
-        end
-
-        def disabled_dsls
-          @disabled_dsls ||= []
-        end
-
-        def enabled_dsls=(dsl_names)
-          dsls.each {|dsl_name| disable_dsl(dsl_name)}
-          dsl_names.each {|dsl_name| enable_dsl(dsl_name)}
-        end
-    
-        # Resets Glimmer's engine activity and configuration. Useful in rspec before or after blocks in tests.
-        def reset
-          parent_stacks.values.each do |a_parent_stack|
-            a_parent_stack.clear
-          end
-          dsl_stack.clear
-          disabled_dsls.clear
-        end
-
-        # Dynamic expression chains of responsibility indexed by dsl
-        def dynamic_expression_chains_of_responsibility
-          @dynamic_expression_chains_of_responsibility ||= {}
-        end
-
-        # Static expressions indexed by keyword and dsl
-        def static_expressions
-          @static_expressions ||= {}
-        end
-
-        # Sets an ordered array of DSL expressions to support
-        #
-        # Every expression has an underscored name corresponding to an upper
-        # camelcase AbstractExpression subclass name in glimmer/dsl
-        #
-        # 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
-          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|
-            Glimmer::Config.logger&.debug "Adding dynamic expression: #{expression.class.name}"
-            expression_handler = ExpressionHandler.new(expression)
-            expression_handler.next = last_expresion_handler if last_expresion_handler
-            expression_handler
-          end                   
-        end
-
-        def add_static_expression(static_expression)
-          Glimmer::Config.logger&.debug "Adding static expression: #{static_expression.class.name}"
-          keyword = static_expression.class.keyword
-          static_expression_dsl = static_expression.class.dsl
-          static_expressions[keyword] ||= {}
-          static_expressions[keyword][static_expression_dsl] = static_expression
-          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).last 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
-              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
-            rescue StandardError => e
-#               Glimmer::DSL::Engine.dsl_stack.pop
-                Glimmer::DSL::Engine.reset
-              raise e
-            end
-          end
-        end
-
-        def expression_class(dsl_namespace, expression_name)
-          dsl_namespace.const_get(expression_class_name(expression_name).to_sym)
-        end
-
-        def expression_class_name(expression_name)
-          "#{expression_name}_expression".camelcase(:upper)
-        end
-
-        # Interprets Glimmer dynamic DSL expression consisting of keyword, args, and block (e.g. shell(:no_resize) { ... })
-        def interpret(keyword, *args, &block)
-          keyword = keyword.to_s
-          dynamic_expression_dsl = (dynamic_expression_chains_of_responsibility.keys - disabled_dsls).last if dsl.nil?
-          dsl_stack.push(dynamic_expression_dsl || dsl)
-          expression = dynamic_expression_chains_of_responsibility[dsl].handle(parent, keyword, *args, &block)
-          expression.interpret(parent, keyword, *args, &block).tap do |ui_object|            
-            add_content(ui_object, expression, &block)
-            dsl_stack.pop
-          end
-        rescue StandardError => e
-#           dsl_stack.pop
-          reset
-          raise e
-        end
-
-        # Adds content block to parent UI object
-        #
-        # This allows evaluating parent UI object properties and children
-        #
-        # For example, a shell widget would get properties set and children added
-        def add_content(parent, expression, &block)
-          if block_given? && expression.is_a?(ParentExpression)
-            dsl_stack.push(expression.class.dsl)
-            parent_stack.push(parent) 
-            expression.add_content(parent, &block)
-            parent_stack.pop
-            dsl_stack.pop
-          end
-        end
-
-        # Current parent while evaluating Glimmer DSL (nil if just started or done evaluatiing)
-        #
-        # Parents are maintained in a stack while evaluating Glimmer DSL
-        # to ensure properly ordered interpretation of DSL syntax
-        def parent
-          parent_stack.last
-        end
-
-        def parent_stack
-          parent_stacks[dsl] ||= []
-        end
-
-        def parent_stacks
-          @parent_stacks ||= {}
-        end
-
-        # Enables multiple DSLs to play well with each other when mixing together
-        def dsl_stack
-          @dsl_stack ||= []
-        end
-      end
-    end
-  end
-end

data/lib/glimmer/dsl/expression.rb

@@ -1,42 +0,0 @@
-require 'glimmer/error'
-
-module Glimmer
-  module DSL
-    # Represents a Glimmer DSL expression (e.g. label(:center) { ... })
-    #
-    # An expression object can interpret a keyword, args, and a block into a UI object
-    #
-    # Expressions subclasses follow the convention of using `and` and `or`
-    # english versino of Ruby's boolean operations. This allows easy DSL-like
-    # readability of the rules, and easy tagging with pd when troubleshooting.
-    class Expression
-      class << self
-        def dsl
-          @dsl ||= name.split(/::/)[-2].downcase.to_sym
-        end
-      end
-
-      # Checks if it can interpret parameters (subclass must override)
-      def can_interpret?(parent, keyword, *args, &block)
-        raise Error, "#can_interpret? must be implemented by an Expression subclass"
-      end
-
-      # Interprets parameters (subclass must override)
-      def interpret(parent, keyword, *args, &block)
-        raise Error, "#interpret must be implemented by an Expression subclass"
-      end
-
-      # Adds block content to specified parent UI object (Optional)
-      #
-      # Only expressions that receive a content block should implement
-      def add_content(parent, &block)
-        # No Op by default
-      end
-
-      # Checks if object is a Symbol or a String
-      def textual?(object)
-        object.is_a?(Symbol) or object.is_a?(String)
-      end
-    end
-  end
-end

data/lib/glimmer/dsl/expression_handler.rb

@@ -1,48 +0,0 @@
-require 'glimmer/invalid_keyword_error'
-
-module Glimmer
-  module DSL
-    # Expression handler for a Glimmer DSL specific expression
-    #
-    # Follows the Chain of Responsibility Design Pattern
-    #
-    # Handlers are configured in Glimmer::DSL in the right order
-    # to attempt handling Glimmer DSL interpretation calls
-    #
-    # Each handler knows the next handler in the chain of responsibility.
-    #
-    # If it handles successfully, it returns. Otherwise, it forwards to the next
-    # handler in the chain of responsibility
-    class ExpressionHandler
-      def initialize(expression)
-        @expression = expression
-      end
-
-      # Handles interpretation of Glimmer DSL expression if expression supports it
-      # If it succeeds, it returns the correct Glimmer DSL expression object
-      # Otherwise, it forwards to the next handler configured via `#next=` method
-      # If there is no handler next, then it raises an error
-      def handle(parent, keyword, *args, &block)
-        Glimmer::Config.logger&.debug "Attempting to handle #{keyword} with #{@expression.class.name.split(":").last}"
-        if @expression.can_interpret?(parent, keyword, *args, &block)
-          Glimmer::Config.logger&.debug "#{@expression.class.name} will handle expression keyword #{keyword}"
-          return @expression
-        elsif @next_expression_handler
-          return @next_expression_handler.handle(parent, keyword, *args, &block)
-        else
-          # TODO see if we need a better response here (e.g. dev mode error raising vs production mode silent failure)
-          message = "Glimmer keyword #{keyword} with args #{args} cannot be handled"
-          message += " inside parent #{parent}" if parent
-          message += "! Check the validity of the code."
-          # Glimmer::Config.logger&.error message
-          raise InvalidKeywordError, message
-        end
-      end
-
-      # Sets the next handler in the expression handler chain of responsibility
-      def next=(next_expression_handler)
-        @next_expression_handler = next_expression_handler
-      end
-    end
-  end
-end

data/lib/glimmer/dsl/opal/browser_expression.rb

@@ -1,17 +0,0 @@
-require 'glimmer/dsl/static_expression'
-require 'glimmer/dsl/parent_expression'
-require 'glimmer/opal/iframe_proxy'
-
-module Glimmer
-  module DSL
-    module Opal
-      class BrowserExpression < StaticExpression
-        include ParentExpression
-
-        def interpret(parent, keyword, *args, &block)
-          Glimmer::Opal::IframeProxy.new(parent, args)
-        end
-      end
-    end
-  end
-end

data/lib/glimmer/dsl/opal/button_expression.rb

@@ -1,18 +0,0 @@
-require 'glimmer/dsl/static_expression'
-require 'glimmer/dsl/parent_expression'
-require 'glimmer/opal/input_proxy'
-
-module Glimmer
-  module DSL
-    module Opal
-      class ButtonExpression < StaticExpression
-        include ParentExpression
-
-        def interpret(parent, keyword, *args, &block)
-          args << {type: 'button'}
-          Glimmer::Opal::InputProxy.new(parent, args)
-        end
-      end
-    end
-  end
-end

data/lib/glimmer/dsl/opal/combo_expression.rb

@@ -1,17 +0,0 @@
-require 'glimmer/dsl/static_expression'
-require 'glimmer/dsl/parent_expression'
-require 'glimmer/opal/select_proxy'
-
-module Glimmer
-  module DSL
-    module Opal
-      class ComboExpression < StaticExpression
-        include ParentExpression
-
-        def interpret(parent, keyword, *args, &block)
-          Glimmer::Opal::SelectProxy.new(parent, args)
-        end
-      end
-    end
-  end
-end

data/lib/glimmer/dsl/opal/grid_layout_expression.rb

@@ -1,17 +0,0 @@
-require 'glimmer/dsl/static_expression'
-require 'glimmer/dsl/parent_expression'
-require 'glimmer/opal/grid_layout_proxy'
-
-module Glimmer
-  module DSL
-    module Opal
-      class GridLayoutExpression < StaticExpression
-        include ParentExpression
-
-        def interpret(parent, keyword, *args, &block)
-          Glimmer::Opal::GridLayoutProxy.new(parent, args)
-        end
-      end
-    end
-  end
-end

data/lib/glimmer/dsl/opal/label_expression.rb

@@ -1,17 +0,0 @@
-require 'glimmer/dsl/static_expression'
-require 'glimmer/dsl/parent_expression'
-require 'glimmer/opal/label_proxy'
-
-module Glimmer
-  module DSL
-    module Opal
-      class LabelExpression < StaticExpression
-        include ParentExpression
-
-        def interpret(parent, keyword, *args, &block)
-          Glimmer::Opal::LabelProxy.new(parent, args)
-        end
-      end
-    end
-  end
-end

data/lib/glimmer/dsl/opal/tab_folder_expression.rb

@@ -1,17 +0,0 @@
-require 'glimmer/dsl/static_expression'
-require 'glimmer/dsl/parent_expression'
-require 'glimmer/opal/tab_folder'
-
-module Glimmer
-  module DSL
-    module Opal
-      class TabFolderExpression < StaticExpression
-        include ParentExpression
-        
-        def interpret(parent, keyword, *args, &block)
-          Glimmer::Opal::TabFolder.new(parent, args)
-        end
-      end
-    end
-  end
-end

data/lib/glimmer/dsl/opal/tab_item_expression.rb

@@ -1,17 +0,0 @@
-require 'glimmer/dsl/static_expression'
-require 'glimmer/dsl/parent_expression'
-require 'glimmer/opal/tab_item'
-
-module Glimmer
-  module DSL
-    module Opal
-      class TabItemExpression < StaticExpression
-        include ParentExpression
-
-        def interpret(parent, keyword, *args, &block)
-          Glimmer::Opal::TabItem.new(parent, args)
-        end
-      end
-    end
-  end
-end

data/lib/glimmer/dsl/opal/text_expression.rb

@@ -1,22 +0,0 @@
-require 'glimmer/dsl/expression'
-require 'glimmer/dsl/parent_expression'
-require 'glimmer/opal/input_proxy'
-
-module Glimmer
-  module DSL
-    module Opal
-      class TextExpression < Expression
-        include ParentExpression
-
-        def can_interpret?(parent, keyword, *args, &block)
-          keyword == 'text' and parent and block_given?
-        end
-
-        def interpret(parent, keyword, *args, &block)
-          args << {type: 'text'}
-          Glimmer::Opal::InputProxy.new(parent, args)
-        end
-      end
-    end
-  end
-end