w_syntax_tree-erb 0.10.5 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d75bcbb66fc50b3559fa73a7ecb906aaa208a16bf041ae95793aed008bdd60f6
-  data.tar.gz: d2f882155d6e2ab774de0367586926c853a367c55123f7bc05edebebbba9fe6d
+  metadata.gz: b83deb85beac0716fe402b7c52cb54b9b097343cb22d7c533690fe98ecbc2d82
+  data.tar.gz: 5b0d14ae4c9da04a0f478d4b1676cd8405fc3a608cbf1602d7ef98d28badb7e6
 SHA512:
-  metadata.gz: d7e9cc9b0c675244216ffd52db0751ee59b6ba79af00cb2b56ff955e351aa51c5a5d25d2737084283fa00707d51f4fb38fb7b6bbddf0c6bcc9f2831afd1fe9e1
-  data.tar.gz: 2cd81b89e3ebdd1b1010f7c7509c9ef9a81eacf30d2285c34c36d3a97b7e86cb8d7d4f460ea3a7ba2ad1dd333b2e2e6a709056d328ff373b8692218701892d57
+  metadata.gz: 6fcd8ed3ced75d085b893878d540e99936ad7d9a4a6747949e8f5c2cb51068a78a5f66a02ab477d8a2467c62c5455b121491a3f078aec913c3addabd983c52f1
+  data.tar.gz: 37449987cd5f235d02709bfc65ac07b65234df303df850b36378d00a347efb1f87915aa48ca7e6562a90c74ea10bca3578c78ef7832f2df9319783b4f7df6c8c

data/.github/workflows/main.yml

@@ -16,6 +16,7 @@ jobs:
           - "3.0"
           - "3.1"
           - "3.2"
+          - "3.3"
     name: CI
     runs-on: ubuntu-latest
     env:

data/.tool-versions

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

data/CHANGELOG.md

@@ -6,6 +6,17 @@ 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.
+- Allow html void tags and format self-closing tags
+
 ## [0.10.5] - 2023-09-03
 
 - Handle ERB-tags inside HTML-tags, like `<div <%= "class='foo'" %>>`
@@ -109,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.10.5)
+    w_syntax_tree-erb (0.12.0)
       prettier_print (~> 1.2, >= 1.2.0)
       syntax_tree (~> 6.1, >= 6.1.1)
 
@@ -9,20 +9,21 @@ GEM
   remote: https://rubygems.org/
   specs:
     docile (1.4.0)
-    minitest (5.19.0)
+    minitest (5.22.3)
     prettier_print (1.2.1)
-    rake (13.0.6)
+    rake (13.2.1)
     simplecov (0.22.0)
       docile (~> 1.1)
       simplecov-html (~> 0.11)
       simplecov_json_formatter (~> 0.1)
     simplecov-html (0.12.3)
     simplecov_json_formatter (0.1.4)
-    syntax_tree (6.1.1)
+    syntax_tree (6.2.0)
       prettier_print (>= 1.2.0)
 
 PLATFORMS
   arm64-darwin-21
+  arm64-darwin-23
   x86_64-darwin-21
   x86_64-darwin-22
   x86_64-linux

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"
@@ -79,6 +87,12 @@ puts failures
 
 ## Development
 
+Install `husky`:
+
+```sh
+npm i -g husky
+```
+
 Setup linting:
 
 ```sh

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)
@@ -203,6 +213,10 @@ module SyntaxTree
             q.text(" ")
           end
 
+          # If element is a valid void element, but not currently self-closing
+          # format to be self-closing
+          q.text(" /") if node.is_void_element? and node.closing.value == ">"
+
           visit(node.closing)
         end
       end

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)
@@ -185,6 +143,25 @@ module SyntaxTree
     # potentially contain an opening tag that self-closes, in which case the
     # content and closing tag will be nil.
     class HtmlNode < Block
+      # These elements do not require a closing tag
+      # https://developer.mozilla.org/en-US/docs/Glossary/Void_element
+      HTML_VOID_ELEMENTS = %w[
+        area
+        base
+        br
+        col
+        embed
+        hr
+        img
+        input
+        link
+        meta
+        param
+        source
+        track
+        wbr
+      ]
+
       # The opening tag of an element. It contains the opening character (<),
       # the name of the element, any optional attributes, and the closing
       # token (either > or />).
@@ -214,6 +191,10 @@ module SyntaxTree
           [opening, name, *attributes, closing]
         end
 
+        def is_void_element?
+          HTML_VOID_ELEMENTS.include?(name.value)
+        end
+
         alias deconstruct child_nodes
 
         def deconstruct_keys(keys)
@@ -253,6 +234,10 @@ module SyntaxTree
         end
       end
 
+      def is_void_element?
+        false
+      end
+
       def without_new_line
         self.class.new(
           **deconstruct_keys([]).merge(
@@ -295,6 +280,7 @@ module SyntaxTree
             )
           end
 
+        @content = content
         @content = prepare_content(content)
         @closing_tag = closing_tag
       end
@@ -343,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
 
@@ -462,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
@@ -481,7 +496,7 @@ module SyntaxTree
       end
 
       def child_nodes
-        []
+        [@value].compact
       end
 
       alias deconstruct child_nodes
@@ -491,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 =
@@ -419,21 +487,31 @@ module SyntaxTree
       def parse_html_element
         opening = parse_html_opening_tag
 
-        if opening.closing.value == ">"
+        if opening.closing.value == "/>"
+          HtmlNode.new(opening: opening, location: opening.location)
+        elsif opening.is_void_element?
+          HtmlNode.new(opening: opening, location: opening.location)
+        else
           elements = many { parse_any_tag }
           closing = maybe { parse_html_closing }
 
           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
 
@@ -443,8 +521,6 @@ module SyntaxTree
             closing: closing,
             location: opening.location.to(closing.location)
           )
-        else
-          HtmlNode.new(opening: opening, location: opening.location)
         end
       end
 
@@ -457,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
 
@@ -480,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
@@ -497,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
 
@@ -526,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
@@ -539,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
 
@@ -578,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
 
@@ -611,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
 
@@ -626,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
@@ -646,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
@@ -699,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.10.5"
+    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.10.5
+  version: 0.12.0
 platform: ruby
 authors:
 - Kevin Newton
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-09-03 00:00:00.000000000 Z
+date: 2024-05-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: prettier_print
@@ -118,10 +118,10 @@ files:
 - ".github/ISSUE_TEMPLATE/formatting-report.md"
 - ".github/ISSUE_TEMPLATE/general.md"
 - ".github/dependabot.yml"
-- ".github/workflows/auto-merge.yml"
 - ".github/workflows/main.yml"
 - ".gitignore"
 - ".husky/pre-commit"
+- ".tool-versions"
 - ".vscode/launch.json"
 - CHANGELOG.md
 - Gemfile
@@ -159,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

data/.github/workflows/auto-merge.yml

@@ -1,22 +0,0 @@
-name: Dependabot auto-merge
-on: pull_request
-
-permissions:
-  contents: write
-  pull-requests: write
-
-jobs:
-  dependabot:
-    runs-on: ubuntu-latest
-    if: ${{ github.actor == 'dependabot[bot]' }}
-    steps:
-      - name: Dependabot metadata
-        id: metadata
-        uses: dependabot/fetch-metadata@v1.3.3
-        with:
-          github-token: "${{ secrets.GITHUB_TOKEN }}"
-      - name: Enable auto-merge for Dependabot PRs
-        run: gh pr merge --auto --merge "$PR_URL"
-        env:
-          PR_URL: ${{github.event.pull_request.html_url}}
-          GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}