Support for more syntax and better multiline ERB formatting (#92)

* Several improvements

- Fix alignment in multiline Ruby, at the cost of making the code less
  concise
- Don't break the line between "<% if" and the condition
- Support <% when 1, 2 %>

The most controversial change is

<%=
  long_command(
    ...
  )
%>

instead of

<%= long_command(
  ...
) %>

* Support <div <%= erb %>>

lib/syntax_tree/erb/format.rb

@@ -7,6 +7,7 @@ class Format < Visitor
 
       def initialize(q)
         @q = q
+        @inside_html_attributes = false
       end
 
       # Visit a Token node.
@@ -28,20 +29,33 @@ def visit_document(node)
         q.breakable(force: true)
       end
 
-      def visit_block(node)
-        visit(node.opening)
+      # Dependent block is one that follows after a "main one", e.g. <% else %>
+      def visit_block(node, dependent: false)
+        process =
+          proc do
+            visit(node.opening)
 
-        breakable = breakable_inside(node)
-        if node.elements.any?
-          q.indent do
-            q.breakable if breakable
-            handle_child_nodes(node.elements)
+            breakable = breakable_inside(node)
+            if node.elements.any?
+              q.indent do
+                q.breakable("") if breakable
+                handle_child_nodes(node.elements)
+              end
+            end
+
+            if node.closing
+              q.breakable("") if breakable
+              visit(node.closing)
+            end
           end
-        end
 
-        if node.closing
-          q.breakable("") if breakable
-          visit(node.closing)
+        if dependent
+          process.call
+        else
+          q.group do
+            q.break_parent unless @inside_html_attributes
+            process.call
+          end
         end
       end
 
@@ -92,39 +106,54 @@ def visit_erb_if(node)
       end
 
       def visit_erb_elsif(node)
-        visit_block(node)
+        visit_block(node, dependent: true)
       end
 
       def visit_erb_else(node)
-        visit_block(node)
+        visit_block(node, dependent: true)
       end
 
       def visit_erb_case(node)
         visit_block(node)
       end
 
       def visit_erb_case_when(node)
-        visit_block(node)
+        visit_block(node, dependent: true)
       end
 
       # Visit an ErbNode node.
       def visit_erb(node)
         visit(node.opening_tag)
 
-        if node.keyword
-          q.text(" ")
-          visit(node.keyword)
+        q.group do
+          if !node.keyword && node.content.blank?
+            q.text(" ")
+          elsif node.keyword && node.content.blank?
+            q.text(" ")
+            visit(node.keyword)
+            q.text(" ")
+          else
+            visit_erb_content(node.content, keyword: node.keyword)
+            q.breakable unless node.closing_tag.is_a?(ErbDoClose)
+          end
         end
 
-        node.content.blank? ? q.text(" ") : visit(node.content)
-
         visit(node.closing_tag)
       end
 
       def visit_erb_do_close(node)
         closing = node.closing.value.end_with?("-%>") ? "-%>" : "%>"
-        q.text(node.closing.value.gsub(closing, "").rstrip)
-        q.text(" ")
+        # Append the "do" at the end of Ruby code (within the same group)
+        last_erb_content_group = q.current_group.contents.last
+        last_erb_content_indent = last_erb_content_group.contents.last
+        q.with_target(last_erb_content_indent.contents) do
+          q.text(" ")
+          q.text(node.closing.value.gsub(closing, "").rstrip)
+        end
+
+        # Add a breakable space after the indent, but within the same group
+        q.with_target(last_erb_content_group.contents) { q.breakable }
+
         q.text(closing)
       end
 
@@ -145,55 +174,26 @@ def visit_erb_end(node)
         visit(node.closing_tag)
       end
 
-      def visit_erb_content(node)
+      def visit_erb_content(node, keyword: nil)
         # Reject all VoidStmt to avoid empty lines
-        nodes =
-          (node.value&.statements&.child_nodes || []).reject do |node|
-            node.is_a?(SyntaxTree::VoidStmt)
-          end
-
-        if nodes.size == 1
-          q.text(" ")
-          format_statement(nodes.first)
-          q.text(" ")
-        elsif nodes.size > 1
-          q.indent do
-            q.breakable("")
-            q.seplist(nodes, -> { q.breakable("") }) do |child_node|
-              format_statement(child_node)
-            end
-          end
+        nodes = child_nodes_without_void_statements(node)
+        return if nodes.empty?
 
+        q.indent do
           q.breakable
-        end
-      end
-
-      def format_statement(statement)
-        formatter =
-          SyntaxTree::Formatter.new("", [], SyntaxTree::ERB::MAX_WIDTH)
-
-        formatter.format(statement)
-        formatter.flush
-
-        formatted =
-          formatter.output.join.gsub(
-            SyntaxTree::ERB::ErbYield::PLACEHOLDER,
-            "yield"
-          )
-
-        output_rows(formatted.split("\n"))
-      end
-
-      def output_rows(rows)
-        if rows.size > 1
-          q.seplist(rows, -> { q.breakable("") }) { |row| q.text(row) }
-        elsif rows.size == 1
-          q.text(rows.first)
+          q.seplist(nodes, -> { q.breakable(force: true) }) do |child_node|
+            code =
+              format_statement_with_keyword_prefix(child_node, keyword: keyword)
+            output_rows(code.split("\n"))
+            # Pass the keyword only to the first child node
+            keyword = nil
+          end
         end
       end
 
       # Visit an HtmlNode::OpeningTag node.
       def visit_opening_tag(node)
+        @inside_html_attributes = true
         q.group do
           visit(node.opening)
           visit(node.name)
@@ -219,6 +219,7 @@ def visit_opening_tag(node)
 
           visit(node.closing)
         end
+        @inside_html_attributes = false
       end
 
       # Visit an HtmlNode::ClosingTag node.
@@ -383,6 +384,108 @@ def node_should_group(node)
         node.is_a?(SyntaxTree::ERB::CharData) ||
           node.is_a?(SyntaxTree::ERB::ErbNode)
       end
+
+      def child_nodes_without_void_statements(node)
+        (node.value&.statements&.child_nodes || []).reject do |node|
+          node.is_a?(SyntaxTree::VoidStmt)
+        end
+      end
+
+      def format_statement_with_keyword_prefix(statement, keyword: nil)
+        case keyword&.value
+        when nil
+          format_statement(statement)
+        when "if"
+          statement =
+            SyntaxTree::IfNode.new(
+              predicate: statement,
+              statements: void_body,
+              consequent: nil,
+              location: keyword.location
+            )
+          format_statement(statement).delete_suffix("\nend")
+        when "unless"
+          statement =
+            SyntaxTree::UnlessNode.new(
+              predicate: statement,
+              statements: void_body,
+              consequent: nil,
+              location: keyword.location
+            )
+          format_statement(statement).delete_suffix("\nend")
+        when "elsif"
+          statement =
+            SyntaxTree::Elsif.new(
+              predicate: statement,
+              statements: void_body,
+              consequent: nil,
+              location: keyword.location
+            )
+          format_statement(statement).delete_suffix("\nend")
+        when "case"
+          statement =
+            SyntaxTree::Case.new(
+              keyword:
+                SyntaxTree::Kw.new(value: "case", location: keyword.location),
+              value: statement,
+              consequent: void_body,
+              location: keyword.location
+            )
+          format_statement(statement).delete_suffix("\nend")
+        when "when"
+          statement =
+            SyntaxTree::When.new(
+              arguments: statement.contents,
+              statements: void_body,
+              consequent: nil,
+              location: keyword.location
+            )
+          format_statement(statement).delete_suffix("\nend")
+        else
+          q.text(keyword.value)
+          q.breakable
+          format_statement(statement)
+        end
+      end
+
+      def format_statement(statement)
+        formatter =
+          SyntaxTree::Formatter.new("", [], SyntaxTree::ERB::MAX_WIDTH)
+
+        formatter.format(statement)
+        formatter.flush
+
+        formatter.output.join.gsub(
+          SyntaxTree::ERB::ErbYield::PLACEHOLDER,
+          "yield"
+        )
+      end
+
+      def output_rows(rows)
+        if rows.size > 1
+          q.seplist(rows, -> { q.breakable(force: true) }) { |row| q.text(row) }
+        elsif rows.size == 1
+          q.text(rows.first)
+        end
+      end
+
+      def fake_location
+        Location.new(
+          start_line: 0,
+          start_char: 0,
+          start_column: 0,
+          end_line: 0,
+          end_char: 0,
+          end_column: 0
+        )
+      end
+
+      def void_body
+        SyntaxTree::Statements.new(
+          body: [SyntaxTree::VoidStmt.new(location: fake_location)],
+          location: fake_location
+        )
+      end
     end
   end
 end

lib/syntax_tree/erb/nodes.rb

@@ -322,10 +322,15 @@ def prepare_content(content)
         if content.is_a?(ErbContent)
           content
         else
-          # Set content to nil if it is empty
           content ||= []
 
-          ErbContent.new(value: content)
+          if !content.empty? && keyword&.value == "when"
+            # "when" accepts multiple comma-separated arguments, so let's try
+            # to make them parsable.
+            ErbContent.new(value: ["[", *content, "]"])
+          else
+            ErbContent.new(value: content)
+          end
         end
       rescue SyntaxTree::Parser::ParseError
         # Try to add the keyword to see if it parses

lib/syntax_tree/erb/parser.rb

@@ -19,6 +19,7 @@ def initialize(source)
         @source = source
         @tokens = make_tokens
         @found_doctype = false
+        @erb_context = :outside
       end
 
       def parse
@@ -300,7 +301,7 @@ def make_tokens
                 # strong, vue-component-kebab, VueComponentPascal
                 # abc, #abc, @abc, :abc
                 enum.yield :name, $&, index, line, column_index
-              when /\A<%/
+              when /\A<%={1,2}/, /\A<%-/, /\A<%/
                 # the beginning of an ERB tag
                 # <%
                 enum.yield :erb_open, $&, index, line, column_index
@@ -419,7 +420,20 @@ def parse_until_erb(classes:)
         items = []
 
         loop do
-          result = parse_any_tag
+          result =
+            case @erb_context
+            when :string
+              atleast do
+                maybe { consume(:text) } || maybe { consume(:whitespace) } ||
+                  maybe { parse_erb_tag }
+              end
+            when :inside
+              atleast do
+                maybe { parse_erb_tag } || maybe { parse_html_attribute }
+              end
+            when :outside
+              parse_any_tag
+            end
           items << result
           break if classes.any? { |cls| result.is_a?(cls) }
         end
@@ -441,13 +455,17 @@ def parse_html_opening_tag
           )
         end
 
+        @erb_context = :inside
+
         attributes =
           many do
             atleast do
               maybe { parse_erb_tag } || maybe { parse_html_attribute }
             end
           end
 
+        @erb_context = :outside
+
         closing =
           atleast do
             maybe { consume(:close) } || maybe { consume(:slash_close) }
@@ -812,6 +830,8 @@ def parse_html_string
           )
         end
 
+        @erb_context = :string
+
         contents =
           many do
             atleast do
@@ -820,6 +840,8 @@ def parse_html_string
             end
           end
 
+        @erb_context = :inside
+
         closing =
           if opening.type == :string_open_double_quote
             consume(:string_close_double_quote)