rbexy 1.1.0 → 2.0.0.beta1

data/lib/rbexy/nodes/abstract_attr.rb

@@ -0,0 +1,12 @@
+module Rbexy
+  module Nodes
+    class AbstractAttr < AbstractNode
+      attr_accessor :name, :value
+
+      def initialize(name, value)
+        @name = name
+        @value = value
+      end
+    end
+  end
+end

data/lib/rbexy/nodes/abstract_element.rb

@@ -0,0 +1,13 @@
+module Rbexy
+  module Nodes
+    class AbstractElement < AbstractNode
+      attr_accessor :name, :members, :children
+
+      def initialize(name, members, children)
+        @name = name
+        @members = members || []
+        @children = children
+      end
+    end
+  end
+end

data/lib/rbexy/nodes/abstract_node.rb

@@ -0,0 +1,58 @@
+module Rbexy
+  module Nodes
+    class AbstractNode
+      PrecompileRequired = Class.new(StandardError)
+
+      attr_reader :compile_context
+
+      def precompile
+        [self]
+      end
+
+      def compile
+        raise PrecompileRequired, "#{self.class.name} must be precompiled first"
+      end
+
+      def inject_compile_context(context)
+        @compile_context = context
+        children.each { |c| c.inject_compile_context(context) } if respond_to?(:children)
+        members.each { |c| c.inject_compile_context(context) } if respond_to?(:members)
+      end
+
+      def transform!
+        return unless ast_transformer
+        ast_transformer.transform(self, compile_context)
+        children.each(&:transform!) if respond_to?(:children)
+        members.each(&:transform!) if respond_to?(:members)
+      end
+
+      private
+
+      def ast_transformer
+        compile_context.ast_transformer
+      end
+
+      def compact(nodes)
+        compacted = []
+        curr_raw = nil
+
+        nodes.each do |node|
+          if node.is_a?(Newline) && curr_raw
+            curr_raw.merge(Raw.new("\n"))
+          elsif node.is_a?(Raw)
+            if !curr_raw
+              curr_raw ||= Raw.new("")
+              compacted << curr_raw
+            end
+            curr_raw.merge(node)
+          else
+            curr_raw = nil
+            compacted << node
+          end
+        end
+
+        compacted
+      end
+    end
+  end
+end

data/lib/rbexy/nodes/component_element.rb

@@ -0,0 +1,69 @@
+module Rbexy
+  module Nodes
+    class ComponentElement < AbstractElement
+      attr_reader :template
+
+      OUTPUT = "@output_buffer.safe_concat(%s);"
+      EXPR_STRING = "%s.html_safe"
+
+      def initialize(*args, template: OUTPUT)
+        super(*args)
+        @template = template
+      end
+
+      def precompile
+        [ComponentElement.new(name, precompile_members, precompile_children)]
+      end
+
+      def compile
+        templates = Rbexy.configuration.component_rendering_templates
+
+        tag = templates[:component] % {
+          component_class: name,
+          view_context: "self",
+          kwargs: compile_members,
+          children_block: children.any? ? templates[:children] % { children: children.map(&:compile).join } : ""
+        }
+
+        if Rbexy.configuration.enable_context
+          tag = "(rbexy_context.push({});#{tag}.tap{rbexy_context.pop})"
+        end
+
+        template % tag
+      end
+
+      def compile_members
+        members.each_with_object("") do |member, result|
+          case member
+          when ExpressionGroup
+            result << "**#{member.compile},"
+          when Newline
+            result << member.compile
+          else
+            result << "#{member.compile},"
+          end
+        end.gsub(/,\z/, "")
+      end
+
+      private
+
+      def precompile_members
+        members.map do |node|
+          if node.is_a? ExpressionGroup
+            ExpressionGroup.new(
+              node.members,
+              inner_template: ExpressionGroup::SUB_EXPR,
+              outer_template: ExpressionGroup::SUB_EXPR
+            )
+          else
+            node
+          end
+        end.map(&:precompile).flatten
+      end
+
+      def precompile_children
+        compact(children.map(&:precompile).flatten)
+      end
+    end
+  end
+end

data/lib/rbexy/nodes/component_prop.rb

@@ -0,0 +1,29 @@
+module Rbexy
+  module Nodes
+    class ComponentProp < AbstractAttr
+      def precompile
+        [ComponentProp.new(name, precompile_value)]
+      end
+
+      def compile
+        key = ActiveSupport::Inflector.underscore(name)
+        "#{key}: #{value.compile}"
+      end
+
+      private
+
+      def precompile_value
+        node = value.precompile.first
+
+        case node
+        when Raw
+          Raw.new(node.content, template: Raw::EXPR_STRING)
+        when ExpressionGroup
+          ExpressionGroup.new(node.members, outer_template: ExpressionGroup::SUB_EXPR, inner_template: node.inner_template)
+        else
+          node
+        end
+      end
+    end
+  end
+end

data/lib/rbexy/nodes/declaration.rb

@@ -0,0 +1,15 @@
+module Rbexy
+  module Nodes
+    class Declaration < AbstractNode
+      attr_accessor :content
+
+      def initialize(content)
+        @content = content
+      end
+
+      def precompile
+        [Raw.new(Util.escape_string(content))]
+      end
+    end
+  end
+end

data/lib/rbexy/nodes/expression.rb

@@ -0,0 +1,15 @@
+module Rbexy
+  module Nodes
+    class Expression < AbstractNode
+      attr_accessor :content
+
+      def initialize(content)
+        @content = content
+      end
+
+      def compile
+        content
+      end
+    end
+  end
+end

data/lib/rbexy/nodes/expression_group.rb

@@ -0,0 +1,55 @@
+module Rbexy
+  module Nodes
+    class ExpressionGroup < AbstractNode
+      using Rbexy::Refinements::Array::MapTypeWhenNeighboringType
+      using Rbexy::Refinements::Array::InsertBetweenTypes
+
+      attr_accessor :members
+      attr_reader :outer_template, :inner_template
+
+      OUTPUT_UNSAFE = "@output_buffer.concat(Rbexy::Runtime.expr_out(%s));"
+      OUTPUT_SAFE = "@output_buffer.safe_concat(Rbexy::Runtime.expr_out(%s));"
+      SUB_EXPR = "%s"
+      SUB_EXPR_OUT = "Rbexy::Runtime.expr_out(%s)"
+
+      def initialize(members, outer_template: OUTPUT_UNSAFE, inner_template: "%s")
+        @members = members
+        @outer_template = outer_template
+        @inner_template = inner_template
+      end
+
+      def precompile
+        [ExpressionGroup.new(precompile_members, outer_template: outer_template, inner_template: inner_template)]
+      end
+
+      def compile
+        outer_template % (inner_template % members.map(&:compile).join)
+      end
+
+      private
+
+      def precompile_members
+        precompiled = compact(members.map(&:precompile).flatten)
+
+        transformed = precompiled.map do |node|
+          case node
+          when Raw
+            Raw.new(node.content, template: Raw::EXPR_STRING)
+          when ComponentElement
+            ComponentElement.new(node.name, node.members, node.children, template: ComponentElement::EXPR_STRING)
+          when ExpressionGroup
+            ExpressionGroup.new(node.members, outer_template: SUB_EXPR, inner_template: node.inner_template)
+          else
+            node
+          end
+        end.map_type_when_neighboring_type(ExpressionGroup, Raw) do |node|
+          ExpressionGroup.new(node.members, outer_template: SUB_EXPR_OUT, inner_template: node.inner_template)
+        end.insert_between_types(ExpressionGroup, Raw) do
+          Expression.new("+")
+        end.insert_between_types(ComponentElement, Raw) do
+          Expression.new("+")
+        end
+      end
+    end
+  end
+end

data/lib/rbexy/nodes/html_attr.rb

@@ -0,0 +1,13 @@
+module Rbexy
+  module Nodes
+    class HTMLAttr < AbstractAttr
+      def precompile
+        [
+          Raw.new(" #{name}=\""),
+          value.precompile,
+          Raw.new("\"")
+        ].flatten
+      end
+    end
+  end
+end

data/lib/rbexy/nodes/html_element.rb

@@ -0,0 +1,48 @@
+module Rbexy
+  module Nodes
+    class HTMLElement < AbstractElement
+      KNOWN_VOID_ELEMENTS = ActionView::Helpers::TagHelper::TagBuilder::VOID_ELEMENTS.map(&:to_s).to_set
+
+      def precompile
+        nodes = []
+
+        if void? && children.length == 0
+          nodes.concat(precompile_open_tag)
+        else
+          nodes.concat(precompile_open_tag)
+          nodes.concat(children.map(&:precompile).flatten)
+          nodes << Raw.new("</#{name}>")
+        end
+
+        nodes
+      end
+
+      private
+
+      def void?
+        KNOWN_VOID_ELEMENTS.include?(name)
+      end
+
+      def precompile_open_tag
+        nodes = [Raw.new("<#{name}")]
+        nodes.concat(precompile_members)
+        nodes << Raw.new(">")
+        nodes
+      end
+
+      def precompile_members
+        members.map do |node|
+          if node.is_a? ExpressionGroup
+            ExpressionGroup.new(
+              node.members,
+              inner_template: "Rbexy::Runtime.splat_attrs(%s)",
+              outer_template: ExpressionGroup::OUTPUT_SAFE
+            )
+          else
+            node
+          end
+        end.map(&:precompile).flatten
+      end
+    end
+  end
+end

data/lib/rbexy/nodes/newline.rb

@@ -0,0 +1,9 @@
+module Rbexy
+  module Nodes
+    class Newline < AbstractNode
+      def compile
+        "\n"
+      end
+    end
+  end
+end

data/lib/rbexy/nodes/raw.rb

@@ -0,0 +1,23 @@
+module Rbexy
+  module Nodes
+    class Raw < AbstractNode
+      attr_reader :content, :template
+
+      OUTPUT = "@output_buffer.safe_concat('%s'.freeze);"
+      EXPR_STRING = "'%s'.html_safe.freeze"
+
+      def initialize(content, template: OUTPUT)
+        @content = content
+        @template = template
+      end
+
+      def compile
+        template % content
+      end
+
+      def merge(other_raw)
+        content << other_raw.content
+      end
+    end
+  end
+end

data/lib/rbexy/nodes/root.rb

@@ -0,0 +1,19 @@
+module Rbexy
+  module Nodes
+    class Root < AbstractNode
+      attr_accessor :children
+
+      def initialize(children)
+        @children = children
+      end
+
+      def precompile
+        Root.new(compact(children.map(&:precompile).flatten))
+      end
+
+      def compile
+        "#{children.map(&:compile).join}@output_buffer.to_s"
+      end
+    end
+  end
+end

data/lib/rbexy/nodes/text.rb

@@ -0,0 +1,15 @@
+module Rbexy
+  module Nodes
+    class Text < AbstractNode
+      attr_accessor :content
+
+      def initialize(content)
+        @content = content
+      end
+
+      def precompile
+        [Raw.new(Util.escape_string(content))]
+      end
+    end
+  end
+end

data/lib/rbexy/nodes/util.rb

@@ -0,0 +1,9 @@
+module Rbexy
+  module Nodes
+    module Util
+      def self.escape_string(str)
+        str.gsub('"', '\\"').gsub("'", "\\'")
+      end
+    end
+  end
+end

data/lib/rbexy/parser.rb

@@ -12,7 +12,7 @@ module Rbexy
 
     def parse
       validate_tokens!
-      Nodes::Template.new(parse_tokens)
+      Nodes::Root.new(parse_tokens)
     end
 
     def parse_tokens
@@ -26,7 +26,7 @@ module Rbexy
     end
 
     def parse_token
-      parse_text || parse_silent_newline || parse_expression || parse_tag || parse_declaration
+      parse_text || parse_newline || parse_expression || parse_tag || parse_declaration
     end
 
     def parse_text
@@ -37,14 +37,14 @@ module Rbexy
     def parse_expression
       return unless take(:OPEN_EXPRESSION)
 
-      statements = []
+      members = []
 
       eventually!(:CLOSE_EXPRESSION)
       until take(:CLOSE_EXPRESSION)
-        statements << (parse_expression_body || parse_tag)
+        members << (parse_expression_body || parse_tag)
       end
 
-      Nodes::ExpressionGroup.new(statements)
+      Nodes::ExpressionGroup.new(members)
     end
 
     def parse_expression!
@@ -60,26 +60,32 @@ module Rbexy
     def parse_tag
       return unless take(:OPEN_TAG_DEF)
 
-      name = take!(:TAG_NAME)
+      details = take!(:TAG_DETAILS)[1]
+      attr_class = details[:type] == :component ? Nodes::ComponentProp : Nodes::HTMLAttr
+
       members = []
-      members.concat(take_all(:SILENT_NEWLINE).map { Nodes::SilentNewline.new })
-      members.concat(parse_attrs)
+      members.concat(take_all(:NEWLINE).map { Nodes::Newline.new })
+      members.concat(parse_attrs(attr_class))
 
       take!(:CLOSE_TAG_DEF)
 
       children = parse_children
 
-      Nodes::XmlNode.new(name[1], members, children)
+      if details[:type] == :component
+        Nodes::ComponentElement.new(details[:component_class], members, children)
+      else
+        Nodes::HTMLElement.new(details[:name], members, children)
+      end
     end
 
-    def parse_attrs
+    def parse_attrs(attr_class)
       return [] unless take(:OPEN_ATTRS)
 
       attrs = []
 
       eventually!(:CLOSE_ATTRS)
       until take(:CLOSE_ATTRS)
-        attrs << (parse_splat_attr || parse_silent_newline || parse_attr)
+        attrs << (parse_splat_attr || parse_newline || parse_attr(attr_class))
       end
 
       attrs
@@ -94,12 +100,12 @@ module Rbexy
       expression
     end
 
-    def parse_silent_newline
-      return unless take(:SILENT_NEWLINE)
-      Nodes::SilentNewline.new
+    def parse_newline
+      return unless take(:NEWLINE)
+      Nodes::Newline.new
     end
 
-    def parse_attr
+    def parse_attr(attr_class)
       name = take!(:ATTR_NAME)[1]
       value = nil
 
@@ -111,7 +117,7 @@ module Rbexy
         value = default_empty_attr_value
       end
 
-      Nodes::XmlAttr.new(name, value)
+      attr_class.new(name, value)
     end
 
     def parse_children