grsx 0.1.0

data/lib/grsx/lexer.rb

@@ -0,0 +1,325 @@
+module Grsx
+  class Lexer
+    class SyntaxError < StandardError
+      attr_reader :line, :path
+
+      def initialize(lexer)
+        @line = lexer.current_line
+        # Template#identifier is the file path; Anonymous is an empty String.
+        ident = lexer.template.identifier
+        @path = ident.to_s.empty? ? nil : ident.to_s
+
+        location = path ? "#{File.basename(path)}:#{line}" : "line #{line}"
+        snippet  = lexer.scanner.peek(30).chomp.inspect
+
+        super("#{location}: unexpected token near #{snippet}")
+      end
+    end
+
+    PATTERNS = {
+      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: /<![^>]*>/
+    }.freeze
+
+    attr_reader :stack, :tokens, :scanner, :element_resolver, :template
+    attr_accessor :curr_expr, :curr_default_text, :curr_quoted_text
+
+    def initialize(template, element_resolver)
+      @template = template
+      @scanner = StringScanner.new(template.source)
+      @element_resolver = element_resolver
+      @stack = [:default]
+      @curr_expr = ""
+      @curr_default_text = ""
+      @curr_quoted_text = ""
+      @tokens = []
+      @line = 1
+    end
+
+    # Current line number (1-indexed). Derived from the scanner's current
+    # position — counts newlines consumed so far. Called only on errors
+    # so O(n) is acceptable.
+    def current_line
+      scanner.string[0, scanner.pos].count("\n") + 1
+    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 << [: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])
+            # Check if this is </> (fragment close) vs </tagname>
+            if scanner.check(/>\s*/)
+              scanner.scan(/>\s*/)
+              tokens << [:CLOSE_FRAGMENT]
+              stack.pop
+            else
+              tokens << [:OPEN_TAG_END]
+              stack.push(:tag_end)
+            end
+          elsif scanner.scan(PATTERNS[:open_expression])
+            open_expression
+          elsif scanner.scan(PATTERNS[:comment])
+            tokens << [: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 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 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_DETAILS, tag_details(scanner.matched)]
+          elsif scanner.scan(PATTERNS[:whitespace])
+            scanner.matched.count("\n").times { tokens << [: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 << [: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 << [: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
+      # Lookahead: if the scanner is immediately at `>` (with optional leading whitespace)
+      # then this is a JSX fragment opener `<>` — emit OPEN_FRAGMENT and stay in current context.
+      if scanner.check(/\s*>/)
+        scanner.scan(/\s*>/)
+        tokens << [:OPEN_FRAGMENT]
+        stack.push(:tag)  # enter :tag context so children are parsed, fragment close handled above
+      else
+        tokens << [:OPEN_TAG_DEF]
+        stack.push(:tag, :tag_def)
+      end
+    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
+
+    def expression_content?
+      # PATTERNS[:expression_content] ends at `<` characters, because we need to
+      # separately scan for allowed open_tag_defs within expressions. We should
+      # support any found open_tag_ends as expression content, as that means the
+      # open_tag_def was not considered allowed (or stack would be inside
+      # :tag_def instead of :expression) so we should thus also consider the
+      # open_tag_end to just be a part of the expression (maybe its in a string,
+      # etc).
+      scanner.scan(PATTERNS[:expression_content]) || scanner.scan(PATTERNS[:open_tag_end])
+    end
+
+    def tag_details(name)
+      type = element_resolver.component?(name, template) ? :component : :html
+      details = { name: scanner.matched, type: type }
+      details[:component_class] = element_resolver.component_class(name, template) if type == :component
+      details
+    end
+  end
+end

data/lib/grsx/nodes/abstract_attr.rb

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

data/lib/grsx/nodes/abstract_element.rb

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

@@ -0,0 +1,31 @@
+module Grsx
+  module Nodes
+    class AbstractNode
+      # Compact adjacent Raw/Newline nodes into a single Raw node.
+      # Used by the parser when building the AST.
+      private
+
+      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/grsx/nodes/component_element.rb

@@ -0,0 +1,69 @@
+module Grsx
+  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 = Grsx.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 Grsx.configuration.enable_context
+          tag = "(grsx_context.push({});#{tag}.tap{grsx_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/grsx/nodes/component_prop.rb

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

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

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

data/lib/grsx/nodes/expression_group.rb

@@ -0,0 +1,15 @@
+module Grsx
+  module Nodes
+    class ExpressionGroup < AbstractNode
+      attr_accessor :members
+      attr_reader :outer_template, :inner_template
+
+      def initialize(members, outer_template: nil, inner_template: nil)
+        @members = members
+        @outer_template = outer_template
+        @inner_template = inner_template
+      end
+    end
+  end
+end
+

data/lib/grsx/nodes/fragment.rb

@@ -0,0 +1,30 @@
+module Grsx
+  module Nodes
+    # A Fragment node renders its children without a wrapping element.
+    # It corresponds to the JSX <></> syntax.
+    #
+    # In JSX:
+    #   <>
+    #     <h1>Title</h1>
+    #     <p>Body</p>
+    #   </>
+    #
+    # Compiled Phlex DSL: just the children inline, no wrapper.
+    class Fragment < AbstractNode
+      attr_accessor :children
+
+      def initialize(children)
+        @children = children
+      end
+
+      # ActionView codegen: compile children directly, no wrapper tag
+      def precompile
+        children.map(&:precompile).flatten
+      end
+
+      def compile
+        children.map(&:compile).join
+      end
+    end
+  end
+end

data/lib/grsx/nodes/html_attr.rb

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

data/lib/grsx/nodes/html_element.rb

@@ -0,0 +1,49 @@
+module Grsx
+  module Nodes
+    class HTMLElement < AbstractElement
+      # Referenced from https://html.spec.whatwg.org/#void-elements
+      HTML_VOID_ELEMENTS = %w(area base br col embed hr img input link meta source track wbr)
+
+      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?
+        HTML_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: "Grsx::Runtime.splat_attrs(%s)",
+              outer_template: ExpressionGroup::OUTPUT_SAFE
+            )
+          else
+            node
+          end
+        end.map(&:precompile).flatten
+      end
+    end
+  end
+end

data/lib/grsx/nodes/newline.rb

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

data/lib/grsx/nodes/raw.rb

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

@@ -0,0 +1,19 @@
+module Grsx
+  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