grsx 0.1.0

data/lib/grsx/nodes/text.rb

@@ -0,0 +1,15 @@
+module Grsx
+  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/grsx/nodes/util.rb

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

data/lib/grsx/nodes.rb

@@ -0,0 +1,20 @@
+module Grsx
+  module Nodes
+    autoload :Util, "grsx/nodes/util"
+    autoload :AbstractNode, "grsx/nodes/abstract_node"
+    autoload :Root, "grsx/nodes/root"
+    autoload :Raw, "grsx/nodes/raw"
+    autoload :Text, "grsx/nodes/text"
+    autoload :ExpressionGroup, "grsx/nodes/expression_group"
+    autoload :Expression, "grsx/nodes/expression"
+    autoload :AbstractElement, "grsx/nodes/abstract_element"
+    autoload :HTMLElement, "grsx/nodes/html_element"
+    autoload :ComponentElement, "grsx/nodes/component_element"
+    autoload :AbstractAttr, "grsx/nodes/abstract_attr"
+    autoload :HTMLAttr, "grsx/nodes/html_attr"
+    autoload :ComponentProp, "grsx/nodes/component_prop"
+    autoload :Newline, "grsx/nodes/newline"
+    autoload :Declaration, "grsx/nodes/declaration"
+    autoload :Fragment, "grsx/nodes/fragment"
+  end
+end

data/lib/grsx/parser.rb

@@ -0,0 +1,238 @@
+module Grsx
+  class Parser
+    class ParseError < StandardError
+      attr_reader :position
+
+      def initialize(message = nil, position: nil)
+        @position = position
+        msg = message || "Unexpected token"
+        msg = "#{msg} at token #{position}" if position
+        super(msg)
+      end
+    end
+
+    attr_reader :tokens
+    attr_accessor :position
+
+    def initialize(tokens)
+      @tokens = tokens
+      @position = 0
+    end
+
+    def parse
+      validate_tokens!
+      Nodes::Root.new(parse_tokens)
+    end
+
+    def parse_tokens
+      results = []
+
+      while result = parse_token
+        results << result
+      end
+
+      results
+    end
+
+    def parse_token
+      parse_text || parse_newline || parse_expression || parse_fragment || 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)
+
+      members = []
+
+      eventually!(:CLOSE_EXPRESSION)
+      until take(:CLOSE_EXPRESSION)
+        members << (parse_expression_body || parse_tag)
+      end
+
+      Nodes::ExpressionGroup.new(members)
+    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_fragment
+      return unless take(:OPEN_FRAGMENT)
+
+      children = []
+      until take(:CLOSE_FRAGMENT)
+        children << parse_token
+      end
+
+      Nodes::Fragment.new(children)
+    end
+
+    def parse_tag
+      return unless take(:OPEN_TAG_DEF)
+
+      details = take!(:TAG_DETAILS)[1]
+      attr_class = details[:type] == :component ? Nodes::ComponentProp : Nodes::HTMLAttr
+
+      members = []
+      members.concat(take_all(:NEWLINE).map { Nodes::Newline.new })
+      members.concat(parse_attrs(attr_class))
+
+      take!(:CLOSE_TAG_DEF)
+
+      children = parse_children(details[:name])
+
+      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(attr_class)
+      return [] unless take(:OPEN_ATTRS)
+
+      attrs = []
+
+      eventually!(:CLOSE_ATTRS)
+      until take(:CLOSE_ATTRS)
+        attrs << (parse_splat_attr || parse_newline || parse_attr(attr_class))
+      end
+
+      attrs
+    end
+
+    def parse_splat_attr
+      return unless take(:OPEN_ATTR_SPLAT)
+
+      expression = parse_expression!
+      take!(:CLOSE_ATTR_SPLAT)
+
+      expression
+    end
+
+    def parse_newline
+      return unless take(:NEWLINE)
+      Nodes::Newline.new
+    end
+
+    def parse_attr(attr_class)
+      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
+
+      attr_class.new(name, value)
+    end
+
+    def parse_children(expected_name)
+      children = []
+
+      eventually!(:OPEN_TAG_END)
+      until take(:OPEN_TAG_END)
+        children << parse_token
+      end
+
+      if tag_name_token = take(:TAG_NAME)
+        closing_name = tag_name_token[1]
+        if closing_name != expected_name
+          raise ParseError, "Mismatched tag: expected </#{expected_name}> but got </#{closing_name}>"
+        end
+      end
+
+      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 } +
+                    tokens.count { |t| t[0] == :OPEN_FRAGMENT }
+      close_count = tokens.count { |t| t[0] == :OPEN_TAG_END } +
+                    tokens.count { |t| t[0] == :CLOSE_FRAGMENT }
+      if open_count != close_count
+        raise(ParseError, "#{open_count - close_count} tags fail to close. All tags must close, either <NAME></NAME>, self-closing <NAME />, or <>...</>")
+      end
+    end
+  end
+end

data/lib/grsx/phlex_compiler.rb

@@ -0,0 +1,223 @@
+module Grsx
+  # Converts a Grsx AST into a Ruby string of Phlex DSL method calls.
+  #
+  # The emitted code is suitable for evaluation inside a Grsx::PhlexComponent
+  # (or Grsx::PhlexRuntime for standalone use).  All output goes through
+  # Phlex's structural buffer — no ActionView @output_buffer.
+  #
+  # Key mappings from JSX → Phlex DSL:
+  #
+  #   <div class="foo">text</div>   → div(class: "foo") { plain("text") }
+  #   <br />                        → br
+  #   <Button label={x} />         → render(ButtonComponent.new(label: x))
+  #   <Card>{content}</Card>       → render(Card.new) { yield_content }
+  #   {"Hello"}                    → plain("Hello")  (CGI.escapeHTML called)
+  #   {render MyComp.new}          → render(MyComp.new)  (structural, shared buffer)
+  #   {content}                    → yield_content  (slot pattern in components)
+  #
+  class PhlexCompiler
+    HTML_VOID_ELEMENTS = %w(area base br col embed hr img input link meta source track wbr).to_set
+
+    attr_reader :root
+
+    def initialize(root)
+      @root = root
+    end
+
+    def compile
+      compile_nodes(root.children)
+    end
+
+    private
+
+    def compile_nodes(nodes)
+      nodes.map { |n| compile_node(n) }.join("\n")
+    end
+
+    def compile_node(node)
+      case node
+      when Nodes::HTMLElement      then compile_html(node)
+      when Nodes::ComponentElement then compile_component(node)
+      when Nodes::Fragment         then compile_fragment(node)
+      when Nodes::ExpressionGroup  then compile_expression_group(node)
+      when Nodes::Text             then compile_text(node)
+      when Nodes::Newline          then ""
+      when Nodes::Declaration      then compile_declaration(node)
+      else
+        raise "PhlexCompiler: unknown AST node #{node.class}"
+      end
+    end
+
+    # <></> → children rendered inline, no wrapper element.
+    # The JSX fragment pattern eliminates the need for meaningless <div> wrappers.
+    def compile_fragment(node)
+      compile_nodes(node.children)
+    end
+
+    # <div class="foo"> ... </div>
+    # → div(class: "foo") do ... end
+    def compile_html(node)
+      tag_name = node.name
+      attrs = compile_html_attrs(node.members)
+
+      if HTML_VOID_ELEMENTS.include?(tag_name)
+        # void: <br /> → br
+        attrs.empty? ? tag_name : "#{tag_name}(#{attrs})"
+      elsif node.children.empty?
+        # no children: <span class="x" /> → span(class: "x") {}
+        attrs.empty? ? "#{tag_name} {}" : "#{tag_name}(#{attrs}) {}"
+      else
+        inner = compile_nodes(node.children)
+        if attrs.empty?
+          "#{tag_name} do\n#{inner}\nend"
+        else
+          "#{tag_name}(#{attrs}) do\n#{inner}\nend"
+        end
+      end
+    end
+
+    # Build keyword argument string from HTMLAttr and ExpressionGroup (splat) members
+    def compile_html_attrs(members)
+      parts = []
+      members.each do |m|
+        case m
+        when Nodes::HTMLAttr
+          key = normalize_html_attr_key(m.name)
+          val = compile_attr_value(m.value)
+          parts << "#{key}: #{val}"
+        when Nodes::ExpressionGroup
+          # {**spread_hash} → spread into tag kwargs
+          parts << "**#{compile_expression_group_value(m)}"
+        when Nodes::Newline
+          # ignore
+        end
+      end
+      parts.join(", ")
+    end
+
+    def compile_attr_value(node)
+      case node
+      when Nodes::Text
+        # A boolean (bare) attribute like `disabled` or `required` has an empty
+        # text value in the AST. Phlex emits the attribute name alone for `true`
+        # and omits it completely for `false`. Empty string would produce `attr=""`
+        # which is technically valid HTML but semantically wrong for boolean attrs.
+        node.content.empty? ? "true" : node.content.inspect
+      when Nodes::ExpressionGroup  then compile_expression_group_value(node)
+      else node.class.name
+      end
+    end
+
+    # <Button label={@title} disabled />  — key prop is silently dropped
+    # → render ButtonComponent.new(label: @title, disabled: "")
+    def compile_component(node)
+      kwargs_parts = []
+      node.members.each do |m|
+        case m
+        when Nodes::ComponentProp
+          # Strip the React `key` prop — it has no server-side meaning and
+          # would otherwise cause an ArgumentError on the Ruby component.
+          next if m.name == "key"
+
+          key = normalize_component_prop_key(m.name)
+          val = compile_attr_value(m.value)
+          kwargs_parts << "#{key}: #{val}"
+        when Nodes::ExpressionGroup
+          kwargs_parts << "**#{compile_expression_group_value(m)}"
+        when Nodes::Newline then next
+        end
+      end
+
+      kwargs = kwargs_parts.join(", ")
+      component_expr = kwargs.empty? ? "::#{node.name}.new" : "::#{node.name}.new(#{kwargs})"
+
+      if node.children.any?
+        inner = compile_nodes(node.children)
+        "render(#{component_expr}) {\n#{inner}\n}"
+      else
+        "render(#{component_expr})"
+      end
+    end
+
+    # { ruby_expr } in text position:
+    #
+    #   {content}        → yield_content  (children slot)
+    #   {"Hello"}        → __rbx_expr_out("Hello")  → plain() with auto-escape
+    #   {render Foo.new} → __rbx_expr_out(render Foo.new)
+    def compile_expression_group(node)
+      # Special case: bare `content` identifier → forward children via Phlex yield
+      if content_call?(node)
+        return "yield"
+      end
+
+      expr = compile_expression_group_value(node)
+      "__rbx_expr_out(#{expr})"
+    end
+
+    # Returns true when the expression group is a bare `content` identifier.
+    # This is the JSX children-slot pattern: {content}
+    def content_call?(node)
+      node.members.length == 1 &&
+        node.members.first.is_a?(Nodes::Expression) &&
+        node.members.first.content.strip == "content"
+    end
+
+    # Returns the raw ruby expression string (no output call wrap)
+    def compile_expression_group_value(node)
+      node.members.map { |m| compile_expression_value(m) }.join
+    end
+
+    def compile_expression_value(node)
+      case node
+      when Nodes::Expression         then node.content
+      when Nodes::HTMLElement        then compile_html(node)
+      when Nodes::ComponentElement   then compile_component(node)
+      when Nodes::ExpressionGroup    then "(#{compile_expression_group_value(node)})"
+      else node.class.name
+      end
+    end
+
+    # Static text: "Hello" → plain("Hello")
+    def compile_text(node)
+      "plain(#{node.content.inspect})"
+    end
+
+    # <!DOCTYPE html> → raw(safe("<!DOCTYPE html>"))
+    def compile_declaration(node)
+      "raw(safe(#{node.content.inspect}))"
+    end
+
+    # Normalize HTML attribute names to Ruby keyword argument keys.
+    #
+    # One rule: kebab-case → snake_case (the only transformation needed
+    # to make HTML attribute names legal Ruby keyword arguments).
+    #
+    #   class            → class       (Phlex accepts `class:` just fine)
+    #   data-controller  → data_controller  (Phlex re-emits as data-controller)
+    #   aria-label       → aria_label      (Phlex re-emits as aria-label)
+    #   for              → for         (no htmlFor nonsense)
+    #   id, src, href    → unchanged
+    #
+    # We do NOT do camelCase → snake_case. That's a React-ism: React uses
+    # camelCase because JSX is JavaScript where `class` / `for` are reserved.
+    # In rbx we're in Ruby; write HTML attributes as HTML writes them.
+    def normalize_html_attr_key(name)
+      name.tr("-", "_")
+    end
+
+    # Normalize component prop names to Ruby keyword argument keys.
+    #
+    # Component props map directly to Ruby kwargs, so we accept both
+    # HTML-style kebab-case and Ruby snake_case:
+    #   card-title  → card_title  (kebab, HTML-like)
+    #   card_title  → card_title  (snake, Ruby-like, unchanged)
+    #
+    # camelCase props are also normalized via ActiveSupport::Inflector
+    # since component props are Ruby identifiers, not HTML attributes:
+    #   cardTitle   → card_title  (reasonable to accept in component context)
+    def normalize_component_prop_key(name)
+      # Kebab-to-underscore first, then underscore for camelCase
+      ActiveSupport::Inflector.underscore(name.tr("-", "_"))
+    end
+  end
+end