rbexy 0.1.0

data/lib/rbexy/nodes.rb

@@ -0,0 +1,142 @@
+module Rbexy
+  module Nodes
+    module Util
+      def self.safe_string(str)
+        str.gsub('"', '\\"')
+      end
+
+      def self.safe_tag_name(name)
+        name.gsub(".", "__")
+      end
+    end
+
+    class Template
+      attr_reader :children
+
+      def initialize(children)
+        @children = children
+      end
+
+      def compile
+        [
+          "Rbexy::OutputBuffer.new.tap { |output|",
+            children.map(&:compile).map { |c| "output << (#{c})"}.join(";"),
+          "}.html_safe"
+        ].join(" ")
+      end
+    end
+
+    class Text
+      attr_reader :content
+
+      def initialize(content)
+        @content = content
+      end
+
+      def compile
+        "\"#{Util.safe_string(content)}\""
+      end
+    end
+
+    class ExpressionGroup
+      attr_reader :statements
+
+      def initialize(statements)
+        @statements = statements
+      end
+
+      def compile
+        statements.map(&:compile).join
+      end
+    end
+
+    class Expression
+      attr_reader :content
+
+      def initialize(content)
+        @content = content
+      end
+
+      def compile
+        content
+      end
+    end
+
+    class XmlNode
+      attr_reader :name, :members, :children
+
+      def initialize(name, members, children)
+        @name = name
+        @members = members || []
+        @children = children
+      end
+
+      def compile
+        base_tag = "rbexy_tag.#{Util.safe_tag_name(name)}(#{compile_members})"
+        tag = if children.length > 0
+          [
+            "#{base_tag} {",
+              "Rbexy::OutputBuffer.new.tap { |output|",
+                children.map(&:compile).map { |c| "output << (#{c})"}.join(";"),
+              "}.html_safe",
+            "}"
+          ].join(" ")
+        else
+          base_tag
+        end
+
+        [
+          "Rbexy::OutputBuffer.new.tap { |output|",
+            "rbexy_context.push({}) if defined?(Rbexy::Component) && self.is_a?(Rbexy::Component);",
+            "output << (#{tag});",
+            "rbexy_context.pop if defined?(Rbexy::Component) && self.is_a?(Rbexy::Component);",
+          "}.html_safe"
+        ].join(" ")
+      end
+
+      def compile_members
+        members.each_with_object("") do |member, result|
+          case member
+          when ExpressionGroup
+            result << "**#{member.compile},"
+          when SilentNewline
+            result << member.compile
+          else
+            result << "#{member.compile},"
+          end
+        end
+      end
+    end
+
+    class XmlAttr
+      attr_reader :name, :value
+
+      def initialize(name, value)
+        @name = name
+        @value = value
+      end
+
+      def compile
+        "\"#{name}\": #{value.compile}"
+      end
+    end
+
+    class SilentNewline
+      def compile
+        "\n"
+      end
+    end
+
+    class Declaration
+      attr_reader :content
+
+      def initialize(content)
+        @content = content
+      end
+
+      def compile
+        "\"#{Util.safe_string(content)}\".html_safe"
+      end
+    end
+  end
+end

data/lib/rbexy/output_buffer.rb

@@ -0,0 +1,8 @@
+module Rbexy
+  class OutputBuffer < String
+    def <<(content)
+      value = content.is_a?(Array) ? content.join : content
+      super([nil, false].include?(value) ? "" : value.to_s)
+    end
+  end
+end

data/lib/rbexy/parser.rb

@@ -0,0 +1,204 @@
+module Rbexy
+  class Parser
+    class ParseError < StandardError; end
+
+    attr_reader :tokens
+    attr_accessor :position
+
+    def initialize(tokens)
+      @tokens = tokens
+      @position = 0
+    end
+
+    def parse
+      validate_tokens!
+      Nodes::Template.new(parse_tokens)
+    end
+
+    def parse_tokens
+      results = []
+
+      while result = parse_token
+        results << result
+      end
+
+      results
+    end
+
+    def parse_token
+      parse_text || parse_silent_newline || parse_expression || parse_tag || parse_declaration
+    end
+
+    def parse_text
+      return unless token = take(:TEXT)
+      Nodes::Text.new(token[1])
+    end
+
+    def parse_expression
+      return unless take(:OPEN_EXPRESSION)
+
+      statements = []
+
+      eventually!(:CLOSE_EXPRESSION)
+      until take(:CLOSE_EXPRESSION)
+        statements << (parse_expression_body || parse_tag)
+      end
+
+      Nodes::ExpressionGroup.new(statements)
+    end
+
+    def parse_expression!
+      peek!(:OPEN_EXPRESSION)
+      parse_expression
+    end
+
+    def parse_expression_body
+      return unless token = take(:EXPRESSION_BODY)
+      Nodes::Expression.new(token[1])
+    end
+
+    def parse_tag
+      return unless take(:OPEN_TAG_DEF)
+
+      name = take!(:TAG_NAME)
+      members = []
+      members.concat(take_all(:SILENT_NEWLINE).map { Nodes::SilentNewline.new })
+      members.concat(parse_attrs)
+
+      take!(:CLOSE_TAG_DEF)
+
+      children = parse_children
+
+      Nodes::XmlNode.new(name[1], members, children)
+    end
+
+    def parse_attrs
+      return [] unless take(:OPEN_ATTRS)
+
+      attrs = []
+
+      eventually!(:CLOSE_ATTRS)
+      until take(:CLOSE_ATTRS)
+        attrs << (parse_splat_attr || parse_silent_newline || parse_attr)
+      end
+
+      attrs
+    end
+
+    def parse_splat_attr
+      return unless take(:OPEN_ATTR_SPLAT)
+
+      expression = parse_expression!
+      take!(:CLOSE_ATTR_SPLAT)
+
+      expression
+    end
+
+    def parse_silent_newline
+      return unless take(:SILENT_NEWLINE)
+      Nodes::SilentNewline.new
+    end
+
+    def parse_attr
+      name = take!(:ATTR_NAME)[1]
+      value = nil
+
+      if take(:OPEN_ATTR_VALUE)
+        value = parse_text || parse_expression
+        raise ParseError, "Missing attribute value" unless value
+        take(:CLOSE_ATTR_VALUE)
+      else
+        value = default_empty_attr_value
+      end
+
+      Nodes::XmlAttr.new(name, value)
+    end
+
+    def parse_children
+      children = []
+
+      eventually!(:OPEN_TAG_END)
+      until take(:OPEN_TAG_END)
+        children << parse_token
+      end
+
+      take(:TAG_NAME)
+      take!(:CLOSE_TAG_END)
+
+      children
+    end
+
+    private
+
+    def parse_declaration
+      return unless token = take(:DECLARATION)
+      Nodes::Declaration.new(token[1])
+    end
+
+    def take(token_name)
+      if token = peek(token_name)
+        self.position += 1
+        token
+      end
+    end
+
+    def take_all(token_name)
+      result = []
+      while token = take(token_name)
+        result << token
+      end
+      result
+    end
+
+    def take!(token_name)
+      take(token_name) || unexpected_token!(token_name)
+    end
+
+    def peek(token_name)
+      if (token = tokens[position]) && token[0] == token_name
+        token
+      end
+    end
+
+    def peek!(token_name)
+      peek(token_name) || unexpected_token!(token_name)
+    end
+
+    def eventually!(token_name)
+      tokens[position..-1].first { |t| t[0] == token_name } ||
+        raise(ParseError, "Expected to find a #{token_name} but never did")
+    end
+
+    def default_empty_attr_value
+      Nodes::Text.new("")
+    end
+
+    def error_window
+      window_start = position - 2
+      window_start = 0 if window_start < 0
+      window_end = position + 2
+      window_end = tokens.length-1 if window_end >= tokens.length
+
+      tokens[window_start..window_end].map.with_index do |token, i|
+        prefix = window_start + i == position ? "=>" : "  "
+        "#{prefix} #{token}"
+      end.join("\n")
+    end
+
+    def unexpected_token!(expected_token)
+      raise(ParseError, "Unexpected token #{tokens[position][0]}, expecting #{expected_token}\n#{error_window}")
+    end
+
+    def validate_tokens!
+      validate_all_tags_close!
+    end
+
+    def validate_all_tags_close!
+      open_count = tokens.count { |t| t[0] == :OPEN_TAG_DEF }
+      close_count = tokens.count { |t| t[0] == :OPEN_TAG_END }
+      if open_count != close_count
+        raise(ParseError, "#{open_count - close_count} tags fail to close. All tags must close, either <NAME></NAME> or self-closing <NAME />")
+      end
+    end
+  end
+end

data/lib/rbexy/rails.rb

@@ -0,0 +1,8 @@
+module Rbexy
+  autoload :Component, "rbexy/component"
+
+  module Rails
+    autoload :TemplateHandler, "rbexy/rails/template_handler"
+    autoload :Engine, "rbexy/rails/engine"
+  end
+end

data/lib/rbexy/rails/engine.rb

@@ -0,0 +1,25 @@
+require "rbexy/rails"
+
+module Rbexy
+  module Rails
+    class Engine < ::Rails::Engine
+      initializer "rbexy" do |app|
+        ActionView::Template.register_template_handler(:rbx, Rbexy::Rails::TemplateHandler)
+
+        ActiveSupport.on_load :action_controller do
+          helper Rbexy::ViewContextHelper
+        end
+
+        if defined?(ViewComponent)
+          ViewComponent::Base.include Rbexy::ViewContextHelper
+        end
+
+        Rbexy.configure do |config|
+          require "rbexy/component_providers/rbexy_provider"
+          config.component_provider = Rbexy::ComponentProviders::RbexyProvider.new
+          config.template_paths << ::Rails.root.join("app", "components")
+        end
+      end
+    end
+  end
+end

data/lib/rbexy/rails/template_handler.rb

@@ -0,0 +1,9 @@
+module Rbexy
+  module Rails
+    class TemplateHandler
+      def self.call(template, source)
+        Rbexy.compile(source)
+      end
+    end
+  end
+end

data/lib/rbexy/runtime.rb

@@ -0,0 +1,33 @@
+require "active_support/all"
+require "action_view/helpers"
+require "action_view/context"
+require "action_view/buffers"
+
+module Rbexy
+  class Runtime
+    include ActionView::Context
+    include ActionView::Helpers::TagHelper
+    include ViewContextHelper
+
+    DefaultTagBuilder = ActionView::Helpers::TagHelper::TagBuilder
+
+    def self.create_tag_builder(context, provider = Rbexy.configuration.component_provider)
+      if provider
+        ComponentTagBuilder.new(context, provider)
+      else
+        ActionView::Helpers::TagHelper::TagBuilder.new(context)
+      end
+    end
+
+    def initialize(component_provider = nil)
+      @rbexy_tag = self.class.create_tag_builder(self, component_provider)
+    end
+
+    def evaluate(code)
+      instance_eval(code)
+    rescue => e
+      e.set_backtrace(e.backtrace.map { |l| l.gsub("(eval)", "(rbx template string)") })
+      raise e
+    end
+  end
+end

data/lib/rbexy/version.rb

@@ -0,0 +1,3 @@
+module Rbexy
+  VERSION = "0.1.0"
+end

data/lib/rbexy/view_context_helper.rb

@@ -0,0 +1,11 @@
+module Rbexy
+  module ViewContextHelper
+    def rbexy_tag
+      @rbexy_tag ||= Runtime.create_tag_builder(self)
+    end
+
+    def rbexy_context
+      @rbexy_context ||= [{}]
+    end
+  end
+end