ejx 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7d977622dbdaa5af0afbc8c9c024439f104337c3b4133dbf2c7866656256f373
+  data.tar.gz: e02233b080ee6d8dce9e94135993771464e33497a9102419d75ad8cf058f8984
+SHA512:
+  metadata.gz: e5dd9308fe7904ad51c24475de414887f92cdc62c76111f2c98ff03342d4d2874e17d44cbea939ae9dc3285670ebce7b027afb278630931b96898a40657babd1
+  data.tar.gz: f53c0b6ca412d595ae449f8db65f6038a152ba411f12debc9f57226d9679134c2a471f5e69a14572f8728c97bd0b797e9243322cf47e3af12532ce8719e4b6f4

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Jon Bracy
+
+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,80 @@
+EJX (Embedded JavaScript) template compiler for Ruby
+====================================================
+
+EJX templates embed JavaScript code inside `<% ... %>` tags, much like ERB. This
+library is inspired by [Underscore.js](https://underscorejs.org)'s
+[`_.template` function](https://underscorejs.org/#template) and
+[JSX](https://reactjs.org/docs/jsx-in-depth.html), but without the virtual DOM.
+
+The EJX tag syntax is as follows:
+
+* `<% ... %>` silently evaluates the statement inside the tags.
+* `<%= ... %>` evaluates the expression inside the tags, escapes and inserts it
+               into the template output.
+* `<%- ... %>` behaves like `<%= ... %>` but does not escape it's output.
+
+The functions compiled with EJX will return an array containing `Node` objects
+and/or `DOMString` which can be appended to a Node via `Node.append(...)`
+
+Examples
+--------
+
+To compile an EJX template into a Javascript module pass the template to `EJX.compile`:
+
+```ruby
+    EJX.compile("Hello <span><%= name %></span>")
+    # => import {append as __ejx_append} from 'ejx';
+    # => 
+    # => export default async function (locals) {
+    # =>     var __output = [], __promises = [];
+    # => 
+    # =>     __output.push("Hello ");
+    # =>     var __a = document.createElement("span");
+    # =>     __ejx_append(name, __a, true, __promises);
+    # =>     __ejx_append(__a, __output, false, __promises);
+    # => 
+    # =>     await Promise.all(__promises);
+    # =>     return __output;
+    # => }
+    JS
+```
+
+If a evalation tag (`<%=` or `<%-`) ends with an opening of a function, the
+function returns a compiled template. For example:
+
+```erb
+<%  formTag = function(template) {
+        var a = document.createElement("form");
+        a.append.apply(a, template());
+        return a;
+    } %>
+
+<%= formTag(function () { %>
+  <input type="submit" />
+<% }) %>
+```
+
+generates:
+
+```js
+import {append as __ejx_append} from 'ejx';
+
+export default async function (locals) {
+    var __output = [], __promises = [];
+  
+    formTag = function(template) {
+        var a = document.createElement("form");
+        a.append.apply(a, template());
+        return a;
+    }
+    var __a = [];
+    __ejx_append(formTag(function () {
+        var __b = document.createElement("input");
+        __b.setAttribute("type", "submit");
+        __ejx_append(__b, __a, false, __promises);
+    }), __output, true, __promises, __a);
+
+    await Promise.all(__promises);
+    return __output;
+}
+```

data/lib/condenser/transformers/ejx.rb

@@ -0,0 +1,23 @@
+class Condenser::EjxTransformer < Condenser::NodeProcessor
+
+  def initialize(options = {})
+    @options = options
+  end
+  
+  def self.setup(environment)
+    require 'ejx' unless defined?(::EJX)
+
+    if !environment.path.include?(EJX::ASSET_DIR)
+      environment.append_path(EJX::ASSET_DIR)
+    end
+  end
+  
+  def self.call(environment, input)
+    new.call(environment, input)
+  end
+
+  def call(environment, input)
+    input[:source] = EJX::Template.new(input[:source], @options).to_module
+  end
+
+end

data/lib/ejx.rb

@@ -0,0 +1,66 @@
+module EJX
+
+  class TemplateError < StandardError
+  end
+    
+  autoload :Template, File.expand_path('../ejx/template', __FILE__)
+
+  @@settings = {
+    open_tag: '<%',
+    close_tag: '%>',
+    
+    open_tag_modifiers: {
+      escape: '=',
+      unescape: '-',
+      comment: '#',
+      literal: '%'
+    },
+  
+    close_tag_modifiers: {
+      trim: '-',
+      literal: '%'
+    },
+    
+    escape: nil
+  }
+  
+  ASSET_DIR = File.join(__dir__, 'ejx', 'assets')
+  
+  VOID_ELEMENTS = [
+    'area',
+    'base',
+    'br',
+    'col',
+    'embed',
+    'hr',
+    'img',
+    'input',
+    'link',
+    'meta',
+    'param',
+    'source',
+    'track',
+    'wbr'
+  ]
+
+  def self.compile(source, options = {})
+    EJX::Template.new(source, options).to_module
+  end
+  
+  def self.settings
+    @@settings
+  end
+  
+  def self.settings=(value)
+    @@settings = value
+  end
+end
+
+
+if defined?(Condenser)
+  Condenser.configure do
+    autoload :EjxTransformer, 'condenser/transformers/ejx'
+    register_mime_type 'application/ejx', extensions: '.ejx', charset: :unicode
+    register_template  'application/ejx', Condenser::EjxTransformer
+  end
+end

data/lib/ejx/assets/ejx.js

@@ -0,0 +1,34 @@
+function repalceejx(el, withItems) {
+  if ( Array.isArray(withItems) ) {
+    withItems.forEach((i) => {
+      if (i instanceof Node) {
+        el.insertAdjacentElement('beforebegin', i)
+      } else {
+        // el.insertAdjacentHTML()
+        el.insertAdjacentText('beforebegin', i)
+      }
+    })
+    el.remove();
+  } else {
+    el.replaceWith(withItems);
+  }
+}
+
+export function append(items, to, escape, promises, promise_results) {
+  if ( Array.isArray(items) ) {
+    items.forEach((i) => append(i, to, escape, promises));
+  } else {
+    let method = Array.isArray(to) ? 'push' : 'append';
+    
+    if (items instanceof Promise) {
+      let holder = document.createElement( "div");
+      to[method](holder);
+      promises.push( items.then((resolvedItems) => {
+        repalceejx(holder, promise_results || resolvedItems)
+      }));
+    } else {
+      to[method](items);
+    }
+
+  }
+}

data/lib/ejx/template.rb

@@ -0,0 +1,206 @@
+class EJX::Template
+
+  autoload :JS, File.expand_path('../template/js', __FILE__)
+  autoload :Base, File.expand_path('../template/base', __FILE__)
+  autoload :String, File.expand_path('../template/string', __FILE__)
+  autoload :HTMLTag, File.expand_path('../template/html_tag', __FILE__)
+  autoload :ParseHelpers, File.expand_path('../template/parse_helpers', __FILE__)
+  autoload :Subtemplate, File.expand_path('../template/subtemplate', __FILE__)
+  autoload :VarGenerator, File.expand_path('../template/var_generator', __FILE__)
+  
+  include EJX::Template::ParseHelpers
+  
+  attr_accessor :source
+  
+  def initialize(source, options={})
+    @source = source.strip
+
+    @js_start_tags = [options[:open_tag] || EJX.settings[:open_tag]]
+    @html_start_tags = ['<']
+    @start_tags = @js_start_tags + @html_start_tags
+    
+    @js_close_tags = [options[:close_tag] || EJX.settings[:close_tag]]
+    @html_close_tags = ['/>', '>']
+    @close_tags = @js_close_tags + @html_close_tags
+    
+    @open_tag_modifiers = EJX.settings[:open_tag_modifiers].merge(options[:open_tag_modifiers] || {})
+    @close_tag_modifiers = EJX.settings[:close_tag_modifiers].merge(options[:close_tag_modifiers] || {})
+    
+    @escape = options[:escape]
+    process
+  end
+
+  def process
+    seek(0)
+    @tree =   [EJX::Template::Base.new(escape: @escape)]
+    @stack =  [:str]
+    
+    while !eos?
+      case @stack.last
+      when :str
+        scan_until(Regexp.new("(#{@start_tags.map{|s| Regexp.escape(s) }.join('|')}|\\z)"))
+        if !pre_match.strip.empty?
+          @tree.last.children << EJX::Template::String.new(pre_match)
+        end
+        
+        if !matched.nil?
+          if @js_start_tags.include?(matched)
+            @stack << :js
+          elsif @html_start_tags.include?(matched)
+            @stack << :html_tag
+          end
+        end
+      when :js
+        scan_until(Regexp.new("(#{@js_close_tags.map{|s| Regexp.escape(s) }.join('|')})"))
+        pm = pre_match
+        open_modifier = @open_tag_modifiers.find { |k,v| pm.start_with?(v) }&.first
+        close_modifier = @close_tag_modifiers.find { |k,v| matched.end_with?(v) }&.first
+        pm.slice!(0, open_modifier[1].size) if open_modifier
+        pm.slice!(pm.size - close_modifier[1].size, close_modifier[1].size) if close_modifier
+        
+        if pm =~ /\A\s*import/
+          import = pm.strip
+          import += ';' if !import.end_with?(';')
+          @tree.first.imports << import
+          @stack.pop
+        elsif @tree.last.is_a?(EJX::Template::Subtemplate) && pm.match(/\A\s*\}\s*\)/m) && !pm.match(/\A\s*\}.*\{\s*\Z/m)
+          subtemplate = @tree.pop
+          subtemplate.children << pm.strip
+          @tree.last.children << subtemplate
+          @stack.pop
+        elsif pm.match(/function\s*\([^\)]*\)\s*\{\s*\Z/m)
+          @tree << EJX::Template::Subtemplate.new(pm.strip, [open_modifier, close_modifier].compact)
+          @stack.pop
+        else
+          value = EJX::Template::JS.new(pm.strip, [open_modifier, close_modifier].compact)
+
+          @stack.pop
+          case @stack.last
+          when :html_tag
+            @tree.last.tag_name = value
+            push(:html_tag_attr_key)
+          when :html_tag_attr_key
+            @tree.last.attrs << value
+          when :html_tag_attr_value
+            @tree.last.attrs << {@stack_info.last => value}
+            @stack.pop
+          else
+            @tree.last.children << value
+          end
+        end
+      when :html_tag
+        scan_until(Regexp.new("(#{@js_start_tags.map{|s| Regexp.escape(s) }.join('|')}|\\/|[^\\s>]+)"))
+        if @js_start_tags.include?(matched)
+          @tree << EJX::Template::HTMLTag.new
+          @stack << :js
+        elsif matched == '/'
+          @stack.pop
+          @stack << :html_close_tag
+        else
+          @tree << EJX::Template::HTMLTag.new
+          @tree.last.tag_name = matched
+          @stack << :html_tag_attr_key
+        end
+      when :html_close_tag
+        scan_until(Regexp.new("(#{@js_start_tags.map{|s| Regexp.escape(s) }.join('|')}|[^\\s>]+)"))
+
+        if @js_start_tags.include?(matched)
+          @stack << :js
+        else
+          el = @tree.pop
+          if el.tag_name != matched
+            raise EJX::TemplateError.new("Expected to close #{el.tag_name} tag, instead closed #{matched}\n#{cursor}")
+          end
+          @tree.last.children << el
+          scan_until(Regexp.new("(#{@html_close_tags.map{|s| Regexp.escape(s) }.join('|')})"))
+          @stack.pop
+        end
+      when :html_tag_attr_key
+        scan_until(Regexp.new("(#{(@js_start_tags+@html_close_tags).map{|s| Regexp.escape(s) }.join('|')}|[^\\s=>]+)"))
+        if @js_start_tags.include?(matched)
+          @stack << :js
+        elsif @html_close_tags.include?(matched)
+          if matched == '/>' || EJX::VOID_ELEMENTS.include?(@tree.last.tag_name)
+            el = @tree.pop
+            @tree.last.children << el
+            @stack.pop
+            @stack.pop
+          else
+            @stack << :str
+          end
+        else
+          key = if matched.start_with?('"') && matched.end_with?('"')
+            matched[1..-2]
+          elsif matched.start_with?('"') && matched.end_with?('"')
+            matched[1..-2]
+          else
+            matched
+          end
+          @tree.last.attrs << key
+          @stack << :html_tag_attr_value_tx
+        end
+      when :html_tag_attr_value_tx
+        scan_until(Regexp.new("(#{(@js_start_tags+@html_close_tags).map{|s| Regexp.escape(s) }.join('|')}|=|\\S)"))
+        tag_key = @tree.last.attrs.pop
+        if @js_start_tags.include?(matched)
+          @stack << :js
+        elsif @html_close_tags.include?(matched)
+          el = @tree.last
+          el.attrs << tag_key
+          if EJX::VOID_ELEMENTS.include?(el.tag_name)
+            @tree.pop
+            @tree.last.children << el
+          end
+          @stack.pop
+          @stack.pop
+          @stack.pop
+        elsif matched == '='
+          @stack.pop
+          @tree.last.attrs << tag_key
+          @stack << :html_tag_attr_value
+        else
+          @stack.pop
+          @tree.last.attrs << tag_key
+          rewind(1)
+        end
+
+      when :html_tag_attr_value
+        scan_until(Regexp.new("(#{(@js_start_tags+@html_close_tags).map{|s| Regexp.escape(s) }.join('|')}|'|\"|\\S+)"))
+
+        if @js_start_tags.include?(matched)
+          push(:js)
+        elsif matched == '"'
+          @stack.pop
+          @stack << :html_tag_attr_value_double_quoted
+        elsif matched == "'"
+          @stack.pop
+          @stack << :html_tag_attr_value_single_quoted
+        else
+          @stack.pop
+          key = @tree.last.attrs.pop
+          @tree.last.namespace = matched if key == 'xmlns'
+          @tree.last.attrs << { key => matched }
+        end
+      when :html_tag_attr_value_double_quoted
+        scan_until(/[^\"]*/)
+        key = @tree.last.attrs.pop
+        @tree.last.namespace = matched if key == 'xmlns'
+        @tree.last.attrs << { key => matched }
+        scan_until(/\"/)
+        @stack.pop
+      when :html_tag_attr_value_single_quoted
+        scan_until(/[^']*/)
+        key = @tree.last.attrs.pop
+        @tree.last.namespace = matched if key == 'xmlns'
+        @tree.last.attrs << { key => matched }
+        scan_until(/'/)
+        @stack.pop
+      end
+    end
+  end
+
+  def to_module
+    @tree.first.to_module
+  end
+
+end

data/lib/ejx/template/base.rb

@@ -0,0 +1,41 @@
+class EJX::Template::Base
+  
+  attr_accessor :children, :imports
+
+  def initialize(escape: nil)
+    @children = []
+    @escape = escape
+    @imports = []
+  end
+
+  def to_module
+    var_generator = EJX::Template::VarGenerator.new
+    
+    output = if @escape
+      "import {" + @escape.split('.').reverse.join(" as escape} from '") + "';\n"
+    else
+      "import {append as __ejx_append} from 'ejx';\n"
+    end
+    
+    @imports.each do |import|
+      output << import << "\n"
+    end
+    
+    output << "\nexport default async function (locals) {\n"
+    output << "    var __output = [], __promises = [];\n    \n"
+    
+    @children.each do |child|
+      output << case child
+      when EJX::Template::String
+        "    __output.push(#{child.to_js});\n"
+      else
+        child.to_js(var_generator: var_generator)
+      end
+    end
+    output << "\n    await Promise.all(__promises);\n"
+    output << "    return __output;\n"
+    output << "}"
+    output
+  end
+
+end

data/lib/ejx/template/html_tag.rb

@@ -0,0 +1,53 @@
+class EJX::Template::HTMLTag
+  
+  attr_accessor :tag_name, :attrs, :children, :namespace
+
+  def initialize
+    @attrs = []
+    @children = []
+  end
+
+  def to_s
+    @value
+  end
+
+  def inspect
+    "#<EJX::HTMLTag:#{self.object_id} @tag_name=#{tag_name}>"
+  end
+
+  def to_js(append: "__output", var_generator:, indentation: 4, namespace: nil)
+    namespace ||= self.namespace
+    
+    output_var = var_generator.next
+    js = "#{' '*indentation}var #{output_var} = document.createElement"
+    js << if namespace
+      "NS(#{JSON.generate(namespace)}, #{JSON.generate(tag_name)});\n"
+    else
+      "(#{JSON.generate(tag_name)});\n"
+    end
+
+    @attrs.each do |attr|
+      if attr.is_a?(Hash)
+        attr.each do |k, v|
+          js << "#{' '*indentation}#{output_var}.setAttribute(#{JSON.generate(k)}, #{JSON.generate(v)});\n"
+        end
+      else
+        js << "#{' '*indentation}#{output_var}.setAttribute(#{JSON.generate(attr)}, \"\");\n"
+      end
+    end
+
+    @children.each do |child|
+      js << if child.is_a?(EJX::Template::String)
+        "#{' '*indentation}__ejx_append(#{child.to_js}, #{output_var}, false, __promises);\n"
+      elsif child.is_a?(EJX::Template::HTMLTag)
+        child.to_js(var_generator: var_generator, indentation: indentation, append: output_var, namespace: namespace)
+      else
+        child.to_js(var_generator: var_generator, indentation: indentation, append: output_var)
+      end
+    end
+
+    js << "#{' '*indentation}__ejx_append(#{output_var}, #{append}, false, __promises);\n"
+    js
+  end
+  
+end

data/lib/ejx/template/js.rb

@@ -0,0 +1,19 @@
+class EJX::Template::JS
+  
+  def initialize(value, modifiers)
+    @modifiers = modifiers
+    @value = value
+  end
+
+  def to_js(indentation: 4, var_generator: nil, append: "__output")
+    output = @value
+    
+    if @modifiers.include? :escape
+      "#{' '*indentation}__ejx_append(#{output}, #{append}, true, __promises);\n"
+    elsif @modifiers.include? :unescape
+      "#{' '*indentation}__ejx_append(#{output}, #{append}, false, __promises);\n"
+    elsif !@modifiers.include? :comment
+      "#{' '*indentation}#{output}\n"
+    end
+  end
+end

data/lib/ejx/template/parse_helpers.rb

@@ -0,0 +1,44 @@
+module EJX::Template::ParseHelpers
+
+  attr_accessor :matched
+
+  def eos?
+    @index >= @source.size
+  end
+
+  def scan_until(r)
+    index = @source.index(r, @index)
+    match = @source.match(r, @index)
+    @matched = match.to_s
+    @old_index = @index
+    @index = index + @matched.size
+    match
+  end
+
+  def pre_match
+    @source[@old_index...(@index-@matched.size)]
+  end
+
+  def rewind(by)
+    @index -= 1
+  end
+
+  def seek(pos)
+    @old_index = nil
+    @matched = nil
+    @index = pos
+  end
+
+  def current_line
+    start = (@source.rindex("\n", @old_index) || 0) + 1
+    uptop = @source.index("\n", @index) || (@old_index + @matched.length)
+    @source[start..uptop]
+  end
+  
+  def cursor
+    start = (@source.rindex("\n", @old_index) || 0) + 1
+    uptop = @source.index("\n", @index) || (@old_index + @matched.length)
+    lineno = @source[0..start].count("\n") + 1
+    "#{lineno.to_s.rjust(4)}: " + @source[start..uptop] + "\n      #{'-'* (@old_index-start)}#{'^'*(@matched.length)}"
+  end
+end

data/lib/ejx/template/string.rb

@@ -0,0 +1,13 @@
+require 'json'
+
+class EJX::Template::String
+
+  def initialize(value)
+    @value = value
+  end
+
+  def to_js
+    JSON.generate(@value)
+  end
+
+end

data/lib/ejx/template/subtemplate.rb

@@ -0,0 +1,33 @@
+class EJX::Template::Subtemplate
+
+  attr_reader :children
+  
+  def initialize(opening, modifiers)
+    @children = [opening]
+    @modifiers = modifiers
+  end
+
+  def to_js(indentation: 4, var_generator: nil, append: "__output")
+    output_var = var_generator.next
+    output =  "#{' '*indentation}var #{output_var} = [];\n"
+    output << "#{' '*indentation}__ejx_append("
+    output << @children.first
+    output << "\n"
+
+    # var_generator ||= EJX::Template::VarGenerator.new
+    @children[1..-2].each do |child|
+      output << case child
+      when EJX::Template::String
+        "#{' '*(indentation+4)}__ejx_append(#{child.to_js}, #{output_var}, false, __promises);\n"
+      else
+        child.to_js(indentation: indentation + 4, var_generator: var_generator, append: output_var)
+      end
+    end
+    output << ' '*indentation
+    output << @children.last
+    output << ", #{append}, true, __promises, #{output_var});\n"
+
+    output
+  end
+
+end

data/lib/ejx/template/var_generator.rb

@@ -0,0 +1,10 @@
+class EJX::Template::VarGenerator
+  def initialize
+    @current = nil
+  end
+  
+  def next
+    @current = @current.nil? ? '__a' : @current.next
+    @current
+  end
+end

data/lib/ejx/version.rb

@@ -0,0 +1,3 @@
+module EJX
+  VERSION = '0.1'
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: ejx
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Jonathan Bracy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-04-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-reporters
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |
+  Compile EJX (Embedded JavaScript) templates to Javascript
+  functions with Ruby.
+email:
+- jonbracy@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/condenser/transformers/ejx.rb
+- lib/ejx.rb
+- lib/ejx/assets/ejx.js
+- lib/ejx/template.rb
+- lib/ejx/template/base.rb
+- lib/ejx/template/html_tag.rb
+- lib/ejx/template/js.rb
+- lib/ejx/template/parse_helpers.rb
+- lib/ejx/template/string.rb
+- lib/ejx/template/subtemplate.rb
+- lib/ejx/template/var_generator.rb
+- lib/ejx/version.rb
+homepage: https://github.com/malomalo/ejx
+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: EJX Template Compiler
+test_files: []