rbexy 1.1.0 → 2.0.0.beta5

data/lib/rbexy/nodes.rb

@@ -1,139 +1,19 @@
 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
-        "#{children.map(&:compile).map { |c| "@output_buffer << rbexy_prep_output(#{c})"}.join(";")};@output_buffer"
-      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} { capture {",
-              children.map(&:compile).map { |c| "@output_buffer << rbexy_prep_output(#{c})" }.join(";"),
-            "} }"
-          ].join
-        else
-          base_tag
-        end + ".html_safe"
-
-        if Rbexy.configuration.enable_context
-          [
-            "(",
-              "rbexy_context.push({});",
-              "#{tag}.tap { rbexy_context.pop }",
-            ")"
-          ].join
-        else
-          tag
-        end
-      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
+    autoload :Util, "rbexy/nodes/util"
+    autoload :AbstractNode, "rbexy/nodes/abstract_node"
+    autoload :Root, "rbexy/nodes/root"
+    autoload :Raw, "rbexy/nodes/raw"
+    autoload :Text, "rbexy/nodes/text"
+    autoload :ExpressionGroup, "rbexy/nodes/expression_group"
+    autoload :Expression, "rbexy/nodes/expression"
+    autoload :AbstractElement, "rbexy/nodes/abstract_element"
+    autoload :HTMLElement, "rbexy/nodes/html_element"
+    autoload :ComponentElement, "rbexy/nodes/component_element"
+    autoload :AbstractAttr, "rbexy/nodes/abstract_attr"
+    autoload :HTMLAttr, "rbexy/nodes/html_attr"
+    autoload :ComponentProp, "rbexy/nodes/component_prop"
+    autoload :Newline, "rbexy/nodes/newline"
+    autoload :Declaration, "rbexy/nodes/declaration"
   end
 end

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}.transform_keys { |k| ActiveSupport::Inflector.underscore(k).to_sym },"
+          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