glimmer-dsl-css 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: b8bc05a543f2281ad44c1073149fda8c8f947ebf4205d98cc106219e1477f14e
+  data.tar.gz: e4f674a887a0c6d231a6ed6e259662de616eb3a6be770e20ddff30ca52946a00
+SHA512:
+  metadata.gz: 8c0aadaad6a38cabfea3b4e2d62aea9d429389b298c3b89187a5548ed50ad90a91a00dce46773edc9b93248561c55f2966bba19f2af3f2031b7eec14e777f04f
+  data.tar.gz: ffe9a44219bca30c59fa961df2792792c3957e49118ea16da617fb026e843088b5ffa8c22f7cfded1a794a018c61b2fb082284bbe86c961bdf417edba71a2bf6

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,111 @@
+# Glimmer DSL for CSS 0.1.0 Beta (Cascading Style Sheets)
+[![Gem Version](https://badge.fury.io/rb/glimmer-dsl-css.svg)](http://badge.fury.io/rb/glimmer-dsl-css)
+[![Travis CI](https://travis-ci.com/AndyObtiva/glimmer-dsl-css.svg?branch=master)](https://travis-ci.com/github/AndyObtiva/glimmer-dsl-css)
+
+[Glimmer](https://github.com/AndyObtiva/glimmer) DSL for CSS provides Ruby syntax for building CSS (Cascading Style Sheets).
+
+Within the context of desktop development, Glimmer DSL for CSS is useful in providing CSS for the [SWT Browser widget](https://github.com/AndyObtiva/glimmer/tree/master#browser-widget).
+
+## Setup
+
+Please follow these instructions to make the `glimmer` command available on your system.
+
+### Option 1: Direct Install
+
+Run this command to install directly:
+```
+jgem install glimmer-dsl-xml -v 0.1.0
+```
+
+`jgem` is JRuby's version of `gem` command. 
+RVM allows running `gem` as an alias.
+Otherwise, you may also run `jruby -S gem install ...`
+
+Add `require 'glimmer-dsl-xml'` to your code after `require glimmer-dsl-swt` or `require glimmer-dsl-opal`
+
+### Option 2: Bundler
+
+Add the following to `Gemfile` after `glimmer-dsl-swt` or `glimmer-dsl-opal`:
+```
+gem 'glimmer-dsl-xml', '~> 0.1.0'
+```
+
+And, then run:
+```
+jruby -S bundle install
+```
+
+That's it! Requiring the gem activates the Glimmer XML DSL automatically.
+
+## 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
+
+Selectors may be specified by `s` keyword or HTML element keyword directly (e.g. `body`)
+Rule property values may be specified by `pv` keyword or underscored property name directly (e.g. `font_size`)
+
+Example (you may copy/paste in [`girb`](#girb-glimmer-irb-command)):
+
+```ruby
+@css = css {
+  body {
+    font_size '1.1em'
+    pv 'background', 'white'
+  }
+  
+  s('body > h1') {
+    background_color :red
+    pv 'font-size', '2em'
+  }
+}
+puts @css
+```
+
+## Multi-DSL Support
+
+Learn more about how to use this DSL alongside other Glimmer DSLs:
+
+[Glimmer Multi-DSL Support](https://github.com/AndyObtiva/glimmer/tree/master#multi-dsl-support)
+
+## 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)
+* [Dennis Theisen](https://github.com/Soleone) (Contributor)
+
+[Click here to view contributor commits.](https://github.com/AndyObtiva/glimmer/graphs/contributors)
+
+## License
+
+Copyright (c) 2007-2020 Andy Maleh.
+See LICENSE.txt for further details.

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/glimmer-dsl-css.rb

@@ -0,0 +1,7 @@
+$LOAD_PATH.unshift(File.expand_path('..', __FILE__))
+
+require 'facets/string/underscore'
+require 'facets/string/camelcase'
+require 'glimmer'
+
+require 'glimmer/dsl/css/dsl'

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/css/rule.rb

@@ -0,0 +1,25 @@
+module Glimmer
+  module CSS
+    class Rule
+      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}{"
+        css << @properties.map { |name, value| "#{name}:#{value}" }.join(';')
+        css << "}"
+      end
+
+      alias to_s to_css      
+    end
+  end
+end

data/lib/glimmer/css/style_sheet.rb

@@ -0,0 +1,19 @@
+require 'glimmer/css/rule'
+
+module Glimmer
+  module CSS
+    class StyleSheet
+      attr_reader :rules
+
+      def initialize
+        @rules = []
+      end
+
+      def to_css
+        rules.map(&:to_css).join
+      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,21 @@
+require 'glimmer/dsl/engine'
+# Dir[File.expand_path('../*_expression.rb', __FILE__)].each {|f| require f} # cannot in Opal
+require 'glimmer/dsl/css/rule_expression'
+require 'glimmer/dsl/css/dynamic_property_expression'
+require 'glimmer/dsl/css/css_expression'
+require 'glimmer/dsl/css/s_expression'
+require 'glimmer/dsl/css/pv_expression'
+
+module Glimmer
+  module DSL
+    module CSS
+      Engine.add_dynamic_expressions(
+        CSS,
+        %w[
+          rule
+          dynamic_property
+        ]
+      )
+    end
+  end
+end

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

@@ -0,0 +1,12 @@
+require 'glimmer/dsl/expression'
+require 'glimmer/dsl/css/property_expression'
+
+module Glimmer
+  module DSL
+    module CSS
+      class DynamicPropertyExpression < Expression
+        include PropertyExpression
+      end
+    end
+  end
+end

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

@@ -0,0 +1,22 @@
+require 'glimmer/dsl/expression'
+require 'glimmer/css/rule'
+
+module Glimmer
+  module DSL
+    module CSS
+      module PropertyExpression
+        include ParentExpression
+
+        def can_interpret?(parent, keyword, *args, &block)
+          parent.is_a?(Glimmer::CSS::Rule) 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/pv_expression.rb

@@ -0,0 +1,17 @@
+require 'glimmer/dsl/static_expression'
+require 'glimmer/dsl/css/property_expression'
+
+module Glimmer
+  module DSL
+    module CSS
+      # Static keyword 'pv' version of CSS DSL dynamic property expression
+      class PVExpression < StaticExpression
+        include PropertyExpression
+
+        def interpret(parent, keyword, *args, &block)
+          parent.add_property(args[0], args[1])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+require 'glimmer/dsl/expression'
+require 'glimmer/dsl/parent_expression'
+require 'glimmer/css/style_sheet'
+require 'glimmer/css/rule'
+
+module Glimmer
+  module DSL
+    module CSS
+      class RuleExpression < 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::Rule.new(keyword.to_s.downcase).tap do |rule|
+            parent.rules << rule
+          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'
+
+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::Rule.new(args.first.to_s).tap do |rule|
+            parent.rules << rule
+          end
+        end
+      end
+    end
+  end
+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