super-slim 3.0.0

data/lib/super_slim/cli.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative "../super_slim"
+require_relative "linter"
+require_relative "parallel"
+
+module SuperSlim
+  class CLI
+    USAGE = <<~TEXT
+      Usage: super-slim lint [PATH…]               report what breaks the rules of .super-slim.yml
+             super-slim format [--check] [PATH…]   rewrite templates in their canonical layout (alias: fmt)
+             super-slim version
+    TEXT
+    SKIPPED_DIRECTORIES = %r{(\A|/)(\.git|node_modules|tmp|vendor)/}
+    EX_USAGE = 64
+    HELP_OPTIONS = %w[--help -h].freeze
+    OPTIONS_BY_COMMAND = {"format" => ["--check"], "fmt" => ["--check"]}.freeze
+
+    def call(arguments)
+      return puts(USAGE) || 0 if arguments.first == "help" || arguments.intersect?(HELP_OPTIONS)
+
+      command, *arguments = arguments
+      unknown_option = (arguments.grep(/\A-/) - OPTIONS_BY_COMMAND.fetch(command, [])).first
+      return warn("Unknown option #{unknown_option}", USAGE) || EX_USAGE if unknown_option
+
+      configuration = Linter.configuration
+      SuperSlim.tailwind_classes = configuration["tailwind_classes"] if configuration.key?("tailwind_classes")
+      case command
+      when "lint" then lint(arguments, configuration)
+      when "format", "fmt" then format(arguments, configuration["format"] || configuration.fetch("fmt", {}))
+      when "version", "--version" then puts(VERSION) || 0
+      else warn(USAGE) || EX_USAGE
+      end
+    end
+
+    private
+
+    def lint(paths, configuration)
+      linter = Linter.new(configuration.fetch("linters", {}))
+      offenses = Parallel.map(templates(paths)) { |path| linter.call(path, File.read(path)) }.flatten
+      offenses.each { |offense| puts "#{offense.path}:#{offense.lineno}: [#{offense.rule}] #{offense.message}" }
+      offenses.empty? ? 0 : 1
+    end
+
+    def format(arguments, options)
+      check = arguments.delete("--check")
+      formatter = Formatter.new(max_line_length: options["max_line_length"], attribute_delimiters: options.fetch("attribute_delimiters", "()"))
+      outcomes = Parallel.map(templates(arguments)) do |path|
+        source = File.read(path)
+        formatted = formatter.call(source)
+        next if formatted == source
+
+        File.write(path, formatted) unless check
+        [:reformatted, path]
+      rescue Error => exception
+        [:refused, "#{path}: #{exception.message.lines.first.strip}"]
+      end
+      outcomes.compact.each { |outcome, text| (outcome == :reformatted) ? puts(text) : warn(text) }
+      (outcomes.any? { |outcome,| outcome == :refused || (outcome == :reformatted && check) }) ? 1 : 0
+    end
+
+    def templates(paths)
+      paths = ["."] if paths.empty?
+      paths.flat_map do |path|
+        next [path] unless File.directory?(path)
+
+        Dir.glob("**/*.slim", base: path).filter_map { |template| File.join(path, template) unless template.match?(SKIPPED_DIRECTORIES) }
+      end.sort
+    end
+  end
+end

data/lib/super_slim/compiler.rb

@@ -0,0 +1,467 @@
+# frozen_string_literal: true
+
+module SuperSlim
+  class Compiler
+    include AST
+
+    VOID_ELEMENTS = %w[area base br col embed hr img input keygen link menuitem meta param source track wbr].to_h { [_1, true] }.freeze
+    HYPHENATED_ATTRIBUTES = %w[data aria].freeze
+    DOCTYPES = {
+      html: {
+        "5" => "<!DOCTYPE html>",
+        "html" => "<!DOCTYPE html>",
+        "strict" => '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">',
+        "frameset" => '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">',
+        "transitional" => '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">'
+      },
+      xml: {
+        "1.1" => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">',
+        "5" => "<!DOCTYPE html>",
+        "html" => "<!DOCTYPE html>",
+        "strict" => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">',
+        "frameset" => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">',
+        "mobile" => '<!DOCTYPE html PUBLIC "-//WAPFORUM//DTD XHTML Mobile 1.2//EN" "http://www.openmobilealliance.org/tech/DTD/xhtml-mobile12.dtd">',
+        "basic" => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML Basic 1.1//EN" "http://www.w3.org/TR/xhtml-basic/xhtml-basic11.dtd">',
+        "transitional" => '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">',
+        "svg" => '<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN" "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd">'
+      }
+    }.freeze
+
+    BLOCK_SELF_OPENING = /(\A(if|unless|else|elsif|when|in|begin|rescue|ensure|case)\b)|\bdo\s*(\|[^|]*\|\s*)?\z/
+    BLOCK_OPENING = /\A(if|begin|unless|else|elsif|when|in|rescue|ensure)\b|\bdo\s*(\|[^|]*\|)?\s*$/
+    BLOCK_CONTINUATION = /\A(else|elsif|when|in|rescue|ensure)\b/
+    EXPLICIT_END = /\Aend\b/
+    CAPTURED_OUTPUT = /\A(if|unless)\b|\bdo\s*(\|[^|]*\|)?\s*$/
+
+    ESCAPED_INTERPOLATION = /\A\\#\{/
+    INTERPOLATION = /\A#\{((?>[^{}]|(\{(?>[^{}]|\g<1>)*\}))*)\}/
+    UNESCAPED_INTERPOLATION_CODE = /\A\{.*\}\Z/
+    INTERPOLATION_FREE_TEXT = /\A([#\\]?[^#\\]*([#\\][^\\#\{][^#\\]*)*)/ # rubocop:disable Style/RedundantRegexpEscape -- `#{` would open an interpolation
+
+    def initialize(format: :html, rails: false, html_safe: String.method_defined?(:html_safe?), preamble: nil, postamble: nil)
+      raise ArgumentError, "Invalid format #{format.inspect}" unless DOCTYPES.key?(format)
+
+      @xml = format == :xml
+      @doctypes = DOCTYPES.fetch(format)
+      @rails = rails
+      @html_safe = html_safe
+      @escape_function = html_safe ? "::SuperSlim::Runtime.escape_html_safe" : "::ERB::Escape.html_escape"
+      @preamble = preamble
+      @postamble = postamble
+    end
+
+    def call(nodes)
+      @code = +""
+      @static = +""
+      @variable_count = 0
+      @buffer = @rails ? OutputBuffer.new : StringBuffer.new("_buf", @escape_function)
+
+      emit_code(@buffer.open)
+      emit_static(@preamble) if @preamble
+      compile_children(nodes)
+      emit_static(@postamble) if @postamble
+      emit_code(@buffer.close)
+      @code
+    end
+
+    private
+
+    def compile_children(nodes)
+      block_open = false
+      nodes.each do |node|
+        if node.is_a?(Control)
+          raise Error, "Explicit end statements are forbidden" if node.code.match?(EXPLICIT_END)
+
+          emit_code("end") if block_open && !node.code.match?(BLOCK_CONTINUATION)
+          block_open = with_do(node.code, node.children).match?(BLOCK_OPENING)
+        elsif block_open && node != NEWLINE
+          emit_code("end")
+          block_open = false
+        end
+        compile_node(node)
+      end
+      emit_code("end") if block_open
+    end
+
+    def compile_node(node)
+      case node
+      when NEWLINE
+        @code << "\n" unless @newline_emitted
+        @newline_emitted = false
+      when Static then emit_static(node.text)
+      when Text then emit_interpolated(node.text)
+      when TextBlock then compile_children(node.children)
+      when Tag then compile_tag(node)
+      when Control then compile_control(node)
+      when Output then compile_output(node)
+      when InlineHtml
+        emit_interpolated(node.text)
+        compile_children(node.children)
+      when Comment
+        emit_static("<!--")
+        compile_children(node.children)
+        emit_static("-->")
+      when Doctype then emit_static(doctype(node.type))
+      when Embedded then compile_embedded(node)
+      end
+    end
+
+    def compile_control(control)
+      emit_code(with_do(control.code, control.children))
+      compile_children(control.children)
+    end
+
+    def compile_output(output)
+      code = with_do(output.code, output.children)
+      unless code.match?(CAPTURED_OUTPUT)
+        emit_output(code, output.escape)
+        return compile_children(output.children)
+      end
+
+      result = new_variable
+      emit_code("#{result} = #{code}")
+      if @rails
+        compile_children(output.children)
+      else
+        capture_into(new_variable) { compile_children(output.children) }
+      end
+      emit_code("end")
+      emit_output(result, output.escape)
+    end
+
+    def with_do(code, children)
+      (code.match?(BLOCK_SELF_OPENING) || AST.empty?(children)) ? code : "#{code} do"
+    end
+
+    def compile_tag(tag)
+      return compile_dynamic_tag(tag) if tag.name == "*"
+
+      closed = tag.content.nil? || (AST.renders_nothing?(tag.content) && (@xml || VOID_ELEMENTS.key?(tag.name)))
+      @static << "<" << tag.name
+      compile_attributes(tag.attributes)
+      emit_static((closed && @xml) ? " />" : ">")
+      return if closed && tag.content.nil?
+
+      compile_children(tag.content)
+      @static << "</" << tag.name << ">" unless closed
+    end
+
+    def compile_dynamic_tag(tag)
+      attributes = compile_runtime_attributes(tag.attributes)
+      if tag.content.nil?
+        emit_output("#{attributes}.build_tag", false)
+      elsif AST.empty?(tag.content)
+        emit_output(%(#{attributes}.build_tag("")), false)
+        compile_children(tag.content)
+      else
+        content = new_variable
+        capture_into(content) { compile_children(tag.content) }
+        emit_output("#{attributes}.build_tag(#{content})", false)
+      end
+    end
+
+    def compile_attributes(attributes)
+      return if attributes.empty?
+      return emit_output(compile_runtime_attributes(attributes), false) if attributes.any? { runtime_attribute?(_1) }
+
+      if attributes.size > 1
+        seen_names = {}
+        attributes.each do |attribute|
+          next if attribute.name == "class"
+          raise Error, "Multiple #{attribute.name} attributes specified" if seen_names.key?(attribute.name)
+
+          seen_names[attribute.name] = true
+        end
+      end
+
+      # Every class value renders at the place of the first class attribute.
+      class_attributes = nil
+      attributes.each do |attribute|
+        next compile_attribute(attribute) unless attribute.name == "class"
+        next if class_attributes
+
+        class_attributes = attributes.select { _1.name == "class" }
+        compile_class_attribute(class_attributes.map { attribute_parts(_1) })
+      end
+    end
+
+    def runtime_attribute?(attribute)
+      attribute.is_a?(Splat) || (attribute.is_a?(CodeAttribute) && HYPHENATED_ATTRIBUTES.include?(attribute.name))
+    end
+
+    def compile_attribute(attribute)
+      case attribute
+      when BooleanAttribute then emit_boolean_attribute(attribute.name)
+      when CodeAttribute then compile_code_attribute(attribute)
+      else emit_attribute(attribute.name, attribute_parts(attribute))
+      end
+    end
+
+    def compile_code_attribute(attribute)
+      case attribute.code
+      when "true" then emit_boolean_attribute(attribute.name)
+      when "false", "nil" then nil
+      else
+        value = new_variable
+        # A case on literals compiles to a jump table: no `==` call for the strings and numbers most values are.
+        emit_code("case (#{value} = #{attribute.code})")
+        emit_code("when true")
+        emit_boolean_attribute(attribute.name)
+        emit_code("when false, nil")
+        emit_code("else")
+        emit_attribute(attribute.name, [[:dynamic, value, attribute.escape]])
+        emit_code("end")
+      end
+    end
+
+    # Slim joins the non-empty values with spaces and drops an empty result. When the first value carries literal
+    # text, as shortcuts always come first, the attribute is certain to render: each later value only needs its
+    # separator, so nothing is joined at render time.
+    def compile_class_attribute(values)
+      values = values.reject { |parts| parts.all? { |kind, value| kind == :static && value.empty? } }
+      if values.empty?
+        nil
+      elsif literal_text?(values.first)
+        emit_static(' class="')
+        values.each_with_index { |parts, index| emit_class_value(parts, separator: index > 0) }
+        emit_static('"')
+      else
+        classes = new_variable
+        expressions = values.map { string_expression(_1) }
+        emit_code((values.size == 1) ? "#{classes} = #{expressions.first}" : "#{classes} = ::SuperSlim::Runtime.join_classes(#{expressions.join(", ")})")
+        emit_code("unless #{classes}.empty?")
+        emit_attribute("class", [[:raw, classes]])
+        emit_code("end")
+      end
+    end
+
+    def emit_class_value(parts, separator:)
+      if literal_text?(parts)
+        emit_static(" ") if separator
+        emit_parts(parts)
+      else
+        value = new_variable
+        emit_code("#{value} = #{string_expression(parts)}")
+        emit_code("unless #{value}.empty?")
+        emit_static(" ") if separator
+        emit_output(value, false)
+        emit_code("end")
+      end
+    end
+
+    def literal_text?(parts)
+      parts.any? { |kind, value| kind == :static && !value.empty? }
+    end
+
+    def compile_runtime_attributes(attributes)
+      builder = new_variable
+      emit_code("#{builder} = ::SuperSlim::Runtime::Attributes.new(#{@html_safe})")
+      attributes.each do |attribute|
+        case attribute
+        when Splat
+          emit_code("#{builder}.splat_attrs((#{attribute.code}))")
+        when CodeAttribute
+          emit_code("#{builder}.code_attr(#{attribute.name.inspect}, #{attribute.escape}, (#{attribute.code}))")
+        else
+          emit_code("#{builder}.attr(#{attribute.name.inspect}, #{string_expression(attribute_parts(attribute))})")
+        end
+      end
+      builder
+    end
+
+    def attribute_parts(attribute)
+      case attribute
+      when StaticAttribute then [[:static, attribute.value]]
+      when BooleanAttribute then []
+      when CodeAttribute
+        value = new_variable
+        emit_code("#{value} = #{attribute.code}")
+        [[:raw, "::SuperSlim::Runtime.class_value(#{value}, #{attribute.escape}, #{@html_safe})"]]
+      when QuotedAttribute
+        interpolation_parts(attribute.text).map do |kind, value, escape|
+          (kind == :static && attribute.escape) ? [:static, ERB::Escape.html_escape(value)] : [kind, value, escape]
+        end
+      end
+    end
+
+    def emit_attribute(name, parts)
+      emit_static(%( #{name}="))
+      emit_parts(parts)
+      emit_static('"')
+    end
+
+    def emit_boolean_attribute(name)
+      emit_static(@xml ? %( #{name}="") : " #{name}")
+    end
+
+    def emit_parts(parts)
+      parts.each do |kind, value, escape|
+        case kind
+        when :static then emit_static(value)
+        when :dynamic then emit_output(value, escape)
+        when :raw then emit_output(value, false)
+        end
+      end
+    end
+
+    def string_expression(parts)
+      if parts.size == 1
+        kind, value, escape = parts.first
+        return "#{@escape_function}((#{value}))" if kind == :dynamic && escape
+        return value if kind == :raw
+      end
+
+      literal = parts.map do |kind, value, escape|
+        case kind
+        when :static then value.inspect[1..-2]
+        when :dynamic then escape ? "\#{#{@escape_function}((#{value}))}" : "\#{#{value}}"
+        when :raw then "\#{#{value}}"
+        end
+      end
+      %("#{literal.join}")
+    end
+
+    def emit_interpolated(text)
+      emit_parts(interpolation_parts(text))
+    end
+
+    def interpolation_parts(text)
+      return [[:static, text]] unless text.include?('#{')
+
+      parts = []
+      loop do
+        case text
+        when ESCAPED_INTERPOLATION
+          parts << [:static, '#{']
+        when INTERPOLATION
+          code = $1
+          escape = !code.match?(UNESCAPED_INTERPOLATION_CODE)
+          parts << [:dynamic, escape ? code : code[1..-2], escape]
+        when INTERPOLATION_FREE_TEXT
+          parts << [:static, $&]
+        end
+        text = $'
+        break if text.empty?
+      end
+      parts
+    end
+
+    def compile_embedded(embedded)
+      case embedded.engine
+      when "ruby"
+        compile_ruby(embedded.children)
+      when "javascript" then compile_tag(Tag.new("script", embedded.attributes, [TextBlock.new(embedded.children)]))
+      when "css" then compile_tag(Tag.new("style", embedded.attributes, embedded.children))
+      when "markdown" then compile_markdown(embedded.children)
+      end
+    end
+
+    # Keeps every line of the block on its template line, blank lines included. The code must end with a
+    # newline, as its last line may be a comment: when no blank line follows, that newline is the one of the
+    # newline node that comes next.
+    def compile_ruby(children)
+      code = children.grep(Text).map(&:text).join
+      trailing_newline_count = children.count(NEWLINE) - 1 - code.count("\n")
+      @code << "\n"
+      emit_code(code)
+      @code << ("\n" * [trailing_newline_count, 1].max)
+      @newline_emitted = trailing_newline_count.zero?
+    end
+
+    def compile_markdown(children)
+      require "markly"
+
+      placeholder = "%#{object_id.abs.to_s(36)}%"
+      dynamic_parts = []
+      markdown = children.grep(Text).flat_map { interpolation_parts(_1.text) }.map do |part|
+        next part[1] if part.first == :static
+
+        dynamic_parts << part
+        "#{placeholder}#{dynamic_parts.size - 1}%"
+      end
+      Markly.render_html(markdown.join).split(/#{placeholder}(\d+)%/).each_with_index do |piece, index|
+        index.odd? ? emit_parts([dynamic_parts[piece.to_i]]) : emit_static(piece)
+      end
+      children.count(NEWLINE).times { @code << "\n" }
+    rescue LoadError
+      raise Error, "Embedded engine markdown requires the markly gem"
+    end
+
+    def doctype(type)
+      type = type.downcase
+      if (xml = type.match(/\Axml(\s+(.+))?\z/))
+        raise Error, "Invalid xml directive in html mode" unless @xml
+
+        %(<?xml version="1.0" encoding="#{xml[2] || "utf-8"}" ?>)
+      else
+        @doctypes[type] || raise(Error, "Invalid doctype #{type}")
+      end
+    end
+
+    def capture_into(variable)
+      if @rails
+        emit_code("#{variable} = capture do")
+        yield
+        emit_code("end")
+      else
+        outer_buffer = @buffer
+        flush_static
+        @buffer = StringBuffer.new(variable, @escape_function)
+        emit_code(@buffer.open)
+        yield
+        emit_code(@buffer.close)
+        @buffer = outer_buffer
+      end
+    end
+
+    def emit_static(text)
+      @static << text
+    end
+
+    def emit_output(code, escape)
+      emit_code(escape ? @buffer.escaped(code) : @buffer.raw(code))
+    end
+
+    def emit_code(code)
+      flush_static
+      append(code)
+    end
+
+    def flush_static
+      return if @static.empty?
+
+      append(@buffer.static(@static))
+      @static = +""
+    end
+
+    def append(code)
+      @code << "; " unless @code.empty? || @code.end_with?("\n")
+      @code << code
+    end
+
+    def new_variable
+      "_super_slim#{@variable_count += 1}"
+    end
+
+    class StringBuffer
+      def initialize(name, escape_function)
+        @name = name
+        @escape_function = escape_function
+      end
+
+      def open = "#{@name} = +\"\""
+      def close = @name
+      def static(text) = "#{@name} << #{text.inspect}.freeze"
+      def escaped(code) = "#{@name} << #{@escape_function}((#{code}))"
+      def raw(code) = "#{@name} << (#{code}).to_s"
+    end
+
+    class OutputBuffer
+      def open = "@output_buffer = output_buffer || ActionView::OutputBuffer.new"
+      def close = "@output_buffer"
+      def static(text) = "@output_buffer.safe_concat(#{text.inspect}.freeze)"
+      def escaped(code) = "@output_buffer << (#{code})"
+      def raw(code) = "@output_buffer.safe_concat((#{code}).to_s)"
+    end
+  end
+end

data/lib/super_slim/formatter/line_wrapper.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+module SuperSlim
+  class Formatter
+    # Breaks the lines of a formatted template longer than max_line_length: a tag's attributes one per line
+    # inside attribute_delimiters, then the arguments of its Ruby code after each comma, as Slim reads a line ending
+    # with a comma as continued on the next one. Lines already spread over several lines are left as they are.
+    class LineWrapper
+      CODE_LINE = /\A *(?:-|==?[<>]*) /
+      TAG_OUTPUT = /\G\s*==?['<>]*\s*/
+      OPENINGS = %i[on_lparen on_lbracket on_lbrace on_tlambeg on_embexpr_beg].freeze
+      CLOSINGS = %i[on_rparen on_rbracket on_rbrace on_embexpr_end].freeze
+      CONTINUATION_KINDS = %i[continuation text text_blank].freeze
+      MODIFIERS = %w[if unless while until rescue].freeze
+
+      # Templates attach ( and [ to their tag but set { apart, as a Ruby block: 6,097 public templates agree.
+      OPENING_BY_ATTRIBUTE_DELIMITERS = {"()" => "(", "[]" => "[", "{}" => " {"}.freeze
+
+      def initialize(max_line_length, tailwind_classes:, attribute_delimiters: "()")
+        @opening = OPENING_BY_ATTRIBUTE_DELIMITERS.fetch(attribute_delimiters) do
+          raise ArgumentError, "Invalid attribute_delimiters #{attribute_delimiters.inspect}: one of #{OPENING_BY_ATTRIBUTE_DELIMITERS.keys.join(", ")}"
+        end
+
+        @max_line_length = max_line_length
+        @tailwind_classes = tailwind_classes
+        @closing = attribute_delimiters[1]
+      end
+
+      def call(source)
+        lines = source.split("\n")
+        return source if lines.none? { _1.size > @max_line_length }
+
+        parser = Parser.new(outline: true, tailwind_classes: @tailwind_classes)
+        parser.call(source)
+        wrapped = lines.each.with_index(1).flat_map do |line, lineno|
+          info = parser.outline[lineno]
+          next [line] unless line.size > @max_line_length && info.kind == :structure && one_line?(parser.outline[lineno + 1], lineno)
+
+          wrap(line, info, children?(parser.outline, lineno))
+        end
+        "#{wrapped.join("\n")}\n"
+      end
+
+      private
+
+      def one_line?(next_info, lineno)
+        next_info.nil? || next_info.owner != lineno || !CONTINUATION_KINDS.include?(next_info.kind)
+      end
+
+      def children?(outline, lineno)
+        next_structure = outline[(lineno + 1)..].find { _1.kind == :structure }
+        next_structure && next_structure.depth > outline[lineno].depth
+      end
+
+      def wrap(line, info, children)
+        indent = line[/\A */]
+        lists = info.attribute_lists
+        lines, code_start =
+          if lists&.size == 1 && named_tag?(line[0...lists.first.first].strip)
+            wrap_attributes(line, lists.first, indent, info.output_column)
+          else
+            [[line], code_start(line, info.output_column)]
+          end
+        return lines unless code_start && lines.last.size > @max_line_length
+
+        # Arguments go two levels deeper than the line when it opens a block, so they stand apart from its children.
+        argument_indent = indent + (" " * (children ? 2 * INDENT_WIDTH : INDENT_WIDTH))
+        lines[0...-1] + wrap_arguments(lines.last, code_start, argument_indent)
+      end
+
+      # A dynamic tag, `*{tag: name}` or `li: *{tag: name}`, has no name for its attribute list to follow.
+      def named_tag?(head)
+        !head.empty? && !head.end_with?(":")
+      end
+
+      # Returns the lines and where the Ruby code of the last one starts, if it outputs some.
+      def wrap_attributes(line, (first, last, spans), indent, output_column)
+        attribute_indent = indent + (" " * INDENT_WIDTH)
+        closing_line = indent + @closing + line[last..]
+        lines = [line[0...first].rstrip + @opening, *spans.map { |span_first, span_last| attribute_indent + line[span_first...span_last] }, closing_line]
+        [lines, output_column && code_start(closing_line, output_column - last + indent.size + @closing.size)]
+      end
+
+      def code_start(line, output_column)
+        if output_column
+          TAG_OUTPUT.match(line, output_column)&.end(0)
+        elsif (match = CODE_LINE.match(line))
+          match.end(0)
+        end
+      end
+
+      def wrap_arguments(line, code_start, argument_indent)
+        code = line[code_start..]
+        offsets = argument_breaks(code)
+        return [line] if offsets.empty?
+
+        first = 0
+        first_piece, *pieces = [*offsets, code.bytesize].map do |last|
+          piece = code.byteslice(first...last).strip
+          first = last
+          piece
+        end
+        [line[0...code_start] + first_piece, *pieces.map { argument_indent + _1 }]
+      end
+
+      # Byte offsets right after each comma that separates the arguments of the outermost call, up to its block.
+      def argument_breaks(code)
+        depth = 0
+        offsets = []
+        Ripper.lex(code).each do |(_, column), type, token|
+          case type
+          when :on_heredoc_beg then return []
+          when :on_kw
+            break if token == "do"
+            # RuboCop refuses a modifier that ends a statement spread over several lines (Style/MultilineIfModifier).
+            return [] if depth.zero? && MODIFIERS.include?(token)
+          when :on_op
+            # `a, b = …` assigns several variables: its commas separate no arguments.
+            return [] if depth.zero? && token == "=" && !offsets.empty?
+          when :on_comma then offsets << column + 1 if depth.zero?
+          when *OPENINGS then depth += 1
+          when *CLOSINGS then depth -= 1
+          end
+        end
+        offsets
+      end
+    end
+  end
+end