mdom 0.1.0 → 0.3.0

data/lib/mdom/inline_parser.rb

@@ -1,185 +1,584 @@
 # frozen_string_literal: true
 
+require "prism"
+
+require_relative "node/inline_nodes"
+
 module MDOM
-  # Tokenizes a run of inline text into inline nodes: Text, Emphasis, Strong,
-  # Code, Link, Image, Softbreak, Hardbreak and escaped characters.
+  # 行内解析器：把一段**行内文本**解析为行内节点数组（docs/IMPLEMENTATION.md §2.4）。
+  #
+  # 覆盖 CSM 的行内语法：行内代码（§1.5）、强调（§1.7）、增删（§1.8）、行内引用
+  # （§1.9）、进度与度量（§1.10）、公式（§1.11）、WikiLink（§2.1）、提及（§2.2）、
+  # 链接与图片（§2.3）、行首转义与行内转义（§3.11）、插值（§3.13），以及软换行
+  # 折叠与硬换行（§1.1）。
   #
-  # This is a pragmatic subset of CommonMark inline syntax. Code spans and
-  # links/images are matched textually; emphasis/strong is resolved by finding
-  # the next matching delimiter and recursing into the enclosed text. Delimiter
-  # runs and exact flanking rules are intentionally simplified.
-  module InlineParser
-    ESCAPABLE = /[\x00`*_{}\[\]()#+\-.!>]/.freeze
-    SPECIAL = /[\\`!*_\[\n]/.freeze
+  # 产出的是**未求值**的节点：`#{}` 只保存表达式原文，公式只保存 TeX 原文。
+  # 块级结构（围栏、块级公式、透明 Ruby……）不属于本类。
+  #
+  #   MDOM::InlineParser.parse("**粗** 与 *斜* 与 `code`")
+  class InlineParser
+    # 可以被 `\` 转义的字符（CommonMark 的 ASCII 标点，外加 CSM 用到的 `$`、`@`）。
+    ESCAPABLE = %w[` * _ { } [ ] ( ) # + - . ! " $ % & ' , / : ; < = > ? @ ^ | ~ \\].freeze
+
+    # 东亚（CJK）标点（CSM §1.1：`\n` 前是它们时不插入空格）。
+    CJK_PUNCTUATION = /
+      [\u3000-\u303F]   # CJK 符号和标点（、。〈〉《》「」【】…）
+      |[\uFF01-\uFF0F]  # 全角标点（！ ～ ／）
+      |[\uFF1A-\uFF20]  # 全角标点（： ～ ＠）
+      |[\uFF3B-\uFF40]  # 全角标点（［ ～ ｀）
+      |[\uFF5B-\uFF65]  # 全角标点（｛ ～ ･）
+      |[\u2013\u2014]   # – —
+      |[\u2018-\u201D]  # ‘ ’ “ ”
+      |[\u2026\u00B7\u30FB]
+    /x
 
-    module_function
+    MENTION_RE = /\A@([A-Za-z0-9_][\w-]*)(?::([A-Za-z0-9_][\w-]*))?/
+    AUTOLINK_RE = /\A(?:[A-Za-z][A-Za-z0-9+.-]*:[^\s<>]*|[^\s<>@]+@[^\s<>@]+\.[^\s<>@]+)\z/
+    DESTINATION_RE = /\A(\S*?)(?:\s+"([^"]*)")?\z/
+    RATIO_RE = %r{\A(\S+?)/(\S+)\z}
+
+    # 行内代码最多 2 个反引号（CSM §1.5）。
+    MAX_CODE_TICKS = 2
+
+    # 链接 `[]` 内允许的单个样式标签（CSM §2.3）：开标记、闭标记、节点类。
+    # 长标记在前——`**` 要先于 `*` 试。
+    STYLE_MARKERS = [
+      ["**", "**", Node::Strong],
+      ["~~", "~~", Node::Del],
+      ["~+", "+~", Node::Ins],
+      ["*", "*", Node::Emphasis]
+    ].freeze
+
+    # 解析行内文本，返回行内节点数组。
+    #
+    # * +styles:+ 为 +false+ 时不再识别样式标签（`*` `**` `~~` `~+`）——样式不得
+    #   嵌套（CSM §1.7）；
+    # * +literal:+ 为 +true+ 时只识别转义与 `#{}` 插值，其余一律按字面，用于
+    #   链接的 `[]` 内容（CSM §2.3）。
+    def self.parse(text, styles: true, literal: false)
+      new(styles: styles, literal: literal).parse(text)
+    end
 
-    def parse(source)
-      Scanner.new(source.to_s).read_nodes
+    def initialize(styles: true, literal: false)
+      @styles = styles
+      @literal = literal
     end
 
-    class Scanner
-      def initialize(text)
-        @text = text
-        @len = text.length
-        @pos = 0
+    def parse(text)
+      @text = text.to_s
+      @pos = 0
+      @nodes = []
+      buffer = +""
+
+      while @pos < @text.length
+        char = @text[@pos]
+        next if handle(char, buffer)
+
+        buffer << char
+        @pos += 1
       end
 
-      def read_nodes
-        nodes = []
-        while @pos < @len
-          node = read_node
-          nodes << node if node
-        end
-        nodes
+      flush(buffer)
+      @nodes
+    end
+
+    private
+
+    # 按当前模式分派一个字符，返回是否已消费。
+    def handle(char, buffer)
+      return literal_char(char, buffer) if @literal
+
+      case char
+      when "\\" then escape(buffer)
+      when "`" then code_span(buffer)
+      when "*" then emphasis(buffer)
+      when "~" then tilde_mark(buffer)
+      when "[" then bracket(buffer)
+      when "!" then image(buffer)
+      when "<" then autolink(buffer)
+      when "$" then math(buffer)
+      when "#" then interpolation(buffer)
+      when "@" then mention(buffer)
+      when "\n" then line_break(buffer)
       end
+    end
 
-      private
-
-      def read_node
-        case @text[@pos]
-        when "\\" then read_escape
-        when "`" then read_code_span
-        when "!" then read_link_or_image
-        when "[" then read_link_or_image
-        when "\n" then read_break
-        when "*" then read_emphasis
-        when "_" then read_emphasis
-        else read_plain_run
-        end
+    # 字面模式：只认转义、插值与换行折叠。
+    def literal_char(char, buffer)
+      case char
+      when "\\" then escape(buffer)
+      when "#" then interpolation(buffer)
+      when "\n" then line_break(buffer)
       end
+    end
 
-      def read_escape
-        nxt = @text[@pos + 1]
-        if nxt && ESCAPABLE.match?(nxt)
-          @pos += 2
-          Text.new(nxt)
-        else
-          @pos += 1
-          Text.new("\\")
-        end
+    # 行内文本里的 `\`：行尾是硬换行，否则按 Markdown 转义语义（CSM §3.11）。
+    def escape(buffer)
+      following = @text[@pos + 1]
+      return false if following.nil?
+
+      if following == "\n"
+        @pos += 2
+        emit(buffer, Node::HardBreak.new)
+        return true
       end
 
-      def read_code_span
-        count = 1
-        count += 1 while @text[@pos + count] == "`"
-        closer = "`" * count
-        @pos += count
-        closing = @text.index(closer, @pos)
-        if closing.nil?
-          @pos -= count
-          read_plain_run
+      return false unless ESCAPABLE.include?(following)
+
+      buffer << following
+      @pos += 2
+      true
+    end
+
+    # 软换行折叠（CSM §1.1）：前一个字符是 CJK 标点则直接相连，否则折叠为一个空格。
+    def line_break(buffer)
+      previous = @pos.zero? ? nil : @text[@pos - 1]
+      @pos += 1
+      buffer << " " unless cjk_punctuation?(previous)
+      true
+    end
+
+    # `` `代码` `` / ``` ``代码`` ```（CSM §1.5）。内容按字面处理。
+    def code_span(buffer)
+      ticks = run_length("`")
+      return false if ticks > MAX_CODE_TICKS
+
+      after = skip_code_span(@pos, ticks)
+      return false if after.nil?
+
+      code = @text[(@pos + ticks)...(after - ticks)]
+      @pos = after
+      emit(buffer, Node::CodeSpan.new(code))
+      true
+    end
+
+    # `*斜体*` / `**加粗**`（CSM §1.7）。
+    #
+    # 三个条件同时满足才成立：定界符数量相同（`**` 只配 `**`）、开 `*` 的右边与
+    # 闭 `*` 的左边都是非空白、且强调不嵌套（内部不再识别 `*`）。任一不满足就把
+    # 整个定界符串按字面收下，不退化成更短的定界符。
+    def emphasis(buffer)
+      count = run_length("*")
+      return literal_emphasis(buffer, count) unless @styles && count <= 2
+      return literal_emphasis(buffer, count) if blank?(@text[@pos + count])
+
+      closing = find_emphasis_close(count)
+      return literal_emphasis(buffer, count) if closing.nil?
+
+      inner = @text[(@pos + count)...closing]
+      @pos = closing + count
+      klass = count == 2 ? Node::Strong : Node::Emphasis
+      emit(buffer, klass.new(children: InlineParser.parse(inner, styles: false)))
+      true
+    end
+
+    def literal_emphasis(buffer, count)
+      buffer << @text[@pos, count]
+      @pos += count
+      true
+    end
+
+    # `~~删除~~`（`<del>`）与 `~+增加+~`（`<ins>`）（CSM §1.8）。
+    def tilde_mark(buffer)
+      return false unless @styles
+
+      if @text[@pos, 2] == "~~"
+        closing = find_sequence("~~", @pos + 2)
+        return false if closing.nil?
+
+        inner = @text[(@pos + 2)...closing]
+        @pos = closing + 2
+        emit(buffer, Node::Del.new(children: InlineParser.parse(inner)))
+        true
+      elsif @text[@pos, 2] == "~+"
+        closing = find_sequence("+~", @pos + 2)
+        return false if closing.nil?
+
+        inner = @text[(@pos + 2)...closing]
+        @pos = closing + 2
+        emit(buffer, Node::Ins.new(children: InlineParser.parse(inner)))
+        true
+      else
+        false
+      end
+    end
+
+    # `[` 家族：WikiLink、进度条、度量、链接/行内引用。
+    def bracket(buffer)
+      if @text[@pos, 2] == "[["
+        wiki_link(buffer)
+      elsif @text[@pos, 3] == "[->"
+        bar(buffer, Node::Progress)
+      elsif @text[@pos, 2] == "[="
+        bar(buffer, Node::Meter)
+      else
+        link(buffer)
+      end
+    end
+
+    def wiki_link(buffer)
+      closing = find_sequence("]]", @pos + 2)
+      return false if closing.nil?
+
+      inner = @text[(@pos + 2)...closing]
+      @pos = closing + 2
+      target, _, label = inner.partition("|")
+      label = nil if label.empty?
+      # label 的策略与一般链接的文本相同：最多一个紧邻的样式标签，其余按字面
+      # （CSM §2.1、§2.3）。
+      emit(buffer, Node::WikiLink.new(target, label: label, children: link_label_nodes(label || target)))
+      true
+    end
+
+    # `[=m/n]` → `<meter>`，`[->m/n]` → `<progress>`（CSM §1.10）。
+    def bar(buffer, klass)
+      offset = klass == Node::Meter ? 2 : 3
+      closing = @text.index("]", @pos + offset)
+      return false if closing.nil?
+
+      ratio = @text[(@pos + offset)...closing]
+      match = RATIO_RE.match(ratio)
+      return false if match.nil?
+
+      @pos = closing + 1
+      emit(buffer, klass.new(match[1], match[2], children: literal_nodes(ratio)))
+      true
+    end
+
+    # `[文本](uri "title")` → `<a>`；`[文本](@uri)` → `<q>`（CSM §1.9、§2.3）。
+    def link(buffer)
+      closing = matching_bracket(@pos)
+      return false if closing.nil?
+      return false unless @text[closing + 1] == "("
+
+      paren = matching_paren(closing + 1)
+      return false if paren.nil?
+
+      label = @text[(@pos + 1)...closing]
+      destination = @text[(closing + 2)...paren]
+      @pos = paren + 1
+      emit(buffer, build_link(destination, label))
+      true
+    end
+
+    # `![alt](uri "title")` → `<img>`（CSM §2.3）。
+    def image(buffer)
+      return false unless @text[@pos + 1] == "["
+
+      closing = matching_bracket(@pos + 1)
+      return false if closing.nil?
+      return false unless @text[closing + 1] == "("
+
+      paren = matching_paren(closing + 1)
+      return false if paren.nil?
+
+      alt = @text[(@pos + 2)...closing]
+      destination = @text[(closing + 2)...paren]
+      uri, title = split_destination(destination)
+      @pos = paren + 1
+      emit(buffer, Node::Image.new(uri, alt: alt, title: title, children: literal_nodes(alt)))
+      true
+    end
+
+    # `<uri>` / `<mailto:a@b.c>` → `<a>`（CSM §2.3）。
+    def autolink(buffer)
+      closing = @text.index(">", @pos + 1)
+      return false if closing.nil?
+
+      inner = @text[(@pos + 1)...closing]
+      return false if inner.empty? || !AUTOLINK_RE.match?(inner)
+
+      @pos = closing + 1
+      emit(buffer, Node::Link.new(inner, children: literal_nodes(inner)))
+      true
+    end
+
+    # `$\TeX$` → 行内 `<span class="math">`（CSM §1.11）。`$$` 属于块级公式，这里按字面处理。
+    def math(buffer)
+      return false if @text[@pos + 1] == "$"
+
+      closing = find_sequence("$", @pos + 1)
+      return false if closing.nil?
+
+      tex = @text[(@pos + 1)...closing]
+      return false if tex.empty?
+
+      @pos = closing + 1
+      emit(buffer, Node::Math.new(tex, children: literal_nodes(tex)))
+      true
+    end
+
+    # `#{expr}` → 插值节点（CSM §3.13）。只保存表达式原文，不求值。
+    #
+    # 边界交给 Prism 判定：把从 `#{` 起的剩余文本包进一个双引号字符串字面量，
+    # Prism 给出的插值节点 location 就是 `#{}` 的范围。嵌套 `{}`、字符串与注释
+    # 里的 `}` 由 Ruby 自己的词法处理，不需要自研扫描器（CSM §3.12）。
+    def interpolation(buffer)
+      return false unless @text[@pos + 1] == "{"
+
+      closing = interpolation_end
+      return false if closing.nil?
+
+      expr = @text[(@pos + 2)...closing]
+      @pos = closing + 1
+      emit(buffer, Node::Interpolation.new(expr))
+      true
+    end
+
+    # `@user` / `@project:x` / `@tag:kw`（CSM §2.2）。`:` 前是作用域，其后是名字。
+    def mention(buffer)
+      return false if @pos.positive? && @text[@pos - 1].match?(/\w/)
+
+      match = MENTION_RE.match(@text[@pos..])
+      return false if match.nil?
+
+      @pos += match[0].length
+      scope = match[1]
+      name = match[2]
+      emit(buffer, Node::Mention.new(name || scope, kind: name ? scope : nil))
+      true
+    end
+
+    # 链接与行内引用的构造（CSM §1.9、§2.3）。
+    #
+    # `[]` 内容最多含**一个**样式标签，且必须紧邻方括号（`[*strong link*](url)`）；
+    # 其余按字面（`#{}` 插值始终解析）。链接本身处在样式标签内部时，`[]` 内容
+    # 一律按字面——样式与链接不得互相嵌套。
+    def build_link(destination, label)
+      uri, title = split_destination(destination)
+      children = link_label_nodes(label)
+
+      if uri&.start_with?("@")
+        Node::InlineQuote.new(uri[1..], children: children)
+      else
+        Node::Link.new(uri, title: title, children: children)
+      end
+    end
+
+    def split_destination(destination)
+      match = DESTINATION_RE.match(destination.strip)
+      return [destination.strip, nil] if match.nil?
+
+      [match[1], match[2]]
+    end
+
+    # `[]` 内容的节点：至多一个紧邻方括号的样式标签，其余按字面。
+    def link_label_nodes(label)
+      wrapped = @styles ? wrapping_style(label) : nil
+      return literal_nodes(label) if wrapped.nil?
+
+      klass, inner = wrapped
+      [klass.new(children: literal_nodes(inner))]
+    end
+
+    # 整个 +label+ 恰好被一个样式标签包裹时返回 +[节点类, 内文]+，否则 +nil+。
+    def wrapping_style(label)
+      STYLE_MARKERS.each do |opener, closer, klass|
+        next if label.length <= opener.length + closer.length
+        next unless label.start_with?(opener) && label.end_with?(closer)
+
+        inner = label[opener.length, label.length - opener.length - closer.length]
+        next if blank?(inner[0]) || blank?(inner[-1])
+        # 内文不得再出现同族定界符（那会是第二个样式标签）
+        next if unescaped?(inner, opener[0])
+
+        return [klass, inner]
+      end
+      nil
+    end
+
+    def literal_nodes(text)
+      InlineParser.parse(text, literal: true)
+    end
+
+    # +text+ 里是否存在未被 `\` 转义的 +char+。
+    def unescaped?(text, char)
+      cursor = 0
+      while cursor < text.length
+        if text[cursor] == "\\"
+          cursor += 2
+        elsif text[cursor] == char
+          return true
         else
-          content = @text[@pos...closing].gsub(/\A +| +\z/, "").gsub(/\n/, " ")
-          @pos = closing + count
-          Code.new(content)
+          cursor += 1
         end
       end
+      false
+    end
+
+    def flush(buffer)
+      return if buffer.empty?
+
+      @nodes << Node::Text.new(buffer.dup)
+      buffer.clear
+    end
 
-      def read_link_or_image
-        image = @text[@pos] == "!"
-        @pos += 1 if image
-        return read_plain_run unless @text[@pos] == "["
+    def emit(buffer, node)
+      flush(buffer)
+      @nodes << node
+    end
 
-        label_start = @pos + 1
-        closing = @text.index("]", label_start)
-        return read_plain_run unless closing
+    # 从 +@pos+ 起连续 +char+ 的个数。
+    def run_length(char)
+      run_length_at(@pos, char)
+    end
 
-        label = @text[label_start...closing]
-        return read_plain_run unless @text[closing + 1] == "("
+    def run_length_at(pos, char)
+      cursor = pos
+      cursor += 1 while cursor < @text.length && @text[cursor] == char
+      cursor - pos
+    end
 
-        dest_end = @text.index(")", closing + 1)
-        return read_plain_run unless dest_end
+    # 从 +pos+（一个反引号序列的起点）跳到配对的结束反引号之后；找不到返回 nil。
+    def skip_code_span(pos, ticks)
+      cursor = pos + ticks
+      while cursor < @text.length
+        if @text[cursor] == "`"
+          run = run_length_at(cursor, "`")
+          return cursor + run if run == ticks
 
-        dest, title = split_destination(@text[(closing + 2)...dest_end])
-        @pos = dest_end + 1
-        if image
-          Image.new(dest, alt: label, title: title)
+          cursor += run
         else
-          Link.new(dest, title: title, children: InlineParser.parse(label))
+          cursor += 1
         end
       end
+      nil
+    end
 
-      def split_destination(raw)
-        raw = raw.strip
-        raw = raw[1..-2] if raw.start_with?("<") && raw.end_with?(">")
-        body = raw
-        title = nil
-        if (m = /\A(.+?)\s+(?:"([^"]*)"|'([^']*)'|\(([^)]*)\))\z/.match(raw))
-          body = m[1]
-          title = m[2] || m[3] || m[4]
+    # 找可以充当闭定界符的 `*`：长度必须与 +count+ 相同，且左侧是非空白
+    # （CSM §1.7）。跳过转义、行内代码与链接——它们的 `*` 不算定界符。
+    def find_emphasis_close(count)
+      cursor = @pos + count
+      while cursor < @text.length
+        case @text[cursor]
+        when "\\" then cursor += 2
+        when "`" then cursor = skip_code_span(cursor, run_length_at(cursor, "`")) || @text.length
+        when "[", "!"
+          cursor = link_extent(cursor) || cursor + 1
+        when "*"
+          run = run_length_at(cursor, "*")
+          return cursor if run == count && !blank?(@text[cursor - 1])
+
+          cursor += run
+        else cursor += 1
         end
-        [body, title]
       end
+      nil
+    end
 
-      # A newline preceded by two spaces is a hard break; otherwise soft break.
-      def read_break
-        # Two spaces immediately before the newline => hard break.
-        before = @text[0...@pos]
-        hard = before.end_with?("  ")
-        @pos += 1
-        hard ? Hardbreak.new : Softbreak.new
+    # 找下一个未被转义的 +sequence+。
+    def find_sequence(sequence, from)
+      cursor = from
+      while (found = @text.index(sequence, cursor))
+        return found if found.zero? || @text[found - 1] != "\\"
+
+        cursor = found + 1
       end
+      nil
+    end
 
-      def read_emphasis
-        # Double marker -> strong, single -> emphasis.
-        if @text[@pos, 2] == "**" || @text[@pos, 2] == "__"
-          open = @text[@pos, 2]
-          idx = @pos + 2
-          closer = find_closer(idx, open[0], open.length)
-          if closer
-            inner = @text[idx...closer]
-            @pos = closer + open.length
-            Strong.new(children: InlineParser.parse(inner))
-          else
-            read_plain_run
-          end
-        else
-          open_ch = @text[@pos]
-          idx = @pos + 1
-          # A single marker must close on a lone delimiter, not part of "**".
-          closer = find_closer(idx, open_ch, 1, skip_double: true)
-          if closer
-            inner = @text[idx...closer]
-            @pos = closer + 1
-            Emphasis.new(children: InlineParser.parse(inner))
-          else
-            read_plain_run
-          end
+    # 从 `[` 的位置找配对的 `]`，跳过嵌套、转义与行内代码。
+    def matching_bracket(open)
+      depth = 0
+      cursor = open
+      while cursor < @text.length
+        case @text[cursor]
+        when "\\" then cursor += 2
+        when "`" then cursor = skip_code_span(cursor, run_length_at(cursor, "`")) || @text.length
+        when "[" then depth += 1
+                      cursor += 1
+        when "]"
+          depth -= 1
+          return cursor if depth.zero?
+
+          cursor += 1
+        else cursor += 1
         end
       end
+      nil
+    end
+
+    def matching_paren(open)
+      matching_pair(open, "(", ")")
+    end
+
+    # 若 +pos+（`[` 或 `!`）处是一个链接/图片，返回它之后的下标；否则 +nil+。
+    def link_extent(pos)
+      open = @text[pos] == "!" ? pos + 1 : pos
+      return nil unless @text[open] == "["
+
+      closing = matching_bracket(open)
+      return nil if closing.nil? || @text[closing + 1] != "("
 
-      # Find the index of a closing delimiter, scanning from +from+. With
-      # +skip_double+, a doubled delimiter is skipped (so "*a **b** c*" resolves
-      # the outer emphasis to the final lone '*', recursing into the strong).
-      def find_closer(from, ch, width, skip_double: false)
-        i = from
-        while i < @len
-          if @text[i] == ch
-            if width > 1
-              return i if @text[i, width] == ch * width
-            elsif @text[i, 2] == ch * 2
-              i += 2 # skip doubled marker entirely
-              next
-            elsif @text[i, width] == ch * width
-              return i
-            end
-          end
-          i += 1
+      paren = matching_paren(closing + 1)
+      paren && paren + 1
+    end
+
+    # 从 +open+（开括号的位置）找配对闭括号；跳过嵌套、反斜杠转义与引号内的括号。
+    def matching_pair(open, opener, closer)
+      depth = 0
+      quote = nil
+      cursor = open
+      while cursor < @text.length
+        char = @text[cursor]
+        if char == "\\"
+          cursor += 2
+          next
+        end
+        if quote
+          quote = nil if char == quote
+          cursor += 1
+          next
         end
-        nil
-      end
 
-      def read_plain_run
-        start = @pos
-        while @pos < @len && !SPECIAL.match?(@text[@pos])
-          @pos += 1
+        case char
+        when "\"", "'" then quote = char
+        when opener then depth += 1
+        when closer
+          depth -= 1
+          return cursor if depth.zero?
         end
-        # Guarantee forward progress so a special char that couldn't be parsed
-        # as its own construct is treated as literal text.
-        @pos += 1 if @pos == start
-        Text.new(@text[start...@pos])
+        cursor += 1
+      end
+      nil
+    end
+
+    def cjk_punctuation?(char)
+      !char.nil? && CJK_PUNCTUATION.match?(char)
+    end
+
+    # 空格或换行（含制表符）。强调定界符的内侧不能是它们（CSM §1.7）。
+    def blank?(char)
+      char.nil? || char.match?(/\s/)
+    end
+
+    # 用 Prism 找出与当前位置的 `#{` 配对的 `}` 的下标；不是插值则返回 nil。
+    #
+    # 构造出的字面量里，插值之后若出现裸 `"`，整段就不再是合法 Ruby——Prism
+    # 会报错，但错误恢复仍给出插值节点，边界照常可读。代价是每个插值解析一次
+    # 剩余文本（各次解析互不影响）。
+    def interpolation_end
+      result = Prism.parse("\"#{@text[@pos..]}\"")
+      segment = first_embedded_statement(result.value)
+      return nil if segment.nil?
+
+      slice = segment.location.slice
+      # 未闭合的 `#{` 会一直吞到字符串结尾，此时的 slice 不以 `}` 收尾。
+      return nil unless slice.end_with?("}")
+
+      @pos + slice.length - 1
+    end
+
+    # 先序遍历，取第一个字符串插值节点。
+    def first_embedded_statement(node)
+      return nil unless node
+      return node if node.is_a?(Prism::EmbeddedStatementsNode)
+
+      node.compact_child_nodes.each do |child|
+        found = first_embedded_statement(child)
+        return found if found
       end
+      nil
     end
   end
 end