red_quilt 0.7.1 → 0.8.0

data/lib/red_quilt/inline/emphasis_resolver.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+module RedQuilt
+  module Inline
+    # CommonMark emphasis algorithm (spec 6.2). Phase 2 of inline parsing:
+    # given the delimiter stack the linear pass collected (provisional TEXT
+    # nodes for each `*` / `_` / `~` run), it pairs openers with closers and
+    # rebuilds the arena subtree into EMPHASIS / STRONG / STRIKETHROUGH
+    # nodes.
+    #
+    # Kept separate from Builder because it is a closed algorithm with a
+    # narrow interface: it only needs the arena, the set of still-provisional
+    # nodes (so consumed delimiters can be unmarked), and whether source
+    # spans are tracked. Builder owns the linear pass and bracket handling;
+    # it hands this resolver a delimiter stack to collapse.
+    class EmphasisResolver
+      # `count` is the CommonMark delimiter-run length; a Delimiter is
+      # never enumerated, so shadowing Struct#count (from Enumerable) is
+      # intentional rather than a footgun.
+      Delimiter = Struct.new(:node_id, :char, :count, :can_open, :can_close) # rubocop:disable Lint/StructNewOverride
+
+      def initialize(arena, track_source:)
+        @arena = arena
+        @track_source = track_source
+      end
+
+      # Collapses `stack` (an Array of Delimiter) in place, removing
+      # consumed entries from `provisional_nodes`. Used both for the
+      # document-level stack and for the inner delimiters of a resolved
+      # link/image (see Builder#finalize_link).
+      def resolve(stack, provisional_nodes)
+        # NB: the CommonMark spec describes an `openers_bottom`
+        # optimization keyed by closer character / length / flanking
+        # flags. Implementing that correctly is subtle (a single
+        # per-character bottom blocks valid matches like
+        # `*foo**bar**baz*`), so the implementation here just walks
+        # back to the start of the stack for every closer. This is
+        # O(stack^2) in the worst case but stacks are tiny in practice.
+        closer_idx = 0
+
+        while closer_idx < stack.length
+          closer = stack[closer_idx]
+          unless closer.can_close
+            closer_idx += 1
+            next
+          end
+
+          opener_idx = closer_idx - 1
+          found = false
+          while opener_idx >= 0
+            opener = stack[opener_idx]
+            if opener.can_open && opener.char == closer.char
+              skip = false
+              if (opener.can_close || closer.can_open) &&
+                 ((opener.count + closer.count) % 3).zero? &&
+                 !((opener.count % 3).zero? && (closer.count % 3).zero?)
+                skip = true
+              end
+              unless skip
+                found = true
+                break
+              end
+            end
+            opener_idx -= 1
+          end
+
+          unless found
+            unless closer.can_open
+              provisional_nodes.delete(closer.node_id)
+              stack.delete_at(closer_idx)
+            end
+            closer_idx += 1
+            next
+          end
+
+          opener = stack[opener_idx]
+          strength = [opener.count, closer.count].min >= 2 ? 2 : 1
+          if closer.char == "~"
+            # GFM strikethrough only forms on `~~` runs. A single `~`
+            # leaves the delimiter as text; advance the cursor so future
+            # `~~` pairs can still match.
+            if strength < 2
+              closer_idx += 1
+              next
+            end
+            kind = NodeType::STRIKETHROUGH
+          else
+            kind = strength == 2 ? NodeType::STRONG : NodeType::EMPHASIS
+          end
+
+          # CommonMark spec: any delimiters strictly between this opener and
+          # closer can't open or close anything in this scope, so drop them
+          # from the stack before we rebuild the tree. Their arena nodes
+          # stay where they are (they'll be reparented into the new emphasis
+          # alongside the surrounding content), but they must no longer be
+          # candidates for future iterations. Without this, the next
+          # iteration would try to pair stranded delimiters that have
+          # already been moved into a different parent, which corrupts the
+          # sibling chain (Arena#reparent walks into @parent[-1]).
+          if closer_idx > opener_idx + 1
+            removed = stack.slice!((opener_idx + 1)...closer_idx)
+            removed.each { |e| provisional_nodes.delete(e.node_id) }
+            closer_idx = opener_idx + 1
+            closer = stack[closer_idx]
+          end
+
+          opener_node = opener.node_id
+          closer_node = closer.node_id
+
+          if @track_source
+            opener_match_start = @arena.source_end(opener_node) - strength
+            closer_match_end = @arena.source_start(closer_node) + strength
+          else
+            opener_match_start = -1
+            closer_match_end = 0
+          end
+          emphasis_id = add_node(kind, opener_match_start, closer_match_end)
+
+          first_inside = @arena.raw_next_sibling_id(opener_node)
+          last_inside = @arena.raw_prev_sibling_id(closer_node)
+          if first_inside != -1 && last_inside != -1 &&
+             first_inside != closer_node && last_inside != opener_node
+            @arena.reparent(emphasis_id, first_inside, last_inside)
+          end
+
+          parent_id = @arena.raw_parent_id(opener_node)
+          @arena.insert_before(parent_id, closer_node, emphasis_id)
+
+          # Consume `strength` characters from the inner end of each
+          # delimiter. The opener is trimmed on its right (trailing) end,
+          # the closer on its left (leading) end; removing the opener from
+          # the stack shifts the closer one slot left.
+          closer_idx -= 1 if consume_delimiter(opener, opener_idx, stack, strength, provisional_nodes, from_start: false)
+          consume_delimiter(closer, closer_idx, stack, strength, provisional_nodes, from_start: true)
+        end
+
+        stack.each { |e| provisional_nodes.delete(e.node_id) }
+        stack.clear
+      end
+
+      private
+
+      # Mirrors Builder#add_arena_node for the nodes this resolver creates
+      # (emphasis wrappers only ever take a type and a span).
+      def add_node(type, start_byte, end_byte)
+        if @track_source
+          @arena.add_node(type, source_start: start_byte, source_len: end_byte - start_byte)
+        else
+          @arena.add_node(type, source_start: -1, source_len: 0)
+        end
+      end
+
+      # Removes `strength` characters from one end of a delimiter run. When
+      # the whole run is consumed the node is detached and dropped from the
+      # stack (returns true); otherwise its count, str1, and — in
+      # source-tracking mode — its span are trimmed on the requested side
+      # (`from_start` trims the leading end, used for closers; trailing for
+      # openers) and it stays on the stack (returns false).
+      def consume_delimiter(entry, index, stack, strength, provisional_nodes, from_start:)
+        node = entry.node_id
+        if entry.count == strength
+          provisional_nodes.delete(node)
+          @arena.detach(node)
+          stack.delete_at(index)
+          return true
+        end
+
+        entry.count -= strength
+        str = @arena.str1(node)
+        @arena.update_str1(node, from_start ? str[strength..] : str[0...-strength])
+        if @track_source
+          start_byte = @arena.source_start(node)
+          end_byte = @arena.source_end(node)
+          if from_start
+            @arena.update_span(node, start_byte + strength, end_byte)
+          else
+            @arena.update_span(node, start_byte, end_byte - strength)
+          end
+        end
+        false
+      end
+    end
+  end
+end

data/lib/red_quilt/inline/url_sanitizer.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module RedQuilt
+  module Inline
+    # URL-scheme security policy for inline link / image / autolink
+    # destinations. Kept separate from Builder so the "which schemes are
+    # safe and how blocking is reported" concern has a single home and can
+    # change without touching the inline construction logic.
+    #
+    # Stateless (module_function); diagnostics are appended to the caller's
+    # array (or skipped when it is nil), so there is no per-call allocation.
+    module UrlSanitizer
+      module_function
+
+      SAFE_SCHEMES = %w[http https mailto ftp tel ssh].freeze
+
+      # Autolinks (`<scheme:...>`) are not run through the SAFE_SCHEMES
+      # allowlist: CommonMark permits arbitrary schemes there (e.g.
+      # `<made-up-scheme://x>`), and an allowlist would break that
+      # conformance. Only the schemes that execute script when the link
+      # is navigated are denied.
+      UNSAFE_AUTOLINK_SCHEMES = %w[javascript vbscript data].freeze
+
+      SCHEME_RE = /\A([a-zA-Z][a-zA-Z0-9+\-.]*):/
+
+      # Link / image destinations: allowlist. Relative URLs (starting `/`
+      # or `#`) and scheme-less URLs pass; an unknown scheme is blocked
+      # (href emptied) and a diagnostic is recorded.
+      def sanitize_destination(destination, diagnostics)
+        return "" if destination.nil?
+        return destination if destination.start_with?("/", "#")
+
+        scheme = destination[SCHEME_RE, 1]
+        return destination if scheme.nil?
+        return destination if SAFE_SCHEMES.include?(scheme.downcase)
+
+        report_blocked(diagnostics, scheme)
+        ""
+      end
+
+      # Autolink destinations: denylist. The destination is returned
+      # unchanged unless its scheme executes script on navigation, in which
+      # case the href is emptied and a diagnostic is recorded.
+      def block_unsafe_autolink(destination, diagnostics)
+        scheme = destination[SCHEME_RE, 1]
+        return destination if scheme.nil?
+        return destination unless UNSAFE_AUTOLINK_SCHEMES.include?(scheme.downcase)
+
+        report_blocked(diagnostics, scheme)
+        ""
+      end
+
+      def report_blocked(diagnostics, scheme)
+        return unless diagnostics
+
+        diagnostics << Diagnostic.new(
+          severity: :warning,
+          rule: :unsafe_url,
+          message: "Unsafe URL scheme #{scheme.downcase.inspect} blocked",
+        )
+      end
+    end
+  end
+end

data/lib/red_quilt/line.rb

@@ -10,5 +10,10 @@ module RedQuilt
   # Positional (not keyword_init): one Line is built per source line, so
   # the ~2.5x faster positional constructor matters on large documents.
   # Argument order: content, start_byte, end_byte, blank, lazy_continuation.
-  Line = Struct.new(:content, :start_byte, :end_byte, :blank, :lazy_continuation)
+  Line = Struct.new(:content, :start_byte, :end_byte, :blank, :lazy_continuation) do
+    # Byte length of the line's span in the original source.
+    def span_len
+      end_byte - start_byte
+    end
+  end
 end

data/lib/red_quilt/lint_pass.rb

@@ -22,7 +22,7 @@ module RedQuilt
       walk(@document.root_id) do |id|
         case @arena.type(id)
         when NodeType::HEADING
-          level = @arena.int1(id)
+          level = @arena.heading_level(id)
           if last_heading_level.positive? && level > last_heading_level + 1
             push(:info, :heading_level_skip,
                  "Heading jumps from h#{last_heading_level} to h#{level}",
@@ -45,7 +45,7 @@ module RedQuilt
     end
 
     def check_empty_link(node_id)
-      return unless @arena.str1(node_id).to_s.empty?
+      return unless @arena.link_destination(node_id).to_s.empty?
 
       push(:warning, :empty_link,
            "Link has no destination",

data/lib/red_quilt/node_ref.rb

@@ -46,6 +46,13 @@ module RedQuilt
       text
     end
 
+    # Returns the fence info string of a CODE_BLOCK node.
+    def info
+      return "" unless @arena.type(@node_id) == NodeType::CODE_BLOCK
+
+      @arena.code_block_info(@node_id).to_s
+    end
+
     def source_span
       @arena.source_span(@node_id)
     end
@@ -86,26 +93,28 @@ module RedQuilt
     def ast_attributes
       case @arena.type(@node_id)
       when NodeType::HEADING
-        { level: @arena.int1(@node_id), text: text }
+        { level: @arena.heading_level(@node_id), text: text }
       when NodeType::LIST
         {
-          ordered: @arena.int1(@node_id) == 1,
-          start_number: @arena.int2(@node_id),
-          tight: @arena.int3(@node_id) == 1,
-          delimiter: @arena.str1(@node_id),
+          ordered: @arena.list_ordered?(@node_id),
+          start_number: @arena.list_start(@node_id),
+          tight: @arena.list_tight?(@node_id),
+          delimiter: @arena.list_delimiter(@node_id),
         }
-      when NodeType::TABLE_ROW, NodeType::TABLE_CELL
-        { header: @arena.int1(@node_id) == 1, text: text }
+      when NodeType::TABLE_ROW
+        { header: @arena.table_row_header?(@node_id), text: text }
+      when NodeType::TABLE_CELL
+        { header: @arena.table_cell_header?(@node_id), text: text }
       when NodeType::TEXT, NodeType::CODE_SPAN, NodeType::HTML_BLOCK, NodeType::HTML_INLINE, NodeType::PARAGRAPH
         { text: text }
       when NodeType::CODE_BLOCK
-        { text: @arena.text(@node_id), info: @arena.str2(@node_id) }
+        { text: @arena.text(@node_id), info: @arena.code_block_info(@node_id) }
       when NodeType::LINK, NodeType::IMAGE
-        { destination: @arena.str1(@node_id), title: @arena.str2(@node_id), text: text }
+        { destination: @arena.link_destination(@node_id), title: @arena.link_title(@node_id), text: text }
       when NodeType::FOOTNOTE_REFERENCE
-        { label: @arena.str1(@node_id), number: @arena.int1(@node_id) }
+        { label: @arena.footnote_label(@node_id), number: @arena.footnote_number(@node_id) }
       when NodeType::FOOTNOTE_DEFINITION
-        { label: @arena.str1(@node_id) }
+        { label: @arena.footnote_label(@node_id) }
       else
         {}
       end

data/lib/red_quilt/renderer/html.rb

@@ -3,11 +3,12 @@
 module RedQuilt
   module Renderer
     class HTML
-      def initialize(document, heading_ids: false)
+      def initialize(document, heading_ids: false, mermaid: false)
         @document = document
         @arena = document.arena
         @out = +""
         @slugger = Slug::Counter.new if heading_ids
+        @mermaid = mermaid
       end
 
       def render
@@ -15,6 +16,18 @@ module RedQuilt
         @out
       end
 
+      # Renders the given nodes (an Array of NodeRef) in order and returns
+      # the resulting HTML fragment, without affecting the main render
+      # output.
+      def render_fragment(nodes)
+        saved = @out
+        @out = +""
+        nodes.each { |node| render_node(node.node_id) }
+        @out
+      ensure
+        @out = saved
+      end
+
       private
 
       # CommonMark-compliant HTML escape: only `&`, `<`, `>`, `"` are
@@ -45,7 +58,7 @@ module RedQuilt
           render_children(node_id)
           @out << "</p>\n"
         when NodeType::HEADING
-          level = @arena.int1(node_id)
+          level = @arena.heading_level(node_id)
           if @slugger
             id = @slugger.generate(PlainText.from(@arena, node_id))
             @out << %(<h#{level} id="#{escape_html(id)}">)
@@ -61,9 +74,9 @@ module RedQuilt
           render_children(node_id)
           @out << "</blockquote>\n"
         when NodeType::LIST
-          ordered = @arena.int1(node_id) == 1
+          ordered = @arena.list_ordered?(node_id)
           tag = ordered ? "ol" : "ul"
-          start_number = @arena.int2(node_id)
+          start_number = @arena.list_start(node_id)
           attrs = ordered && start_number != 1 ? %( start="#{start_number}") : ""
           @out << "<#{tag}#{attrs}>\n"
           render_children(node_id)
@@ -73,12 +86,21 @@ module RedQuilt
           render_list_item(node_id)
           @out << "</li>\n"
         when NodeType::CODE_BLOCK
-          @out << "<pre><code"
-          info_word = @arena.str2(node_id).to_s.split.first.to_s
-          @out << %( class="language-#{escape_html(info_word)}") unless info_word.empty?
-          @out << ">"
-          @out << escape_html(@arena.text(node_id).to_s)
-          @out << "</code></pre>\n"
+          info_word = @arena.code_block_info(node_id).to_s.split.first.to_s
+          if @mermaid && info_word == "mermaid"
+            # Emit a container mermaid.js recognizes via class="mermaid".
+            # The diagram source is still HTML-escaped; the browser decodes
+            # the entities back into textContent, which is what mermaid reads.
+            @out << %(<pre class="mermaid">)
+            @out << escape_html(@arena.text(node_id).to_s)
+            @out << "</pre>\n"
+          else
+            @out << "<pre><code"
+            @out << %( class="language-#{escape_html(info_word)}") unless info_word.empty?
+            @out << ">"
+            @out << escape_html(@arena.text(node_id).to_s)
+            @out << "</code></pre>\n"
+          end
         when NodeType::HTML_BLOCK
           render_raw_html(@arena.text(node_id).to_s, block: true)
         when NodeType::TABLE
@@ -106,7 +128,7 @@ module RedQuilt
         when NodeType::CODE_SPAN
           @out << "<code>#{escape_html(@arena.text(node_id).to_s)}</code>"
         when NodeType::LINK
-          dest = escape_html(@arena.str1(node_id).to_s)
+          dest = escape_html(@arena.link_destination(node_id).to_s)
           @out << %(<a href="#{dest}")
           append_title_attribute(node_id)
           @out << ">"
@@ -114,7 +136,7 @@ module RedQuilt
           @out << "</a>"
         when NodeType::IMAGE
           alt = PlainText.from(@arena, node_id)
-          dest = escape_html(@arena.str1(node_id).to_s)
+          dest = escape_html(@arena.link_destination(node_id).to_s)
           @out << %(<img src="#{dest}" alt="#{escape_html(alt)}")
           append_title_attribute(node_id)
           @out << " />"
@@ -131,10 +153,11 @@ module RedQuilt
       # element ids use the footnote number; a second+ reference to the
       # same footnote gets a `-M` suffix so each backref has a unique target.
       def render_footnote_reference(node_id)
-        number = @arena.int1(node_id)
-        occurrence = @arena.int2(node_id)
-        ref_id = occurrence > 1 ? "fnref-#{number}-#{occurrence}" : "fnref-#{number}"
-        @out << %(<sup><a href="#fn-#{number}" id="#{ref_id}">#{number}</a></sup>)
+        number = @arena.footnote_number(node_id)
+        occurrence = @arena.footnote_occurrence(node_id)
+        ref_id = FootnoteAnchors.reference_id(number, occurrence)
+        def_id = FootnoteAnchors.definition_id(number)
+        @out << %(<sup><a href="##{def_id}" id="#{ref_id}">#{number}</a></sup>)
       end
 
       def render_footnotes_section(node_id)
@@ -144,10 +167,9 @@ module RedQuilt
       end
 
       def render_footnote_definition(def_id)
-        label = @arena.str1(def_id).to_s
-        number = @document.footnotes.number(label)
-        occurrences = @document.footnotes.occurrences(label)
-        @out << %(<li id="fn-#{number}">\n)
+        number = @arena.footnote_number(def_id)
+        occurrences = @arena.footnote_total_references(def_id)
+        @out << %(<li id="#{FootnoteAnchors.definition_id(number)}">\n)
 
         # Append the backref(s) inside the definition's last paragraph (GFM);
         # if the last block isn't a paragraph, emit a standalone one.
@@ -174,7 +196,7 @@ module RedQuilt
       def footnote_backrefs(number, occurrences)
         out = +""
         (1..occurrences).each do |occ|
-          ref_id = occ > 1 ? "fnref-#{number}-#{occ}" : "fnref-#{number}"
+          ref_id = FootnoteAnchors.reference_id(number, occ)
           suffix = occ > 1 ? "<sup>#{occ}</sup>" : ""
           out << %( <a href="##{ref_id}">&#8617;#{suffix}</a>)
         end
@@ -183,8 +205,8 @@ module RedQuilt
 
       def render_table(table_id)
         rows = @arena.child_ids(table_id).to_a
-        header_rows = rows.select { |row_id| @arena.int1(row_id) == 1 }
-        body_rows = rows.reject { |row_id| @arena.int1(row_id) == 1 }
+        header_rows = rows.select { |row_id| @arena.table_row_header?(row_id) }
+        body_rows = rows.reject { |row_id| @arena.table_row_header?(row_id) }
 
         unless header_rows.empty?
           @out << "<thead>\n"
@@ -200,7 +222,7 @@ module RedQuilt
 
       def render_list_item(node_id)
         parent_id = @arena.raw_parent_id(node_id)
-        tight = parent_id != -1 && @arena.type(parent_id) == NodeType::LIST && @arena.int3(parent_id) == 1
+        tight = parent_id != -1 && @arena.type(parent_id) == NodeType::LIST && @arena.list_tight?(parent_id)
 
         first_child_id = @arena.raw_first_child_id(node_id)
         first_is_para = first_child_id != -1 &&
@@ -239,7 +261,7 @@ module RedQuilt
       def render_table_row(row_id)
         @out << "<tr>"
         @arena.each_child(row_id) do |cell_id|
-          tag = @arena.int1(cell_id) == 1 ? "th" : "td"
+          tag = @arena.table_cell_header?(cell_id) ? "th" : "td"
           @out << "<#{tag}>"
           render_children(cell_id)
           @out << "</#{tag}>"
@@ -275,7 +297,7 @@ module RedQuilt
       end
 
       def append_title_attribute(node_id)
-        title = @arena.str2(node_id).to_s
+        title = @arena.link_title(node_id).to_s
         return if title.empty?
 
         @out << %( title="#{escape_html(title)}")

data/lib/red_quilt/renderer/mdast.rb

@@ -57,19 +57,19 @@ module RedQuilt
 
         case type_int
         when NodeType::HEADING
-          result["depth"] = @arena.int1(node_id)
+          result["depth"] = @arena.heading_level(node_id)
           result["children"] = children(node_id)
         when NodeType::LIST
-          result["ordered"] = @arena.int1(node_id) == 1
-          tight = @arena.int3(node_id) == 1
-          result["start"] = @arena.int2(node_id) if result["ordered"]
+          result["ordered"] = @arena.list_ordered?(node_id)
+          tight = @arena.list_tight?(node_id)
+          result["start"] = @arena.list_start(node_id) if result["ordered"]
           result["spread"] = !tight
           result["children"] = children(node_id, parent_spread: !tight)
         when NodeType::LIST_ITEM
           result["spread"] = parent_spread
           result["children"] = children(node_id)
         when NodeType::CODE_BLOCK
-          info = @arena.str2(node_id)
+          info = @arena.code_block_info(node_id)
           lang = info && !info.empty? ? info.split.first : nil
           result["lang"] = lang
           result["value"] = @arena.text(node_id).to_s
@@ -81,21 +81,21 @@ module RedQuilt
         when NodeType::CODE_SPAN
           result["value"] = @arena.text(node_id).to_s
         when NodeType::LINK
-          result["url"] = @arena.str1(node_id).to_s
-          title = @arena.str2(node_id)
+          result["url"] = @arena.link_destination(node_id).to_s
+          title = @arena.link_title(node_id)
           result["title"] = title && !title.empty? ? title : nil
           result["children"] = children(node_id)
         when NodeType::IMAGE
-          result["url"] = @arena.str1(node_id).to_s
-          title = @arena.str2(node_id)
+          result["url"] = @arena.link_destination(node_id).to_s
+          title = @arena.link_title(node_id)
           result["title"] = title && !title.empty? ? title : nil
           result["alt"] = NodeRef.new(@document, node_id).text.to_s
         when NodeType::FOOTNOTE_REFERENCE
-          label = @arena.str1(node_id).to_s
+          label = @arena.footnote_label(node_id).to_s
           result["identifier"] = label
           result["label"] = label
         when NodeType::FOOTNOTE_DEFINITION
-          label = @arena.str1(node_id).to_s
+          label = @arena.footnote_label(node_id).to_s
           result["identifier"] = label
           result["label"] = label
           result["children"] = children(node_id)

data/lib/red_quilt/table.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module RedQuilt
+  # GFM table detection (spec 4.10). Pure functions over line text: whether
+  # a line could be a table row and whether a header+delimiter pair starts a
+  # table. Cell splitting lives here too so the recognition rules and the
+  # splitting rules they depend on stay together. Node construction stays in
+  # BlockParser.
+  module Table
+    module_function
+
+    # True when lines[index] / lines[index+1] form a header + delimiter pair
+    # that starts a GFM table.
+    def start?(lines, index)
+      return false if index + 1 >= lines.length
+      return false unless row?(lines[index].content)
+
+      header_cells = split_row(lines[index].content)
+      separators = split_row(lines[index + 1].content)
+      return false if separators.empty?
+
+      # GFM spec: separator row must have valid delimiters AND match header column count.
+      # "The header row must match the delimiter row in the number of cells.
+      #  If not, a table will not be recognized."
+      return false unless header_cells.length == separators.length
+
+      separators.all? { |cell| cell.strip.match?(/\A:?-+:?\z/) }
+    end
+
+    def row?(text)
+      text.include?("|")
+    end
+
+    def split_row(text)
+      body = text.strip
+      body = body[1..] if body.start_with?("|")
+      body = body[0...-1] if body.end_with?("|")
+      body.split("|", -1)
+    end
+
+    # Cached collaborator for BlockParser. A single instance is created in
+    # BlockParser#initialize and reused; per-call state lives in method
+    # locals so reentrant calls are safe.
+    class Parser
+      def initialize(block_parser)
+        @arena = block_parser.arena
+      end
+
+      # Parses the table starting at lines[index] (already confirmed by
+      # Table.start?). Returns the index past the table.
+      def parse(parent_id, lines, index)
+        start_index = index
+        header_cells = Table.split_row(lines[index].content)
+        row_lines = [lines[index]]
+        index += 2
+        while index < lines.length
+          break if lines[index].blank
+          break unless Table.row?(lines[index].content)
+
+          row_lines << lines[index]
+          index += 1
+        end
+
+        table_id = @arena.add_node(NodeType::TABLE,
+                                   source_start: lines[start_index].start_byte,
+                                   source_len: row_lines.last.end_byte - lines[start_index].start_byte)
+        @arena.append_child(parent_id, table_id)
+
+        append_row(table_id, lines[start_index], header_cells, true)
+        row_lines.drop(1).each do |row_line|
+          append_row(table_id, row_line, Table.split_row(row_line.content), false)
+        end
+
+        index
+      end
+
+      private
+
+      def append_row(table_id, line, cells, header)
+        row_id = @arena.add_node(NodeType::TABLE_ROW,
+                                 source_start: line.start_byte,
+                                 source_len: line.span_len,
+                                 int1: header ? 1 : 0)
+        @arena.append_child(table_id, row_id)
+        cells.each do |cell_text|
+          stripped = cell_text.strip
+          cell_id = @arena.add_node(NodeType::TABLE_CELL,
+                                    source_start: line.start_byte,
+                                    source_len: line.span_len,
+                                    int1: header ? 1 : 0,
+                                    str1: stripped)
+          @arena.append_child(row_id, cell_id)
+        end
+      end
+    end
+  end
+end

data/lib/red_quilt/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RedQuilt
-  VERSION = "0.7.1"
+  VERSION = "0.8.0"
 end