w_syntax_tree-erb 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 459993e3b6d5a09ea5a902d6038acac34eeaddb7fa878cbd41a40039712c2d9a
-  data.tar.gz: 48843275b9b5ab46a23d61677c9e7b8cd93e7e4f5095376d128d9f525408cae9
+  metadata.gz: b83deb85beac0716fe402b7c52cb54b9b097343cb22d7c533690fe98ecbc2d82
+  data.tar.gz: 5b0d14ae4c9da04a0f478d4b1676cd8405fc3a608cbf1602d7ef98d28badb7e6
 SHA512:
-  metadata.gz: 373abd1743f157914a3394f127a9e6b7d5c15fce3179894f74de072a220e5a6458fb2d09a25f4b7a2b5764c0f81f870045cba6c6f6756931be8fdbbb23e260eb
-  data.tar.gz: 38d635a29da6044441e6304fd488e8281b6a1ffa0718cea508541c242a9fc9d53d618956185ed1cf8cbf16efa357368ee99c5fb8d6d99a00e212e23eb92ac8a5
+  metadata.gz: 6fcd8ed3ced75d085b893878d540e99936ad7d9a4a6747949e8f5c2cb51068a78a5f66a02ab477d8a2467c62c5455b121491a3f078aec913c3addabd983c52f1
+  data.tar.gz: 37449987cd5f235d02709bfc65ac07b65234df303df850b36378d00a347efb1f87915aa48ca7e6562a90c74ea10bca3578c78ef7832f2df9319783b4f7df6c8c

data/.tool-versions

@@ -0,0 +1 @@
+ruby 3.3.1

data/CHANGELOG.md

@@ -6,6 +6,12 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/) a
 
 ## [Unreleased]
 
+## [0.12.0] - 2024-05-07
+
+- Support Ruby 3.3 by handling yield in ERB specifically
+- Use SyntaxTree own class for ParseError to get better error feedback
+- Adds handling for keeping track of column index, to support better error messages
+
 ## [0.11.0] - 2024-04-23
 
 - ErbContent now has its value as child_nodes instead of empty array.
@@ -114,7 +120,9 @@ Output:
 - Can format a lot of .html.erb-syntax and works as a plugin to syntax_tree.
 - This is still early and there are a lot of different weird syntaxes out there.
 
-[unreleased]: https://github.com/davidwessman/syntax_tree-erb/compare/v0.10.5...HEAD
+[unreleased]: https://github.com/davidwessman/syntax_tree-erb/compare/v0.12.0...HEAD
+[0.12.0]: https://github.com/davidwessman/syntax_tree-erb/compare/v0.11.0...v0.12.0
+[0.11.0]: https://github.com/davidwessman/syntax_tree-erb/compare/v0.10.5...v0.11.0
 [0.10.5]: https://github.com/davidwessman/syntax_tree-erb/compare/v0.10.4...v0.10.5
 [0.10.4]: https://github.com/davidwessman/syntax_tree-erb/compare/v0.10.3...v0.10.4
 [0.10.3]: https://github.com/davidwessman/syntax_tree-erb/compare/v0.10.2...v0.10.3

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    w_syntax_tree-erb (0.11.0)
+    w_syntax_tree-erb (0.12.0)
       prettier_print (~> 1.2, >= 1.2.0)
       syntax_tree (~> 6.1, >= 6.1.1)
 
@@ -9,9 +9,9 @@ GEM
   remote: https://rubygems.org/
   specs:
     docile (1.4.0)
-    minitest (5.20.0)
+    minitest (5.22.3)
     prettier_print (1.2.1)
-    rake (13.1.0)
+    rake (13.2.1)
     simplecov (0.22.0)
       docile (~> 1.1)
       simplecov-html (~> 0.11)

data/README.md

@@ -30,18 +30,26 @@ Currently handles
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "w_syntax_tree-erb", "~> 0.10", require: false
+gem "w_syntax_tree-erb", "~> 0.11", require: false
 ```
 
 > I added the `w_` prefix to avoid conflicts if there will ever be an official `syntax_tree-erb` gem.
 
 ## Usage
 
+### Parsing
+
+```sh
+bundle exec stree ast --plugins=erb "./**/*.html.erb"
+```
+
+### Format
+
 ```sh
-bundle exec stree --plugins=erb "./**/*.html.erb"
+bundle exec stree write --plugins=erb "./**/*.html.erb"
 ```
 
-From code:
+### In code
 
 ```ruby
 require "syntax_tree/erb"

data/lib/syntax_tree/erb/format.rb

@@ -20,7 +20,8 @@ module SyntaxTree
 
       # Visit a Document node.
       def visit_document(node)
-        child_nodes = node.child_nodes.sort_by(&:location)
+        child_nodes =
+          node.child_nodes.sort_by { |node| node.location.start_char }
 
         handle_child_nodes(child_nodes)
 
@@ -131,6 +132,10 @@ module SyntaxTree
         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 +174,14 @@ module SyntaxTree
 
         formatter.format(statement)
         formatter.flush
-        rows = formatter.output.join.split("\n")
 
-        output_rows(rows)
+        formatted =
+          formatter.output.join.gsub(
+            SyntaxTree::ERB::ErbYield::PLACEHOLDER,
+            "yield"
+          )
+
+        output_rows(formatted.split("\n"))
       end
 
       def output_rows(rows)

data/lib/syntax_tree/erb/nodes.rb

@@ -2,48 +2,6 @@
 
 module SyntaxTree
   module ERB
-    # A Location represents a position for a node in the source file.
-    class Location
-      attr_reader :start_char, :end_char, :start_line, :end_line
-
-      def initialize(start_char:, end_char:, start_line:, end_line:)
-        @start_char = start_char
-        @end_char = end_char
-        @start_line = start_line
-        @end_line = end_line
-      end
-
-      def deconstruct_keys(keys)
-        {
-          start_char: start_char,
-          end_char: end_char,
-          start_line: start_line,
-          end_line: end_line
-        }
-      end
-
-      def to(other)
-        Location.new(
-          start_char: start_char,
-          start_line: start_line,
-          end_char: other.end_char,
-          end_line: other.end_line
-        )
-      end
-
-      def <=>(other)
-        start_char <=> other.start_char
-      end
-
-      def to_s
-        if start_line == end_line
-          "line #{start_line}, char #{start_char}..#{end_char}"
-        else
-          "line #{start_line},char #{start_char} to line #{end_line}, char #{end_char}"
-        end
-      end
-    end
-
     # A parent node that contains a bit of shared functionality.
     class Node
       def format(q)
@@ -322,6 +280,7 @@ module SyntaxTree
             )
           end
 
+        @content = content
         @content = prepare_content(content)
         @closing_tag = closing_tag
       end
@@ -370,9 +329,28 @@ module SyntaxTree
         end
       rescue SyntaxTree::Parser::ParseError
         # Try to add the keyword to see if it parses
-        result = ErbContent.new(value: [keyword, *content])
-        @keyword = nil
-        result
+        begin
+          result = ErbContent.new(value: [keyword, *content])
+          @keyword = nil
+
+          result
+        rescue SyntaxTree::Parser::ParseError => error
+          opening_location = opening_tag.location
+          content_location = content.first&.location || opening_location
+          raise(
+            SyntaxTree::Parser::ParseError.new(
+              "Could not parse ERB-tag: #{error.message}",
+              @opening_tag.location.start_line + error.lineno - 1,
+              (
+                if opening_location.start_line == error.lineno
+                  opening_location.start_column + error.column - 1
+                else
+                  content_location.start_column + error.column - 1
+                end
+              )
+            )
+          )
+        end
       end
     end
 
@@ -489,7 +467,17 @@ module SyntaxTree
       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)
+                  ErbYield::PLACEHOLDER
+                else
+                  token
+                end
+              end
+              .join
         end
         @value = SyntaxTree.parse(value.strip)
       end
@@ -518,6 +506,21 @@ module SyntaxTree
       end
     end
 
+    class ErbYield < Element
+      PLACEHOLDER = "qqqqy"
+      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

data/lib/syntax_tree/erb/parser.rb

@@ -5,14 +5,12 @@ module SyntaxTree
     class Parser
       # This is the parent class of any kind of errors that will be raised by
       # the parser.
-      class ParseError < StandardError
-      end
 
       # This error occurs when a certain token is expected in a certain place
       # but is not found. Sometimes this is handled internally because some
       # elements are optional. Other times it is not and it is raised to end the
       # parsing process.
-      class MissingTokenError < ParseError
+      class MissingTokenError < SyntaxTree::Parser::ParseError
       end
 
       attr_reader :source, :tokens
@@ -52,7 +50,13 @@ module SyntaxTree
 
           if tag.is_a?(Doctype)
             if @found_doctype
-              raise(ParseError, "Only one doctype element is allowed")
+              raise(
+                SyntaxTree::Parser::ParseError.new(
+                  "Duplicate doctype declaration",
+                  tag.location.start_line,
+                  tag.location.start_column
+                )
+              )
             else
               @found_doctype = true
             end
@@ -69,6 +73,7 @@ module SyntaxTree
       def make_tokens
         Enumerator.new do |enum|
           index = 0
+          column_index = 0
           line = 1
           state = %i[outside]
 
@@ -78,83 +83,88 @@ module SyntaxTree
               case source[index..]
               when /\A\n{2,}/
                 # two or more newlines should be ONE blank line
-                enum.yield :blank_line, $&, index, line
+                enum.yield(:blank_line, $&, index, line, column_index)
                 line += $&.count("\n")
               when /\A\n/
                 # newlines
-                enum.yield :new_line, $&, index, line
+                enum.yield(:new_line, $&, index, line, column_index)
                 line += 1
               when /\A<!--(.|\r?\n)*?-->/m
                 # comments
                 # <!-- this is a comment -->
-                enum.yield :html_comment, $&, index, line
+                enum.yield(:html_comment, $&, index, line, column_index)
                 line += $&.count("\n")
               when /\A<!DOCTYPE/, /\A<!doctype/
                 # document type tags
                 # <!DOCTYPE
-                enum.yield :doctype, $&, index, line
+                enum.yield(:doctype, $&, index, line, column_index)
                 state << :inside
               when /\A<%#[\s\S]*?%>/
                 # An ERB-comment
                 # <%# this is an ERB comment %>
-                enum.yield :erb_comment, $&, index, line
+                enum.yield(:erb_comment, $&, index, line, column_index)
               when /\A<%={1,2}/, /\A<%-/, /\A<%/
                 # the beginning of an ERB tag
                 # <%
                 # <%=, <%==
-                enum.yield :erb_open, $&, index, line
+                enum.yield(:erb_open, $&, index, line, column_index)
                 state << :erb_start
                 line += $&.count("\n")
               when %r{\A</}
                 # the beginning of a closing tag
                 # </
-                enum.yield :slash_open, $&, index, line
+                enum.yield(:slash_open, $&, index, line, column_index)
                 state << :inside
               when /\A</
                 # the beginning of an opening tag
                 # <
-                enum.yield :open, $&, index, line
+                enum.yield(:open, $&, index, line, column_index)
                 state << :inside
               when /\A(?: |\t|\r)+/m
                 # whitespace
-                enum.yield :whitespace, $&, index, line
+                enum.yield(:whitespace, $&, index, line, column_index)
               when /\A(?!\s+$)[^<\n]+/
                 # plain text content, but do not allow only white space
                 # abc
-                enum.yield :text, $&, index, line
+                enum.yield(:text, $&, index, line, column_index)
               else
-                raise ParseError,
-                      "Unexpected character at #{index}: #{source[index]}"
+                raise(
+                  SyntaxTree::Parser::ParseError.new(
+                    "Unexpected character: #{source[index]}",
+                    line,
+                    column_index
+                  )
+                )
               end
             in :erb_start
               case source[index..]
               when /\A\s*if/
                 # if statement
-                enum.yield :erb_if, $&, index, line
+                enum.yield(:erb_if, $&, index, line, column_index)
                 state.pop
                 state << :erb
               when /\A\s*unless/
-                enum.yield :erb_unless, $&, index, line
+                enum.yield(:erb_unless, $&, index, line, column_index)
                 state.pop
                 state << :erb
               when /\A\s*elsif/
-                enum.yield :erb_elsif, $&, index, line
+                enum.yield(:erb_elsif, $&, index, line, column_index)
                 state.pop
                 state << :erb
               when /\A\s*else/
-                enum.yield :erb_else, $&, index, line
+                enum.yield(:erb_else, $&, index, line, column_index)
                 state.pop
                 state << :erb
               when /\A\s*case/
-                enum.yield :erb_case, $&, index, line
+                enum.yield(:erb_case, $&, index, line, column_index)
                 state.pop
                 state << :erb
               when /\A\s*when/
-                enum.yield :erb_when, $&, index, line
+                enum.yield(:erb_when, $&, index, line, column_index)
                 state.pop
                 state << :erb
               when /\A\s*end/
-                enum.yield :erb_end, $&, index, line
+                enum.yield(:erb_end, $&, index, line, column_index)
                 state.pop
                 state << :erb
               else
@@ -168,68 +178,90 @@ module SyntaxTree
               case source[index..]
               when /\A[\n]+/
                 # newlines
-                enum.yield :erb_code, $&, index, line
+                enum.yield(:erb_code, $&, index, line, column_index)
                 line += $&.count("\n")
               when /\Ado\b(\s*\|[\w\s,]+\|)?\s*-?%>/
-                enum.yield :erb_do_close, $&, index, line
+                enum.yield(:erb_do_close, $&, index, line, column_index)
                 state.pop
               when /\A-?%>/
-                enum.yield :erb_close, $&, index, line
+                enum.yield(:erb_close, $&, index, line, column_index)
                 state.pop
+              when /\Ayield\b/
+                enum.yield(:erb_yield, $&, index, line, column_index)
               when /\A[\p{L}\w]*\b/
                 # Split by word boundary while parsing the code
                 # This allows us to separate what_to_do vs do
-                enum.yield :erb_code, $&, index, line
+                enum.yield(:erb_code, $&, index, line, column_index)
               else
-                enum.yield :erb_code, source[index], index, line
+                enum.yield(:erb_code, source[index], index, line, column_index)
                 index += 1
+                column_index += 1
                 next
               end
             in :string_single_quote
               case source[index..]
               when /\A(?: |\t|\n|\r\n)+/m
-                # whitespace
-                enum.yield :whitespace, $&, index, line
+                enum.yield(:whitespace, $&, index, line, column_index)
                 line += $&.count("\n")
               when /\A\'/
                 # the end of a quoted string
-                enum.yield :string_close_single_quote, $&, index, line
+                enum.yield(
+                  :string_close_single_quote,
+                  $&,
+                  index,
+                  line,
+                  column_index
+                )
                 state.pop
               when /\A<%[=]?/
                 # the beginning of an ERB tag
                 # <%
-                enum.yield :erb_open, $&, index, line
+                enum.yield(:erb_open, $&, index, line, column_index)
                 state << :erb_start
               when /\A[^<']+/
                 # plain text content
                 # abc
-                enum.yield :text, $&, index, line
+                enum.yield(:text, $&, index, line, column_index)
               else
-                raise ParseError,
-                      "Unexpected character in string at #{index}: #{source[index]}"
+                raise(
+                  SyntaxTree::Parser::ParseError.new(
+                    "Unexpected character, #{source[index]}, when looking for closing single quote",
+                    line,
+                    column_index
+                  )
+                )
               end
             in :string_double_quote
               case source[index..]
               when /\A(?: |\t|\n|\r\n)+/m
-                # whitespace
-                enum.yield :whitespace, $&, index, line
+                enum.yield(:whitespace, $&, index, line, column_index)
                 line += $&.count("\n")
               when /\A\"/
-                # the end of a quoted string
-                enum.yield :string_close_double_quote, $&, index, line
+                enum.yield(
+                  :string_close_double_quote,
+                  $&,
+                  index,
+                  line,
+                  column_index
+                )
                 state.pop
               when /\A<%[=]?/
                 # the beginning of an ERB tag
                 # <%
-                enum.yield :erb_open, $&, index, line
+                enum.yield(:erb_open, $&, index, line, column_index)
                 state << :erb_start
               when /\A[^<"]+/
                 # plain text content
                 # abc
-                enum.yield :text, $&, index, line
+                enum.yield(:text, $&, index, line, column_index)
               else
-                raise ParseError,
-                      "Unexpected character in string at #{index}: #{source[index]}"
+                raise(
+                  SyntaxTree::Parser::ParseError.new(
+                    "Unexpected character, #{source[index]}, when looking for closing double quote",
+                    line,
+                    column_index
+                  )
+                )
               end
             in :inside
               case source[index..]
@@ -239,58 +271,76 @@ module SyntaxTree
               when /\A-?%>/
                 # the end of an ERB tag
                 # -%> or %>
-                enum.yield :erb_close, $&, index, line
+                enum.yield(:erb_close, $&, index, line, column_index)
                 state.pop
               when /\A>/
                 # the end of a tag
                 # >
-                enum.yield :close, $&, index, line
+                enum.yield(:close, $&, index, line, column_index)
                 state.pop
               when /\A\?>/
                 # the end of a tag
                 # ?>
-                enum.yield :special_close, $&, index, line
+                enum.yield(:special_close, $&, index, line, column_index)
                 state.pop
               when %r{\A/>}
                 # the end of a self-closing tag
-                enum.yield :slash_close, $&, index, line
+                enum.yield(:slash_close, $&, index, line, column_index)
                 state.pop
               when %r{\A/}
                 # a forward slash
                 # /
-                enum.yield :slash, $&, index, line
+                enum.yield :slash, $&, index, line, column_index
               when /\A=/
                 # an equals sign
                 # =
-                enum.yield :equals, $&, index, line
+                enum.yield :equals, $&, index, line, column_index
               when /\A[@#]*[:\w\.\-\_]+\b/
                 # a name for an element or an attribute
                 # strong, vue-component-kebab, VueComponentPascal
                 # abc, #abc, @abc, :abc
-                enum.yield :name, $&, index, line
+                enum.yield :name, $&, index, line, column_index
               when /\A<%/
                 # the beginning of an ERB tag
                 # <%
-                enum.yield :erb_open, $&, index, line
+                enum.yield :erb_open, $&, index, line, column_index
                 state << :erb_start
               when /\A"/
                 # the beginning of a string
-                enum.yield :string_open_double_quote, $&, index, line
+                enum.yield(
+                  :string_open_double_quote,
+                  $&,
+                  index,
+                  line,
+                  column_index
+                )
                 state << :string_double_quote
               when /\A'/
                 # the beginning of a string
-                enum.yield :string_open_single_quote, $&, index, line
+                enum.yield(
+                  :string_open_single_quote,
+                  $&,
+                  index,
+                  line,
+                  column_index
+                )
                 state << :string_single_quote
               else
-                raise ParseError,
-                      "Unexpected character at #{index}: #{source[index]}"
+                raise(
+                  SyntaxTree::Parser::ParseError.new(
+                    "Unexpected character, #{source[index]}, when parsing HTML- or ERB-tag",
+                    line,
+                    column_index
+                  )
+                )
               end
             end
 
             index += $&.length
+            column_index = $&.rindex("\n") || column_index + $&.length
           end
 
-          enum.yield :EOF, nil, index, line
+          enum.yield(:EOF, nil, index, line, column_index)
         end
       end
 
@@ -299,14 +349,22 @@ module SyntaxTree
       # return the new Token. Otherwise we're going to raise a
       # MissingTokenError.
       def consume(expected)
-        type, value, index, line = tokens.peek
+        type, value, index, line, column = tokens.peek
 
         if expected != type
-          raise MissingTokenError, "expected #{expected} got #{type}"
+          raise(
+            MissingTokenError.new(
+              "expected #{expected} got #{type}",
+              line,
+              index
+            )
+          )
         end
 
         tokens.next
 
+        rindex = value.rindex("\n")
+
         Token.new(
           type: type,
           value: value,
@@ -315,7 +373,9 @@ module SyntaxTree
               start_char: index,
               end_char: index + value.length,
               start_line: line,
-              end_line: line + value.count("\n")
+              end_line: line + value.count("\n"),
+              start_column: column,
+              end_column: rindex ? value.length - rindex : column + value.length
             )
         )
       end
@@ -333,7 +393,9 @@ module SyntaxTree
       # Otherwise we'll return the value returned by the block.
       def atleast
         result = yield
-        raise MissingTokenError if result.nil?
+        if result.nil?
+          raise(MissingTokenError.new("No matching token", nil, nil))
+        end
         result
       end
 
@@ -370,7 +432,13 @@ module SyntaxTree
         name = consume(:name)
 
         if name.value =~ /\A[@:#]/
-          raise ParseError, "Invalid html-tag name #{name}"
+          raise(
+            SyntaxTree::Parser::ParseError.new(
+              "Invalid HTML-tag name #{name.value}",
+              name.location.start_line,
+              name.location.start_column
+            )
+          )
         end
 
         attributes =
@@ -429,15 +497,21 @@ module SyntaxTree
 
           if closing.nil?
             raise(
-              ParseError,
-              "Missing closing tag for <#{opening.name.value}> at #{opening.location}"
+              SyntaxTree::Parser::ParseError.new(
+                "Missing closing tag for <#{opening.name.value}>",
+                opening.location.start_line,
+                opening.location.start_column
+              )
             )
           end
 
           if closing.name.value != opening.name.value
             raise(
-              ParseError,
-              "Expected closing tag for <#{opening.name.value}> but got <#{closing.name.value}> at #{closing.location}"
+              SyntaxTree::Parser::ParseError.new(
+                "Expected closing tag for <#{opening.name.value}> but got <#{closing.name.value}>",
+                closing.location.start_line,
+                closing.location.start_column
+              )
             )
           end
 
@@ -459,9 +533,13 @@ module SyntaxTree
 
         unless erb_tag.is_a?(ErbCaseWhen) || erb_tag.is_a?(ErbElse) ||
                  erb_tag.is_a?(ErbEnd)
+          location = erb_tag&.location || erb_node.location
           raise(
-            ParseError,
-            "Found no matching erb-tag to the if-tag at #{erb_node.location}"
+            SyntaxTree::Parser::ParseError.new(
+              "No matching ERB-tag for the <% #{erb_node.keyword.value} %>",
+              location.start_line,
+              location.start_column
+            )
           )
         end
 
@@ -482,8 +560,11 @@ module SyntaxTree
           )
         else
           raise(
-            ParseError,
-            "Found no matching when- or else-tag to the case-tag at #{erb_node.location}"
+            SyntaxTree::Parser::ParseError.new(
+              "No matching when- or else-tag for the case-tag",
+              erb_node.location.start_line,
+              erb_node.location.start_column
+            )
           )
         end
       end
@@ -499,8 +580,11 @@ module SyntaxTree
 
         unless erb_tag.is_a?(ErbControl) || erb_tag.is_a?(ErbEnd)
           raise(
-            ParseError,
-            "Found no matching erb-tag to the if-tag at #{erb_node.location}"
+            SyntaxTree::Parser::ParseError.new(
+              "No matching ERB-tag for the <% if %>",
+              erb_node.location.start_line,
+              erb_node.location.start_column
+            )
           )
         end
 
@@ -528,8 +612,11 @@ module SyntaxTree
           )
         else
           raise(
-            ParseError,
-            "Found no matching elsif- or else-tag to the if-tag at #{erb_node.location}"
+            SyntaxTree::Parser::ParseError.new(
+              "No matching <% elsif %> or <% else %> for the <% if %>",
+              erb_node.location.start_line,
+              erb_node.location.start_column
+            )
           )
         end
       end
@@ -541,8 +628,11 @@ module SyntaxTree
 
         unless erb_end.is_a?(ErbEnd)
           raise(
-            ParseError,
-            "Found no matching end-tag for the else-tag at #{erb_node.location}"
+            SyntaxTree::Parser::ParseError.new(
+              "No matching <% end %> for the <% else %>",
+              erb_node.location.start_line,
+              erb_node.location.start_column
+            )
           )
         end
 
@@ -580,8 +670,11 @@ module SyntaxTree
 
         if !closing_tag.is_a?(ErbClose)
           raise(
-            ParseError,
-            "Found no matching closing tag for the erb-tag at #{opening_tag.location}"
+            SyntaxTree::Parser::ParseError.new(
+              "No matching closing tag for the <% #{keyword.value} %>",
+              closing_tag.location.start_line,
+              closing_tag.location.start_column
+            )
           )
         end
 
@@ -613,8 +706,11 @@ module SyntaxTree
 
             unless erb_end.is_a?(ErbEnd)
               raise(
-                ParseError,
-                "Found no matching end-tag for the do-tag at #{erb_node.location}"
+                SyntaxTree::Parser::ParseError.new(
+                  "No matching <% end %> for the <% do %>",
+                  erb_node.location.start_line,
+                  erb_node.location.start_column
+                )
               )
             end
 
@@ -628,17 +724,6 @@ module SyntaxTree
             erb_node
           end
         end
-      rescue MissingTokenError => error
-        # If we have parsed tokens that we cannot process after we parsed <%, we should throw a ParseError
-        # and not let it be handled by a `maybe`.
-        if opening_tag
-          raise(
-            ParseError,
-            "Could not parse ERB-tag at #{opening_tag.location}"
-          )
-        else
-          raise(error)
-        end
       end
 
       def parse_until_erb_close
@@ -648,7 +733,7 @@ module SyntaxTree
           result =
             atleast do
               maybe { parse_erb_do_close } || maybe { parse_erb_close } ||
-                maybe { consume(:erb_code) }
+                maybe { parse_erb_yield } || maybe { consume(:erb_code) }
             end
 
           items << result
@@ -701,6 +786,14 @@ module SyntaxTree
         )
       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) } ||

data/lib/syntax_tree/erb/pretty_print.rb

@@ -143,6 +143,10 @@ module SyntaxTree
         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)

data/lib/syntax_tree/erb/version.rb

@@ -2,6 +2,6 @@
 
 module SyntaxTree
   module ERB
-    VERSION = "0.11.0"
+    VERSION = "0.12.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: w_syntax_tree-erb
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Kevin Newton
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-04-23 00:00:00.000000000 Z
+date: 2024-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prettier_print
@@ -121,6 +121,7 @@ files:
 - ".github/workflows/main.yml"
 - ".gitignore"
 - ".husky/pre-commit"
+- ".tool-versions"
 - ".vscode/launch.json"
 - CHANGELOG.md
 - Gemfile
@@ -158,7 +159,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.5.9
 signing_key:
 specification_version: 4
 summary: Syntax Tree support for ERB