rbexy 0.1.0

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "rbexy"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/docker-compose.yml

@@ -0,0 +1,15 @@
+version: '3'
+
+volumes:
+  bundle:
+
+services:
+  rbexy:
+    build: .
+    volumes:
+      - .:/app
+      - bundle:/usr/local/bundle
+      - $HOME/.ssh:/root/.ssh:ro
+      - $HOME/.gitconfig:/root/.gitconfig:ro
+      - $HOME/.gem/credentials:/root/.gem/credentials
+    working_dir: /app

data/example.rb

@@ -0,0 +1,113 @@
+require "bundler"
+Bundler.require
+
+require "active_support/all"
+require "action_view/helpers"
+require "action_view/context"
+require "action_view/buffers"
+
+template_string = <<-RBX
+# A comment here
+<div>
+  <h1 {**{ class: "myClass" }} {**splat_attrs}>Hello world</h1>
+  <div {**{ class: "myClass" }}></div>
+  Some words
+  # A comment here
+  # A comment here
+  <p>Lorem ipsum</p>
+  <input type="submit" value={@ivar_val} disabled />
+  {true && <p>Is true</p>}
+  {false && <p>Is false</p>}
+  {true ? <p {**{ class: "myClass" }}>Ternary is {'true'.upcase}</p> : <p>Ternary is false</p>}
+  <Button prop1="val1" prop2={true && "val2"} multi-word-prop="value">the content</Button>
+  <Forms.TextField label={->(n) { <label id={n}>Something</label> }} note={<p>the note</p>} />
+  <ul>
+    # A comment here
+    {["hi", "there", "nick"].map { |val| <li>{val}</li> }}
+  </ul>
+  <p
+    class="something">Text</p>
+  <input
+    class="foobar"
+    />
+  <div
+    with="lots"
+    of="attributes"
+  >
+    Content
+  </div>
+  # comment
+</div>
+# comment
+RBX
+
+module Components
+  class ButtonComponent
+    def initialize(prop1:, prop2:, multi_word_prop:)
+      @prop1 = prop1
+      @prop2 = prop2
+      @multi_word_prop = multi_word_prop
+    end
+
+    def render
+      # Render it yourself, call one of Rails view helpers (link_to,
+      # content_tag, etc), or use a template file. Be sure to render
+      # children by yielding to the given block.
+      "<button class=\"#{[@prop1, @prop2, @multi_word_prop].join("-")}\">#{yield}</button>"
+    end
+  end
+
+  module Forms
+    class TextFieldComponent
+      def initialize(label:, note:, **attrs)
+        @label = label
+        @note = note
+      end
+
+      def render
+        "#{@label.call(2)} <input type=\"text\" />#{@note}"
+      end
+    end
+  end
+end
+
+class ComponentProvider
+  def match?(name)
+    find(name) != nil
+  end
+
+  def render(context, name, **attrs, &block)
+    props = attrs.transform_keys { |k| ActiveSupport::Inflector.underscore(k.to_s).to_sym }
+    find(name).new(**props).render(&block)
+  end
+
+  private
+
+  def find(name)
+    ActiveSupport::Inflector.constantize("Components::#{name}Component")
+  rescue NameError => e
+    raise e unless e.message =~ /constant/
+    nil
+  end
+end
+
+class MyRuntime < Rbexy::Runtime
+  def initialize(component_provider)
+    super(component_provider)
+    @ivar_val = "ivar value"
+  end
+
+  def splat_attrs
+    {
+      key1: "val1",
+      key2: "val2"
+    }
+  end
+end
+
+puts "=============== Compiled ruby code ==============="
+code = Rbexy.compile(template_string)
+puts code
+
+puts "=============== Result of eval ==============="
+puts MyRuntime.new(ComponentProvider.new).evaluate(code)

data/lib/rbexy.rb

@@ -0,0 +1,35 @@
+require "rbexy/version"
+
+module Rbexy
+  autoload :Lexer, "rbexy/lexer"
+  autoload :Parser, "rbexy/parser"
+  autoload :Nodes, "rbexy/nodes"
+  autoload :Runtime, "rbexy/runtime"
+  autoload :HashMash, "rbexy/hash_mash"
+  autoload :OutputBuffer, "rbexy/output_buffer"
+  autoload :ComponentTagBuilder, "rbexy/component_tag_builder"
+  autoload :ViewContextHelper, "rbexy/view_context_helper"
+  autoload :Configuration, "rbexy/configuration"
+
+  ContextNotFound = Class.new(StandardError)
+
+  class << self
+    def configure
+      yield(configuration)
+    end
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def compile(template_string)
+      tokens = Rbexy::Lexer.new(template_string).tokenize
+      template = Rbexy::Parser.new(tokens).parse
+      template.compile
+    end
+
+    def evaluate(template_string, runtime)
+      runtime.evaluate compile(template_string)
+    end
+  end
+end

data/lib/rbexy/component.rb

@@ -0,0 +1,100 @@
+require "action_view"
+
+module Rbexy
+  class Component < ActionView::Base
+    class LookupContext < ActionView::LookupContext
+      def self.details_hash(context)
+        context.registered_details.each_with_object({}) do |key, details_hash|
+          value = key == :locale ? [context.locale] : context.send(key)
+          details_hash[key] = value
+        end
+      end
+
+      # We override any calls to args_for_lookup and set partial=false so that
+      # the lookup context doesn't automatically add a `_` prefix to the
+      # template path, since we're using the Rails partial-rendering
+      # functionality but don't want our templates prefixed with a `_`
+      def args_for_lookup(name, prefixes, partial, keys, details_options)
+        super(name, prefixes, false, keys, details_options)
+      end
+    end
+
+    def initialize(view_context, **props)
+      super(
+        view_context.lookup_context,
+        view_context.assigns,
+        view_context.controller
+      )
+
+      @view_context = view_context
+
+      setup(**props)
+    end
+
+    # Override in your subclass to handle props, setup your component, etc.
+    # You can also implement `initialize` but you just need to remember to
+    # call super(view_context).
+    def setup(**props); end
+
+    def render(&block)
+      @content = nil
+      @content_block = block_given? ? block : nil
+      call
+    end
+
+    def call
+      old_lookup_context = view_renderer.lookup_context
+      view_renderer.lookup_context = build_lookup_context(old_lookup_context)
+      view_renderer.render(self, partial: component_name, &nil)
+    ensure
+      view_renderer.lookup_context = old_lookup_context
+    end
+
+    def content
+      @content ||= content_block ? view_context.capture(self, &content_block) : ""
+    end
+
+    def create_context(name, value)
+      rbexy_context.last[name] = value
+    end
+
+    def use_context(name)
+      index = rbexy_context.rindex { |c| c.has_key?(name) }
+      index ?
+        rbexy_context[index][name] :
+        raise(ContextNotFound, "no parent context `#{name}`")
+    end
+
+    private
+
+    attr_reader :view_context, :content_block
+
+    def build_lookup_context(existing_context)
+      paths = existing_context.view_paths.dup.unshift(
+        *Rbexy.configuration.template_paths.map { |p| ActionView::OptimizedFileSystemResolver.new(p) }
+      )
+
+      LookupContext.new(
+        paths,
+        LookupContext.details_hash(existing_context),
+        Rbexy.configuration.template_prefixes
+      )
+    end
+
+    def view_renderer
+      view_context.view_renderer
+    end
+
+    def component_name
+      self.class.name.underscore
+    end
+
+    def method_missing(meth, *args, &block)
+      if view_context.respond_to?(meth)
+        view_context.send(meth, *args, &block)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/rbexy/component_providers/rbexy_provider.rb

@@ -0,0 +1,23 @@
+module Rbexy
+  module ComponentProviders
+    class RbexyProvider
+      def match?(name)
+        name =~ /^[A-Z]/ && find(name) != nil
+      end
+
+      def render(context, name, **attrs, &block)
+        props = attrs.transform_keys { |k| ActiveSupport::Inflector.underscore(k.to_s).to_sym }
+        find(name).new(context, **props).render(&block)
+      end
+
+      private
+
+      def find(name)
+        ActiveSupport::Inflector.constantize("#{name}Component")
+      rescue NameError => e
+        raise e unless e.message =~ /wrong constant name/ || e.message =~ /uninitialized constant/
+        nil
+      end
+    end
+  end
+end

data/lib/rbexy/component_providers/view_component_provider.rb

@@ -0,0 +1,23 @@
+module Rbexy
+  module ComponentProviders
+    class ViewComponentProvider
+      def match?(name)
+        name =~ /^[A-Z]/ && find(name) != nil
+      end
+
+      def render(context, name, **attrs, &block)
+        props = attrs.transform_keys { |k| ActiveSupport::Inflector.underscore(k.to_s).to_sym }
+        find(name).new(**props).render_in(context, &block)
+      end
+
+      private
+
+      def find(name)
+        ActiveSupport::Inflector.constantize("#{name}Component")
+      rescue NameError => e
+        raise e unless e.message =~ /wrong constant name/ || e.message =~ /uninitialized constant/
+        nil
+      end
+    end
+  end
+end

data/lib/rbexy/component_tag_builder.rb

@@ -0,0 +1,19 @@
+module Rbexy
+  class ComponentTagBuilder < ActionView::Helpers::TagHelper::TagBuilder
+    attr_reader :component_provider
+
+    def initialize(context, component_provider)
+      super(context)
+      @component_provider = component_provider
+    end
+
+    def method_missing(called, *args, **attrs, &block)
+      component_name = called.to_s.gsub("__", "::")
+      if component_provider.match?(component_name)
+        component_provider.render(@view_context, component_name, **attrs, &block)
+      else
+        super
+      end
+    end
+  end
+end

data/lib/rbexy/configuration.rb

@@ -0,0 +1,15 @@
+module Rbexy
+  class Configuration
+    attr_accessor :component_provider
+    attr_accessor :template_paths
+    attr_accessor :template_prefixes
+
+    def template_paths
+      @template_paths ||= []
+    end
+
+    def template_prefixes
+      @template_prefixes ||= []
+    end
+  end
+end

data/lib/rbexy/hash_mash.rb

@@ -0,0 +1,15 @@
+module Rbexy
+  class HashMash < Hash
+    def initialize(hash)
+      replace(hash)
+    end
+
+    def method_missing(meth, *args, &block)
+      if has_key?(meth)
+        self[meth]
+      else
+        super
+      end
+    end
+  end
+end

data/lib/rbexy/lexer.rb

@@ -0,0 +1,279 @@
+module Rbexy
+  class Lexer
+    class SyntaxError < StandardError
+      def initialize(lexer)
+        super(
+          "Invalid syntax: `#{lexer.scanner.peek(20)}`\n" +
+          "Stack: #{lexer.stack}\n" +
+          "Tokens: #{lexer.tokens}"
+        )
+      end
+    end
+
+    Patterns = HashMash.new(
+      open_expression: /{/,
+      close_expression: /}/,
+      expression_content: /[^}{"'<]+/,
+      open_tag_def: /<(?!\/)/,
+      open_tag_end: /<\//,
+      close_tag: /\s*\/?>/,
+      close_self_closing_tag: /\s*\/>/,
+      tag_name: /\/?[A-Za-z0-9\-_.]+/,
+      text_content: /[^<{#]+/,
+      comment: /^\p{Blank}*#.*(\n|\z)/,
+      whitespace: /\s+/,
+      attr: /[A-Za-z0-9\-_\.]+/,
+      open_attr_splat: /{\*\*/,
+      attr_assignment: /=/,
+      double_quote: /"/,
+      single_quote: /'/,
+      double_quoted_text_content: /[^"]+/,
+      single_quoted_text_content: /[^']+/,
+      expression_internal_tag_prefixes: /(\s+(&&|\?|:|do|do\s*\|[^\|]+\||{|{\s*\|[^\|]+\|)\s+\z|\A\s*\z)/,
+      declaration: /<![^>]*>/
+    )
+
+    attr_reader :stack, :tokens, :scanner, :curr_expr_quote_levels
+    attr_accessor :curr_expr_bracket_levels, :curr_expr, :curr_default_text,
+                  :curr_quoted_text
+
+    def initialize(code)
+      @stack = [:default]
+      @curr_expr_bracket_levels = 0
+      @curr_expr_quote_levels = { single: 0, double: 0 }
+      @curr_expr = ""
+      @curr_default_text = ""
+      @curr_quoted_text = ""
+      @tokens = []
+      @scanner = StringScanner.new(code)
+    end
+
+    def tokenize
+      until scanner.eos?
+        case stack.last
+        when :default
+          if scanner.scan(Patterns.declaration)
+            tokens << [:DECLARATION, scanner.matched]
+          elsif scanner.scan(Patterns.open_tag_def)
+            open_tag_def
+          elsif scanner.scan(Patterns.open_expression)
+            open_expression
+          elsif scanner.scan(Patterns.comment)
+            tokens << [:SILENT_NEWLINE]
+          elsif scanner.check(Patterns.text_content)
+            stack.push(:default_text)
+          else
+            raise SyntaxError, self
+          end
+        when :tag
+          if scanner.scan(Patterns.open_tag_def)
+            open_tag_def
+          elsif scanner.scan(Patterns.open_tag_end)
+            tokens << [:OPEN_TAG_END]
+            stack.push(:tag_end)
+          elsif scanner.scan(Patterns.open_expression)
+            open_expression
+          elsif scanner.scan(Patterns.comment)
+            tokens << [:SILENT_NEWLINE]
+          elsif scanner.check(Patterns.text_content)
+            stack.push(:default_text)
+          else
+            raise SyntaxError, self
+          end
+        when :default_text
+          if scanner.scan(Patterns.text_content)
+            self.curr_default_text += scanner.matched
+            if scanner.matched.end_with?('\\') && scanner.peek(1) == "{"
+              self.curr_default_text += scanner.getch
+            elsif scanner.matched.end_with?('\\') && scanner.peek(1) == "#"
+              self.curr_default_text += scanner.getch
+            else
+              if scanner.peek(1) == "#"
+                # If the next token is a comment, trim trailing whitespace from
+                # the text value so we don't add to the indentation of the next
+                # value that is output after the comment
+                self.curr_default_text = curr_default_text.gsub(/^\p{Blank}*\z/, "")
+              end
+              tokens << [:TEXT, curr_default_text]
+              self.curr_default_text = ""
+              stack.pop
+            end
+          else
+            raise SyntaxError, self
+          end
+        when :expression
+          if scanner.scan(Patterns.close_expression)
+            tokens << [:EXPRESSION_BODY, curr_expr]
+            tokens << [:CLOSE_EXPRESSION]
+            self.curr_expr = ""
+            stack.pop
+          elsif scanner.scan(Patterns.open_expression)
+            expression_inner_bracket
+          elsif scanner.scan(Patterns.double_quote)
+            expression_inner_double_quote
+          elsif scanner.scan(Patterns.single_quote)
+            expression_inner_single_quote
+          elsif scanner.scan(Patterns.open_tag_def)
+            potential_expression_inner_tag
+          elsif scanner.scan(Patterns.expression_content)
+            self.curr_expr += scanner.matched
+          else
+            raise SyntaxError, self
+          end
+        when :expression_inner_bracket
+          if scanner.scan(Patterns.close_expression)
+            self.curr_expr += scanner.matched
+            stack.pop
+          elsif scanner.scan(Patterns.open_expression)
+            expression_inner_bracket
+          elsif scanner.scan(Patterns.double_quote)
+            expression_inner_double_quote
+          elsif scanner.scan(Patterns.single_quote)
+            expression_inner_single_quote
+          elsif scanner.scan(Patterns.open_tag_def)
+            potential_expression_inner_tag
+          elsif scanner.scan(Patterns.expression_content)
+            self.curr_expr += scanner.matched
+          else
+            raise SyntaxError, self
+          end
+        when :expression_inner_double_quote
+          if scanner.check(Patterns.double_quote)
+            expression_quoted_string_content
+          elsif scanner.scan(Patterns.double_quoted_text_content)
+            self.curr_expr += scanner.matched
+          else
+            raise SyntaxError, self
+          end
+        when :expression_inner_single_quote
+          if scanner.check(Patterns.single_quote)
+            expression_quoted_string_content
+          elsif scanner.scan(Patterns.single_quoted_text_content)
+            self.curr_expr += scanner.matched
+          else
+            raise SyntaxError, self
+          end
+        when :tag_def
+          if scanner.scan(Patterns.close_self_closing_tag)
+            tokens << [:CLOSE_TAG_DEF]
+            tokens << [:OPEN_TAG_END]
+            tokens << [:CLOSE_TAG_END]
+            stack.pop(2)
+          elsif scanner.scan(Patterns.close_tag)
+            tokens << [:CLOSE_TAG_DEF]
+            stack.pop
+          elsif scanner.scan(Patterns.tag_name)
+            tokens << [:TAG_NAME, scanner.matched]
+          elsif scanner.scan(Patterns.whitespace)
+            scanner.matched.count("\n").times { tokens << [:SILENT_NEWLINE] }
+            tokens << [:OPEN_ATTRS]
+            stack.push(:tag_attrs)
+          else
+            raise SyntaxError, self
+          end
+        when :tag_end
+          if scanner.scan(Patterns.close_tag)
+            tokens << [:CLOSE_TAG_END]
+            stack.pop(2)
+          elsif scanner.scan(Patterns.tag_name)
+            tokens << [:TAG_NAME, scanner.matched]
+          else
+            raise SyntaxError, self
+          end
+        when :tag_attrs
+          if scanner.scan(Patterns.whitespace)
+            scanner.matched.count("\n").times { tokens << [:SILENT_NEWLINE] }
+          elsif scanner.check(Patterns.close_tag)
+            tokens << [:CLOSE_ATTRS]
+            stack.pop
+          elsif scanner.scan(Patterns.attr_assignment)
+            tokens << [:OPEN_ATTR_VALUE]
+            stack.push(:tag_attr_value)
+          elsif scanner.scan(Patterns.attr)
+            tokens << [:ATTR_NAME, scanner.matched.strip]
+          elsif scanner.scan(Patterns.open_attr_splat)
+            tokens << [:OPEN_ATTR_SPLAT]
+            tokens << [:OPEN_EXPRESSION]
+            stack.push(:tag_attr_splat, :expression)
+          else
+            raise SyntaxError, self
+          end
+        when :tag_attr_value
+          if scanner.scan(Patterns.double_quote)
+            stack.push(:quoted_text)
+          elsif scanner.scan(Patterns.open_expression)
+            open_expression
+          elsif scanner.scan(Patterns.whitespace) || scanner.check(Patterns.close_tag)
+            tokens << [:CLOSE_ATTR_VALUE]
+            scanner.matched.count("\n").times { tokens << [:SILENT_NEWLINE] }
+            stack.pop
+          else
+            raise SyntaxError, self
+          end
+        when :tag_attr_splat
+          # Splat is consumed by :expression. It pops control back to here once
+          # it's done, and we just record the completion and pop back to :tag_attrs
+          tokens << [:CLOSE_ATTR_SPLAT]
+          stack.pop
+        when :quoted_text
+          if scanner.scan(Patterns.double_quoted_text_content)
+            self.curr_quoted_text += scanner.matched
+            if scanner.matched.end_with?('\\') && scanner.peek(1) == "\""
+              self.curr_quoted_text += scanner.getch
+            end
+          elsif scanner.scan(Patterns.double_quote)
+            tokens << [:TEXT, curr_quoted_text]
+            self.curr_quoted_text = ""
+            stack.pop
+          else
+            raise SyntaxError, self
+          end
+        else
+          raise SyntaxError, self
+        end
+      end
+
+      tokens
+    end
+
+    def potential_expression_inner_tag
+      if self.curr_expr =~ Patterns.expression_internal_tag_prefixes
+        tokens << [:EXPRESSION_BODY, curr_expr]
+        self.curr_expr = ""
+        open_tag_def
+      else
+        self.curr_expr += scanner.matched
+      end
+    end
+
+    def open_tag_def
+      tokens << [:OPEN_TAG_DEF]
+      stack.push(:tag, :tag_def)
+    end
+
+    def open_expression
+      tokens << [:OPEN_EXPRESSION]
+      stack.push(:expression)
+    end
+
+    def expression_inner_bracket
+      self.curr_expr += scanner.matched
+      stack.push(:expression_inner_bracket)
+    end
+
+    def expression_inner_double_quote
+      self.curr_expr += scanner.matched
+      stack.push(:expression_inner_double_quote)
+    end
+
+    def expression_inner_single_quote
+      self.curr_expr += scanner.matched
+      stack.push(:expression_inner_single_quote)
+    end
+
+    def expression_quoted_string_content
+      self.curr_expr += scanner.getch
+      stack.pop unless curr_expr.end_with?('\\')
+    end
+  end
+end