glimmer 0.5.11 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e6264cb7899c16ec9e6df0a24fc1365d1cd116633c6ce20010723badd50e4041
-  data.tar.gz: 98e5d5bb061edaae3a139540c6e0b7721bdba5c703a4cb7ce26e3232e85f62f4
+  metadata.gz: 3610ccbe7872450d8b38005411e05be5b282c6f9785dbb21f87a239944ff304b
+  data.tar.gz: d80b1a110bd98b8dd5bd84be107ef9cd316af755cc052f94449b2249ddee1d4b
 SHA512:
-  metadata.gz: d33841165b7d420be235057b4a95cf6f7a7ec6f4b3d04b7fcedd7e5233cdf2d3b3597bc83694fae30288ebf2f32741b9d1a0941be98472c1270190f2146a0890
-  data.tar.gz: 627a9b85c3709fd097e7b2cbb54266091e9c83f5a2005a5d9e97fa3bff1c68b6a32d76f67f70f67f19f44254a12c65d3f22b064cd6351c42e1f7fcf11503b825
+  metadata.gz: 9d7810d076c698cab8d9c43fb4c7c3743ba37cad314e090e5d4112dcee50d6b5b5a389dce908e63e2c35a755079e944d69acff2b8ee9620f3541d474f97190a7
+  data.tar.gz: 64843e0799b6c035ca8aafa09be1ace82fda2ae7c188553e4db61ed8579b33598bc0f141ee90d8fb99f2383e810059278f2dfec8f4cbb862eac7d6e6288c0ae7

data/README.markdown

@@ -1,7 +1,7 @@
-# Glimmer 0.5.11 Beta (JRuby Desktop UI DSL + Data-Binding)
+# Glimmer 0.6.0 Beta (JRuby Desktop UI DSL + Data-Binding)
 [![Coverage Status](https://coveralls.io/repos/github/AndyObtiva/glimmer/badge.svg?branch=master)](https://coveralls.io/github/AndyObtiva/glimmer?branch=master)
 
-Glimmer is a native-UI cross-platform desktop development library written in Ruby. Glimmer's main innovation is a JRuby DSL that enables productive and efficient authoring of desktop application user-interfaces while relying on the robust platform-native Eclipse SWT library. Glimmer additionally innovates by having built-in data-binding support to greatly facilitate synchronizing the UI with domain models. As a result, that achieves true decoupling of object oriented components, enabling developers to solve business problems without worrying about UI concerns, or alternatively drive development UI-first, and then write clean business components test-first afterwards.
+Glimmer is a native-UI cross-platform desktop development library written in Ruby. Glimmer's main innovation is a JRuby DSL that enables productive and efficient authoring of desktop application user-interfaces while relying on the robust Eclipse SWT library. Glimmer additionally innovates by having built-in data-binding support to greatly facilitate synchronizing the UI with domain models. As a result, that achieves true decoupling of object oriented components, enabling developers to solve business problems without worrying about UI concerns, or alternatively drive development UI-first, and then write clean business components test-first afterwards.
 
 ## Examples
 
@@ -70,7 +70,7 @@ NOTE: Glimmer is in beta mode. Please help make better by adopting for small or
 ## Table of Contents
 
 <!-- TOC START min:1 max:3 link:true asterisk:false update:true -->
-- [Glimmer 0.5.11 Beta (JRuby Desktop UI DSL + Data-Binding)](#glimmer-058-beta-jruby-desktop-ui-dsl--data-binding)
+- [Glimmer 0.6.0 Beta (JRuby Desktop UI DSL + Data-Binding)](#glimmer-058-beta-jruby-desktop-ui-dsl--data-binding)
   - [Examples](#examples)
     - [Hello World](#hello-world)
     - [Tic Tac Toe](#tic-tac-toe)
@@ -163,14 +163,14 @@ Please follow these instructions to make the `glimmer` command available on your
 
 Run this command to install directly:
 ```
-jgem install glimmer -v 0.5.11
+jgem install glimmer -v 0.6.0
 ```
 
 ### Option 2: Bundler
 
 Add the following to `Gemfile`:
 ```
-gem 'glimmer', '~> 0.5.11'
+gem 'glimmer', '~> 0.6.0'
 ```
 
 And, then run:
@@ -1558,6 +1558,119 @@ shell(:no_resize) {
 
 Also, you may invoke `Display.setAppVersion('1.0.0')` if needed for OS app version identification reasons during development, replacing `'1.0.0'` with your application version.
 
+#### Multi-DSL Support
+
+Glimmer supports two other DSLs in addition to the SWT DSL; that is Glimmer XML DSL and Glimmer CSS DSL. It also allows mixing DSLs, which comes in handy when doing things like using the `browser` widget. Glimmer automatically recognizes top-level keywords in each DSL
+and switches DSLs accordingly until it finishes processes the top-level keywords, at which point it switches back to the prior DSL.
+
+For example, the SWT DSL has the following top-level keywords:
+- `shell`
+- `display`
+- `observe`
+- `async_exec`
+- `sync_exec`
+
+##### XML DSL
+
+Simply start with `html` keyword and add HTML inside its block using Glimmer DSL syntax.
+Once done, you may call `to_s`, `to_xml`, or `to_html` to get the formatted HTML output.
+
+Here are all the Glimmer XML DSL top-level keywords:
+- `html`
+- `tag`: enables custom tag creation for exceptional cases by passing tag name as '_name' attribute
+- `name_space`: enables namespacing html tags
+
+Element properties are typically passed as a key/value hash (e.g. `section(id: 'main', class: 'accordion')`) . However, for properties like "selected" or "checked", you must leave value `nil` or otherwise pass in front of the hash (e.g. `input(:checked, type: 'checkbox')` )
+
+Example (basic HTML / you may copy/paste in [`girb`](#girb-glimmer-irb-command)):
+
+```ruby
+@xml = html {
+  head {
+    meta(name: "viewport", content: "width=device-width, initial-scale=2.0")
+  }
+  body {
+    h1 { "Hello, World!" }
+  }
+}
+puts @xml
+```
+
+Output:
+
+```
+<html><head><meta name=\"viewport\" content=\"width=device-width, initial-scale=2.0\" /></head><body><h1>Hello, World!</h1></body></html>
+```
+
+Example (explicit XML tag / you may copy/paste in [`girb`](#girb-glimmer-irb-command)):
+
+```ruby
+puts tag(:_name => "DOCUMENT")
+```
+
+Output:
+
+```
+<DOCUMENT/>
+```
+
+Example (XML namespaces using `name_space` keyword / you may copy/paste in [`girb`](#girb-glimmer-irb-command)):
+
+```ruby
+@xml = name_space(:w3c) {
+  html(:id => "thesis", :class => "document") {
+    body(:id => "main") {
+    }
+  }
+}
+puts @xml
+```
+
+Output:
+
+```
+<w3c:html id=\"thesis\" class=\"document\"><w3c:body id=\"main\"></w3c:body></w3c:html>
+```
+
+Example (XML namespaces using dot operator / you may copy/paste in [`girb`](#girb-glimmer-irb-command)):
+
+```ruby
+@xml = tag(:_name => "DOCUMENT") {
+  document.body(document.id => "main") {
+  }
+}
+puts @xml
+```
+
+Output:
+
+```
+<DOCUMENT><document:body document:id="main"></document:body></DOCUMENT>
+```
+
+
+##### CSS DSL
+
+Simply start with `css` keyword and add stylesheet rule sets inside its block using Glimmer DSL syntax.
+Once done, you may call `to_s` or `to_css` to get the formatted CSS output.
+
+`css` is the only top-level keyword in the Glimmer CSS DSL
+
+Example (you may copy/paste in [`girb`](#girb-glimmer-irb-command)):
+
+```ruby
+@css = css {
+  body {
+    font_size "1.1em"
+  }
+  
+  s('body > h1') {
+    background_color :red
+  }
+}
+puts @css
+```
+
 #### Video Widget
 
 ![Video Widget](images/glimmer-video-widget.png)
@@ -1662,15 +1775,14 @@ Example rendering HTML with JavaScript on document ready (you may copy/paste in
 shell {
   minimum_size 130, 130
   @browser = browser {
-    text <<~HTML
-      <html>
-        <head>
-        </head>
-        <body>
-          <h1>Hello, World!</h1>
-        </body>
-      </html>
-    HTML
+    text html {
+      head {
+        meta(name: "viewport", content: "width=device-width, initial-scale=2.0")
+      }
+      body {
+        h1 { "Hello, World!" }
+      }
+    }
     on_completed { # on load of the page execute this JavaScript
       @browser.swt_widget.execute("alert('Hello, World!');")
     }
@@ -1678,6 +1790,8 @@ shell {
 }.open
 ```
 
+This relies on Glimmer's [Multi-DSL Support](https://github.com/AndyObtiva/glimmer/tree/development#multi-dsl-support) for building the HTML text using Glimmer XML DSL.
+
 ## Glimmer Style Guide
 
 - Widgets are declared with underscored lowercase versions of their SWT names minus the SWT package name.
@@ -1917,7 +2031,7 @@ Glimmer employs smart defaults in packaging.
 
 The package application name (shows up in top menu bar on the Mac) will be a human form of the app root directory name (e.g. "Math Bowling" for "MathBowling" or "math_bowling" app root directory name). However, application name and version may be specified explicitly via "-Bmac.CFBundleName" and "-Bmac.CFBundleVersion" options.
 
-Also, the package will only include these directories: app, config, db, lib, script, bin, images, sounds, videos
+Also, the package will only include these directories: app, config, db, lib, script, bin, docs, fonts, images, sounds, videos
 
 After running once, you will find a `config/warble.rb` file. It has the JAR packaging configuration. You may adjust included directories in it if needed, and then rerun `rake glimmer:package` and it will pick up your custom configuration. Alternatively, if you'd like to customize the included directories to begin with, don't run `rake glimmer:package` right away. Run this command first:
 

data/lib/glimmer.rb

@@ -54,6 +54,16 @@ module Glimmer
     def enable_logging
       @@logger = Logger.new(STDOUT).tap {|logger| logger.level = Logger::WARN}
     end
+
+    # Sets current DSL (e.g. :swt)
+    def dsl=(dsl_name)
+      Glimmer::DSL::Engine.dsl = dsl_name
+    end
+
+    # Currently set DSL (e.g. :swt or :xml)
+    def dsl
+      Glimmer::DSL::Engine.dsl
+    end
   end
 
   def method_missing(method_symbol, *args, &block)
@@ -82,7 +92,9 @@ $LOAD_PATH.unshift(File.expand_path('..', __FILE__))
 require 'glimmer/launcher'
 require Glimmer::Launcher.swt_jar_file
 require 'glimmer/swt/packages'
-require 'glimmer/dsl'
+require 'glimmer/dsl/swt/dsl'
+require 'glimmer/dsl/xml/dsl'
+require 'glimmer/dsl/css/dsl'
 require 'glimmer/error'
 require 'glimmer/invalid_keyword_error'
 require 'glimmer/ui/video'

data/lib/glimmer/css/rule_set.rb

@@ -0,0 +1,27 @@
+module Glimmer
+  module CSS
+    class RuleSet
+      attr_reader :selector, :properties
+
+      def initialize(selector)
+        @selector = selector
+        @properties = {}
+      end
+
+      def add_property(keyword, *args)
+        keyword = keyword.to_s.downcase.gsub('_', '-')
+        @properties[keyword] = args.first
+      end
+
+      def to_css
+        css = "#{@selector} {\n"
+        @properties.each do |name, value|
+          css << "  #{name}: #{value};\n"
+        end
+        css << "}"
+      end
+
+      alias to_s to_css      
+    end
+  end
+end

data/lib/glimmer/css/style_sheet.rb

@@ -0,0 +1,20 @@
+require 'glimmer/css/rule_set'
+
+module Glimmer
+  module CSS
+    class StyleSheet
+      attr_reader :rule_sets
+
+      def initialize
+        @rule_sets = []
+      end
+
+      def to_css
+        rule_set_css = rule_sets.map(&:to_css).join("\n\n")
+        "#{rule_set_css}\n"
+      end
+
+      alias to_s to_css      
+    end
+  end
+end

data/lib/glimmer/dsl/css/css_expression.rb

@@ -0,0 +1,21 @@
+require 'glimmer/dsl/static_expression'
+require 'glimmer/dsl/top_level_expression'
+require 'glimmer/dsl/parent_expression'
+require 'glimmer/css/style_sheet'
+
+module Glimmer
+  module DSL
+    module CSS
+      # This static html expression flips the DSL switch on for 
+      # XML DSL in Glimmer
+      class CssExpression < StaticExpression
+        include TopLevelExpression
+        include ParentExpression
+
+        def interpret(parent, keyword, *args, &block)
+          Glimmer::CSS::StyleSheet.new
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/css/dsl.rb

@@ -0,0 +1,10 @@
+require 'glimmer/dsl/engine'
+Dir[File.expand_path('../*_expression.rb', __FILE__)].each {|f| require f}
+
+Glimmer::DSL::Engine.add_dynamic_expressions(
+  Glimmer::DSL::CSS,
+  %w[
+    rule_set
+    property
+  ]
+)

data/lib/glimmer/dsl/css/p_expression.rb

@@ -0,0 +1,25 @@
+require 'glimmer/dsl/static_expression'
+require 'glimmer/css/style_sheet'
+require 'glimmer/css/rule_set'
+
+module Glimmer
+  module DSL
+    module CSS
+      class PExpression < StaticExpression
+        include ParentExpression
+
+        def can_interpret?(parent, keyword, *args, &block)
+          keyword == 'p' and
+            parent.is_a?(Glimmer::CSS::RuleSet) and
+            !block_given? and
+            !args.empty? and
+            args.size > 1
+        end
+
+        def interpret(parent, keyword, *args, &block)
+          parent.add_property(args[0], args[1])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'glimmer/dsl/expression'
+require 'glimmer/css/rule_set'
+
+module Glimmer
+  module DSL
+    module CSS
+      class PropertyExpression < Expression
+        include ParentExpression
+
+        def can_interpret?(parent, keyword, *args, &block)
+          parent.is_a?(Glimmer::CSS::RuleSet) and
+            !block_given? and
+            !args.empty?
+        end
+
+        def interpret(parent, keyword, *args, &block)
+          parent.add_property(keyword, *args)
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/css/rule_set_expression.rb

@@ -0,0 +1,25 @@
+require 'glimmer/dsl/expression'
+require 'glimmer/css/style_sheet'
+require 'glimmer/css/rule_set'
+
+module Glimmer
+  module DSL
+    module CSS
+      class RuleSetExpression < Expression
+        include ParentExpression
+
+        def can_interpret?(parent, keyword, *args, &block)
+          parent.is_a?(Glimmer::CSS::StyleSheet) and
+            block_given? and
+            args.empty?
+        end
+
+        def interpret(parent, keyword, *args, &block)
+          Glimmer::CSS::RuleSet.new(keyword.to_s.downcase).tap do |rule_set|
+            parent.rule_sets << rule_set
+          end
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/css/s_expression.rb

@@ -0,0 +1,26 @@
+require 'glimmer/dsl/static_expression'
+require 'glimmer/css/style_sheet'
+require 'glimmer/css/rule_set'
+
+module Glimmer
+  module DSL
+    module CSS
+      class SExpression < StaticExpression
+        include ParentExpression
+
+        def can_interpret?(parent, keyword, *args, &block)
+          keyword == 's' and
+            parent.is_a?(Glimmer::CSS::StyleSheet) and
+            block_given? and
+            !args.empty?
+        end
+
+        def interpret(parent, keyword, *args, &block)
+          Glimmer::CSS::RuleSet.new(args.first.to_s).tap do |rule_set|
+            parent.rule_sets << rule_set
+          end
+        end
+      end
+    end
+  end
+end

data/lib/glimmer/dsl/engine.rb

@@ -1,5 +1,4 @@
 require 'glimmer'
-Dir[File.expand_path('../*_expression.rb', __FILE__)].each {|f| require f}
 require 'glimmer/dsl/expression_handler'
 
 module Glimmer
@@ -10,12 +9,31 @@ module Glimmer
     #
     # When DSL engine interprets an expression, it attempts to handle
     # with ordered expression array specified via `.expressions=` method.
-    #
-    # TODO support auto-loading static_expressions in the future for expressions where
-    # the keyword does not vary dynamically. These static keywords are then
-    # predefined as methods in Glimmer instead of needing method_missing
     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
+
+        # 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
@@ -23,33 +41,75 @@ module Glimmer
         #
         # They are used in order following the Chain of Responsibility Design
         # Pattern when interpretting a DSL expression
-        #
-        # TODO rename to dynamic_expressions in the future when supporting static expressions
-        def dynamic_expressions=(expression_names)
-          @dynamic_expression_chain_of_responsibility = expression_names.reverse.reduce(nil) do |last_expresion_handler, expression_name|
-            Glimmer.logger&.debug "Loading #{expression_class_name(expression_name)}..."
-            expression = expression_class(expression_name).new
+        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.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 expression_class(expression_name)
-          DSL.const_get(expression_class_name(expression_name).to_sym)
+        def add_static_expression(static_expression)
+          Glimmer.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.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.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 
+                  raise e if static_expression_dsl.nil?
+                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}"
+              else
+                Glimmer.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
+                end
+              end
+            rescue => e
+              Glimmer::DSL::Engine.dsl_stack.pop
+              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 DSL keyword, args, and block (e.g. shell(:no_resize) { ... })
+        # 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
-          expression = @dynamic_expression_chain_of_responsibility.handle(current_parent, keyword, *args, &block)
-          expression.interpret(current_parent, keyword, *args, &block).tap do |ui_object|
+          dynamic_expression_dsl = dynamic_expression_chains_of_responsibility.keys.first 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 => e
+          dsl_stack.pop
+          raise e
         end
 
         # Adds content block to parent UI object
@@ -58,21 +118,33 @@ module Glimmer
         #
         # For example, a shell widget would get properties set and children added
         def add_content(parent, expression, &block)
+          time = Time.now.to_f
+          dsl_stack.push(expression.class.dsl)
           parent_stack.push(parent) if expression.is_a?(ParentExpression)
           expression.add_content(parent, &block) if block_given?
           parent_stack.pop if expression.is_a?(ParentExpression)
+          dsl_stack.pop
         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 current_parent
+        def parent
           parent_stack.last
         end
 
         def parent_stack
-          @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