glimmer-dsl-css 0.1.0

data/lib/glimmer/dsl/expression.rb

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

@@ -0,0 +1,48 @@
+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/dsl.rb

@@ -0,0 +1,41 @@
+require 'opal'
+# require 'opal-jquery'
+require 'browser'
+
+class String
+  def underscore
+    gsub(/[A-Z]/) {|m| "_#{m.downcase}"}.sub(/^_/, '')
+  end
+  
+  def camelcase(option=nil)
+    new_string = split("_").map {|word| word[0].upcase + word[1..-1]}.join
+    if option == :upper
+      new_string
+    else
+      new_string.sub(/^./) {|c| c.downcase}
+    end
+  end
+  
+#   def titlecase
+#     #TODO
+#   end
+end
+
+require 'glimmer/dsl/engine'
+# Dir[File.expand_path('../*_expression.rb', __FILE__)].each {|f| require f}
+require 'glimmer/dsl/opal/shell_expression'
+require 'glimmer/dsl/opal/label_expression'
+require 'glimmer/dsl/opal/property_expression'
+
+module Glimmer
+  module DSL
+    module Opal
+      Engine.add_dynamic_expressions(
+       Opal,
+       %w[
+         property
+       ]
+      )
+    end
+  end
+end

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

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

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

@@ -0,0 +1,19 @@
+require 'glimmer/dsl/expression'
+
+module Glimmer
+  module DSL
+    module Opal
+      class PropertyExpression < StaticExpression
+        include TopLevelExpression
+
+        def can_interpret?(parent, keyword, *args, &block)          
+          keyword.to_s == 'text'
+        end
+
+        def interpret(parent, keyword, *args, &block)
+          parent.text = args.first.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+require 'glimmer/dsl/static_expression'
+require 'glimmer/dsl/top_level_expression'
+require 'glimmer/dsl/parent_expression'
+require 'glimmer/opal/shell'
+
+module Glimmer
+  module DSL
+    module Opal
+      class ShellExpression < StaticExpression
+        include TopLevelExpression
+        include ParentExpression
+
+        def interpret(parent, keyword, *args, &block)
+          Glimmer::Opal::Shell.new(args)
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/parent_expression.rb

@@ -0,0 +1,12 @@
+require 'glimmer/error'
+
+module Glimmer
+  module DSL
+    # Mixin that represents expressions that always have a content block
+    module ParentExpression
+      def add_content(parent, &block)
+        block.call(parent)
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/static_expression.rb

@@ -0,0 +1,36 @@
+require 'glimmer/error'
+require 'glimmer/dsl/engine'
+require 'glimmer/dsl/expression'
+
+module Glimmer
+  module DSL
+    # Represents a StaticExpression for expressions where
+    # the keyword does not vary dynamically. These static keywords are then
+    # predefined as methods in Glimmer instead of needing method_missing
+    #
+    # StaticExpression subclasses may optionally implement `#can_interpret?`
+    # (not needed if it only checks for keyword)
+    #
+    # StaticExpression subclasses must define `#interpret`.
+    # 
+    # The direct parent namespace of a StaticExpression subclass must match the DSL name (case-insensitive)
+    # (e.g. Glimmer::DSL::SWT::WidgetExpression has a DSL of :swt)
+    class StaticExpression < Expression
+      class << self  
+        def inherited(base)
+          Glimmer::DSL::Engine.add_static_expression(base.new)
+          super
+        end
+
+        def keyword
+          @keyword ||= name.split(/::/).last.sub(/Expression$/, '').underscore
+        end
+      end
+
+      # Subclasses may optionally implement
+      def can_interpret?(parent, keyword, *args, &block)
+        true
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/top_level_expression.rb

@@ -0,0 +1,7 @@
+module Glimmer
+  module DSL
+    # Mixin that represents expressions that are always at the top with parent nil
+    module TopLevelExpression
+    end
+  end
+end

data/lib/glimmer/dsl/xml/dsl.rb

@@ -0,0 +1,23 @@
+require 'glimmer/dsl/engine'
+# Dir[File.expand_path('../*_expression.rb', __FILE__)].each {|f| require f} # cannot in Opal
+require 'glimmer/dsl/xml/text_expression'
+require 'glimmer/dsl/xml/tag_expression'
+require 'glimmer/dsl/xml/xml_expression'
+require 'glimmer/dsl/xml/html_expression'
+require 'glimmer/dsl/xml/meta_expression'
+require 'glimmer/dsl/xml/name_space_expression'
+
+module Glimmer
+  module DSL
+    module XML
+      Engine.add_dynamic_expressions(
+        XML,
+        %w[
+          text
+          tag
+          xml
+        ]
+      )
+    end
+  end
+end

data/lib/glimmer/dsl/xml/html_expression.rb

@@ -0,0 +1,25 @@
+require 'glimmer/dsl/xml/node_parent_expression'
+require 'glimmer/dsl/xml/xml_expression'
+require 'glimmer/dsl/static_expression'
+require 'glimmer/dsl/top_level_expression'
+
+module Glimmer
+  module DSL
+    module XML
+      # This static html expression flips the DSL switch on for 
+      # XML DSL in Glimmer
+      class HtmlExpression < StaticExpression
+        include TopLevelExpression
+        include NodeParentExpression
+
+        def interpret(parent, keyword, *args, &block)
+          xml_expression.interpret(parent, keyword, *args, &block)
+        end
+
+        def xml_expression
+          @xml_expression ||= XmlExpression.new
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/xml/meta_expression.rb

@@ -0,0 +1,23 @@
+require 'glimmer/dsl/xml/node_parent_expression'
+require 'glimmer/dsl/xml/xml_expression'
+require 'glimmer/dsl/static_expression'
+
+module Glimmer
+  module DSL
+    module XML
+      # This static html expression flips the DSL switch on for 
+      # XML DSL in Glimmer
+      class MetaExpression < StaticExpression
+        include NodeParentExpression
+
+        def interpret(parent, keyword, *args, &block)
+          xml_expression.interpret(parent, keyword, *args, &block)
+        end
+
+        def xml_expression
+          @xml_expression ||= XmlExpression.new
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/xml/name_space_expression.rb

@@ -0,0 +1,37 @@
+require 'glimmer/dsl/static_expression'
+require 'glimmer/dsl/top_level_expression'
+require 'glimmer/xml/node'
+require 'glimmer/xml/depth_first_search_iterator'
+require 'glimmer/xml/name_space_visitor'
+
+module Glimmer
+  module DSL
+    module XML
+      class NameSpaceExpression < StaticExpression
+        include TopLevelExpression
+
+        def can_interpret?(parent, keyword, *args, &block)
+          (parent == nil or parent.is_a?(Glimmer::XML::Node)) and
+          (keyword.to_s == "name_space")
+          (args.size == 1) and
+          (args[0].is_a?(Symbol)) and
+          block
+        end
+
+        def interpret(parent, keyword, *args, &block)
+          node = block.call
+          unless node.is_a?(String)
+            name_space_visitor = Glimmer::XML::NameSpaceVisitor.new(args[0].to_s)
+            Glimmer::XML::DepthFirstSearchIterator.new(node, name_space_visitor).iterate
+            def node.process_block(block)
+              Glimmer::Config.logger&.debug 'block'
+              #NOOP
+            end
+          end
+          parent.children << node if parent and !parent.children.include?(node)
+          node
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/xml/node_parent_expression.rb

@@ -0,0 +1,33 @@
+require 'glimmer'
+require 'glimmer/dsl/parent_expression'
+require 'glimmer/xml/node'
+
+module Glimmer
+  module DSL
+    module XML
+      module NodeParentExpression
+        include ParentExpression
+        include Glimmer
+
+        def add_content(parent, &block)
+          return_value = block.call(parent)      
+          if !return_value.is_a?(Glimmer::XML::Node) and !parent.children.include?(return_value)
+            text = return_value.to_s
+            first_match = text.match(/[#][^{]+[{][^}]+[}]/)
+            match = first_match
+            while (match)
+              instance_eval(parent.text_command(match.pre_match))
+              tag_text = match.to_s
+              instance_eval(parent.rubyize(tag_text))
+              text = tag_text
+              post_match = match.post_match
+              match = text.match(/[#]\w+[{]\w+[}]/)
+            end
+            instance_eval(parent.text_command(post_match)) if post_match
+            parent.children << return_value unless first_match
+          end
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/xml/tag_expression.rb

@@ -0,0 +1,29 @@
+require 'glimmer/dsl/xml/node_parent_expression'
+require 'glimmer/dsl/xml/xml_expression'
+require 'glimmer/dsl/static_expression'
+require 'glimmer/dsl/top_level_expression'
+require 'glimmer/xml/node'
+
+module Glimmer
+  module DSL
+    module XML
+      class TagExpression < StaticExpression
+        include TopLevelExpression
+        include NodeParentExpression
+
+        def can_interpret?(parent, keyword, *args, &block)
+          (parent == nil or parent.is_a?(Glimmer::XML::Node)) and
+          (keyword.to_s == "tag") and
+            args[0].include?(:_name)
+        end
+
+        def interpret(parent, keyword, *args, &block)
+          attributes = args[0] if (args.size == 1)
+          tag_name = attributes[:_name]
+          attributes.delete(:_name)
+          Glimmer::XML::Node.new(parent, tag_name, attributes, &block)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'glimmer/dsl/static_expression'
+require 'glimmer/xml/node'
+
+module Glimmer
+  module DSL
+    module XML
+      class TextExpression < StaticExpression
+        def can_interpret?(parent, keyword, *args, &block)
+          (parent == nil or parent.is_a?(Glimmer::XML::Node)) and
+          (keyword.to_s == "text") and
+          (args.size == 1) and
+          !block
+        end
+
+        def interpret(parent, keyword, *args, &block)
+          parent.children << args[0].to_s if parent
+          args[0].to_s
+        end
+      end
+    end
+  end
+end