Support ruby 3.3 by handling yield

.tool-versions

@@ -1 +1 @@
-ruby 3.2.3
+ruby 3.3.0

lib/syntax_tree/erb/format.rb

@@ -131,6 +131,10 @@ def visit_erb_close(node)
         visit(node.closing)
       end
 
+      def visit_erb_yield(node)
+        q.text("yield")
+      end
+
       # Visit an ErbEnd node.
       def visit_erb_end(node)
         visit(node.opening_tag)
@@ -169,9 +173,10 @@ def format_statement(statement)
 
         formatter.format(statement)
         formatter.flush
-        rows = formatter.output.join.split("\n")
 
-        output_rows(rows)
+        formatted = formatter.output.join.gsub(/qqqqy/, "yield") # escape yields
+
+        output_rows(formatted.split("\n"))
       end
 
       def output_rows(rows)

lib/syntax_tree/erb/nodes.rb

@@ -369,9 +369,10 @@ def prepare_content(content)
           ErbContent.new(value: content)
         end
       rescue SyntaxTree::Parser::ParseError
-        # Try to add the keyword to see if it parses
-        result = ErbContent.new(value: [keyword, *content])
-        @keyword = nil
+          # Try to add the keyword to see if it parses
+          result = ErbContent.new(value: [keyword, *content])
+          @keyword = nil
+
         result
       end
     end
@@ -489,7 +490,15 @@ class ErbContent < Node
       def initialize(value:)
         if value.is_a?(Array)
           value =
-            value.map { |token| token.is_a?(Token) ? token.value : token }.join
+            value.map do |token|
+              if token.is_a?(Token)
+                token.value
+              elsif token.is_a?(ErbYield)
+                "qqqqy" # replace with random 5 letter string instead of yield since it throws error
+              else
+                token
+              end
+            end.join
         end
         @value = SyntaxTree.parse(value.strip)
       end
@@ -518,6 +527,20 @@ def deconstruct_keys(keys)
       end
     end
 
+    class ErbYield < Element
+      def initialize(new_line:, location:)
+        super(new_line: new_line, location: location)
+      end
+
+      def accept(visitor)
+        visitor.visit_erb_yield(self)
+      end
+
+      def child_nodes
+        []
+      end
+    end
+
     # An HtmlAttribute is a key-value pair within a tag. It contains the key, the
     # equals sign, and the value.
     class HtmlAttribute < Node

lib/syntax_tree/erb/parser.rb

@@ -176,6 +176,8 @@ def make_tokens
               when /\A-?%>/
                 enum.yield :erb_close, $&, index, line
                 state.pop
+              when /\Ayield\b/
+                enum.yield :erb_yield, $&, index, line
               when /\A[\p{L}\w]*\b/
                 # Split by word boundary while parsing the code
                 # This allows us to separate what_to_do vs do
@@ -648,6 +650,7 @@ def parse_until_erb_close
           result =
             atleast do
               maybe { parse_erb_do_close } || maybe { parse_erb_close } ||
+                maybe { parse_erb_yield } ||
                 maybe { consume(:erb_code) }
             end
 
@@ -701,6 +704,17 @@ def parse_erb_do_close
         )
       end
 
+      def parse_erb_yield
+        token = consume(:erb_yield)
+
+        new_line = maybe { parse_new_line }
+
+        ErbYield.new(
+          location: token.location,
+          new_line: new_line,
+        )
+      end
+
       def parse_html_string
         opening =
           maybe { consume(:string_open_double_quote) } ||

lib/syntax_tree/erb/pretty_print.rb

@@ -143,6 +143,10 @@ def visit_erb_do_close(node)
         visit_node("erb_do_close", node)
       end
 
+      def visit_erb_yield(node)
+        visit_node("erb_yield", node)
+      end
+
       # Visit a Doctype node.
       def visit_doctype(node)
         visit_node("doctype", node)