glimmer-dsl-opal 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 67893f26592de179a00e15688b7814762edd60ff1c036b1389d177437ffaae5d
+  data.tar.gz: 2a6362729a7ecbe86231f2bcab62e25a46caadee1dc82c7f8abd84180d437ea2
+SHA512:
+  metadata.gz: f8ac369bb79fcd6b8b5c46ba357f807d393e99e49303f4d983efb9a1b54551a51a2b80536b2da1111097ce9ed912ae7f7ae6d7968778ade6cd0ec13f1b45e3f3
+  data.tar.gz: 517dbe5aa02c3c6027e9aca9be18c88a60c99c19c362dab098aa0ddb18c42faed884d0e6815a5cb7889fbec1f55c0e19543c843773f1e8720489baad07a7af73

data/CHANGELOG.md

@@ -0,0 +1,6 @@
+# Change Log
+
+## 0.0.1
+
+- Initial support for webifying Glimmer SWT apps
+- Support for Shell and Label widgets (text property only).

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2020 Andy Maleh
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,133 @@
+# Glimmer DSL for Opal 0.0.1 Beta (Web GUI for Desktop Apps)
+[![Gem Version](https://badge.fury.io/rb/glimmer-dsl-opal.svg)](http://badge.fury.io/rb/glimmer-dsl-opal)
+
+[Glimmer](https://github.com/AndyObtiva/glimmer) DSL for Opal is a web GUI adaptor for desktop apps built with [Glimmer DSL for SWT](https://github.com/AndyObtiva/glimmer-dsl-swt).
+
+It enables running [Glimmer](https://github.com/AndyObtiva/glimmer) desktop apps on the web via [Rails](https://rubyonrails.org/) 5 and [Opal](https://opalrb.com/) 1.
+
+NOTE: Version 0.0.1 only supports Hello, World! capabilities.
+
+## Examples
+
+### Hello, World!
+
+Glimmer code (from `samples/hello/hello_world.rb`):
+```ruby
+require 'glimmer-dsl-opal'
+
+include Glimmer
+
+shell {
+  text 'Glimmer'
+  label {
+    text 'Hello, World!'
+  }
+}.open
+```
+
+Run:
+```
+glimmer samples/hello/hello_world.rb
+```
+
+Glimmer app:
+
+![Glimmer DSL for Opal Hello World](images/glimmer-dsl-opal-hello-world.png)
+
+## Background
+
+Ruby is a dynamically-typed object-oriented language, which provides great productivity gains due to its powerful expressive syntax and dynamic nature. While it is proven by the Ruby on Rails framework for web development, it currently lacks a robust platform-independent framework for building desktop applications. Given that Java libraries can now be utilized in Ruby code through JRuby, Eclipse technologies, such as SWT, JFace, and RCP can help fill the gap of desktop application development with Ruby.
+
+## Pre-requisites
+
+- Rails 5: [https://github.com/rails/rails/tree/5-2-stable](https://github.com/rails/rails/tree/5-2-stable)
+- Opal 1: [https://github.com/opal/opal-rails](https://github.com/opal/opal-rails)
+
+## Setup
+
+Please follow these instructions to make Glimmer desktop apps work in Opal inside Rails 5
+
+Start a new Rails 5 app:
+
+```
+rails new hello_world
+```
+
+Follow instructions to setup opal with a rails application: config/initializers/assets.rb
+
+Add the following to `Gemfile`:
+```
+gem 'opal-rails'
+gem 'opal-browser'
+gem 'glimmer-dsl-opal', '~> 0.0.1', require: false
+```
+
+Edit `config/initializers/assets.rb` and add:
+```
+Opal.use_gem 'glimmer-dsl-opal'
+```
+
+Add the following Glimmer code to `app/assets/javascripts/application.js.rb`
+
+```ruby
+require 'glimmer-dsl-opal' # brings opal and opal browser too
+
+include Glimmer
+   
+shell {
+  text 'Glimmer'
+  label {
+    text 'Hello, World!'
+  }
+}
+```
+
+Start the Rails server:
+```
+rails s
+```
+
+Visit `http://localhost:3000`
+
+You should see "Hello, World!"
+
+![Glimmer DSL for Opal Hello World](images/glimmer-dsl-opal-hello-world.png)
+
+## Help
+
+### Issues
+
+You may submit [issues](https://github.com/AndyObtiva/glimmer/issues) on [GitHub](https://github.com/AndyObtiva/glimmer/issues).
+
+[Click here to submit an issue.](https://github.com/AndyObtiva/glimmer/issues)
+
+### IRC Channel
+
+If you need live help, try the [#glimmer](http://widget.mibbit.com/?settings=7514b8a196f8f1de939a351245db7aa8&server=irc.mibbit.net&channel=%23glimmer) IRC channel on [irc.mibbit.net](http://widget.mibbit.com/?settings=7514b8a196f8f1de939a351245db7aa8&server=irc.mibbit.net&channel=%23glimmer). If no one was available, you may [leave a GitHub issue](https://github.com/AndyObtiva/glimmer/issues) to schedule a meetup on IRC. 
+
+[Click here to connect to #glimmer IRC channel immediately via a web interface.](http://widget.mibbit.com/?settings=7514b8a196f8f1de939a351245db7aa8&server=irc.mibbit.net&channel=%23glimmer)
+
+## Feature Suggestions
+
+These features have been suggested. You might see them in a future version of Glimmer. You are welcome to contribute more feature suggestions.
+
+[TODO.md](TODO.md)
+
+## Change Log
+
+[CHANGELOG.md](CHANGELOG.md)
+
+## Contributing
+
+[CONTRIBUTING.md](CONTRIBUTING.md)
+
+## Contributors
+
+* [Andy Maleh](https://github.com/AndyObtiva) (Founder)
+
+[Click here to view contributor commits.](https://github.com/AndyObtiva/glimmer-dsl-opal/graphs/contributors)
+
+## License
+
+Copyright (c) 2020 Andy Maleh.
+See LICENSE.txt for further details.

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/glimmer-dsl-opal.rb

@@ -0,0 +1,8 @@
+# if RUBY_ENGINE == 'opal' # or test if env is test
+  $LOAD_PATH.unshift(File.expand_path('..', __FILE__))
+  
+  require 'opal'
+  require 'glimmer'
+  
+  require 'glimmer/dsl/opal/dsl' 
+# end

data/lib/glimmer/config.rb

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

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

@@ -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,21 @@
+require 'opal'
+require 'browser'
+
+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/error.rb

@@ -0,0 +1,6 @@
+module Glimmer
+  # Represents Glimmer errors that occur due to invalid use of Glimmer
+  # without handing control flow back to original method_missing
+  class Error < RuntimeError
+  end
+end

data/lib/glimmer/invalid_keyword_error.rb

@@ -0,0 +1,6 @@
+module Glimmer
+  # Represents Glimmer errors that occur due to invalid use of Glimmer
+  # without handing control flow back to original method_missing
+  class InvalidKeywordError < RuntimeError
+  end
+end

data/lib/glimmer/opal/label.rb

@@ -0,0 +1,31 @@
+module Glimmer
+  module Opal
+    class Label
+      attr_reader :text
+
+      def initialize(parent, args)
+        @parent = parent
+        @args = args
+        @parent.add_child(self)
+      end
+
+      def text=(value)
+        @text = value
+        redraw
+      end
+
+      def redraw
+        old_dom = @dom
+        @dom = nil
+        old_dom.replace dom
+      end
+
+      def dom
+        label_text = @text
+        @dom ||= DOM {
+          label label_text
+        }
+      end
+    end
+  end
+end

data/lib/glimmer/opal/shell.rb

@@ -0,0 +1,38 @@
+module Glimmer
+  module Opal
+    class Shell
+      def initialize(args)
+        @args = args
+        @children = []
+        $document.ready do
+          $document.body.replace(dom)
+        end
+      end      
+
+      def text
+        $document.title
+      end
+
+      def text=(value)
+        $document.title = value
+      end
+
+      def add_child(child)
+        return if @children.include?(child)
+        @children << child
+        dom << child.dom
+      end
+
+      def dom
+        @dom ||= DOM {
+          body {
+          }
+        }
+      end
+      
+      def open
+        # No Op (just a placeholder since it is not needed on the web)
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,209 @@
+--- !ruby/object:Gem::Specification
+name: glimmer-dsl-opal
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- AndyMaleh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-06-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: glimmer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+- !ruby/object:Gem::Dependency
+  name: rspec-mocks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.5.0
+- !ruby/object:Gem::Dependency
+  name: puts_debuggerer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.1.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 14.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.1.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 14.0.0
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.9
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.3.9
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.2.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.2.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+- !ruby/object:Gem::Dependency
+  name: opal-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.7.1
+- !ruby/object:Gem::Dependency
+  name: opal-browser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+description: Glimmer DSL for Opal (Web GUI Adapter for Desktop Apps)
+email: andy.am@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- VERSION
+- lib/glimmer-dsl-opal.rb
+- lib/glimmer/config.rb
+- lib/glimmer/dsl/engine.rb
+- lib/glimmer/dsl/expression.rb
+- lib/glimmer/dsl/expression_handler.rb
+- lib/glimmer/dsl/opal/dsl.rb
+- lib/glimmer/dsl/opal/label_expression.rb
+- lib/glimmer/dsl/opal/property_expression.rb
+- lib/glimmer/dsl/opal/shell_expression.rb
+- lib/glimmer/dsl/parent_expression.rb
+- lib/glimmer/dsl/static_expression.rb
+- lib/glimmer/dsl/top_level_expression.rb
+- lib/glimmer/error.rb
+- lib/glimmer/invalid_keyword_error.rb
+- lib/glimmer/opal/label.rb
+- lib/glimmer/opal/shell.rb
+homepage: http://github.com/AndyObtiva/glimmer-dsl-opal
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Glimmer DSL for Opal
+test_files: []