{} use protected markers that are preserved
+ # unless join_lines_by_lang is explicitly enabled
+ content = if config['join_lines_by_lang']
+ content.tr("\n", ' ')
+ else
+ content.delete("\n")
+ end
+
+ # Handle noindent attribute
+ if node.attribute?(:noindent)
+ return %Q(#{content}
)
+ end
+
+ # Check for tab indentation (inlist attribute)
+ if content =~ /\A(\t+)/
+ indent_level = $1.size
+ content_without_tabs = content.sub(/\A\t+/, '')
+ return %Q(#{content_without_tabs}
)
+ end
+
+ # Regular paragraph
+ "#{content}
"
+ end
+
+ def visit_text(node)
+ escape(node.content.to_s)
+ end
+
+ def visit_reference(node)
+ if node.resolved?
+ format_resolved_reference(node.resolved_data)
+ else
+ # Reference resolution was skipped or disabled
+ # Return content as fallback
+ node.content || ''
+ end
+ end
+
+ # Format resolved reference based on ResolvedData
+ # Uses TextFormatter for centralized text formatting
+ def format_resolved_reference(data)
+ plain_text = text_formatter.format_reference(data.reference_type, data)
+ # IDGXML is XML-based, so escape all text content
+ escape_html(plain_text)
+ end
+
+ def visit_list(node)
+ case node.list_type
+ when :ul
+ visit_ul(node)
+ when :ol
+ visit_ol(node)
+ when :dl
+ visit_dl(node)
+ else
+ raise NotImplementedError, "IdgxmlRenderer does not support list_type #{node.list_type}"
+ end
+ end
+
+ def visit_list_item(node)
+ # Should not be called directly; handled by parent list
+ raise NotImplementedError, 'List item processing should be handled by visit_list'
+ end
+
+ # visit_code_block is now handled by Base renderer with dynamic method dispatch
+ # Aliases will be defined after the original methods
+
+ def visit_code_line(node)
+ # Render children and detab
+ content = render_children(node)
+ detab(content, tabwidth)
+ end
+
+ def visit_table(node)
+ # Handle imgtable specially
+ if node.table_type == :imgtable
+ return visit_imgtable(node)
+ end
+
+ # Regular table processing
+ visit_regular_table(node)
+ end
+
+ def visit_table_row(node)
+ # Should be handled by visit_table
+ raise NotImplementedError, 'Table row processing should be handled by visit_table'
+ end
+
+ def visit_table_cell(node)
+ # Should be handled by visit_table
+ raise NotImplementedError, 'Table cell processing should be handled by visit_table'
+ end
+
+ def visit_image(node)
+ image_type = node.image_type
+
+ case image_type
+ when :indepimage, :numberlessimage
+ visit_indepimage(node)
+ else
+ visit_regular_image(node)
+ end
+ end
+
+ def visit_minicolumn(node)
+ type = node.minicolumn_type.to_s
+ caption = render_children(node.caption_node) if node.caption_node
+ content = render_children(node)
+
+ # notice uses -t suffix when caption is present
+ if type == 'notice' && caption && !caption.empty?
+ captionblock_with_content('notice-t', content, caption, 'notice-title')
+ else
+ # Content already contains tags from paragraphs
+ captionblock_with_content(type, content, caption)
+ end
+ end
+
+ def visit_column(node)
+ caption = render_children(node.caption_node) if node.caption_node
+ content = render_children(node)
+
+ # Determine column type (empty string for regular column)
+ type = ''
+
+ # Generate column output using auto_id from Compiler
+ id_attr = %Q(id="#{node.auto_id}")
+
+ result = []
+ result << "<#{type}column #{id_attr}>"
+ if caption
+ result << %Q(
#{caption} )
+ end
+ result << content.chomp
+ result << ""
+
+ result.join("\n") + "\n"
+ end
+
+ # visit_block is now handled by Base renderer with dynamic method dispatch
+ # Individual block type visitors
+
+ def visit_block_quote(node)
+ content = render_children(node)
+ "#{content}
\n"
+ end
+
+ def visit_block_lead(node)
+ content = render_children(node)
+ "#{content} \n"
+ end
+
+ def visit_block_read(node)
+ content = render_children(node)
+ "#{content} \n"
+ end
+
+ def visit_block_note(node)
+ caption = node.args.first
+ content = render_children(node)
+ captionblock('note', content, caption)
+ end
+
+ def visit_block_memo(node)
+ caption = node.args.first
+ content = render_children(node)
+ captionblock('memo', content, caption)
+ end
+
+ def visit_block_tip(node)
+ caption = node.args.first
+ content = render_children(node)
+ captionblock('tip', content, caption)
+ end
+
+ def visit_block_info(node)
+ caption = node.args.first
+ content = render_children(node)
+ captionblock('info', content, caption)
+ end
+
+ def visit_block_warning(node)
+ caption = node.args.first
+ content = render_children(node)
+ captionblock('warning', content, caption)
+ end
+
+ def visit_block_important(node)
+ caption = node.args.first
+ content = render_children(node)
+ captionblock('important', content, caption)
+ end
+
+ def visit_block_caution(node)
+ caption = node.args.first
+ content = render_children(node)
+ captionblock('caution', content, caption)
+ end
+
+ def visit_block_planning(node)
+ caption = node.args.first
+ content = render_children(node)
+ captionblock('planning', content, caption)
+ end
+
+ def visit_block_best(node)
+ caption = node.args.first
+ content = render_children(node)
+ captionblock('best', content, caption)
+ end
+
+ def visit_block_security(node)
+ caption = node.args.first
+ content = render_children(node)
+ captionblock('security', content, caption)
+ end
+
+ def visit_block_reference(node)
+ caption = node.args.first
+ content = render_children(node)
+ captionblock('reference', content, caption)
+ end
+
+ def visit_block_link(node)
+ caption = node.args.first
+ content = render_children(node)
+ captionblock('link', content, caption)
+ end
+
+ def visit_block_practice(node)
+ caption = node.args.first
+ content = render_children(node)
+ captionblock('practice', content, caption)
+ end
+
+ def visit_block_expert(node)
+ caption = node.args.first
+ content = render_children(node)
+ captionblock('expert', content, caption)
+ end
+
+ def visit_block_point(node)
+ caption = node.args.first
+ content = render_block_content_with_paragraphs(node)
+ if caption && !caption.empty? && node.caption_node
+ caption_with_inline = render_caption_inline(node.caption_node)
+ captionblock_with_content('point-t', content, caption_with_inline, 'point-title')
+ else
+ captionblock_with_content('point', content, nil)
+ end
+ end
+
+ def visit_block_shoot(node)
+ caption = node.args.first
+ content = render_block_content_with_paragraphs(node)
+ if caption && !caption.empty? && node.caption_node
+ caption_with_inline = render_caption_inline(node.caption_node)
+ captionblock_with_content('shoot-t', content, caption_with_inline, 'shoot-title')
+ else
+ captionblock_with_content('shoot', content, nil)
+ end
+ end
+
+ def visit_block_notice(node)
+ caption = node.args.first
+ content = render_block_content_with_paragraphs(node)
+ if caption && !caption.empty? && node.caption_node
+ caption_with_inline = render_caption_inline(node.caption_node)
+ captionblock_with_content('notice-t', content, caption_with_inline, 'notice-title')
+ else
+ captionblock_with_content('notice', content, nil)
+ end
+ end
+
+ def visit_block_term(node)
+ content = render_block_content_with_paragraphs(node)
+ captionblock_with_content('term', content, nil)
+ end
+
+ def visit_block_insn(node)
+ visit_syntaxblock(node)
+ end
+
+ def visit_block_box(node)
+ visit_syntaxblock(node)
+ end
+
+ def visit_block_flushright(node)
+ content = render_children(node)
+ content.gsub('', %Q(
)) + "\n"
+ end
+
+ def visit_block_centering(node)
+ content = render_children(node)
+ content.gsub('
', %Q(
)) + "\n"
+ end
+
+ def visit_block_rawblock(node)
+ visit_rawblock(node)
+ end
+
+ def visit_block_comment(node)
+ visit_comment_block(node)
+ end
+
+ def visit_block_noindent(_node)
+ ''
+ end
+
+ def visit_block_blankline(_node)
+ "
\n"
+ end
+
+ def visit_block_pagebreak(_node)
+ "#{content.chomp} \n)
+ end
+
+ def visit_block_printendnotes(node)
+ visit_printendnotes(node)
+ end
+
+ def visit_block_bibpaper(node)
+ visit_bibpaper(node)
+ end
+
+ def visit_block_olnum(_node)
+ ''
+ end
+
+ def visit_block_tsize(_node)
+ # tsize is now processed by TsizeProcessor during AST compilation
+ ''
+ end
+
+ def visit_block_graph(node)
+ visit_graph(node)
+ end
+
+ def visit_block_beginchild(node)
+ visit_beginchild(node)
+ end
+
+ def visit_block_endchild(node)
+ visit_endchild(node)
+ end
+
+ def visit_beginchild(_node)
+ ''
+ end
+
+ def visit_endchild(_node)
+ ''
+ end
+
+ def visit_graph(node)
+ # Graph block generates an image file and then renders it as an image
+ # Args: [id, command, caption]
+ id = node.args[0]
+ command = node.args[1]
+
+ # Get graph content from child TextNodes
+ content = node.children.map { |child| child.is_a?(ReVIEW::AST::TextNode) ? child.content : '' }.join("\n")
+ content += "\n" unless content.empty?
+
+ # Initialize ImgGraph if needed and command is mermaid
+ if command == 'mermaid'
+ begin
+ require 'playwrightrunner'
+ unless @img_graph
+ require 'review/img_graph'
+ @img_graph = ReVIEW::ImgGraph.new(config, 'idgxml')
+ end
+ # Defer mermaid image generation
+ file_path = @img_graph.defer_mermaid_image(content, id)
+ rescue LoadError
+ # Playwright not available, skip graph generation
+ # But we still need a file path for rendering
+ c = 'idgxml'
+ dir = File.join(@book.imagedir, c)
+ file_path = File.join(dir, "#{id}.pdf")
+ end
+ else
+ # For other graph types, generate directly
+ c = 'idgxml' # target_name
+ dir = File.join(@book.imagedir, c)
+ FileUtils.mkdir_p(dir) unless File.directory?(dir)
+
+ # Determine image extension based on format
+ image_ext = 'pdf' # IDGXML typically uses PDF
+ file = "#{id}.#{image_ext}"
+ file_path = File.join(dir, file)
+
+ # Create temporary file and generate graph
+ require 'tempfile'
+ tf = Tempfile.new('review_graph')
+ tf.puts content
+ tf.close
+
+ begin
+ if command == 'graphviz' || command == 'dot'
+ system_graph_graphviz(id, file_path, tf.path)
+ elsif command == 'gnuplot'
+ system_graph_gnuplot(id, file_path, content, tf.path)
+ elsif command == 'blockdiag'
+ system_graph_blockdiag(id, file_path, tf.path, 'blockdiag')
+ elsif command == 'seqdiag'
+ system_graph_blockdiag(id, file_path, tf.path, 'seqdiag')
+ elsif command == 'actdiag'
+ system_graph_blockdiag(id, file_path, tf.path, 'actdiag')
+ elsif command == 'nwdiag'
+ system_graph_blockdiag(id, file_path, tf.path, 'nwdiag')
+ end
+ ensure
+ tf.unlink
+ end
+ end
+
+ # Add the generated file to the image index
+ @chapter.image_index.image_finder.add_entry(file_path) if @chapter.image_index
+
+ # Now render as a regular numbered image
+ # Use caption_node to render inline elements
+ caption_content = node.caption_node ? render_caption_inline(node.caption_node) : nil
+
+ result = []
+ result << ''
+
+ endnotes.each do |endnote_item|
+ id = endnote_item.id
+ number = endnote_item.number
+ # Use footnote_node.children if available to avoid re-parsing
+ content = if endnote_item.footnote_node?
+ endnote_item.footnote_node.children.map { |child| visit(child) }.join
+ else
+ render_caption_inline(endnote_item.content)
+ end
+ result << %Q((#{number}) \t#{content} '
+ # Protect newlines inside endnotes block from nolf processing
+ result.join("\x01IDGXML_ENDNOTE_NEWLINE\x01") + "\x01IDGXML_ENDNOTE_NEWLINE\x01"
+ end
+
+ def visit_bibpaper(node)
+ args = node.args || []
+ raise NotImplementedError, 'Malformed bibpaper block: insufficient arguments' if args.length < 2
+
+ bib_id = args[0]
+
+ result = []
+ result << %Q()
+
+ if node.caption_node
+ # Use caption_node to render inline elements
+ caption_inline = render_caption_inline(node.caption_node)
+ bib_number = resolve_bibpaper_number(bib_id)
+ result << %Q([#{bib_number}] #{caption_inline} tag like Builder does with split_paragraph
+ content = content.strip
+ result << "
#{content}
"
+ end
+
+ result << " \n"
+ result.join("\n")
+ end
+
+ def visit_tex_equation(node)
+ @texblockequation += 1
+ content = node.content
+
+ result = []
+
+ if node.id?
+ result << ''
+
+ # Render caption with inline elements
+ caption_node = node.caption_node
+ rendered_caption = caption_node ? render_children(caption_node) : ''
+
+ # Generate caption
+ caption_str = %Q(#{text_formatter.format_caption_plain('equation', get_chap, @chapter.equation(node.id).number, rendered_caption)} )
+
+ result << caption_str if caption_top?('equation')
+ end
+
+ # Handle math format
+ if config['math_format'] == 'imgmath'
+ # Initialize ImgMath if needed
+ unless @img_math
+ require 'review/img_math'
+ @img_math = ReVIEW::ImgMath.new(config)
+ end
+
+ fontsize = config.dig('imgmath_options', 'fontsize').to_f
+ lineheight = config.dig('imgmath_options', 'lineheight').to_f
+ math_str = "\\begin{equation*}\n\\fontsize{#{fontsize}}{#{lineheight}}\\selectfont\n#{content}\n\\end{equation*}\n"
+ key = Digest::SHA256.hexdigest(math_str)
+ img_path = @img_math.defer_math_image(math_str, key)
+ result << ''
+ result << %Q( '
+ else
+ result << %Q(#{content} '
+ end
+
+ result.join("\n") + "\n"
+ end
+
+ def visit_embed(node)
+ # All embed types now use unified processing
+ process_raw_embed(node)
+ end
+
+ def visit_footnote(_node)
+ # FootnoteNode is not rendered directly - it's just a definition
+ # The actual footnote output is generated by @{id} inline element
+ # Return empty string to indicate no output for this definition block
+ ''
+ end
+
+ def render_list(node, list_type)
+ tag_name = list_tag_name(node, list_type)
+
+ body = case list_type
+ when :ul
+ render_unordered_items(node)
+ when :ol
+ render_ordered_items(node)
+ when :dl
+ render_definition_items(node)
+ else
+ raise NotImplementedError, "IdgxmlRenderer does not support list_type #{list_type}"
+ end
+
+ "<#{tag_name}>#{body}"
+ end
+
+ def list_tag_name(node, list_type)
+ levels = node.children&.map { |item| item.respond_to?(:level) ? item.level : nil }&.compact
+ max_level = levels&.max || 1
+ max_level > 1 ? "#{list_type}#{max_level}" : list_type.to_s
+ end
+
+ def render_unordered_items(node)
+ node.children.map { |item| render_unordered_item(item) }.join
+ end
+
+ def render_unordered_item(item)
+ content = render_list_item_body(item)
+ %Q(#{content} )
+ end
+
+ def render_ordered_items(node)
+ # num attribute: display number from source (start_number or item.number)
+ # olnum attribute: InDesign's internal counter (set by OlnumProcessor)
+ #
+ # OlnumProcessor analyzes the list during AST compilation and sets:
+ # - start_number: the first item's display number
+ # - olnum_start: the starting value for InDesign's counter
+ # - For //olnum[N] directive: olnum_start = N
+ # - For explicit numbering: olnum_start = 1
+
+ start_number = node.start_number || 1
+ current_number = start_number
+ current_olnum = node.olnum_start || 1
+
+ items = node.children.map do |item|
+ # num: the display number (from source or calculated)
+ display_number = item.respond_to?(:number) && item.number ? item.number : current_number
+
+ content = render_list_item_body(item)
+ rendered = %Q(#{content} )
+ current_number += 1
+ current_olnum += 1
+ rendered
+ end
+
+ items.join
+ end
+
+ def render_definition_items(node)
+ node.children.map { |item| render_definition_item(item) }.join
+ end
+
+ def render_definition_item(item)
+ term_content = render_inline_nodes(item.term_children)
+
+ # Definition content handling:
+ # - Initial inline content (paragraphs) are joined together without tags
+ # - Block elements (lists) are rendered as-is
+ # - Paragraphs after block elements are wrapped in
tags
+ definition_parts = []
+ has_block_element = false
+
+ item.children.each do |child|
+ if child.is_a?(ReVIEW::AST::ParagraphNode)
+ # Render paragraph content
+ content = render_children(child)
+ # Join lines in paragraph by removing newlines (like join_lines in Builder)
+ content = if config['join_lines_by_lang']
+ content.tr("\n", ' ')
+ else
+ content.delete("\n")
+ end
+
+ definition_parts << if has_block_element
+ # After a block element, wrap paragraphs in
tags
+ "
#{content}
"
+ else
+ # Initial paragraphs are not wrapped
+ content
+ end
+ else
+ # Block element (list, etc.)
+ definition_parts << visit(child)
+ has_block_element = true
+ end
+ end
+
+ definition_content = definition_parts.join
+
+ if definition_content.empty?
+ %Q(#{term_content} #{term_content} #{definition_content} )
+ end
+ end
+
+ def render_list_item_body(item)
+ parts = []
+ inline_buffer = []
+
+ item.children.each do |child|
+ if inline_node?(child)
+ inline_buffer << visit(child)
+ else
+ unless inline_buffer.empty?
+ parts << format_inline_buffer(inline_buffer)
+ inline_buffer.clear
+ end
+ parts << visit(child)
+ end
+ end
+
+ parts << format_inline_buffer(inline_buffer) unless inline_buffer.empty?
+ content = parts.compact.join
+ content.end_with?("\n") ? content.chomp : content
+ end
+
+ def ast_compiler
+ @ast_compiler ||= ReVIEW::AST::Compiler.for_chapter(@chapter)
+ end
+
+ def render_inline_element(type, content, node)
+ # Delegate to inline element handler
+ method_name = "render_inline_#{type}"
+ if @inline_element_handler.respond_to?(method_name, true)
+ @inline_element_handler.send(method_name, type, content, node)
+ else
+ raise NotImplementedError, "Unknown inline element: #{type}"
+ end
+ end
+
+ # Helpers
+
+ def get_chap(chapter = @chapter)
+ if config['secnolevel'] && config['secnolevel'] > 0 &&
+ !chapter.number.nil? && !chapter.number.to_s.empty?
+ if chapter.is_a?(ReVIEW::Book::Part)
+ return text_formatter.format_part_short(chapter)
+ else
+ return chapter.format_number(nil)
+ end
+ end
+ nil
+ end
+
+ def over_secnolevel?(n)
+ secnolevel = config['secnolevel'] || 2
+ secnolevel >= n.to_s.split('.').size
+ end
+
+ # Render inline elements from caption_node
+ # @param caption_node [CaptionNode] Caption node to render
+ # @return [String] Rendered inline elements
+ def render_caption_inline(caption_node)
+ content = caption_node ? render_children(caption_node) : ''
+
+ if config['join_lines_by_lang']
+ content.gsub(/\n+/, ' ')
+ else
+ content.delete("\n")
+ end
+ end
+
+ # Escape for IDGXML (uses HTML escaping)
+ def escape(str)
+ escape_html(str.to_s)
+ end
+
+ private
+
+ def render_nodes(nodes)
+ return '' unless nodes && !nodes.empty?
+
+ nodes.map { |child| visit(child) }.join
+ end
+
+ def render_inline_nodes(nodes)
+ return '' unless nodes && !nodes.empty?
+
+ format_inline_buffer(nodes.map { |child| visit(child) })
+ end
+
+ def format_inline_buffer(buffer)
+ return '' if buffer.empty?
+
+ content = buffer.join("\n")
+ if config['join_lines_by_lang']
+ content.tr("\n", ' ')
+ else
+ content.delete("\n")
+ end
+ end
+
+ def inline_node?(node)
+ node.is_a?(ReVIEW::AST::TextNode) || node.is_a?(ReVIEW::AST::InlineNode)
+ end
+
+ # Close section tags based on level
+ def output_close_sect_tags(level)
+ return unless @secttags
+
+ closing_tags = []
+ closing_tags << '' if level <= 5 && @subsubsubsection > 0
+ closing_tags << '' if level <= 4 && @subsubsection > 0
+ closing_tags << '' if level <= 3 && @subsection > 0
+ closing_tags << '' if level <= 2 && @section > 0
+
+ closing_tags.join
+ end
+
+ # Get headline prefix
+ def headline_prefix(level)
+ return [nil, nil] unless @sec_counter
+
+ @sec_counter.inc(level)
+ anchor = @sec_counter.anchor(level)
+ prefix = @sec_counter.prefix(level, config['secnolevel'])
+ [prefix, anchor]
+ end
+
+ # Check caption position
+ def caption_top?(type)
+ config.dig('caption_position', type) == 'top'
+ end
+
+ # Handle metric for IDGXML
+ def handle_metric(str)
+ k, v = str.split('=', 2)
+ %Q(#{k}="#{v.sub(/\A["']/, '').sub(/["']\Z/, '')}")
+ end
+
+ def result_metric(array)
+ " #{array.join(' ')}"
+ end
+
+ # Captionblock helper for minicolumns
+ def captionblock(type, content, caption, specialstyle = nil)
+ result = []
+ result << "<#{type}>"
+ if caption && !caption.empty?
+ style = specialstyle || "#{type}-title"
+ result << %Q(#{caption} )
+ end
+ blocked_lines = split_paragraph_content(content)
+ result << blocked_lines.join.chomp
+ result << ""
+ result.join("\n") + "\n"
+ end
+
+ # Captionblock helper for content that already contains tags
+ def captionblock_with_content(type, content, caption, specialstyle = nil)
+ result = []
+ result << "<#{type}>"
+ if caption && !caption.empty?
+ style = specialstyle || "#{type}-title"
+ result << %Q(
#{caption} )
+ end
+ # Content already contains tags, use as-is
+ result << content.chomp
+ result << ""
+ result.join + "\n"
+ end
+
+ # Syntaxblock helper for special code blocks
+ def syntaxblock(type, content, caption)
+ result = []
+
+ captionstr = nil
+ if caption && !caption.empty?
+ titleopentag = %Q(caption aid:pstyle="#{type}-title")
+ titleclosetag = 'caption'
+ if type == 'insn'
+ titleopentag = %Q(floattitle type="insn")
+ titleclosetag = 'floattitle'
+ end
+ captionstr = %Q(<#{titleopentag}>#{caption})
+ end
+
+ result << "<#{type}>"
+ result << captionstr if caption_top?('list') && captionstr
+ result << content.chomp
+ result << captionstr if !caption_top?('list') && captionstr
+ result << ""
+
+ result.join("\n") + "\n"
+ end
+
+ # Split paragraph content (from TextUtils)
+ def split_paragraph_content(content)
+ # Split content by double newlines to create paragraphs
+ paragraphs = content.split(/\n\n+/)
+ paragraphs.map { |para| "
#{para.strip}
" }
+ end
+
+ # Render block content with paragraph grouping
+ # Used for point/shoot/notice/term blocks
+ def render_block_content_with_paragraphs(node)
+ # Render children directly - inline elements are already parsed during AST construction
+ render_children(node)
+ end
+
+ # Visit unordered list
+ def visit_ul(node)
+ render_list(node, :ul)
+ end
+
+ # Visit ordered list
+ def visit_ol(node)
+ render_list(node, :ol)
+ end
+
+ # Visit definition list
+ def visit_dl(node)
+ render_list(node, :dl)
+ end
+
+ # Visit list code block
+ def visit_code_block_list(node)
+ result = []
+ result << ''
+
+ # Generate caption if present
+ caption_content = nil
+ if node.caption_node && node.id?
+ caption_content = render_children(node.caption_node)
+ list_header_output = generate_list_header(node.id, caption_content)
+ result << list_header_output if caption_top?('list')
+ end
+
+ # Generate code content (already includes trailing newlines for each line)
+ code_content = generate_code_lines_body(node)
+ # Combine , code content, and in a single string
+ result << "#{code_content} "
+
+ # Add caption at bottom if configured
+ if caption_content && !caption_top?('list')
+ list_header_output = generate_list_header(node.id, caption_content)
+ result << list_header_output
+ end
+
+ result << ' '
+ # Join without newlines (nolf mode), then add final newline
+ result.join + "\n"
+ end
+
+ # Visit listnum code block
+ def visit_code_block_listnum(node)
+ result = []
+ result << ''
+
+ # Generate caption if present
+ caption_content = nil
+ if node.caption_node && node.id?
+ caption_content = render_children(node.caption_node)
+ list_header_output = generate_list_header(node.id, caption_content)
+ result << list_header_output if caption_top?('list')
+ end
+
+ # Generate code content with line numbers (already includes trailing newlines for each line)
+ code_content = generate_listnum_body(node)
+ # Combine , code content, and in a single string
+ result << "#{code_content} "
+
+ # Add caption at bottom if configured
+ if caption_content && !caption_top?('list')
+ list_header_output = generate_list_header(node.id, caption_content)
+ result << list_header_output
+ end
+
+ result << ' '
+ # Join without newlines (nolf mode), then add final newline
+ result.join + "\n"
+ end
+
+ # Visit emlist code block
+ def visit_code_block_emlist(node)
+ caption_content = node.caption_node ? render_children(node.caption_node) : nil
+ quotedlist(node, 'emlist', caption_content)
+ end
+
+ # Visit emlistnum code block
+ def visit_code_block_emlistnum(node)
+ caption_content = node.caption_node ? render_children(node.caption_node) : nil
+ quotedlist_with_linenum(node, 'emlistnum', caption_content)
+ end
+
+ # Visit cmd code block
+ def visit_code_block_cmd(node)
+ caption_content = node.caption_node ? render_children(node.caption_node) : nil
+ quotedlist(node, 'cmd', caption_content)
+ end
+
+ # Visit source code block
+ def visit_code_block_source(node)
+ result = []
+ result << ''
+
+ caption_content = node.caption_node ? render_children(node.caption_node) : nil
+ caption_content = nil if caption_content && caption_content.empty?
+
+ if caption_top?('list') && caption_content
+ result << %Q(#{caption_content} )
+ end
+
+ # Generate code content (already includes trailing newlines for each line)
+ code_content = generate_code_lines_body(node)
+ # Combine , code content, and in a single string
+ result << "#{code_content} "
+
+ if !caption_top?('list') && caption_content
+ result << %Q(#{caption_content} )
+ end
+
+ result << ' '
+ # Join without newlines (nolf mode), then add final newline
+ result.join + "\n"
+ end
+
+ # Generate list header like IDGXMLBuilder
+ def generate_list_header(id, caption)
+ return '' unless caption && !caption.empty?
+
+ %Q(#{text_formatter.format_caption_plain('list', get_chap, @chapter.list(id).number, caption)} )
+ end
+
+ # Generate code lines body like IDGXMLBuilder
+ def generate_code_lines_body(node)
+ lines = node.children.map { |line| visit(line) }
+
+ result = []
+ no = 1
+
+ lines.each do |line|
+ if config['listinfo']
+ line_output = %Q() + (i + first_line_num).to_s.rjust(2) + ': ' + line, tabwidth)
+
+ if config['listinfo']
+ line_output = %Q()
+
+ # Use present? like Builder to avoid empty caption tags
+ if caption_top?('list') && caption.present?
+ result << %Q(#{caption} )
+ end
+
+ # Generate code content (already includes trailing newlines for each line)
+ code_content = generate_code_lines_body(node)
+ # Combine , code content, and in a single string
+ # This matches IDGXMLBuilder behavior: print ''; print lines; puts ' '
+ result << "#{code_content} "
+
+ if !caption_top?('list') && caption.present?
+ result << %Q(#{caption} )
+ end
+
+ result << ''
+ # Join without newlines (nolf mode), then add final newline
+ result.join + "\n"
+ end
+
+ # Quotedlist with line numbers
+ def quotedlist_with_linenum(node, css_class, caption)
+ result = []
+ result << %Q()
+
+ # Use present? like Builder to avoid empty caption tags
+ if caption_top?('list') && caption.present?
+ result << %Q(#{caption} )
+ end
+
+ # Generate code content with line numbers (already includes trailing newlines for each line)
+ code_content = generate_listnum_body(node)
+ # Combine , code content, and in a single string
+ result << "#{code_content} "
+
+ if !caption_top?('list') && caption.present?
+ result << %Q(#{caption} )
+ end
+
+ result << '
'
+ # Join without newlines (nolf mode), then add final newline
+ result.join + "\n"
+ end
+
+ # Visit regular table
+ def visit_regular_table(node)
+ @tablewidth = nil
+ if config['tableopt']
+ pt_unit = config['pt_to_mm_unit']
+ pt_unit = pt_unit.to_f if pt_unit
+ pt_unit = 1.0 if pt_unit.nil? || pt_unit == 0
+ @tablewidth = config['tableopt'].split(',')[0].to_f / pt_unit
+ end
+ @col = 0
+
+ # Parse table rows
+ all_rows = node.header_rows + node.body_rows
+ rows_data = parse_table_rows_from_ast(all_rows)
+
+ result = []
+ result << ''
+
+ caption_content = node.caption_node ? render_children(node.caption_node) : nil
+
+ # Caption at top if configured
+ if caption_top?('table') && caption_content
+ result << generate_table_header(node.id, caption_content)
+ end
+
+ # Generate tbody
+ result << if @tablewidth.nil?
+ ''
+ else
+ %Q( )
+ end
+
+ @table_id = node.id
+
+ # Get cellwidth from TableNode (set by TsizeProcessor) for use in generate_table_rows
+ # This is a raw array of width specifications (e.g., ["10", "20", "30"] for simple format)
+ @table_node_cellwidth = node.cellwidth
+
+ result << generate_table_rows(rows_data, node.header_rows.length)
+
+ result << ' '
+
+ # Caption at bottom if configured
+ if !caption_top?('table') && caption_content
+ result << generate_table_header(node.id, caption_content)
+ end
+
+ result << '
'
+
+ result.join("\n") + "\n"
+ end
+
+ # Parse table rows from AST
+ def parse_table_rows_from_ast(rows)
+ processed_rows = []
+
+ rows.each do |row_node|
+ cells = row_node.children.map do |cell_node|
+ render_children(cell_node)
+ end
+
+ col_count = cells.length
+ @col = col_count if col_count > @col
+
+ # Apply table width processing if enabled
+ if @tablewidth
+ cells = cells.map do |cell|
+ cell.gsub("\t.\t", "\tDUMMYCELLSPLITTER\t").
+ gsub("\t..\t", "\t.\t").
+ gsub(/\t\.\Z/, "\tDUMMYCELLSPLITTER").
+ gsub(/\t\.\.\Z/, "\t.").
+ gsub(/\A\./, '')
+ end
+ end
+
+ processed_rows << cells
+ end
+
+ { rows: processed_rows }
+ end
+
+ # Generate table header
+ def generate_table_header(id, caption)
+ return '' unless caption && !caption.empty?
+
+ if id.nil?
+ %Q(#{caption} )
+ else
+ %Q(#{text_formatter.format_caption_plain('table', get_chap, @chapter.table(id).number, caption)} )
+ end
+ end
+
+ # Generate table rows
+ def generate_table_rows(rows_data, header_count)
+ rows = rows_data[:rows]
+
+ # Calculate cell widths
+ cellwidth = []
+ if @tablewidth
+ if @table_node_cellwidth.nil?
+ # No tsize specified - distribute width equally
+ @col.times { |n| cellwidth[n] = @tablewidth / @col }
+ else
+ # Extract numeric values from cellwidth specifications
+ # For simple format: ["p{10mm}", "p{20mm}", "p{30mm}"] -> ["10", "20", "30"]
+ # For IDGXML simple format: ["10", "20", "30"] (already numeric)
+ cellwidth = @table_node_cellwidth.map do |spec|
+ # Extract numeric part from p{Nmm} format or use as-is if already numeric
+ if /\A(\d+(?:\.\d+)?)\z/.match?(spec)
+ spec
+ elsif spec =~ /p\{(\d+(?:\.\d+)?)mm\}/
+ $1
+ else # rubocop:disable Style/EmptyElse
+ # Unknown format - use default
+ nil
+ end
+ end.compact
+
+ totallength = 0
+ cellwidth.size.times do |n|
+ cellwidth[n] = cellwidth[n].to_f / config['pt_to_mm_unit']
+ totallength += cellwidth[n]
+ end
+ if cellwidth.size < @col
+ cw = (@tablewidth - totallength) / (@col - cellwidth.size)
+ (cellwidth.size..(@col - 1)).each { |i| cellwidth[i] = cw }
+ end
+ end
+ end
+
+ result = []
+
+ # Output header rows if present
+ if header_count > 0
+ header_count.times do |y|
+ if @tablewidth.nil?
+ result << %Q(#{rows.shift.join("\t")} )
+ else
+ i = 0
+ rows.shift.each_with_index do |cell, x|
+ result << %Q(#{cell.sub('DUMMYCELLSPLITTER', '')} )
+ i += 1
+ end
+ end
+ end
+ end
+
+ # Output body rows
+ if @tablewidth
+ rows.each_with_index do |row, y|
+ i = 0
+ row.each_with_index do |cell, x|
+ result << %Q(#{cell.sub('DUMMYCELLSPLITTER', '')} )
+ i += 1
+ end
+ end
+ else
+ lastline = rows.pop
+ rows.each { |row| result << "#{row.join("\t")} " }
+ result << %Q(#{lastline.join("\t")} ) if lastline
+ end
+
+ result.join("\n")
+ end
+
+ # Visit imgtable
+ def visit_imgtable(node)
+ caption_content = node.caption_node ? render_children(node.caption_node) : nil
+
+ if @chapter.image_bound?(node.id)
+ metrics = parse_metric('idgxml', node.metric)
+
+ result = []
+ result << ''
+
+ if caption_top?('table') && caption_content
+ result << generate_table_header(node.id, caption_content)
+ end
+
+ result << %Q(
'
+
+ result.join("\n") + "\n"
+ else
+ # Fall back to image dummy
+ visit_image_dummy(node.id, caption_content, [])
+ end
+ end
+
+ # Visit regular image
+ def visit_regular_image(node)
+ caption_content = node.caption_node ? render_children(node.caption_node) : nil
+
+ if @chapter.image_bound?(node.id)
+ metrics = parse_metric('idgxml', node.metric)
+
+ result = []
+ result << '#{caption_content} )
+ end
+
+ begin
+ result << %Q(#{caption_content} )
+ end
+
+ result << ''
+
+ result.join("\n") + "\n"
+ end
+
+ # Visit image dummy
+ def visit_image_dummy(id, caption, lines)
+ result = []
+ result << ')
+ lines.each do |line|
+ result << detab(line, tabwidth)
+ result << "\n"
+ end
+ result << ' '
+
+ if !caption_top?('image') && caption
+ result << generate_image_header(id, caption)
+ end
+
+ result << ''
+
+ result.join("\n") + "\n"
+ end
+
+ # Generate image header
+ def generate_image_header(id, caption)
+ return '' unless caption && !caption.empty?
+
+ %Q(#{text_formatter.format_caption_plain('image', get_chap, @chapter.image(id).number, caption)} )
+ end
+
+ # Visit rawblock
+ def visit_rawblock(node)
+ result = []
+ no = 1
+
+ # Get lines from child TextNodes
+ lines = node.children.map { |child| child.is_a?(ReVIEW::AST::TextNode) ? child.content : '' }
+ lines.each do |line|
+ # Unescape HTML entities
+ unescaped = line.gsub('<', '<').gsub('>', '>').gsub('"', '"').gsub('&', '&')
+ result << unescaped
+ result << "\n" unless lines.length == no
+ no += 1
+ end
+
+ result.join
+ end
+
+ # Visit comment block
+ def visit_comment_block(node)
+ return '' unless config['draft']
+
+ lines = []
+ lines << escape(node.args.first) if node.args.first && !node.args.first.empty?
+
+ # Process children as separate text lines (not as paragraphs)
+ if node.children && !node.children.empty?
+ node.children.each do |child|
+ lines << if child.is_a?(ReVIEW::AST::TextNode)
+ escape(child.content.to_s)
+ else
+ # For other node types, render normally
+ visit(child)
+ end
+ end
+ end
+
+ return '' if lines.empty?
+
+ str = lines.join("\n")
+ "#{str} "
+ end
+
+ # Process raw embed
+ def process_raw_embed(node)
+ # Check if this embed is targeted for IDGXML
+ unless node.targeted_for?('idgxml')
+ return ''
+ end
+
+ # Get content
+ content = node.content || ''
+
+ # Process \n based on embed type
+ case node.embed_type
+ when :inline
+ # For inline raw/embed, convert literal \n to protected newline marker
+ content = content.gsub('\n', "\x01IDGXML_INLINE_NEWLINE\x01")
+ when :raw
+ # For raw blocks, convert \\n to actual newlines
+ content = content.gsub('\\n', "\n")
+ end
+
+ # For block embeds, add trailing newline
+ node.embed_type == :block ? content + "\n" : content
+ end
+
+ # Visit syntaxblock (box, insn) - processes lines with listinfo
+ def visit_syntaxblock(node)
+ type = node.block_type.to_s
+
+ # Render caption if present
+ captionstr = nil
+ if node.caption_node
+ titleopentag = %Q(caption aid:pstyle="#{type}-title")
+ titleclosetag = 'caption'
+ if type == 'insn'
+ titleopentag = %Q(floattitle type="insn")
+ titleclosetag = 'floattitle'
+ end
+ # Use caption_node to render inline elements
+ caption_with_inline = render_caption_inline(node.caption_node)
+ captionstr = %Q(<#{titleopentag}>#{caption_with_inline})
+ end
+
+ result = []
+ result << "<#{type}>"
+
+ # Output caption at top if configured
+ result << captionstr if caption_top?('list') && captionstr
+
+ # Process lines with listinfo
+ lines = extract_lines_from_node(node)
+ if config['listinfo'] && lines.any?
+ # Generate all listinfo entries as a single string (like IDGXMLBuilder's print/puts)
+ listinfo_output = lines.map.with_index do |line, i|
+ no = i + 1
+ line_parts = []
+ line_parts << %Q('
+ # Always include line content (even if empty) followed by newline
+ # Protect newlines inside listinfo from nolf processing
+ line_parts << detab(line, tabwidth)
+ line_parts << "\x01IDGXML_LISTINFO_NEWLINE\x01"
+ line_parts << ' '
+ line_parts.join
+ end.join
+ result << listinfo_output
+ else
+ lines_output = lines.map { |line| detab(line, tabwidth) + "\n" }.join
+ result << lines_output
+ end
+
+ # Output caption at bottom if configured
+ result << captionstr if !caption_top?('list') && captionstr
+
+ result << ""
+ result.join + "\n"
+ end
+
+ # Extract lines from block node and process inline elements
+ def extract_lines_from_node(node)
+ # If node has ParagraphNode children (e.g., box/insn blocks), treat each as a separate line
+ if node.children.all?(AST::ParagraphNode)
+ # Each ParagraphNode represents one line - inline elements are already parsed
+ node.children.map { |para| render_children(para) }
+ else
+ # Fallback: render all children and split by newlines
+ full_content = render_children(node)
+
+ # Split by newlines to get individual lines
+ # Keep empty lines (important for blank lines in the source)
+ lines = full_content.split("\n", -1)
+
+ # Remove the last empty line if present (split always creates one at the end)
+ lines.pop if lines.last == ''
+
+ lines
+ end
+ end
+
+ def resolve_bibpaper_number(bib_id)
+ if @chapter
+ begin
+ return @chapter.bibpaper(bib_id).number
+ rescue StandardError
+ # Fallback to AST indexer if chapter lookup fails
+ end
+ end
+
+ if @ast_indexer&.bibpaper_index
+ begin
+ return @ast_indexer.bibpaper_index.number(bib_id)
+ rescue StandardError
+ # fall through
+ end
+ end
+
+ '??'
+ end
+
+ # Parse tsize target specification like |idgxml|2 or |idgxml,html|2
+ def parse_tsize_target(arg)
+ # Format: |target1,target2,...|value
+ if arg =~ /\A\|([^|]+)\|(.+)/
+ targets = Regexp.last_match(1).split(',').map(&:strip)
+ value = Regexp.last_match(2)
+ [targets, value]
+ else
+ # No target specification (malformed)
+ [nil, arg]
+ end
+ end
+
+ # Get tabwidth setting (default to 8)
+ def tabwidth
+ config['tabwidth'] || 8
+ end
+
+ # Graph generation helper methods (for non-mermaid graphs)
+ def system_graph_graphviz(_id, file_path, tf_path)
+ system("dot -Tpdf -o#{file_path} #{tf_path}")
+ end
+
+ def system_graph_gnuplot(_id, file_path, content, tf_path)
+ File.open(tf_path, 'w') do |tf|
+ tf.puts <<~GNUPLOT
+ set terminal pdf
+ set output "#{file_path}"
+ #{content}
+ GNUPLOT
+ end
+ system("gnuplot #{tf_path}")
+ end
+
+ def system_graph_blockdiag(_id, file_path, tf_path, command)
+ system("#{command} -Tpdf -o #{file_path} #{tf_path}")
+ end
+ end
+ end
+end
diff --git a/lib/review/renderer/inline_render_proxy.rb b/lib/review/renderer/inline_render_proxy.rb
new file mode 100644
index 000000000..2f1c857e5
--- /dev/null
+++ b/lib/review/renderer/inline_render_proxy.rb
@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2025 Kenshi Muto, Masayoshi Takahashi
+#
+# This program is free software.
+# You can distribute or modify this program under the terms of
+# the GNU LGPL, Lesser General Public License version 2.1.
+
+module ReVIEW
+ module Renderer
+ # Shared proxy class that provides minimal interface to renderer for InlineContext classes.
+ # This proxy limits access to renderer methods, exposing only what's needed for inline rendering.
+ #
+ # This class is used by HTML, LaTeX, and IDGXML InlineContext classes to prevent
+ # tight coupling between InlineElementHandler and the full renderer interface.
+ #
+ # Common methods (always available):
+ # - render_children(node): Render all children of a node
+ # - text_formatter: Access to TextFormatter instance
+ #
+ # Optional methods (available if renderer supports them):
+ # - rendering_context: Current rendering context (for LaTeX footnote handling)
+ # - render_caption_inline(caption_node): Render caption with inline markup (for LaTeX/IDGXML)
+ # - increment_texinlineequation: Increment equation counter (for IDGXML math rendering)
+ class InlineRenderProxy
+ def initialize(renderer)
+ @renderer = renderer
+ end
+
+ # Render all children of a node and join the results
+ # @param node [Object] The parent node whose children should be rendered
+ # @return [String] The joined rendered output of all children
+ def render_children(node)
+ @renderer.render_children(node)
+ end
+
+ # Get TextFormatter instance from the renderer
+ # @return [ReVIEW::Renderer::TextFormatter] Text formatter instance
+ def text_formatter
+ @renderer.text_formatter
+ end
+
+ # Get current rendering context (LaTeX-specific feature)
+ # @return [RenderingContext, nil] Current rendering context if available
+ def rendering_context
+ @renderer.rendering_context if @renderer.respond_to?(:rendering_context)
+ end
+
+ # Render caption with inline markup (LaTeX/IDGXML-specific feature)
+ # @param caption_node [Object] Caption node to render
+ # @return [String, nil] Rendered caption if available
+ def render_caption_inline(caption_node)
+ if @renderer.respond_to?(:render_caption_inline)
+ @renderer.render_caption_inline(caption_node)
+ end
+ end
+
+ # Increment inline equation counter (IDGXML-specific feature)
+ # @return [Integer, nil] Counter value if available
+ def increment_texinlineequation
+ if @renderer.respond_to?(:increment_texinlineequation)
+ @renderer.increment_texinlineequation
+ end
+ end
+ end
+ end
+end
diff --git a/lib/review/renderer/latex/inline_context.rb b/lib/review/renderer/latex/inline_context.rb
new file mode 100644
index 000000000..8a3d9ae73
--- /dev/null
+++ b/lib/review/renderer/latex/inline_context.rb
@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2025 Kenshi Muto, Masayoshi Takahashi
+#
+# This program is free software.
+# You can distribute or modify this program under the terms of
+# the GNU LGPL, Lesser General Public License version 2.1.
+
+require 'review/latexutils'
+require_relative '../inline_render_proxy'
+
+module ReVIEW
+ module Renderer
+ module Latex
+ # Context for inline element rendering with business logic
+ # Used by InlineElementHandler
+ class InlineContext
+ include ReVIEW::LaTeXUtils
+
+ attr_reader :config, :book, :chapter, :index_db, :index_mecab
+
+ def initialize(config:, book:, chapter:, renderer:)
+ @config = config
+ @book = book
+ @chapter = chapter
+ # Automatically create proxy from renderer to limit access
+ @render_proxy = InlineRenderProxy.new(renderer)
+ # Initialize index support
+ initialize_index_support
+ end
+
+ # Get current rendering context dynamically from renderer
+ # This ensures we always have the most up-to-date context,
+ # even when it changes during rendering (e.g., caption context)
+ def rendering_context
+ @render_proxy.rendering_context
+ end
+
+ def chapter_link_enabled?
+ config['chapterlink']
+ end
+
+ def draft_mode?
+ config['draft']
+ end
+
+ def over_secnolevel?(n)
+ secnolevel = config['secnolevel'] || 2
+ secnolevel >= n.to_s.split('.').size
+ end
+
+ def render_children(node)
+ @render_proxy.render_children(node)
+ end
+
+ def render_caption_inline(caption_node)
+ @render_proxy.render_caption_inline(caption_node)
+ end
+
+ def text_formatter
+ @render_proxy.text_formatter
+ end
+
+ def bibpaper_number(bib_id)
+ if book.bibpaper_index.blank?
+ raise ReVIEW::KeyError, "unknown bib: #{bib_id}"
+ end
+
+ book.bibpaper_index.number(bib_id)
+ end
+
+ private
+
+ # Initialize index support (database and MeCab)
+ def initialize_index_support
+ @index_db = {}
+ @index_mecab = nil
+
+ return unless config['pdfmaker'] && config['pdfmaker']['makeindex']
+
+ # Load index dictionary file
+ if config['pdfmaker']['makeindex_dic']
+ @index_db = load_idxdb(config['pdfmaker']['makeindex_dic'])
+ end
+
+ return unless config['pdfmaker']['makeindex_mecab']
+
+ # Initialize MeCab for Japanese text indexing
+ begin
+ begin
+ require 'MeCab'
+ rescue LoadError
+ require 'mecab'
+ end
+ require 'nkf'
+ @index_mecab = MeCab::Tagger.new(config['pdfmaker']['makeindex_mecab_opts'])
+ rescue LoadError
+ # MeCab not available, will fall back to text-only indexing
+ end
+ end
+
+ # Load index database from file
+ def load_idxdb(file)
+ table = {}
+ File.foreach(file) do |line|
+ key, value = *line.strip.split(/\t+/, 2)
+ table[key] = value
+ end
+ table
+ end
+ end
+ end
+ end
+end
diff --git a/lib/review/renderer/latex/inline_element_handler.rb b/lib/review/renderer/latex/inline_element_handler.rb
new file mode 100644
index 000000000..802939693
--- /dev/null
+++ b/lib/review/renderer/latex/inline_element_handler.rb
@@ -0,0 +1,834 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2025 Kenshi Muto, Masayoshi Takahashi
+#
+# This program is free software.
+# You can distribute or modify this program under the terms of
+# the GNU LGPL, Lesser General Public License version 2.1.
+
+require 'review/latexutils'
+
+module ReVIEW
+ module Renderer
+ module Latex
+ # Inline element handler for LaTeX rendering
+ # Uses InlineContext for shared logic
+ class InlineElementHandler
+ include ReVIEW::LaTeXUtils
+
+ def initialize(inline_context)
+ @ctx = inline_context
+ @chapter = @ctx.chapter
+ @book = @ctx.book
+ @config = @ctx.config
+ # Initialize LaTeX character escaping
+ initialize_metachars(@config['texcommand'])
+ end
+
+ def render_inline_b(_type, content, _node)
+ "\\reviewbold{#{content}}"
+ end
+
+ def render_inline_i(_type, content, _node)
+ "\\reviewit{#{content}}"
+ end
+
+ def render_inline_em(_type, content, _node)
+ "\\reviewem{#{content}}"
+ end
+
+ def render_inline_tt(_type, content, _node)
+ "\\reviewtt{#{content}}"
+ end
+
+ def render_inline_ttb(_type, content, _node)
+ "\\reviewttb{#{content}}"
+ end
+
+ def render_inline_tti(_type, content, _node)
+ "\\reviewtti{#{content}}"
+ end
+
+ def render_inline_code(_type, content, _node)
+ "\\reviewcode{#{content}}"
+ end
+
+ def render_inline_u(_type, content, _node)
+ "\\reviewunderline{#{content}}"
+ end
+
+ def render_inline_strong(_type, content, _node)
+ "\\reviewstrong{#{content}}"
+ end
+
+ def render_inline_href(_type, content, node)
+ if node.args.length >= 2
+ url = node.args[0]
+ text = node.args[1]
+ # Handle internal references (URLs starting with #)
+ if url.start_with?('#')
+ anchor = url.sub(/\A#/, '')
+ "\\hyperref[#{escape_latex(anchor)}]{#{escape_latex(text)}}"
+ elsif /\A[a-z]+:/.match?(url)
+ # External URL with scheme
+ "\\href{#{escape_url(url)}}{#{escape_latex(text)}}"
+ else
+ # Plain reference without scheme
+ "\\ref{#{escape_latex(url)}}"
+ end
+ else
+ # For single argument href, get raw text from first text child to avoid double escaping
+ raw_url = if node.children.first.leaf_node?
+ node.children.first.content
+ else
+ raise NotImplementedError, "URL is invalid: #{content}"
+ end
+ # Handle internal references (URLs starting with #)
+ if raw_url.start_with?('#')
+ anchor = raw_url.sub(/\A#/, '')
+ "\\hyperref[#{escape_latex(anchor)}]{#{escape_latex(raw_url)}}"
+ elsif /\A[a-z]+:/.match?(raw_url)
+ # External URL with scheme
+ url_content = escape_url(raw_url)
+ "\\url{#{url_content}}"
+ else
+ # Plain reference without scheme
+ "\\ref{#{escape_latex(raw_url)}}"
+ end
+ end
+ end
+
+ def render_inline_fn(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ footnote_number = data.item_number
+
+ # Check if we need to use footnotetext mode
+ if @ctx.config['footnotetext']
+ "\\footnotemark[#{footnote_number}]"
+ elsif @ctx.rendering_context.requires_footnotetext?
+ if data.caption_node
+ @ctx.rendering_context.collect_footnote(data.caption_node, footnote_number)
+ end
+ '\\protect\\footnotemark{}'
+ else
+ footnote_content = if data.caption_node
+ @ctx.render_children(data.caption_node).strip
+ else
+ escape(data.caption_text || '')
+ end
+ "\\footnote{#{footnote_content}}"
+ end
+ end
+
+ # Render list reference
+ def render_inline_list(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ list_number = data.item_number
+
+ chapter_num = @ctx.text_formatter.format_chapter_number_short(data.chapter_number, data.chapter_type)
+ if chapter_num && !chapter_num.empty?
+ "\\reviewlistref{#{chapter_num}.#{list_number}}"
+ else
+ "\\reviewlistref{#{list_number}}"
+ end
+ end
+
+ # Render listref reference (same as list)
+ def render_inline_listref(type, content, node)
+ render_inline_list(type, content, node)
+ end
+
+ # Render table reference
+ def render_inline_table(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ table_number = data.item_number
+ # Use current chapter ID if chapter_id is not set in resolved_data
+ chapter_id = data.chapter_id || @chapter&.id
+ table_label = "table:#{chapter_id}:#{data.item_id}"
+
+ short_num = @ctx.text_formatter.format_chapter_number_short(data.chapter_number, data.chapter_type)
+ if short_num && !short_num.empty?
+ "\\reviewtableref{#{short_num}.#{table_number}}{#{table_label}}"
+ else
+ "\\reviewtableref{#{table_number}}{#{table_label}}"
+ end
+ end
+
+ # Render tableref reference (same as table)
+ def render_inline_tableref(type, content, node)
+ render_inline_table(type, content, node)
+ end
+
+ # Render image reference
+ def render_inline_img(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ image_number = data.item_number
+ # Use current chapter ID if chapter_id is not set in resolved_data
+ chapter_id = data.chapter_id || @chapter&.id
+ image_label = "image:#{chapter_id}:#{data.item_id}"
+
+ short_num = @ctx.text_formatter.format_chapter_number_short(data.chapter_number, data.chapter_type)
+ if short_num && !short_num.empty?
+ "\\reviewimageref{#{short_num}.#{image_number}}{#{image_label}}"
+ else
+ "\\reviewimageref{#{image_number}}{#{image_label}}"
+ end
+ end
+
+ # Render imgref reference (same as img)
+ def render_inline_imgref(type, content, node)
+ render_inline_img(type, content, node)
+ end
+
+ # Render equation reference
+ def render_inline_eq(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ equation_number = data.item_number
+
+ short_num = @ctx.text_formatter.format_chapter_number_short(data.chapter_number, data.chapter_type)
+ if short_num && !short_num.empty?
+ "\\reviewequationref{#{short_num}.#{equation_number}}"
+ else
+ "\\reviewequationref{#{equation_number}}"
+ end
+ end
+
+ # Render eqref reference (same as eq)
+ def render_inline_eqref(type, content, node)
+ render_inline_eq(type, content, node)
+ end
+
+ # Render same-chapter list reference
+ def render_same_chapter_list_reference(node)
+ list_ref = node.args.first.to_s
+ if @chapter && @ctx.chapter.list_index
+ begin
+ list_item = @ctx.chapter.list_index.number(list_ref)
+ if @ctx.chapter.number
+ chapter_num = @ctx.chapter.format_number(false)
+ "\\reviewlistref{#{chapter_num}.#{list_item}}"
+ else
+ "\\reviewlistref{#{list_item}}"
+ end
+ rescue ReVIEW::KeyError => e
+ raise NotImplementedError, "List reference failed for #{list_ref}: #{e.message}"
+ end
+ else
+ "\\ref{#{escape(list_ref)}}"
+ end
+ end
+
+ # Render bibliography reference
+ def render_inline_bib(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ bib_number = data.item_number
+ bib_id = data.item_id
+ "\\reviewbibref{[#{bib_number}]}{bib:#{bib_id}}"
+ end
+
+ # Render bibref reference (same as bib)
+ def render_inline_bibref(type, content, node)
+ render_inline_bib(type, content, node)
+ end
+
+ # Render same-chapter table reference
+ def render_same_chapter_table_reference(node)
+ table_ref = node.args.first.to_s
+ if @chapter && @ctx.chapter.table_index
+ begin
+ table_item = @ctx.chapter.table_index.number(table_ref)
+ table_label = "table:#{@ctx.chapter.id}:#{table_ref}"
+ if @ctx.chapter.number
+ chapter_num = @ctx.chapter.format_number(false)
+ "\\reviewtableref{#{chapter_num}.#{table_item}}{#{table_label}}"
+ else
+ "\\reviewtableref{#{table_item}}{#{table_label}}"
+ end
+ rescue ReVIEW::KeyError => e
+ raise NotImplementedError, "Table reference failed for #{table_ref}: #{e.message}"
+ end
+ else
+ "\\ref{#{escape(table_ref)}}"
+ end
+ end
+
+ # Render same-chapter image reference
+ def render_same_chapter_image_reference(node)
+ image_ref = node.args.first.to_s
+ if @chapter && @ctx.chapter.image_index
+ begin
+ image_item = @ctx.chapter.image_index.number(image_ref)
+ image_label = "image:#{@ctx.chapter.id}:#{image_ref}"
+ if @ctx.chapter.number
+ chapter_num = @ctx.chapter.format_number(false)
+ "\\reviewimageref{#{chapter_num}.#{image_item}}{#{image_label}}"
+ else
+ "\\reviewimageref{#{image_item}}{#{image_label}}"
+ end
+ rescue ReVIEW::KeyError => e
+ raise NotImplementedError, "Image reference failed for #{image_ref}: #{e.message}"
+ end
+ else
+ # Don't escape underscores in ref labels
+ "\\ref{#{image_ref}}"
+ end
+ end
+
+ # Render cross-chapter list reference
+ def render_cross_chapter_list_reference(node)
+ chapter_id, list_id = node.args
+
+ # Find the target chapter
+ target_chapter = @ctx.book.contents&.detect { |chap| chap.id == chapter_id }
+ unless target_chapter
+ raise NotImplementedError, "Cross-chapter list reference failed: chapter '#{chapter_id}' not found"
+ end
+
+ # Ensure the target chapter has list index
+ unless target_chapter.list_index
+ raise NotImplementedError, "Cross-chapter list reference failed: no list index for chapter '#{chapter_id}'"
+ end
+
+ begin
+ list_item = target_chapter.list_index.number(list_id)
+ if target_chapter.number
+ chapter_num = target_chapter.format_number(false)
+ "\\reviewlistref{#{chapter_num}.#{list_item}}"
+ else
+ "\\reviewlistref{#{list_item}}"
+ end
+ rescue ReVIEW::KeyError => e
+ raise NotImplementedError, "Cross-chapter list reference failed for #{chapter_id}|#{list_id}: #{e.message}"
+ end
+ end
+
+ # Render cross-chapter table reference
+ def render_cross_chapter_table_reference(node)
+ chapter_id, table_id = node.args
+
+ # Find the target chapter
+ target_chapter = @ctx.book.contents&.detect { |chap| chap.id == chapter_id }
+ unless target_chapter
+ raise NotImplementedError, "Cross-chapter table reference failed: chapter '#{chapter_id}' not found"
+ end
+
+ # Ensure the target chapter has table index
+ unless target_chapter.table_index
+ raise NotImplementedError, "Cross-chapter table reference failed: no table index for chapter '#{chapter_id}'"
+ end
+
+ begin
+ table_item = target_chapter.table_index.number(table_id)
+ table_label = "table:#{chapter_id}:#{table_id}"
+ if target_chapter.number
+ chapter_num = target_chapter.format_number(false)
+ "\\reviewtableref{#{chapter_num}.#{table_item}}{#{table_label}}"
+ else
+ "\\reviewtableref{#{table_item}}{#{table_label}}"
+ end
+ rescue ReVIEW::KeyError => e
+ raise NotImplementedError, "Cross-chapter table reference failed for #{chapter_id}|#{table_id}: #{e.message}"
+ end
+ end
+
+ # Render cross-chapter image reference
+ def render_cross_chapter_image_reference(node)
+ chapter_id, image_id = node.args
+
+ # Find the target chapter
+ target_chapter = @ctx.book.contents&.detect { |chap| chap.id == chapter_id }
+ unless target_chapter
+ raise NotImplementedError, "Cross-chapter image reference failed: chapter '#{chapter_id}' not found"
+ end
+
+ # Ensure the target chapter has image index
+ unless target_chapter.image_index
+ raise NotImplementedError, "Cross-chapter image reference failed: no image index for chapter '#{chapter_id}'"
+ end
+
+ begin
+ image_item = target_chapter.image_index.number(image_id)
+ image_label = "image:#{chapter_id}:#{image_id}"
+ if target_chapter.number
+ chapter_num = target_chapter.format_number(false)
+ "\\reviewimageref{#{chapter_num}.#{image_item}}{#{image_label}}"
+ else
+ "\\reviewimageref{#{image_item}}{#{image_label}}"
+ end
+ rescue ReVIEW::KeyError => e
+ raise NotImplementedError, "Cross-chapter image reference failed for #{chapter_id}|#{image_id}: #{e.message}"
+ end
+ end
+
+ # Render chapter number reference
+ def render_inline_chap(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ # Format chapter number to full form (e.g., "第1章", "付録A", "第II部")
+ chapter_num = @ctx.text_formatter.format_chapter_number_full(data.chapter_number, data.chapter_type)
+ "\\reviewchapref{#{chapter_num}}{chap:#{data.item_id}}"
+ end
+
+ # Render chapter title reference
+ def render_inline_chapref(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ display_str = @ctx.text_formatter.format_reference(:chapter, data)
+ "\\reviewchapref{#{escape(display_str)}}{chap:#{data.item_id}}"
+ end
+
+ # Extract heading reference from node.args, handling ReferenceResolver's array splitting
+ # ReferenceResolver splits "ch02|ブロック命令" into ["ch02", "ブロック命令"]
+ # We need to join them back together to get the original format
+ # Build heading reference parts from resolved_data
+ # Returns [section_number, section_label, section_title]
+ def build_heading_reference_parts(data)
+ # Get headline_number array (e.g., [1, 2] for section 1.2)
+ headline_number = data.headline_number || []
+
+ # Get caption from caption_node
+ section_title = data.caption_text
+
+ # Determine chapter context
+ if data.chapter_id && data.chapter_number
+ # Cross-chapter reference
+ short_chapter = @ctx.text_formatter.format_chapter_number_short(data.chapter_number, data.chapter_type)
+ chapter_prefix = short_chapter
+ elsif @chapter && @ctx.chapter.number
+ # Same chapter reference
+ short_chapter = @ctx.chapter.format_number(false)
+ chapter_prefix = short_chapter
+ else
+ # Reference without chapter number
+ short_chapter = '0'
+ chapter_prefix = '0'
+ end
+
+ # Build section number for display
+ full_number_parts = [short_chapter] + headline_number
+ full_section_number = full_number_parts.join('.')
+
+ # Check if we should show the number based on secnolevel
+ section_number = if short_chapter != '0' && @ctx.over_secnolevel?(full_section_number)
+ # Show full number with chapter: "2.1", "2.1.2", etc.
+ full_section_number
+ else
+ # Without chapter number - use relative section number only
+ headline_number.join('.')
+ end
+
+ # Generate label using chapter prefix and relative section number
+ relative_parts = headline_number.join('-')
+ section_label = "sec:#{chapter_prefix}-#{relative_parts}"
+
+ [section_number, section_label, section_title]
+ end
+
+ # Render heading reference
+ def render_inline_hd(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ section_number, section_label, section_title = build_heading_reference_parts(data)
+ "\\reviewsecref{「#{section_number} #{escape(section_title)}」}{#{section_label}}"
+ end
+
+ # Render section reference
+ def render_inline_sec(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ section_number, section_label, _section_title = build_heading_reference_parts(data)
+ "\\reviewsecref{#{section_number}}{#{section_label}}"
+ end
+
+ # Render section reference with full title
+ def render_inline_secref(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ section_number, section_label, section_title = build_heading_reference_parts(data)
+ "\\reviewsecref{「#{section_number} #{escape(section_title)}」}{#{section_label}}"
+ end
+
+ # Render section title only
+ def render_inline_sectitle(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ _section_number, section_label, section_title = build_heading_reference_parts(data)
+ "\\reviewsecref{#{escape(section_title)}}{#{section_label}}"
+ end
+
+ # Render index entry
+ def render_inline_idx(_type, content, node)
+ return content unless node.args.first
+
+ index_str = node.args.first
+ # Process hierarchical index like LATEXBuilder's index method
+ index_entry = process_index(index_str)
+ # Index entry like LATEXBuilder - content first, then index
+ "#{content}\\index{#{index_entry}}"
+ end
+
+ # Render hidden index entry
+ def render_inline_hidx(_type, content, node)
+ return content unless node.args.first
+
+ index_str = node.args.first
+ # Process hierarchical index like LATEXBuilder's index method
+ index_entry = process_index(index_str)
+ # Hidden index entry like LATEXBuilder - just output index, content is already rendered
+ "\\index{#{index_entry}}"
+ end
+
+ # Process index string for hierarchical index entries (mendex/upmendex)
+ # This is a simplified version of LATEXBuilder's index method (latexbuilder.rb:1406-1427)
+ def process_index(str)
+ # Split by <<>> delimiter for hierarchical index entries
+ parts = str.split('<<>>')
+
+ # Process each part and format for mendex
+ formatted_parts = parts.map { |item| format_index_item(item) }
+
+ # Join hierarchical parts with '!' for mendex/upmendex
+ formatted_parts.join('!')
+ end
+
+ # Format a single index item for mendex/upmendex
+ def format_index_item(item)
+ if ascii_only?(item)
+ format_ascii_index_item(item)
+ else
+ format_japanese_index_item(item)
+ end
+ end
+
+ # Check if string contains only ASCII characters
+ def ascii_only?(str)
+ str =~ /\A[[:ascii:]]+\Z/
+ end
+
+ # Format ASCII-only index item
+ def format_ascii_index_item(item)
+ escaped_item = escape(item)
+ mendex_escaped = escape_index(escaped_item)
+
+ # If no escaping was needed, just return the item
+ return item if mendex_escaped == item
+
+ # Generate key@display format for proper sorting like LATEXBuilder (latexbuilder.rb:1418)
+ "#{escape_mendex_key(escape_index(item))}@#{escape_mendex_display(mendex_escaped)}"
+ end
+
+ # Format Japanese (non-ASCII) index item with yomi reading
+ def format_japanese_index_item(item)
+ # Check dictionary first like LATEXBuilder (latexbuilder.rb:1411-1412)
+ index_db = @ctx.index_db
+ yomi = if index_db && index_db[item]
+ index_db[item]
+ else
+ # Generate yomi using MeCab like LATEXBuilder (latexbuilder.rb:1421-1422)
+ generate_yomi(item)
+ end
+ escaped_item = escape(item)
+ "#{escape_mendex_key(escape_index(yomi))}@#{escape_mendex_display(escape_index(escaped_item))}"
+ end
+
+ # Generate yomi (reading) for Japanese text using MeCab + NKF like LATEXBuilder (latexbuilder.rb:1421)
+ def generate_yomi(text)
+ # If MeCab is available, use it to parse and generate reading
+ index_mecab = @ctx.index_mecab
+ if index_mecab
+ require 'nkf'
+ NKF.nkf('-w --hiragana', index_mecab.parse(text).force_encoding('UTF-8').chomp)
+ else
+ # Fallback: use the original text as-is if MeCab is unavailable
+ text
+ end
+ rescue LoadError, ArgumentError, TypeError, RuntimeError
+ # Fallback: use the original text as-is if processing fails
+ text
+ end
+
+ # Render keyword notation
+ def render_inline_kw(_type, content, node)
+ if node.args.length >= 2
+ term = escape(node.args[0])
+ description = escape(node.args[1])
+ "\\reviewkw{#{term}}（#{description}）"
+ else
+ "\\reviewkw{#{content}}"
+ end
+ end
+
+ # Render ruby notation
+ def render_inline_ruby(_type, content, node)
+ if node.args.length >= 2
+ base_text = escape(node.args[0])
+ ruby_text = escape(node.args[1])
+ "\\ruby{#{base_text}}{#{ruby_text}}"
+ else
+ content
+ end
+ end
+
+ # Render icon
+ def render_inline_icon(_type, content, node)
+ return content unless node.args.first
+
+ icon_id = node.args.first
+ image_path = find_image_path(icon_id)
+
+ if image_path
+ command = 'reviewicon'
+ "\\#{command}{#{image_path}}"
+ else
+ "\\verb|--[[path = #{icon_id} (not exist)]]--|"
+ end
+ end
+
+ # Render ami notation
+ def render_inline_ami(_type, content, _node)
+ "\\reviewami{#{content}}"
+ end
+
+ # Render bou notation
+ def render_inline_bou(_type, content, _node)
+ # Boudou (emphasis)
+ "\\reviewbou{#{content}}"
+ end
+
+ # Render tcy notation (tate-chu-yoko: horizontal-in-vertical text)
+ def render_inline_tcy(_type, content, _node)
+ # Tate-chu-yoko (縦中横) for vertical typesetting
+ "\\reviewtcy{#{content}}"
+ end
+
+ # Render balloon notation
+ def render_inline_balloon(_type, content, _node)
+ # Balloon annotation - content contains the balloon text
+ "\\reviewballoon{#{content}}"
+ end
+
+ # Render mathematical expression
+ def render_inline_m(_type, content, node)
+ # Mathematical expressions - don't escape content
+ "$#{node.args.first || content}$"
+ end
+
+ # Render superscript
+ def render_inline_sup(_type, content, _node)
+ "\\textsuperscript{#{content}}"
+ end
+
+ # Render subscript
+ def render_inline_sub(_type, content, _node)
+ "\\textsubscript{#{content}}"
+ end
+
+ # Render strikethrough
+ def render_inline_del(_type, content, _node)
+ "\\reviewstrike{#{content}}"
+ end
+
+ # Render strikethrough (alias)
+ def render_inline_strike(type, content, node)
+ render_inline_del(type, content, node)
+ end
+
+ # Render insert
+ def render_inline_ins(_type, content, _node)
+ "\\reviewinsert{#{content}}"
+ end
+
+ # Render insert (alias)
+ def render_inline_insert(type, content, node)
+ render_inline_ins(type, content, node)
+ end
+
+ # Render unicode character
+ def render_inline_uchar(_type, content, node)
+ # Unicode character handling like LATEXBuilder
+ if node.args.first
+ char_code = node.args.first
+ texcompiler = @ctx.config['texcommand']
+ if texcompiler&.start_with?('platex')
+ # with otf package - use \UTF macro
+ "\\UTF{#{escape(char_code)}}"
+ else
+ # upLaTeX or other - convert to actual Unicode character
+ [char_code.to_i(16)].pack('U')
+ end
+ else
+ content
+ end
+ end
+
+ # Render line break
+ def render_inline_br(_type, _content, _node)
+ "\\\\\n"
+ end
+
+ # Render word expansion
+ def render_inline_w(_type, content, _node)
+ # Word expansion - pass through content
+ content
+ end
+
+ # Render word expansion (bold)
+ def render_inline_wb(_type, content, _node)
+ # Word expansion - pass through content
+ content
+ end
+
+ # Render raw content
+ def render_inline_raw(_type, _content, node)
+ node.targeted_for?('latex') ? (node.content || '') : ''
+ end
+
+ # Render embedded content
+ def render_inline_embed(_type, _content, node)
+ node.targeted_for?('latex') ? (node.content || '') : ''
+ end
+
+ # Render label reference
+ def render_inline_labelref(_type, content, node)
+ # Use resolved content from ReferenceResolver if available,
+ # otherwise fall back to legacy behavior
+ if content && !content.empty?
+ "\\textbf{#{escape(content)}}"
+ elsif node.args.first
+ ref_id = node.args.first
+ "\\ref{#{escape(ref_id)}}"
+ else
+ ''
+ end
+ end
+
+ # Render reference (same as labelref)
+ def render_inline_ref(type, content, node)
+ render_inline_labelref(type, content, node)
+ end
+
+ # Render inline comment
+ def render_inline_comment(_type, content, _node)
+ if @ctx.draft_mode?
+ "\\pdfcomment{#{escape(content)}}"
+ else
+ ''
+ end
+ end
+
+ # Render column reference
+ def render_inline_column(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ column_number = data.item_number
+ chapter_id = data.chapter_id || @ctx.chapter&.id
+ column_label = "column:#{chapter_id}:#{column_number}"
+
+ # Render caption with inline markup
+ compiled_caption = if data.caption_node
+ @ctx.render_caption_inline(data.caption_node)
+ else
+ data.caption_text
+ end
+ column_text = @ctx.text_formatter.format_column_label(compiled_caption)
+ "\\reviewcolumnref{#{column_text}}{#{column_label}}"
+ end
+
+ # Render endnote
+ def render_inline_endnote(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ endnote_content = escape(data.caption_text || '')
+ "\\endnote{#{endnote_content}}"
+ end
+
+ # Render title reference (@{chapter_id})
+ def render_inline_title(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ title = data.chapter_title || ''
+ if @ctx.chapter_link_enabled?
+ "\\reviewchapref{#{escape(title)}}{chap:#{data.item_id}}"
+ else
+ escape(title)
+ end
+ end
+
+ private
+
+ # Find image path for icon
+ def find_image_path(icon_id)
+ @ctx.chapter&.image(icon_id)&.path
+ rescue StandardError
+ nil
+ end
+ end
+ end
+ end
+end
diff --git a/lib/review/renderer/latex_renderer.rb b/lib/review/renderer/latex_renderer.rb
new file mode 100644
index 000000000..4ee3c3322
--- /dev/null
+++ b/lib/review/renderer/latex_renderer.rb
@@ -0,0 +1,1551 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2025 Kenshi Muto, Masayoshi Takahashi
+#
+# This program is free software.
+# You can distribute or modify this program under the terms of
+# the GNU LGPL, Lesser General Public License version 2.1.
+
+require 'review/ast/caption_node'
+require 'review/ast/table_column_width_parser'
+require 'review/latexutils'
+require 'review/sec_counter'
+require 'review/i18n'
+require 'review/textutils'
+require_relative 'base'
+require_relative 'rendering_context'
+require_relative 'latex/inline_context'
+require_relative 'latex/inline_element_handler'
+
+module ReVIEW
+ module Renderer
+ class LatexRenderer < Base
+ include ReVIEW::LaTeXUtils
+ include ReVIEW::TextUtils
+
+ attr_reader :chapter, :book, :rendering_context
+
+ def initialize(chapter)
+ super
+
+ # For AST rendering, we need to set up indexing properly
+ # The indexing will be done when we process the AST
+ @ast_indexer = nil
+ @ast_compiler = nil
+ @list_structure_normalizer = nil
+
+ I18n.setup(config['language'] || 'ja')
+
+ # Initialize LaTeX character escaping
+ initialize_metachars(config['texcommand'])
+
+ # Initialize section counter like LATEXBuilder
+ @sec_counter = SecCounter.new(5, @chapter) if @chapter
+
+ # Initialize RenderingContext for cleaner state management
+ @rendering_context = RenderingContext.new(:document)
+
+ # Initialize LaTeX-specific inline context and inline element handler
+ @inline_context = Latex::InlineContext.new(
+ config: config,
+ book: book,
+ chapter: chapter,
+ renderer: self
+ )
+ @inline_element_handler = Latex::InlineElementHandler.new(@inline_context)
+ end
+
+ # Format type for this renderer
+ # @return [Symbol] Format type :latex
+ def format_type
+ :latex
+ end
+
+ def visit_document(node)
+ # Generate content with proper separation between document-level elements
+ content = render_document_children(node)
+
+ # Wrap Part documents with reviewpart environment
+ if should_wrap_part_with_reviewpart?
+ content = "\\begin{reviewpart}\n" + content + "\\end{reviewpart}\n"
+ end
+
+ # Add any remaining collected footnotetext commands
+ if @rendering_context.footnote_collector.any?
+ content += generate_footnotetext_from_collector(@rendering_context.footnote_collector)
+ @rendering_context.footnote_collector.clear
+ end
+
+ # Ensure content ends with single newline if it contains content
+ # Remove all trailing newlines and add exactly one back
+ if content && !content.empty?
+ content.sub(/\n+\z/, '') + "\n"
+ else
+ content || ''
+ end
+ end
+
+ def visit_headline(node)
+ level = node.level
+ caption = render_children(node.caption_node) if node.caption_node
+
+ # Handle special headline options (nonum, notoc, nodisp)
+ # These do NOT increment the section counter (matching LATEXBuilder behavior)
+ if node.nodisp?
+ # nodisp: Only add TOC entry, no visible heading
+ return generate_toc_entry(level, caption)
+ elsif node.nonum?
+ # nonum: Unnumbered section that appears in TOC
+ return generate_nonum_headline(level, caption, node)
+ elsif node.notoc?
+ # notoc: Unnumbered section that does NOT appear in TOC
+ return generate_notoc_headline(level, caption, node)
+ end
+
+ # Update section counter like LATEXBuilder (only for regular numbered headlines)
+ if @sec_counter
+ @sec_counter.inc(level)
+ end
+
+ # Regular headline processing
+ section_command = headline_name(level)
+
+ # Format with exact newlines like LATEXBuilder to match expected format
+ result = []
+ result << "\\#{section_command}{#{caption}}"
+
+ # Add \addcontentsline for unnumbered sections within toclevel
+ # Match LATEXBuilder logic: only add to TOC if level is within toclevel
+ if (level > config['secnolevel'] || (@chapter.number.to_s.empty? && level > 1)) &&
+ level <= config['toclevel'].to_i
+ # Get the base section name for TOC entry
+ toc_section_name = get_base_section_name(level)
+ result << "\\addcontentsline{toc}{#{toc_section_name}}{#{caption}}"
+ end
+
+ # Generate labels like LATEXBuilder - add both automatic and custom labels
+ if level == 1 && @chapter
+ result << "\\label{chap:#{@chapter.id}}"
+ elsif @sec_counter && level >= 2
+ # Generate section labels like LATEXBuilder (sec:x-y format)
+ anchor = @sec_counter.anchor(level)
+ result << "\\label{sec:#{anchor}}"
+ # Add custom label if specified (only for level > 1, matching LATEXBuilder)
+ if node.label && !node.label.empty?
+ result << "\\label{#{escape(node.label)}}"
+ end
+ end
+
+ result.join("\n") + "\n\n"
+ end
+
+ def visit_paragraph(node)
+ content = render_children(node)
+
+ # Check for noindent attribute
+ if node.attribute?(:noindent)
+ # Add \noindent command like LATEXBuilder
+ "\\noindent\n#{content}\n\n"
+ else
+ # Add double newline for paragraph separation (LaTeX standard)
+ "#{content}\n\n"
+ end
+ end
+
+ def visit_text(node)
+ content = node.content.to_s
+ # Preserve newlines and escape content properly
+ # Don't escape newlines so they are preserved in the output
+ escape(content)
+ end
+
+ # Process caption for code blocks with proper context management
+ # @param node [CodeBlockNode] The code block node
+ # @return [Array<String, Object>] [caption, caption_collector]
+ def process_code_block_caption(node)
+ caption = nil
+ caption_collector = nil
+
+ if node.caption_node
+ @rendering_context.with_child_context(:caption) do |caption_context|
+ caption = render_children_with_context(node.caption_node, caption_context)
+ caption_collector = caption_context.footnote_collector
+ end
+ end
+
+ [caption, caption_collector]
+ end
+
+ # Add footnotetext commands from collector to result
+ # @param result [String] The rendered result
+ # @param caption_collector [Object] The footnote collector
+ # @return [String] Result with footnotetext commands appended
+ def append_footnotetext_from_collector(result, caption_collector)
+ if caption_collector && caption_collector.any?
+ result += generate_footnotetext_from_collector(caption_collector)
+ caption_collector.clear
+ end
+ result
+ end
+
+ # Visit list code block
+ def visit_code_block_list(node)
+ caption, caption_collector = process_code_block_caption(node)
+ content = render_children(node)
+ result = visit_list_block(node, content, caption)
+ append_footnotetext_from_collector(result, caption_collector)
+ end
+
+ # Visit listnum code block (list with line numbers)
+ def visit_code_block_listnum(node)
+ caption, caption_collector = process_code_block_caption(node)
+ content = render_children(node)
+ result = visit_list_block(node, add_line_numbers(content, node), caption)
+ append_footnotetext_from_collector(result, caption_collector)
+ end
+
+ # Visit emlist code block
+ def visit_code_block_emlist(node)
+ caption, caption_collector = process_code_block_caption(node)
+ content = render_children(node)
+ result = visit_emlist_block(node, content, caption)
+ append_footnotetext_from_collector(result, caption_collector)
+ end
+
+ # Visit emlistnum code block (emlist with line numbers)
+ def visit_code_block_emlistnum(node)
+ caption, caption_collector = process_code_block_caption(node)
+ content = render_children(node)
+ result = visit_emlist_block(node, add_line_numbers(content, node), caption)
+ append_footnotetext_from_collector(result, caption_collector)
+ end
+
+ # Visit cmd code block
+ def visit_code_block_cmd(node)
+ caption, caption_collector = process_code_block_caption(node)
+ content = render_children(node)
+ result = visit_cmd_block(node, content, caption)
+ append_footnotetext_from_collector(result, caption_collector)
+ end
+
+ # Visit source code block
+ def visit_code_block_source(node)
+ caption, caption_collector = process_code_block_caption(node)
+ content = render_children(node)
+ result = visit_source_block(node, content, caption)
+ append_footnotetext_from_collector(result, caption_collector)
+ end
+
+ def visit_code_line(node)
+ # Render children (TextNode and InlineNode) to process inline elements properly
+ content = render_children(node)
+ # Add proper newline for LaTeX code line formatting
+ "#{content}\n"
+ end
+
+ def visit_table(node)
+ # Process caption with proper context management and collect footnotes
+ caption = nil
+ caption_collector = nil
+
+ if node.caption_node
+ @rendering_context.with_child_context(:caption) do |caption_context|
+ caption = render_children_with_context(node.caption_node, caption_context)
+ # Save the collector for later processing
+ caption_collector = caption_context.footnote_collector
+ end
+ end
+
+ table_type = node.table_type
+
+ # Handle imgtable specially - it should be rendered as an image
+ if table_type == :imgtable
+ result = visit_imgtable(node, caption)
+ # Add collected footnotetext commands from caption context for imgtable
+ if caption_collector && caption_collector.any?
+ result += generate_footnotetext_from_collector(caption_collector)
+ caption_collector.clear
+ end
+ return result
+ end
+
+ # Process table content with table context
+ table_context = nil
+ table_content = @rendering_context.with_child_context(:table) do |ctx|
+ table_context = ctx
+
+ # Get column specification from TableNode (set by TsizeProcessor)
+ # or use default values if not set
+ col_spec = node.col_spec || node.default_col_spec
+ cellwidth = node.cellwidth || node.default_cellwidth
+
+ # Store cellwidth temporarily for visit_table_cell_with_index to access
+ # This is needed because cell rendering happens in nested visitor calls
+ @current_table_cellwidth = cellwidth
+
+ # Get all rows for processing
+ all_rows = node.header_rows + node.body_rows
+
+ result = []
+
+ # Only output \begin{table} if caption is present (like LATEXBuilder)
+ if caption.present?
+ result << if node.id?
+ "\\begin{table}%%#{node.id}"
+ else
+ '\\begin{table}%%'
+ end
+ end
+
+ # Process caption and label
+ if caption.present?
+ # emtable uses reviewtablecaption* (with asterisk)
+ caption_command = table_type == :emtable ? 'reviewtablecaption*' : 'reviewtablecaption'
+ result << "\\#{caption_command}{#{caption}}"
+ end
+
+ if node.id?
+ # Generate label like LATEXBuilder: table:chapter:id
+ # Don't escape underscores in labels - they're allowed in LaTeX label names
+ result << if @chapter
+ "\\label{table:#{@chapter.id}:#{node.id}}"
+ else
+ "\\label{table:test:#{node.id}}"
+ end
+ end
+
+ result << "\\begin{reviewtable}{#{col_spec}}"
+ result << '\\hline'
+
+ # Process all rows using visitor pattern with table context
+ all_rows.each do |row|
+ row_content = visit_with_context(row, table_context)
+ result << "#{row_content} \\\\ \\hline"
+ end
+
+ result << '\\end{reviewtable}'
+
+ # Only output \end{table} if caption is present (like LATEXBuilder)
+ if caption.present?
+ result << '\\end{table}'
+ end
+
+ result.join("\n") + "\n"
+ end
+
+ # Add collected footnotetext commands from caption context
+ if caption_collector && caption_collector.any?
+ table_content += generate_footnotetext_from_collector(caption_collector)
+ caption_collector.clear
+ end
+
+ # Add collected footnotetext commands from table context
+ if table_context && table_context.footnote_collector.any?
+ table_content += generate_footnotetext_from_collector(table_context.footnote_collector)
+ table_context.footnote_collector.clear
+ end
+
+ table_content.chomp + "\n\n"
+ end
+
+ def visit_imgtable(node, caption)
+ # imgtable is rendered as table with image inside (like LATEXBuilder)
+ result = []
+
+ # Check if image is bound like LATEXBuilder does
+ unless node.id? && @chapter && @chapter.image_bound?(node.id)
+ # No ID or chapter, or image not bound - return dummy
+ result << '\\begin{reviewdummyimage}'
+ result << "% image not bound: #{node.id}" if node.id?
+ result << '\\end{reviewdummyimage}'
+ return result.join("\n") + "\n"
+ end
+
+ # Get image path - image is bound, so this should succeed
+ image_path = @chapter.image(node.id).path
+
+ # Generate table structure with image like LATEXBuilder
+ # Start table environment if caption exists (line 911)
+ if caption && !caption.empty?
+ result << "\\begin{table}[h]%%#{node.id}"
+
+ # Add caption and label at top if caption_top?
+ if caption_top?('table')
+ result << "\\reviewimgtablecaption{#{caption}}"
+ end
+
+ # Add table label (line 919) - this needs table index
+ begin
+ result << "\\label{table:#{@chapter.id}:#{node.id}}"
+ rescue ReVIEW::KeyError
+ # If table lookup fails, still continue
+ end
+ end
+
+ # Add image inside reviewimage environment (lines 937-949)
+ result << "\\begin{reviewimage}%%#{node.id}"
+
+ # Parse metric option like LATEXBuilder
+ metrics = parse_metric('latex', node.metric)
+ command = 'reviewincludegraphics'
+
+ # Use metric if provided, otherwise use default width
+ result << if metrics.present?
+ "\\#{command}[#{metrics}]{#{image_path}}"
+ else
+ "\\#{command}[width=\\maxwidth]{#{image_path}}"
+ end
+
+ result << '\\end{reviewimage}'
+
+ # Close table if caption exists
+ if caption.present?
+ # Add caption at bottom if not caption_top?
+ unless caption_top?('table')
+ result << "\\reviewimgtablecaption{#{caption}}"
+ end
+
+ result << '\\end{table}'
+ end
+
+ result.join("\n") + "\n\n"
+ end
+
+ def visit_table_row(node)
+ # Process all cells in the row using visitor pattern while maintaining table context
+ # Note: table context should already be set by visit_table
+ cells = node.children.map.with_index do |cell, col_index|
+ visit_table_cell_with_index(cell, col_index)
+ end
+ cells.join(' & ')
+ end
+
+ def visit_table_cell(node)
+ # Fallback method if called without index
+ visit_table_cell_with_index(node, 0)
+ end
+
+ def visit_table_cell_with_index(node, col_index)
+ # Process cell content while maintaining table context to collect footnotes
+ # Note: table context should already be set by visit_table
+ content = render_children(node)
+
+ # Get cellwidth for this column from current table's cellwidth array
+ cellwidth = @current_table_cellwidth && @current_table_cellwidth[col_index] ? @current_table_cellwidth[col_index] : 'l'
+
+ # Check if content contains line breaks (from @<br>{})
+ # Like LATEXBuilder: use \newline{} for fixed-width cells (p{...}), otherwise use \shortstack
+ if /\\\\/.match?(content)
+ # Check if cellwidth is fixed-width format (contains `{`)
+ if AST::TableColumnWidthParser.fixed_width?(cellwidth)
+ # Fixed-width cell: replace \\\n with \newline{}
+ content = content.gsub("\\\\\n", '\\newline{}')
+ if node.cell_type == :th
+ "\\reviewth{#{content}}"
+ else
+ content
+ end
+ elsif node.cell_type == :th
+ # Non-fixed-width cell: use \shortstack[l] like LATEXBuilder does
+ "\\reviewth{\\shortstack[l]{#{content}}}"
+ else
+ "\\shortstack[l]{#{content}}"
+ end
+ elsif node.cell_type == :th
+ # No line breaks - standard formatting
+ "\\reviewth{#{content}}"
+ else
+ content
+ end
+ end
+
+ def visit_image(node)
+ # Process caption with proper context management
+ caption = nil
+ caption_collector = nil
+
+ if node.caption_node
+ @rendering_context.with_child_context(:caption) do |caption_context|
+ caption = render_children_with_context(node.caption_node, caption_context)
+ # Save the collector for later processing
+ caption_collector = caption_context.footnote_collector
+ end
+ end
+
+ image_type = node.image_type
+
+ result = case image_type
+ when :indepimage, :numberlessimage
+ visit_indepimage(node, caption)
+ else
+ visit_regular_image(node, caption)
+ end
+
+ # Add collected footnotetext commands from caption context
+ if caption_collector && caption_collector.any?
+ result += generate_footnotetext_from_collector(caption_collector)
+ caption_collector.clear
+ end
+
+ result
+ end
+
+ def visit_regular_image(node, caption)
+ image_path = find_image_path(node.id)
+
+ if image_path
+ render_existing_image(node, image_path, caption, with_label: true)
+ else
+ render_dummy_image(node, caption, double_escape_id: false, with_label: true)
+ end
+ end
+
+ def visit_indepimage(node, caption)
+ image_path = find_image_path(node.id)
+
+ if image_path
+ render_existing_indepimage(node, image_path, caption)
+ else
+ render_dummy_image(node, caption, double_escape_id: true, with_label: false)
+ end
+ end
+
+ def visit_list(node)
+ case node.list_type
+ when :ul
+ # Unordered list - generate LaTeX itemize environment
+ items = node.children.map { |item| "\\item #{render_children(item)}" }.join("\n")
+ "\n\\begin{itemize}\n#{items}\n\\end{itemize}\n\n"
+ when :ol
+ # Ordered list - generate LaTeX enumerate environment
+ items = node.children.map { |item| "\\item #{render_children(item)}" }.join("\n")
+
+ # Check if this list has start_number
+ if node.start_number && node.start_number != 1
+ # Generate enumerate with setcounter for non-default start
+ start_num = node.start_number - 1 # LaTeX counter is 0-based
+ "\n\\begin{enumerate}\n\\setcounter{enumi}{#{start_num}}\n#{items}\n\\end{enumerate}\n\n"
+ else
+ "\n\\begin{enumerate}\n#{items}\n\\end{enumerate}\n\n"
+ end
+ when :dl
+ # Definition list - generate LaTeX description environment like LATEXBuilder
+ visit_definition_list(node)
+ else
+ raise NotImplementedError, "Unsupported list type: #{node.list_type}"
+ end
+ end
+
+ def visit_list_item(node)
+ raise NotImplementedError, 'List item processing should be handled by visit_list, not as standalone items'
+ end
+
+ # Visit quote block
+ def visit_block_quote(node)
+ content = render_children(node)
+ result = "\n\\begin{quote}\n#{content.chomp}\\end{quote}\n\n"
+ apply_noindent_if_needed(node, result)
+ end
+
+ # Visit source block (code block without caption)
+ def visit_block_source(node)
+ content = render_children(node)
+ "\\begin{reviewcmd}\n#{content}\\end{reviewcmd}\n"
+ end
+
+ # Visit lead block (lead paragraph)
+ def visit_block_lead(node)
+ content = render_children(node)
+ result = "\n\\begin{quotation}\n#{content.chomp}\\end{quotation}\n\n"
+ apply_noindent_if_needed(node, result)
+ end
+
+ # Visit olnum block (set ordered list counter)
+ def visit_block_olnum(node)
+ # olnum is now handled as metadata in list processing
+ # If we encounter it here, it means there was no following ordered list
+ # In this case, we should still generate the setcounter command for compatibility
+ if node.args.first
+ num = node.args.first.to_i
+ "\\setcounter{enumi}{#{num - 1}}\n"
+ else
+ "\\setcounter{enumi}{0}\n"
+ end
+ end
+
+ # Visit footnote block
+ def visit_block_footnote(node)
+ # Handle footnote blocks - generate \footnotetext LaTeX command
+ if node.args.length >= 2
+ footnote_id = node.args[0]
+ footnote_content = escape(node.args[1])
+ # Generate footnote number like LaTeXBuilder does
+ if @chapter && @chapter.footnote_index
+ begin
+ footnote_number = @chapter.footnote_index.number(footnote_id)
+ "\\footnotetext[#{footnote_number}]{#{footnote_content}}\n"
+ rescue ReVIEW::KeyError => e
+ raise NotImplementedError, "Footnote block processing failed for #{footnote_id}: #{e.message}"
+ end
+ else
+ raise NotImplementedError, 'Footnote processing requires chapter context but none provided'
+ end
+ else
+ raise NotImplementedError, 'Malformed footnote block: insufficient arguments'
+ end
+ end
+
+ # Visit tsize block (table size control)
+ def visit_block_tsize(_node)
+ # tsize is now processed by TsizeProcessor during AST compilation
+ # The tsize block nodes are removed from AST by TsizeProcessor,
+ # so this case should not be reached. Return empty string for safety.
+ ''
+ end
+
+ # Visit texequation block (mathematical equation)
+ def visit_block_texequation(node)
+ content = render_children(node)
+ # Handle mathematical equation blocks - output content directly
+ # without LaTeX environment wrapping since content is raw LaTeX math
+ content.strip.empty? ? '' : "\n#{content}\n\n"
+ end
+
+ # Visit comment block
+ def visit_block_comment(node)
+ # Handle comment blocks - only output in draft mode
+ visit_comment_block(node)
+ end
+
+ # Visit beginchild block (child nesting control)
+ def visit_block_beginchild(_node)
+ # Child nesting control commands - produce no output
+ ''
+ end
+
+ # Visit endchild block (child nesting control)
+ def visit_block_endchild(_node)
+ # Child nesting control commands - produce no output
+ ''
+ end
+
+ # Visit centering block (center alignment)
+ def visit_block_centering(node)
+ content = render_children(node)
+ "\n\\begin{center}\n#{content.chomp}\\end{center}\n\n"
+ end
+
+ # Visit flushright block (right alignment)
+ def visit_block_flushright(node)
+ content = render_children(node)
+ "\n\\begin{flushright}\n#{content.chomp}\\end{flushright}\n\n"
+ end
+
+ # Visit address block (similar to flushright)
+ def visit_block_address(node)
+ content = render_children(node)
+ "\n\\begin{flushright}\n#{content.chomp}\\end{flushright}\n\n"
+ end
+
+ # Visit talk block (dialog/conversation)
+ def visit_block_talk(node)
+ content = render_children(node)
+ "#{content}\n"
+ end
+
+ # Visit read block (reading material)
+ def visit_block_read(node)
+ content = render_children(node)
+ "\n\\begin{quotation}\n#{content.chomp}\\end{quotation}\n\n"
+ end
+
+ # Visit blockquote block
+ def visit_block_blockquote(node)
+ content = render_children(node)
+ "\n\\begin{quote}\n#{content.chomp}\\end{quote}\n\n"
+ end
+
+ # Visit printendnotes block (print collected endnotes)
+ def visit_block_printendnotes(_node)
+ "\n\\theendnotes\n\n"
+ end
+
+ # Visit label block (create label)
+ def visit_block_label(node)
+ if node.args.first
+ label_id = node.args.first
+ "\\label{#{escape(label_id)}}\n"
+ else
+ ''
+ end
+ end
+
+ # Visit blankline block (control command)
+ def visit_block_blankline(_node)
+ "\\par\\vspace{\\baselineskip}\\par\n\n"
+ end
+
+ # Visit noindent block (control command)
+ def visit_block_noindent(_node)
+ ''
+ end
+
+ # Visit pagebreak block (control command)
+ def visit_block_pagebreak(_node)
+ ''
+ end
+
+ # Visit endnote block (control command)
+ def visit_block_endnote(_node)
+ ''
+ end
+
+ # Visit hr block (control command)
+ def visit_block_hr(_node)
+ ''
+ end
+
+ # Visit bpo block (control command)
+ def visit_block_bpo(_node)
+ ''
+ end
+
+ # Visit parasep block (control command)
+ def visit_block_parasep(_node)
+ ''
+ end
+
+ # Visit bibpaper block (bibliography paper)
+ def visit_block_bibpaper(node)
+ visit_bibpaper(node)
+ end
+
+ def visit_minicolumn(node)
+ # Process caption with proper context management and collect footnotes
+ caption = nil
+ caption_collector = nil
+
+ if node.caption_node
+ @rendering_context.with_child_context(:caption) do |caption_context|
+ caption = render_children_with_context(node.caption_node, caption_context)
+ # Save the collector for later processing
+ caption_collector = caption_context.footnote_collector
+ end
+ end
+
+ content = render_children(node)
+
+ env_name = case node.minicolumn_type.to_s
+ when 'note'
+ 'reviewnote'
+ when 'memo'
+ 'reviewmemo'
+ when 'tip'
+ 'reviewtip'
+ when 'info'
+ 'reviewinfo'
+ when 'warning'
+ 'reviewwarning'
+ when 'important'
+ 'reviewimportant'
+ when 'caution'
+ 'reviewcaution'
+ when 'notice'
+ 'reviewnotice'
+ else
+ 'reviewcolumn'
+ end
+
+ result = []
+ result << if caption && !caption.empty?
+ "\\begin{#{env_name}}[#{caption}]"
+ else
+ "\\begin{#{env_name}}"
+ end
+ result << '' # blank line after begin
+ result << content.chomp
+ result << "\\end{#{env_name}}"
+
+ output = result.join("\n") + "\n\n"
+
+ # Add collected footnotetext commands from caption context
+ if caption_collector && caption_collector.any?
+ output += generate_footnotetext_from_collector(caption_collector)
+ caption_collector.clear
+ end
+
+ output
+ end
+
+ def visit_caption(node)
+ render_children(node)
+ end
+
+ def visit_comment_block(node)
+ # block comment - only display in draft mode
+ return '' unless config['draft']
+
+ content_lines = []
+
+ # add argument if it exists
+ if node.args.first&.then { |arg| !arg.empty? }
+ content_lines << escape(node.args.first)
+ end
+
+ # add body content
+ if node.content && !node.content.empty?
+ body_content = render_children(node)
+ content_lines << body_content unless body_content.empty?
+ end
+
+ return '' if content_lines.empty?
+
+ # use pdfcomment macro in LaTeX
+ content_str = content_lines.join('\\par ')
+ "\\pdfcomment{#{content_str}}\n"
+ end
+
+ def visit_column(node)
+ caption = render_children(node.caption_node) if node.caption_node
+
+ # Generate column label for hypertarget (using auto_id from Compiler)
+ column_label = generate_column_label(node, caption)
+ hypertarget = "\\hypertarget{#{column_label}}{}"
+
+ # Process column content with :column context to collect footnotes
+ column_context = nil
+ content = @rendering_context.with_child_context(:column) do |ctx|
+ column_context = ctx
+ render_children_with_context(node, column_context)
+ end
+
+ result = []
+ result << '' # blank line before column
+
+ # support Re:VIEW Version 3+ format only
+ caption_part = caption ? "[#{caption}#{hypertarget}]" : "[#{hypertarget}]"
+ result << "\\begin{reviewcolumn}#{caption_part}"
+
+ # Add TOC entry if within toclevel
+ if node.level && caption && node.level <= config['toclevel'].to_i
+ toc_level = case node.level
+ when 1
+ 'chapter'
+ when 2
+ 'section'
+ when 3
+ 'subsection'
+ when 4
+ 'subsubsection'
+ else # rubocop:disable Lint/DuplicateBranch
+ 'subsection' # fallback
+ end
+ result << "\\addcontentsline{toc}{#{toc_level}}{#{caption}}"
+ end
+
+ result << '' # blank line after header
+ result << content.chomp
+ result << '\\end{reviewcolumn}'
+ result << '' # blank line after column
+
+ output = result.join("\n") + "\n"
+
+ # Add collected footnotetext commands from column context
+ if column_context && column_context.footnote_collector.any?
+ output += generate_footnotetext_from_collector(column_context.footnote_collector)
+ column_context.footnote_collector.clear
+ end
+
+ output
+ end
+
+ def visit_embed(node)
+ # All embed types now use unified processing
+ process_raw_embed(node)
+ end
+
+ # Code block type handlers
+ def visit_list_block(node, content, caption)
+ result = []
+ result << '\\begin{reviewlistblock}'
+
+ if caption && !caption.empty?
+ # Use LATEXBuilder logic for list caption with proper numbering
+ if node.id?
+ # For list blocks with ID, generate numbered caption like LATEXBuilder
+ begin
+ list_item = @chapter.list(node.id)
+ list_num = list_item.number
+ chapter_num = @chapter.number
+ captionstr = "\\reviewlistcaption{#{text_formatter.format_caption('list', chapter_num, list_num, caption)}}"
+ result << captionstr
+ rescue ReVIEW::KeyError
+ raise NotImplementedError, "no such list: #{node.id}"
+ end
+ else
+ # For list blocks without ID, use simple caption
+ result << "\\reviewlistcaption{#{caption}}"
+ end
+ end
+
+ result << '\\begin{reviewlist}'
+ result << content.chomp
+ result << '\\end{reviewlist}'
+ result << '\\end{reviewlistblock}'
+ result.join("\n") + "\n\n"
+ end
+
+ def visit_emlist_block(_node, content, caption)
+ result = []
+ result << '\\begin{reviewlistblock}'
+
+ if caption && !caption.empty?
+ result << "\\reviewemlistcaption{#{caption}}"
+ end
+
+ result << '\\begin{reviewemlist}'
+ result << content.chomp
+ result << '\\end{reviewemlist}'
+
+ result << '\\end{reviewlistblock}'
+ result.join("\n") + "\n\n"
+ end
+
+ def visit_cmd_block(_node, content, caption)
+ result = []
+ result << '\\begin{reviewlistblock}'
+
+ if caption && !caption.empty?
+ result << "\\reviewcmdcaption{#{caption}}"
+ end
+
+ result << '\\begin{reviewcmd}'
+ result << content.chomp
+ result << '\\end{reviewcmd}'
+ result << '\\end{reviewlistblock}'
+ result.join("\n") + "\n\n"
+ end
+
+ def visit_source_block(_node, content, caption)
+ result = []
+ result << '\\begin{reviewlistblock}'
+
+ if caption && !caption.empty?
+ result << "\\reviewsourcecaption{#{caption}}"
+ end
+
+ result << '\\begin{reviewsource}'
+ result << content.chomp
+ result << '\\end{reviewsource}'
+ result << '\\end{reviewlistblock}'
+ result.join("\n") + "\n\n"
+ end
+
+ def visit_tex_equation(node)
+ # Handle LaTeX mathematical equation blocks
+ # Output the LaTeX content directly without escaping since it's raw LaTeX
+ content = node.content
+
+ if node.id? && node.caption?
+ # Equation with ID and caption - use reviewequationblock like traditional compiler
+ equation_num = get_equation_number(node.id)
+ caption_content = render_children(node.caption_node)
+ result = []
+ result << '\\begin{reviewequationblock}'
+ result << "\\reviewequationcaption{#{escape("式#{equation_num}: #{caption_content}")}}"
+ result << '\\begin{equation*}'
+ result << content
+ result << '\\end{equation*}'
+ result << '\\end{reviewequationblock}'
+ elsif node.id?
+ # Equation with ID only - still use reviewequationblock for consistency
+ equation_num = get_equation_number(node.id)
+ result = []
+ result << '\\begin{reviewequationblock}'
+ result << "\\reviewequationcaption{#{escape("式#{equation_num}")}}"
+ result << '\\begin{equation*}'
+ result << content
+ result << '\\end{equation*}'
+ result << '\\end{reviewequationblock}'
+ else
+ # Equation without ID - use equation* environment (no numbering)
+ result = []
+ result << '\\begin{equation*}'
+ result << content
+ result << '\\end{equation*}'
+ end
+ result.join("\n") + "\n\n"
+ end
+
+ # Get equation number for texequation blocks
+ def get_equation_number(equation_id)
+ if @chapter && @chapter.equation_index
+ begin
+ equation_number = @chapter.equation_index.number(equation_id)
+ if @chapter.number
+ "#{@chapter.number}.#{equation_number}"
+ else
+ equation_number.to_s
+ end
+ rescue ReVIEW::KeyError
+ # Fallback if equation not found in index
+ '??'
+ end
+ else
+ '??'
+ end
+ end
+
+ def visit_bibpaper(node)
+ # Extract bibliography arguments
+ if node.args.length >= 2
+ bib_id = node.args[0]
+ bib_caption = node.args[1]
+
+ # Process content
+ content = render_children(node)
+
+ # Generate bibliography entry like LATEXBuilder
+ result = []
+
+ # Header with number and caption
+ if @book.bibpaper_index
+ begin
+ bib_number = @book.bibpaper_index.number(bib_id)
+ result << "[#{bib_number}] #{escape(bib_caption)}"
+ rescue ReVIEW::KeyError => e
+ # Fallback if not found in index
+ warn "Bibpaper #{bib_id} not found in index: #{e.message}" if $DEBUG
+ result << "[??] #{escape(bib_caption)}"
+ end
+ elsif @ast_indexer && @ast_indexer.bibpaper_index
+ # Try to get from AST indexer if chapter index not available
+ begin
+ bib_number = @ast_indexer.bibpaper_index.number(bib_id)
+ result << "[#{bib_number}] #{escape(bib_caption)}"
+ rescue ReVIEW::KeyError
+ result << "[??] #{escape(bib_caption)}"
+ end
+ else
+ result << "[??] #{escape(bib_caption)}"
+ end
+
+ # Add label for cross-references
+ result << "\\label{bib:#{escape(bib_id)}}"
+ result << ''
+
+ # Add content - process paragraphs
+ result << if config['join_lines_by_lang']
+ split_paragraph(content).join("\n\n")
+ else
+ content
+ end
+
+ result.join("\n") + "\n"
+ else
+ raise NotImplementedError, 'Malformed bibpaper block: insufficient arguments'
+ end
+ end
+
+ # Add line numbers to content like LATEXBuilder does
+ def add_line_numbers(content, node = nil)
+ lines = content.split("\n")
+ numbered_lines = []
+
+ # Use node.first_line_num if set, otherwise start from 1
+ start_num = node&.first_line_num || 1
+
+ lines.each_with_index do |line, i|
+ next if line.strip.empty? && i == lines.length - 1 # Skip last empty line
+
+ numbered_lines << sprintf('%2d: %s', start_num + i, line)
+ end
+
+ numbered_lines.join("\n")
+ end
+
+ # Render footnote content for footnotetext
+ # This method processes the footnote node's children to properly handle
+ # inline markup like @<b>{text} within footnotes
+ def render_footnote_content(footnote_node)
+ render_children(footnote_node)
+ end
+
+ # Render inline elements from caption_node
+ # @param caption_node [CaptionNode] Caption node to render
+ # @return [String] Rendered inline elements
+ def render_caption_inline(caption_node)
+ caption_node ? render_children(caption_node) : ''
+ end
+
+ private
+
+ # Get image path, returning nil if image doesn't exist
+ def find_image_path(id)
+ path = @chapter.image(id).path
+ path && !path.empty? ? path : nil
+ rescue StandardError
+ nil
+ end
+
+ # Render existing image (for regular //image)
+ def render_existing_image(node, image_path, caption, with_label:)
+ result = []
+ result << if node.id?
+ "\\begin{reviewimage}%%#{node.id}"
+ else
+ '\\begin{reviewimage}'
+ end
+
+ metrics = parse_metric('latex', node.metric)
+ command = 'reviewincludegraphics'
+
+ result << if metrics && !metrics.empty?
+ "\\#{command}[#{metrics}]{#{image_path}}"
+ else
+ "\\#{command}[width=\\maxwidth]{#{image_path}}"
+ end
+
+ result << "\\reviewimagecaption{#{caption}}" if caption && !caption.empty?
+
+ if with_label && node.id?
+ result << if @chapter
+ "\\label{image:#{@chapter.id}:#{node.id}}"
+ else
+ "\\label{image:test:#{node.id}}"
+ end
+ end
+
+ result << '\\end{reviewimage}'
+ result.join("\n") + "\n"
+ end
+
+ # Render existing indepimage (for //indepimage)
+ def render_existing_indepimage(node, image_path, caption)
+ result = []
+ result << "\\begin{reviewimage}%%#{node.id}"
+
+ if caption_top?('image') && caption && !caption.empty?
+ caption_str = "\\reviewindepimagecaption{#{text_formatter.format_numberless_image}#{text_formatter.format_caption_prefix}#{caption}}"
+ result << caption_str
+ end
+
+ metrics = parse_metric('latex', node.metric)
+ command = 'reviewincludegraphics'
+
+ result << if metrics && !metrics.empty?
+ "\\#{command}[#{metrics}]{#{image_path}}"
+ else
+ "\\#{command}[width=\\maxwidth]{#{image_path}}"
+ end
+
+ if !caption_top?('image') && caption && !caption.empty?
+ caption_str = "\\reviewindepimagecaption{#{text_formatter.format_numberless_image}#{text_formatter.format_caption_prefix}#{caption}}"
+ result << caption_str
+ end
+
+ result << '\\end{reviewimage}'
+ result.join("\n") + "\n"
+ end
+
+ # Render dummy image for missing images
+ def render_dummy_image(node, caption, double_escape_id:, with_label:)
+ result = []
+ result << '\\begin{reviewdummyimage}'
+
+ if node.id?
+ # For regular images: single escape, for indepimage: double escape (like Builder)
+ result << if double_escape_id
+ escape_latex("--[[path = #{escape_latex(node.id)} (not exist)]]--")
+ else
+ escape_latex("--[[path = #{node.id} (not exist)]]--")
+ end
+ end
+
+ if with_label && node.id?
+ result << if @chapter
+ "\\label{image:#{@chapter.id}:#{node.id}}"
+ else
+ "\\label{image:test:#{node.id}}"
+ end
+ end
+
+ if caption && !caption.empty?
+ result << if double_escape_id
+ # indepimage uses reviewindepimagecaption
+ "\\reviewindepimagecaption{#{text_formatter.format_numberless_image}#{text_formatter.format_caption_prefix}#{caption}}"
+ else
+ # regular image uses reviewimagecaption
+ "\\reviewimagecaption{#{caption}}"
+ end
+ end
+
+ result << '\\end{reviewdummyimage}'
+ result.join("\n") + "\n"
+ end
+
+ def ast_compiler
+ @ast_compiler ||= ReVIEW::AST::Compiler.for_chapter(@chapter)
+ end
+
+ # Render definition list with proper footnote handling
+ # Footnotes in definition terms require special handling in LaTeX:
+ # they must use \protect\footnotemark{} in the term and \footnotetext
+ # after the description environment
+ def visit_definition_list(node)
+ dl_context = nil
+ items_content = @rendering_context.with_child_context(:dl) do |ctx|
+ dl_context = ctx
+ # Temporarily set the renderer's context to the dl context
+ old_context = @rendering_context
+ @rendering_context = dl_context
+
+ items = node.children.map do |item|
+ render_definition_item(item, dl_context)
+ end.join("\n")
+
+ # Restore the previous context
+ @rendering_context = old_context
+ items
+ end
+
+ # Build output
+ result = "\n\\begin{description}\n#{items_content}\n\\end{description}\n\n"
+
+ # Add collected footnotetext commands from dt contexts (transferred to dl_context)
+ if dl_context && dl_context.footnote_collector.any?
+ result += generate_footnotetext_from_collector(dl_context.footnote_collector)
+ dl_context.footnote_collector.clear
+ end
+
+ result
+ end
+
+ # Render a single definition list item
+ def render_definition_item(item, dl_context)
+ # Render term with :dt context like LATEXBuilder does (latexbuilder.rb:361-382)
+ term = render_definition_term(item, dl_context)
+
+ # Escape square brackets in terms like LATEXBuilder does
+ term = term.gsub('[', '\\lbrack{}').gsub(']', '\\rbrack{}')
+
+ # Handle definition content (all children are definition content)
+ if item.children && !item.children.empty?
+ definition_parts = item.children.map do |child|
+ result = visit(child) # Use visit instead of render_children for individual nodes
+ # Strip all trailing whitespace and newlines
+ # LATEXBuilder's dd() joins lines with "\n", so we need single newlines between paragraphs
+ result.rstrip
+ end
+ # Join with single newline to match LATEXBuilder dd() behavior (lines.map(&:chomp).join("\n"))
+ definition = definition_parts.join("\n")
+
+ # Use exact LATEXBuilder format: \item[term] \mbox{} \\
+ "\\item[#{term}] \\mbox{} \\\\\n#{definition}"
+ else
+ # No definition content - term only
+ "\\item[#{term}] \\mbox{} \\\\"
+ end
+ end
+
+ # Render definition term with proper footnote collection
+ def render_definition_term(item, dl_context)
+ term = nil
+ dt_footnote_collector = nil
+
+ @rendering_context.with_child_context(:dt) do |dt_context|
+ # Temporarily set renderer's context to dt context for term rendering
+ old_dt_context = @rendering_context
+ @rendering_context = dt_context
+
+ term = if item.term_children&.any?
+ # Render term children (which contain inline elements)
+ item.term_children.map { |child| visit(child) }.join
+ else
+ ''
+ end
+
+ @rendering_context = old_dt_context
+
+ # Save dt_context's footnote collector to transfer footnotes to dl_context
+ dt_footnote_collector = dt_context.footnote_collector
+ end
+
+ # Transfer footnotes from dt_context to dl_context
+ if dt_footnote_collector && dt_footnote_collector.any?
+ dt_footnote_collector.each do |entry|
+ dl_context.collect_footnote(entry.node, entry.number)
+ end
+ dt_footnote_collector.clear
+ end
+
+ term
+ end
+
+ # Generate LaTeX footnotetext commands from collected footnotes
+ # @param collector [FootnoteCollector] the footnote collector
+ # @return [String] LaTeX footnotetext commands
+ def generate_footnotetext_from_collector(collector)
+ return '' unless collector.any?
+
+ footnotetext_commands = []
+ collector.each do |entry|
+ content = render_footnote_content(entry.node)
+ footnotetext_commands << "\\footnotetext[#{entry.number}]{#{content}}"
+ end
+
+ footnotetext_commands.join("\n") + "\n"
+ end
+
+ HEADLINE = { # rubocop:disable Lint/UselessConstantScoping
+ 1 => 'chapter',
+ 2 => 'section',
+ 3 => 'subsection',
+ 4 => 'subsubsection',
+ 5 => 'paragraph',
+ 6 => 'subparagraph'
+ }.freeze
+
+ def headline_name(level)
+ name = if @chapter.is_a?(ReVIEW::Book::Part) && level == 1
+ 'part'
+ else
+ HEADLINE[level] || raise(CompileError, "Unsupported headline level: #{level}. LaTeX only supports levels 1-6")
+ end
+
+ if level > config['secnolevel'] || (@chapter.number.to_s.empty? && level > 1)
+ "#{name}*"
+ else
+ name
+ end
+ end
+
+ def render_inline_element(type, content, node)
+ # Delegate to inline element handler
+ method_name = "render_inline_#{type}"
+ if @inline_element_handler.respond_to?(method_name, true)
+ @inline_element_handler.send(method_name, type, content, node)
+ else
+ raise NotImplementedError, "Unknown inline element: #{type}"
+ end
+ end
+
+ def visit_reference(node)
+ if node.resolved?
+ format_resolved_reference(node.resolved_data)
+ else
+ # Reference resolution was skipped or disabled
+ # Return content as fallback
+ escape(node.content || '')
+ end
+ end
+
+ # Format resolved reference based on ResolvedData
+ # Gets plain text from TextFormatter and wraps it with LaTeX markup
+ def format_resolved_reference(data)
+ # Get plain text from TextFormatter (no LaTeX markup)
+ plain_text = text_formatter.format_reference(data.reference_type, data)
+
+ # Wrap with LaTeX-specific markup based on reference type
+ case data.reference_type
+ when :image, :table, :list
+ # For image/table/list, use \ref command
+ if data.cross_chapter?
+ "\\ref{#{data.chapter_id}:#{data.item_id}}"
+ else
+ "\\ref{#{data.item_id}}"
+ end
+ when :equation
+ # For equation, use \ref command
+ "\\ref{#{data.item_id}}"
+ when :footnote
+ # For footnote, use \footnotemark command
+ "\\footnotemark[#{data.item_number}]"
+ when :bibpaper
+ # For bibliography, use \reviewbibref command
+ "\\reviewbibref{[#{data.item_number}]}{bib:#{data.item_id}}"
+ else
+ # For other types (chapter, headline, column, word, endnote), return escaped plain text
+ escape(plain_text)
+ end
+ end
+
+ # Render document children with proper separation
+ def render_document_children(node)
+ results = []
+ node.children.each_with_index do |child, _index|
+ result = visit(child)
+ next if result.nil? || result.empty?
+
+ # Add proper separation after raw embeds
+ if child.is_a?(ReVIEW::AST::EmbedNode) && child.embed_type == :raw && !result.end_with?("\n")
+ result += "\n"
+ end
+
+ results << result
+ end
+
+ content = results.join
+
+ # Post-process to fix consecutive minicolumn blocks spacing like LATEXBuilder's solve_nest
+ # When minicolumn blocks are consecutive, remove extra blank line between them
+ # Pattern: \end{reviewnote}\n\n\begin{reviewnote} should become \end{reviewnote}\n\begin{reviewnote}
+ content.gsub!(/\\end\{(reviewnote|reviewmemo|reviewtip|reviewinfo|reviewwarning|reviewimportant|reviewcaution|reviewnotice)\}\n\n\\begin\{(reviewnote|reviewmemo|reviewtip|reviewinfo|reviewwarning|reviewimportant|reviewcaution|reviewnotice)\}/,
+ "\\\\end{\\1}\n\\\\begin{\\2}")
+
+ content
+ end
+
+ # Render children with specific rendering context
+ def render_children_with_context(node, context)
+ old_context = @rendering_context
+ @rendering_context = context
+ result = render_children(node)
+ @rendering_context = old_context
+ result
+ end
+
+ # Visit node with specific rendering context
+ def visit_with_context(node, context)
+ old_context = @rendering_context
+ @rendering_context = context
+ result = visit(node)
+ @rendering_context = old_context
+ result
+ end
+
+ def visit_footnote(_node)
+ # FootnoteNode represents a footnote definition (//footnote[id][content])
+ # In AST rendering, footnote definitions do not produce direct output.
+ # Instead, footnotes are rendered via:
+ # 1. @<fn>{id} inline references produce \footnotemark or \footnote
+ # 2. Collected footnotes (from captions/tables) are output as \footnotetext
+ # by the parent node (code_block, table, image) after processing
+ ''
+ end
+
+ # Check caption position configuration
+ def caption_top?(type)
+ unless %w[top bottom].include?(config.dig('caption_position', type))
+ # Default to top if not configured
+ return true
+ end
+
+ config['caption_position'][type] != 'bottom'
+ end
+
+ # This method calls super to use the base implementation, then applies LaTeX-specific logic
+ def parse_metric(type, metric)
+ s = super
+ # If use_original_image_size is enabled and result is empty and no metric provided
+ if config&.dig('pdfmaker', 'use_original_image_size') && s.empty? && !metric&.present?
+ return ' ' # pass empty space to \reviewincludegraphics to use original size
+ end
+
+ s
+ end
+
+ # Handle individual metric transformations (like scale to width conversion)
+ def handle_metric(str)
+ # Check if image_scale2width is enabled and metric is scale
+ if config&.dig('pdfmaker', 'image_scale2width') && str =~ /\Ascale=([\d.]+)\Z/
+ return "width=#{$1}\\maxwidth"
+ end
+
+ str
+ end
+
+ # Apply noindent if the node has the noindent attribute
+ def apply_noindent_if_needed(node, content)
+ if node.attribute?(:noindent)
+ "\\noindent\n#{content}"
+ else
+ content
+ end
+ end
+
+ # Check if Part document should be wrapped with reviewpart environment
+ def should_wrap_part_with_reviewpart?
+ @chapter.is_a?(ReVIEW::Book::Part)
+ end
+
+ # Generate TOC entry only (for nodisp headlines)
+ def generate_toc_entry(level, caption)
+ toc_type = case level
+ when 1
+ 'chapter'
+ when 2
+ 'section'
+ else
+ 'subsection'
+ end
+ "\\addcontentsline{toc}{#{toc_type}}{#{caption}}\n"
+ end
+
+ # Generate unnumbered headline with TOC entry (for nonum headlines)
+ def generate_nonum_headline(level, caption, _node)
+ section_command = get_base_section_name(level) + '*'
+
+ # Add TOC entry
+ toc_type = case level
+ when 1
+ 'chapter'
+ when 2
+ 'section'
+ else
+ 'subsection'
+ end
+
+ "\\#{section_command}{#{caption}}\n\\addcontentsline{toc}{#{toc_type}}{#{caption}}\n\n"
+ end
+
+ # Generate unnumbered headline without TOC entry (for notoc headlines)
+ def generate_notoc_headline(level, caption, _node)
+ section_command = get_base_section_name(level) + '*'
+
+ "\\#{section_command}{#{caption}}\n\n"
+ end
+
+ # Get base section name without star
+ def get_base_section_name(level)
+ if @chapter.is_a?(ReVIEW::Book::Part) && level == 1
+ 'part'
+ else
+ HEADLINE[level] || raise(CompileError, "Unsupported headline level: #{level}")
+ end
+ end
+
+ # Generate column label for hypertarget (matches LATEXBuilder behavior)
+ def generate_column_label(node, _caption)
+ # Use column_number directly instead of parsing auto_id
+ num = node.column_number || 'unknown'
+
+ "column:#{@chapter&.id || 'unknown'}:#{num}"
+ end
+
+ # Process //raw command with LATEXBuilder-compatible behavior
+ def process_raw_embed(node)
+ # Skip HTML embeds (from Markdown raw HTML) - they are not compatible with LaTeX
+ return '' if node.embed_type.to_s == 'html'
+
+ # Check if this embed is targeted for LaTeX builder
+ unless node.targeted_for?('latex')
+ return ''
+ end
+
+ # Get content
+ content = node.content || ''
+
+ # Process \n based on embed type
+ case node.embed_type
+ when :inline, :raw
+ # For inline and raw embeds, convert \\n to actual newlines
+ content = content.gsub('\\n', "\n")
+ end
+
+ # For block embeds, add trailing newline
+ node.embed_type == :block ? content + "\n" : content
+ end
+ end
+ end
+end
diff --git a/lib/review/renderer/markdown_renderer.rb b/lib/review/renderer/markdown_renderer.rb
new file mode 100644
index 000000000..380664176
--- /dev/null
+++ b/lib/review/renderer/markdown_renderer.rb
@@ -0,0 +1,1039 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2025 Kenshi Muto, Masayoshi Takahashi
+#
+# This program is free software.
+# You can distribute or modify this program under the terms of
+# the GNU LGPL, Lesser General Public License version 2.1.
+
+require 'review/htmlutils'
+require 'review/textutils'
+require 'review/loggable'
+require_relative 'base'
+
+module ReVIEW
+ module Renderer
+ class MarkdownRenderer < Base
+ include ReVIEW::HTMLUtils
+ include ReVIEW::TextUtils
+ include ReVIEW::Loggable
+
+ def initialize(chapter)
+ super
+ @blank_seen = true
+ @ul_indent = 0
+ @table_rows = []
+ @table_header_count = 0
+ @rendering_context = nil
+ end
+
+ def target_name
+ 'markdown'
+ end
+
+ def visit_document(node)
+ render_children(node)
+ end
+
+ def visit_headline(node)
+ level = node.level
+ caption = render_caption_inline(node.caption_node)
+
+ # Use Markdown # syntax
+ prefix = '#' * level
+ "#{prefix} #{caption}\n\n"
+ end
+
+ def visit_paragraph(node)
+ # Render children with spacing between adjacent inline elements
+ content = render_children_with_inline_spacing(node)
+ return '' if content.empty?
+
+ lines = content.split("\n")
+ result = lines.join(' ')
+
+ "#{result}\n\n"
+ end
+
+ def visit_list(node)
+ result = +''
+
+ case node.list_type
+ when :ul
+ node.children.each do |item|
+ result += visit_list_item(item, :ul)
+ end
+ when :ol
+ node.children.each_with_index do |item, index|
+ result += visit_list_item(item, :ol, index + 1)
+ end
+ when :dl
+ node.children.each do |item|
+ result += visit_definition_item(item)
+ end
+ else
+ raise NotImplementedError, "MarkdownRenderer does not support list_type #{node.list_type}."
+ end
+
+ result + "\n"
+ end
+
+ def visit_list_item(node, type = :ul, number = nil)
+ # Separate text content from nested lists
+ text_content = +''
+ nested_lists = +''
+
+ node.children.each do |child|
+ if child.class.name.include?('ListNode')
+ # This is a nested list - render it separately
+ nested_lists += visit(child)
+ else
+ # This is regular content
+ text_content += visit(child)
+ end
+ end
+
+ text_content = text_content.chomp
+
+ # Use the level attribute from the node for proper indentation
+ level = node.level || 1
+
+ result = case type
+ when :ul
+ # Calculate indent based on level (0-based indentation: level 1 = 0 spaces, level 2 = 2 spaces, etc.)
+ indent = ' ' * (level - 1)
+ "#{indent}* #{text_content}\n"
+ when :ol
+ # For ordered lists, also apply indentation based on level
+ indent = ' ' * (level - 1)
+ "#{indent}#{number}. #{text_content}\n"
+ end
+
+ # Add any nested lists after the item
+ result += nested_lists
+ result
+ end
+
+ def visit_item(node)
+ # Handle list items that come directly without parent list context
+ content = render_children(node).chomp
+ "* #{content}\n"
+ end
+
+ def visit_definition_item(node)
+ # Check if term contains inline elements that render as ** (bold/strong)
+ # to avoid nesting issues like ****bold****
+ term_has_bold = node.term_children&.any? do |child|
+ child.is_a?(ReVIEW::AST::InlineNode) && %i[b strong].include?(child.inline_type)
+ end
+
+ # Handle definition term - use term_children (AST structure)
+ term = if node.term_children && !node.term_children.empty?
+ # Render term children (which contain inline elements)
+ node.term_children.map { |child| visit(child) }.join
+ else
+ '' # No term available
+ end
+
+ # Handle definition content (all children are definition content)
+ definition_parts = node.children.map do |child|
+ visit(child) # Use visit instead of render_children for individual nodes
+ end
+ definition = definition_parts.join(' ').strip
+
+ # Format term: if term contains bold inline elements, don't wrap in **
+ if term_has_bold
+ # Term already has strong emphasis, use it as-is
+ "#{term}: #{definition}\n\n"
+ else
+ # Wrap plain term in bold
+ "**#{term}**: #{definition}\n\n"
+ end
+ end
+
+ # Common code block rendering method used by all code block types
+ def render_code_block_common(node)
+ result = ''
+ lang = node.lang || ''
+
+ # Add div wrapper with ID (if node has id)
+ if node.id && !node.id.empty?
+ list_id = normalize_id(node.id)
+ result += %Q(<div id="#{list_id}">\n\n)
+ end
+
+ # Add caption if present
+ caption = render_caption_inline(node.caption_node)
+ if caption && !caption.empty?
+ result += "**#{caption}**\n\n"
+ end
+
+ # Generate fenced code block
+ result += "```#{lang}\n"
+
+ # Handle line numbers if needed
+ if node.line_numbers
+ code_content = render_children(node).chomp
+ lines = code_content.split("\n")
+ first_line_number = (node.respond_to?(:first_line_number) && node.first_line_number) || 1
+
+ lines.each_with_index do |line, i|
+ line_num = (first_line_number + i).to_s.rjust(3)
+ result += "#{line_num}: #{line}\n"
+ end
+ else
+ code_content = render_children(node)
+ # Remove trailing newline if present to avoid double newlines
+ code_content = code_content.chomp if code_content.end_with?("\n")
+ result += code_content
+ result += "\n"
+ end
+
+ result += "```\n\n"
+
+ # Close div wrapper if added
+ if node.id && !node.id.empty?
+ result += "</div>\n\n"
+ end
+
+ result
+ end
+
+ # Individual code block type visitors that delegate to common method
+ def visit_code_block_list(node)
+ render_code_block_common(node)
+ end
+
+ def visit_code_block_listnum(node)
+ render_code_block_common(node)
+ end
+
+ def visit_code_block_emlist(node)
+ render_code_block_common(node)
+ end
+
+ def visit_code_block_emlistnum(node)
+ render_code_block_common(node)
+ end
+
+ def visit_code_block_cmd(node)
+ render_code_block_common(node)
+ end
+
+ def visit_code_block_source(node)
+ render_code_block_common(node)
+ end
+
+ def visit_code_line(node)
+ render_children(node) + "\n"
+ end
+
+ def visit_table(node)
+ @table_rows = []
+ @table_header_count = 0
+
+ # Add div wrapper with ID if present
+ id_attr = node.id ? %Q( id="#{normalize_id(node.id)}") : ''
+ result = "<div#{id_attr}>\n\n"
+
+ # Add caption if present
+ caption = render_caption_inline(node.caption_node)
+ result += "**#{caption}**\n\n" unless caption.empty?
+
+ # Process table content
+ render_children(node)
+
+ # Generate markdown table
+ if @table_rows.any?
+ result += generate_markdown_table
+ end
+
+ result += "\n</div>\n\n"
+ result
+ end
+
+ def visit_table_row(node)
+ cells = []
+ node.children.each do |cell|
+ cell_content = render_children(cell).gsub('|', '\\|')
+ # Skip separator rows (rows that contain only dashes)
+ unless /^-+$/.match?(cell_content.strip)
+ cells << cell_content
+ end
+ end
+
+ # Only add non-empty rows
+ if cells.any? { |cell| !cell.strip.empty? }
+ @table_rows << cells
+ @table_header_count = [@table_header_count, cells.length].max if @table_rows.length == 1
+ end
+ ''
+ end
+
+ def visit_table_cell(node)
+ render_children(node)
+ end
+
+ def visit_image(node)
+ # Use node.id as the image path, get path from chapter if image is bound
+ image_path = begin
+ if @chapter&.image_bound?(node.id)
+ @chapter.image(node.id).path
+ else
+ node.id
+ end
+ rescue StandardError
+ # If image lookup fails (e.g., incomplete book structure), use node.id
+ node.id
+ end
+
+ caption = render_caption_inline(node.caption_node)
+
+ # Remove ./ prefix if present
+ image_path = image_path.sub(%r{\A\./}, '')
+
+ # Generate markdown image syntax
+ "\n\n"
+ end
+
+ def visit_minicolumn(node)
+ result = +''
+
+ # Use HTML div for minicolumns as Markdown doesn't have native support
+ css_class = node.minicolumn_type.to_s
+
+ result += %Q(<div class="#{css_class}">\n\n)
+
+ caption = render_caption_inline(node.caption_node)
+ result += "**#{caption}**\n\n" unless caption.empty?
+
+ result += render_children(node)
+ result += "\n</div>\n\n"
+
+ result
+ end
+
+ # visit_block is now handled by Base renderer with dynamic method dispatch
+
+ def visit_block_quote(node)
+ content = render_children(node).chomp
+ lines = content.split("\n")
+ quoted_lines = lines.map { |line| "> #{line}" }
+ "#{quoted_lines.join("\n")}\n\n"
+ end
+
+ def visit_block_centering(node)
+ # Use HTML div for centering in Markdown
+ content = render_children(node)
+ "<div style=\"text-align: center;\">\n\n#{content}\n</div>\n\n"
+ end
+
+ def visit_block_flushright(node)
+ # Use HTML div for right alignment in Markdown
+ content = render_children(node)
+ "<div style=\"text-align: right;\">\n\n#{content}\n</div>\n\n"
+ end
+
+ def visit_block_captionblock(node)
+ # Use HTML div for caption blocks
+ result = %Q(<div class="captionblock">\n\n)
+ result += render_children(node)
+ result += "\n</div>\n\n"
+ result
+ end
+
+ def visit_embed(node)
+ # Handle //raw and @<raw> commands with target builder specification
+ if node.targeted_for?('markdown')
+ content = node.content || ''
+ # Convert \n to actual newlines
+ content.gsub('\\n', "\n")
+ else
+ ''
+ end
+ end
+
+ def visit_column(node)
+ result = +''
+
+ # Use HTML div for columns as Markdown doesn't have native support
+ css_class = node.column_type.to_s
+
+ result += %Q(<div class="#{css_class}">\n\n)
+
+ caption = render_caption_inline(node.caption_node)
+ result += "**#{caption}**\n\n" unless caption.empty?
+
+ result += render_children(node)
+ result += "\n</div>\n\n"
+
+ result
+ end
+
+ def visit_block_lead(node)
+ # Lead paragraphs - render as regular paragraphs in Markdown
+ render_children(node) + "\n"
+ end
+
+ def visit_block_bibpaper(node)
+ # Bibliography entries - render as list items
+ result = +''
+
+ # Get ID and caption
+ bib_id = node.id || ''
+ caption = render_caption_inline(node.caption_node)
+
+ # Format as markdown list item with ID
+ result += "* **[#{bib_id}]** #{caption}\n" unless caption.empty?
+
+ # Add content if any
+ content = render_children(node)
+ result += " #{content.gsub("\n", "\n ")}\n" unless content.strip.empty?
+
+ result + "\n"
+ end
+
+ def visit_block_blankline(_node)
+ # Blank line directive - render as double newline
+ "\n\n"
+ end
+
+ def visit_block_hr(_node)
+ # Horizontal rule - render as Markdown horizontal line
+ "---\n\n"
+ end
+
+ def visit_tex_equation(node)
+ # LaTeX equation block - render as math code block
+ content = node.content.strip
+ result = +''
+
+ if node.id? && node.caption?
+ # With ID and caption
+ caption = render_caption_inline(node.caption_node)
+ result += "**#{caption}**\n\n" unless caption.empty?
+ end
+
+ # Render equation in display math mode ($$...$$)
+ result += "$$\n#{content}\n$$\n\n"
+ result
+ end
+
+ def render_inline_element(type, content, node)
+ method_name = "render_inline_#{type}"
+ if respond_to?(method_name, true)
+ send(method_name, type, content, node)
+ else
+ # Fallback for unknown inline elements: render as plain text
+ # This allows graceful degradation for specialized elements
+ ReVIEW.logger.warn("Unknown inline element: @<#{type}>{...} - rendering as plain text")
+ content
+ end
+ end
+
+ def render_caption_inline(caption_node)
+ return '' unless caption_node
+
+ # Use inline spacing for captions as well
+ content = render_children_with_inline_spacing(caption_node)
+ # Join lines like visit_paragraph does
+ lines = content.split("\n")
+ lines.join(' ')
+ end
+
+ def visit_footnote(node)
+ footnote_id = normalize_id(node.id)
+ content = render_children(node)
+
+ # Use Markdown standard footnote definition notation
+ "[^#{footnote_id}]: #{content}\n\n"
+ end
+
+ def visit_endnote(node)
+ # Endnote definition - treat similar to footnotes
+ endnote_id = node.id
+ content = render_children(node)
+
+ "[^#{endnote_id}]: #{content}\n\n"
+ end
+
+ def visit_block_label(node)
+ # Label definition for cross-references - render as HTML anchor
+ # Label ID is stored in args[0], not in node.id
+ label_id = node.args&.first
+ return '' unless label_id
+
+ "<a id=\"#{normalize_id(label_id)}\"></a>\n\n"
+ end
+
+ def visit_block_printendnotes(_node)
+ # Directive to print endnotes - in Markdown, endnotes are collected automatically
+ # Just output a horizontal rule or section marker
+ "---\n\n**Endnotes**\n\n"
+ end
+
+ def visit_text(node)
+ node.content || ''
+ end
+
+ def visit_reference(node)
+ node.content || ''
+ end
+
+ def render_inline_b(_type, content, _node)
+ "**#{escape_asterisks(content)}**"
+ end
+
+ def render_inline_strong(_type, content, _node)
+ "**#{escape_asterisks(content)}**"
+ end
+
+ def render_inline_i(_type, content, _node)
+ "*#{escape_asterisks(content)}*"
+ end
+
+ def render_inline_em(_type, content, _node)
+ "*#{escape_asterisks(content)}*"
+ end
+
+ def render_inline_code(_type, content, _node)
+ "`#{content}`"
+ end
+
+ def render_inline_tt(_type, content, _node)
+ "`#{content}`"
+ end
+
+ def render_inline_ttb(_type, content, _node)
+ # Bold + monospace: **`content`**
+ "**`#{content}`**"
+ end
+
+ def render_inline_ttbold(type, content, node)
+ # Alias for ttb
+ render_inline_ttb(type, content, node)
+ end
+
+ def render_inline_tti(_type, content, _node)
+ # Italic + monospace: *`content`*
+ "*`#{content}`*"
+ end
+
+ def render_inline_kbd(_type, content, _node)
+ "`#{content}`"
+ end
+
+ def render_inline_samp(_type, content, _node)
+ "`#{content}`"
+ end
+
+ def render_inline_var(_type, content, _node)
+ "*#{escape_asterisks(content)}*"
+ end
+
+ def render_inline_sup(_type, content, _node)
+ "<sup>#{escape_content(content)}</sup>"
+ end
+
+ def render_inline_sub(_type, content, _node)
+ "<sub>#{escape_content(content)}</sub>"
+ end
+
+ def render_inline_del(_type, content, _node)
+ "~~#{content}~~"
+ end
+
+ def render_inline_ins(_type, content, _node)
+ "<ins>#{escape_content(content)}</ins>"
+ end
+
+ def render_inline_u(_type, content, _node)
+ "<u>#{escape_content(content)}</u>"
+ end
+
+ def render_inline_br(_type, _content, _node)
+ "\n"
+ end
+
+ def render_inline_raw(_type, _content, node)
+ node.targeted_for?('markdown') ? (node.content || '') : ''
+ end
+
+ def render_inline_embed(_type, _content, node)
+ node.targeted_for?('markdown') ? (node.content || '') : ''
+ end
+
+ def render_inline_chap(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ chapter_num = text_formatter.format_chapter_number_full(data.chapter_number, data.chapter_type)
+ chapter_id = data.item_id
+
+ # Generate HTML link (same as HtmlRenderer)
+ %Q(<a href="./#{chapter_id}.html">#{escape_content(chapter_num.to_s)}</a>)
+ end
+
+ def render_inline_title(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ title = data.chapter_title || ''
+ chapter_id = data.item_id
+
+ # Generate HTML link with title
+ %Q(<a href="./#{chapter_id}.html">#{escape_content(title)}</a>)
+ end
+
+ def render_inline_chapref(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ display_str = text_formatter.format_reference(:chapter, data)
+ chapter_id = data.item_id
+
+ # Generate HTML link with full chapter reference
+ %Q(<a href="./#{chapter_id}.html">#{escape_content(display_str)}</a>)
+ end
+
+ def render_inline_list(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ text = text_formatter.format_reference_text(:list, data)
+ wrap_reference_with_html(text, data, 'listref')
+ end
+
+ def render_inline_img(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ text = text_formatter.format_reference_text(:image, data)
+ wrap_reference_with_html(text, data, 'imgref')
+ end
+
+ def render_inline_icon(_type, content, node)
+ if node.args.first
+ image_path = node.args.first
+ image_path = image_path.sub(%r{\A\./}, '')
+ ""
+ else
+ ""
+ end
+ end
+
+ def render_inline_table(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ text = text_formatter.format_reference_text(:table, data)
+ wrap_reference_with_html(text, data, 'tableref')
+ end
+
+ def render_inline_fn(_type, _content, node)
+ ref_node = node.children.first
+
+ # Handle both resolved and unresolved references
+ if ref_node.reference_node? && ref_node.resolved?
+ data = ref_node.resolved_data
+ fn_id = normalize_id(data.item_id)
+ elsif ref_node.reference_node?
+ # Unresolved reference - use the ref_id directly
+ fn_id = ref_node.ref_id
+ elsif node.args.any?
+ # Fallback to args if available
+ fn_id = node.args.first
+ end
+
+ # Use Markdown standard footnote notation
+ "[^#{fn_id}]"
+ end
+
+ def render_inline_endnote(_type, content, node)
+ # Endnote references - treat similar to footnotes
+ if node.args.first
+ endnote_id = node.args.first
+ "[^#{endnote_id}]"
+ else
+ "[^#{content}]"
+ end
+ end
+
+ def render_inline_bib(_type, _content, node)
+ # Bibliography reference
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ bib_number = data.item_number
+ # Format as [number] like other builders
+ "[#{bib_number}]"
+ end
+
+ def render_inline_kw(_type, content, node)
+ if node.args.length >= 2
+ word = node.args[0]
+ alt = node.args[1]
+ "**#{escape_asterisks(word)}** (#{escape_content(alt)})"
+ else
+ "**#{escape_asterisks(content)}**"
+ end
+ end
+
+ def render_inline_bou(_type, content, _node)
+ "*#{escape_asterisks(content)}*"
+ end
+
+ def render_inline_ami(_type, content, _node)
+ "*#{escape_asterisks(content)}*"
+ end
+
+ def render_inline_href(_type, content, node)
+ args = node.args || []
+ if args.length >= 2
+ # @<href>{url,text} format
+ url = args[0]
+ text = args[1]
+ "[#{escape_content(text)}](#{url})"
+ elsif args.length == 1
+ # @<href>{url} format - use URL as both text and href
+ url = args[0]
+ "[#{escape_content(url)}](#{url})"
+ else
+ # Fallback to content
+ "[#{escape_content(content)}](#{content})"
+ end
+ end
+
+ def render_inline_ruby(_type, content, node)
+ if node.args.length >= 2
+ base = node.args[0]
+ ruby = node.args[1]
+ "<ruby>#{escape_content(base)}<rt>#{escape_content(ruby)}</rt></ruby>"
+ else
+ escape_content(content)
+ end
+ end
+
+ def render_inline_m(_type, content, _node)
+ "$$#{content}$$"
+ end
+
+ def render_inline_idx(_type, content, _node)
+ escape_content(content)
+ end
+
+ def render_inline_hidx(_type, _content, _node)
+ ''
+ end
+
+ def render_inline_comment(_type, content, _node)
+ if @book&.config&.[]('draft')
+ "<!-- #{escape_content(content)} -->"
+ else
+ ''
+ end
+ end
+
+ def render_inline_hd(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ n = data.headline_number
+ chapter_num = text_formatter.format_chapter_number_short(data.chapter_number, data.chapter_type)
+
+ # Render caption with inline markup
+ caption_html = if data.caption_node
+ render_children(data.caption_node)
+ else
+ escape_content(data.caption_text)
+ end
+
+ # Build full section number
+ full_number = if n.present? && chapter_num && !chapter_num.to_s.empty? && over_secnolevel?(n)
+ ([chapter_num] + n).join('.')
+ end
+
+ str = text_formatter.format_headline_quote(full_number, caption_html)
+
+ # Generate HTML link if section number exists
+ if full_number
+ chapter_id = data.chapter_id || @chapter.id
+ anchor = 'h' + full_number.tr('.', '-')
+ %Q(<a href="#{chapter_id}.html##{anchor}">#{str}</a>)
+ else
+ str
+ end
+ end
+
+ def render_inline_column(_type, _content, node)
+ # Column reference
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+
+ # Use TextFormatter to format column reference (e.g., "コラム「タイトル」")
+ text_formatter.format_reference_text(:column, data)
+ end
+
+ def render_inline_sec(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ n = data.headline_number
+ chapter_num = text_formatter.format_chapter_number_short(data.chapter_number, data.chapter_type)
+
+ # Build full section number
+ full_number = if n.present? && chapter_num && !chapter_num.to_s.empty? && over_secnolevel?(n)
+ ([chapter_num] + n).join('.')
+ else
+ ''
+ end
+
+ # Generate HTML link if section number exists
+ if full_number.present?
+ chapter_id = data.chapter_id || @chapter.id
+ anchor = 'h' + full_number.tr('.', '-')
+ %Q(<a href="#{chapter_id}.html##{anchor}">#{escape_content(full_number)}</a>)
+ else
+ escape_content(full_number)
+ end
+ end
+
+ def render_inline_secref(_type, _content, node)
+ # secref is usually same as sec
+ render_inline_sec(nil, nil, node)
+ end
+
+ def render_inline_sectitle(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+
+ # Render title with inline markup
+ title_html = if data.caption_node
+ render_children(data.caption_node)
+ else
+ escape_content(data.caption_text)
+ end
+
+ # Generate HTML link
+ n = data.headline_number
+ chapter_num = text_formatter.format_chapter_number_short(data.chapter_number, data.chapter_type)
+ full_number = ([chapter_num] + n).join('.')
+ anchor = 'h' + full_number.tr('.', '-')
+ chapter_id = data.chapter_id || @chapter.id
+ %Q(<a href="#{chapter_id}.html##{anchor}">#{title_html}</a>)
+ end
+
+ def render_inline_labelref(_type, content, _node)
+ escape_content(content)
+ end
+
+ def render_inline_ref(_type, content, _node)
+ escape_content(content)
+ end
+
+ def render_inline_pageref(_type, content, _node)
+ escape_content(content)
+ end
+
+ def render_inline_w(_type, content, _node)
+ # Dictionary lookup for word substitution
+ dictionary = @book&.config&.[]('dictionary') || {}
+ translated = dictionary[content]
+ escape_content(translated || "[missing word: #{content}]")
+ end
+
+ def render_inline_wb(_type, content, _node)
+ # Dictionary lookup with bold formatting
+ dictionary = @book&.config&.[]('dictionary') || {}
+ word_content = dictionary[content] || "[missing word: #{content}]"
+ "**#{escape_asterisks(word_content)}**"
+ end
+
+ def render_inline_uchar(_type, content, _node)
+ # Convert hex code to Unicode character
+ [content.to_i(16)].pack('U').force_encoding('UTF-8')
+ end
+
+ # Helper methods
+ def escape_content(str)
+ escape(str)
+ end
+
+ def escape_asterisks(str)
+ str.gsub('*', '\\*')
+ end
+
+ private
+
+ # Render children with spacing between adjacent inline elements
+ # This prevents Markdown parsing issues when inline elements are adjacent
+ #
+ # Rules:
+ # - Same type adjacent inlines are merged: @<b>{a}@<b>{b} → **ab**
+ # - Different type adjacent inlines get space: @<b>{a}@<i>{b} → **a** *b*
+ def render_children_with_inline_spacing(node)
+ return '' if node.children.empty?
+
+ # Group consecutive inline nodes of the same type
+ groups = group_inline_nodes(node.children)
+
+ result = +''
+ prev_group_was_inline = false
+
+ groups.each do |group|
+ if group[:type] == :inline_group
+ # Add space if previous group was also inline (but different type)
+ result += ' ' if prev_group_was_inline
+
+ # Merge same-type inline nodes and render together
+ merged_content = group[:nodes].map { |n| render_children(n) }.join
+ inline_type = group[:inline_type]
+
+ # Render the merged content as a single inline element
+ result += render_inline_element(inline_type, merged_content, group[:nodes].first)
+
+ prev_group_was_inline = true
+ else
+ # Regular nodes (text, etc.) - just render normally
+ group[:nodes].each do |n|
+ result += visit(n)
+ end
+ prev_group_was_inline = false
+ end
+ end
+
+ result
+ end
+
+ # Group consecutive inline nodes by type
+ # Returns array of groups: [{type: :inline_group, inline_type: 'b', nodes: [...]}, ...]
+ def group_inline_nodes(children)
+ groups = []
+ current_group = nil
+
+ children.each do |child|
+ if child.is_a?(ReVIEW::AST::InlineNode)
+ inline_type = child.inline_type
+
+ # Start new group if type changed or first inline
+ if current_group.nil? || current_group[:type] != :inline_group || current_group[:inline_type] != inline_type
+ # Save previous group if exists
+ groups << current_group if current_group
+
+ # Start new inline group
+ current_group = {
+ type: :inline_group,
+ inline_type: inline_type,
+ nodes: [child]
+ }
+ else
+ # Add to current group (same type)
+ current_group[:nodes] << child
+ end
+ else
+ # Non-inline node
+ # Save previous inline group if exists
+ if current_group && current_group[:type] == :inline_group
+ groups << current_group
+ current_group = nil
+ end
+
+ # Start or continue regular node group
+ if current_group.nil? || current_group[:type] != :regular
+ groups << current_group if current_group
+ current_group = { type: :regular, nodes: [child] }
+ else
+ current_group[:nodes] << child
+ end
+ end
+ end
+
+ # Don't forget the last group
+ groups << current_group if current_group
+
+ groups
+ end
+
+ def generate_markdown_table
+ return '' if @table_rows.empty?
+
+ result = +''
+
+ # Header row
+ header = @table_rows.first
+ result += "| #{header.join(' | ')} |\n"
+
+ # Separator row
+ separators = header.map { ':--' }
+ result += "| #{separators.join(' | ')} |\n"
+
+ # Data rows
+ @table_rows[1..-1]&.each do |row|
+ # Pad row to match header length
+ padded_row = row + ([''] * (@table_header_count - row.length))
+ result += "| #{padded_row.join(' | ')} |\n"
+ end
+
+ result
+ end
+
+ # Get text formatter for reference formatting
+ def text_formatter
+ @text_formatter ||= ReVIEW::TextUtils.new(@chapter)
+ end
+
+ # Wrap reference with HTML span and link (same as HtmlRenderer)
+ def wrap_reference_with_html(text, data, css_class)
+ escaped_text = escape_content(text)
+ chapter_id = data.chapter_id || @chapter&.id
+ item_id = normalize_id(data.item_id)
+
+ # Generate HTML with span and link
+ %Q(<span class="#{css_class}"><a href="./#{chapter_id}.html##{item_id}">#{escaped_text}</a></span>)
+ end
+
+ # Check if section number should be displayed (based on secnolevel)
+ def over_secnolevel?(n)
+ secnolevel = config['secnolevel'] || 0
+ # Section level = chapter level (1) + n.size
+ section_level = n.is_a?(::Array) ? (1 + n.size) : (1 + n.to_s.split('.').size)
+ secnolevel >= section_level
+ end
+ end
+ end
+end
diff --git a/lib/review/renderer/plaintext_renderer.rb b/lib/review/renderer/plaintext_renderer.rb
new file mode 100644
index 000000000..7d4bcf15f
--- /dev/null
+++ b/lib/review/renderer/plaintext_renderer.rb
@@ -0,0 +1,702 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2025 Kenshi Muto, Masayoshi Takahashi
+#
+# This program is free software.
+# You can distribute or modify this program under the terms of
+# the GNU LGPL, Lesser General Public License version 2.1.
+
+require 'review/textutils'
+require 'review/loggable'
+require_relative 'base'
+
+module ReVIEW
+ module Renderer
+ class PlaintextRenderer < Base
+ include ReVIEW::TextUtils
+ include ReVIEW::Loggable
+
+ def initialize(chapter)
+ super
+ @blank_seen = true
+ @ol_num = nil
+ @logger = ReVIEW.logger
+ end
+
+ # Format type for this renderer
+ # @return [Symbol] Format type :text
+ def format_type
+ :text
+ end
+
+ def target_name
+ 'plaintext'
+ end
+
+ def visit_document(node)
+ render_children(node)
+ end
+
+ def visit_headline(node)
+ level = node.level
+ caption = render_caption_inline(node.caption_node)
+
+ # Get headline prefix like PLAINTEXTBuilder
+ prefix = headline_prefix(level)
+ "#{prefix}#{caption}\n"
+ end
+
+ def visit_paragraph(node)
+ content = render_children(node)
+ # Join lines to single paragraph like PLAINTEXTBuilder's join_lines_to_paragraph
+ lines = content.split("\n")
+ result = lines.join
+ "#{result}\n"
+ end
+
+ def visit_list(node)
+ result = +''
+
+ case node.list_type
+ when :ul
+ node.children.each do |item|
+ result += visit_list_item(item, :ul)
+ end
+ when :ol
+ # Reset ol counter
+ @ol_num = node.start_number || 1
+ node.children.each do |item|
+ result += visit_list_item(item, :ol)
+ @ol_num += 1
+ end
+ @ol_num = nil
+ when :dl
+ node.children.each do |item|
+ result += visit_definition_item(item)
+ end
+ else
+ raise NotImplementedError, "PlaintextRenderer does not support list_type #{node.list_type}."
+ end
+
+ "\n#{result}\n"
+ end
+
+ def visit_list_item(node, type = :ul)
+ content = render_children(node)
+ # Remove paragraph newlines and join
+ text = content.gsub(/\n+/, ' ').strip
+
+ case type
+ when :ul
+ "#{text}\n"
+ when :ol
+ "#{@ol_num} #{text}\n"
+ end
+ end
+
+ def visit_definition_item(node)
+ # Handle definition term
+ term = if node.term_children && !node.term_children.empty?
+ node.term_children.map { |child| visit(child) }.join
+ else
+ ''
+ end
+
+ # Handle definition content
+ definition_parts = node.children.map { |child| visit(child) }
+ definition = definition_parts.join.delete("\n")
+
+ "#{term}\n#{definition}\n"
+ end
+
+ # Numbered code block (listnum, emlistnum)
+ def render_numbered_code_block(node)
+ result = +''
+ caption = render_caption_inline(node.caption_node)
+ lines_content = render_children(node)
+
+ lines = lines_content.split("\n")
+ lines.pop if lines.last && lines.last.empty?
+
+ first_line_number = node.first_line_num || 1
+
+ result += "\n" if caption_top?('list') && !caption.empty?
+ result += "#{caption}\n" if caption_top?('list') && !caption.empty?
+ result += "\n" if caption_top?('list') && !caption.empty?
+
+ lines.each_with_index do |line, i|
+ result += "#{(i + first_line_number).to_s.rjust(2)}: #{detab(line)}\n"
+ end
+
+ result += "\n" unless caption_top?('list')
+ result += "#{caption}\n" unless caption_top?('list') || caption.empty?
+ result += "\n"
+
+ result
+ end
+
+ # Regular code block (emlist, cmd, source, etc.)
+ def render_regular_code_block(node)
+ result = +''
+ caption = render_caption_inline(node.caption_node)
+ lines_content = render_children(node)
+
+ result += "\n" if caption_top?('list') && !caption.empty?
+ result += "#{caption}\n" if caption_top?('list') && !caption.empty?
+
+ lines_content.each_line do |line|
+ result += detab(line.chomp) + "\n"
+ end
+
+ result += "#{caption}\n" unless caption_top?('list') || caption.empty?
+ result += "\n"
+
+ result
+ end
+
+ def visit_code_block_list(node)
+ result = +''
+ caption = render_caption_inline(node.caption_node)
+ lines_content = render_children(node)
+
+ result += "\n" if caption_top?('list') && !caption.empty?
+ result += generate_list_header(node.id, caption) + "\n" if caption_top?('list') && !caption.empty?
+ result += "\n" if caption_top?('list') && !caption.empty?
+
+ lines_content.each_line do |line|
+ result += detab(line.chomp) + "\n"
+ end
+
+ result += "\n" unless caption_top?('list')
+ result += generate_list_header(node.id, caption) + "\n" unless caption_top?('list') || caption.empty?
+ result += "\n"
+
+ result
+ end
+
+ def visit_code_block_listnum(node)
+ render_numbered_code_block(node)
+ end
+
+ def visit_code_block_emlist(node)
+ render_regular_code_block(node)
+ end
+
+ def visit_code_block_emlistnum(node)
+ render_numbered_code_block(node)
+ end
+
+ def visit_code_block_cmd(node)
+ render_regular_code_block(node)
+ end
+
+ def visit_code_block_source(node)
+ render_regular_code_block(node)
+ end
+
+ def visit_code_line(node)
+ line_content = render_children(node)
+ # Add newline after each line
+ line_content + "\n"
+ end
+
+ def visit_table(node)
+ result = +''
+
+ # Check if this is an imgtable
+ if node.table_type == :imgtable
+ return render_imgtable(node)
+ end
+
+ # Add caption
+ caption = render_caption_inline(node.caption_node)
+ unless caption.empty?
+ result += "\n"
+ result += if node.id
+ generate_table_header(node.id, caption) + "\n"
+ else
+ "#{caption}\n"
+ end
+ result += "\n" if caption_top?('table')
+ end
+
+ # Process table rows
+ all_rows = node.header_rows + node.body_rows
+ all_rows.each do |row|
+ result += visit_table_row(row)
+ end
+
+ result += "\n" unless caption_top?('table')
+ result += "\n"
+
+ result
+ end
+
+ def visit_table_row(node)
+ cells = node.children.map { |cell| render_children(cell) }
+ cells.join("\t") + "\n"
+ end
+
+ def visit_table_cell(node)
+ render_children(node)
+ end
+
+ def visit_image(node)
+ result = +''
+ caption = render_caption_inline(node.caption_node)
+
+ result += "\n"
+ if node.id && @chapter
+ result += "#{text_formatter.format_caption_plain('image', get_chap, @chapter.image(node.id).number, caption)}\n"
+ else
+ result += "図 #{caption}\n" unless caption.empty?
+ end
+ result += "\n"
+
+ result
+ end
+
+ def visit_minicolumn(node)
+ result = +''
+ caption = render_caption_inline(node.caption_node)
+
+ result += "\n"
+ result += "#{caption}\n" unless caption.empty?
+ result += render_children(node)
+ result += "\n"
+
+ result
+ end
+
+ def visit_column(node)
+ result = +''
+ caption = render_caption_inline(node.caption_node)
+
+ result += "\n"
+ result += "#{caption}\n" unless caption.empty?
+ result += render_children(node)
+ result += "\n"
+
+ result
+ end
+
+ # visit_block is now handled by Base renderer with dynamic method dispatch
+
+ def visit_block_quote(node)
+ result = +"\n"
+ result += render_children(node)
+ result += "\n"
+ result
+ end
+
+ def visit_block_blockquote(node)
+ visit_block_quote(node)
+ end
+
+ def visit_block_comment(_node)
+ # Comments are not rendered in plaintext
+ ''
+ end
+
+ def visit_block_blankline(_node)
+ "\n"
+ end
+
+ def visit_block_pagebreak(_node)
+ # Page breaks are not meaningful in plaintext
+ ''
+ end
+
+ def visit_block_label(_node)
+ # Labels are not rendered
+ ''
+ end
+
+ def visit_block_printendnotes(_node)
+ # Print all endnotes collected in the chapter
+ return '' unless @chapter
+ return '' if @chapter.endnotes.size == 0
+
+ result = +''
+ @chapter.endnotes.each do |en|
+ # Format: (number) content
+ number = en.number
+ content_text = en.content || ''
+ result += "(#{number}) #{content_text}\n"
+ end
+ result
+ end
+
+ def visit_block_tsize(_node)
+ # Table size control is not meaningful in plaintext
+ ''
+ end
+
+ def visit_block_lead(node)
+ result = +"\n"
+ result += render_children(node)
+ result += "\n"
+ result
+ end
+
+ alias_method :visit_block_read, :visit_block_lead
+
+ def visit_block_flushright(node)
+ result = +"\n"
+ result += render_children(node)
+ result += "\n"
+ result
+ end
+
+ def visit_block_centering(node)
+ result = +"\n"
+ result += render_children(node)
+ result += "\n"
+ result
+ end
+
+ def visit_block_bibpaper(node)
+ visit_bibpaper_block(node)
+ end
+
+ def visit_bibpaper_block(node)
+ id = node.args[0]
+ caption_text = node.args[1]
+
+ result = +''
+ if id && @chapter
+ bibpaper_number = @chapter.bibpaper(id).number
+ result += "#{bibpaper_number} "
+ end
+ result += "#{caption_text}\n" if caption_text
+
+ content = render_children(node)
+ result += "#{content}\n" unless content.strip.empty?
+
+ result
+ end
+
+ def visit_generic_block(node)
+ result = +''
+ caption = render_caption_inline(node.caption_node) if node.respond_to?(:caption_node)
+
+ result += "\n"
+ result += "#{caption}\n" if caption && !caption.empty?
+ result += render_children(node)
+ result += "\n"
+
+ result
+ end
+
+ def visit_tex_equation(node)
+ result = +''
+ content = node.content
+
+ result += "\n"
+
+ if node.id? && @chapter
+ caption = render_caption_inline(node.caption_node)
+ result += "#{text_formatter.format_caption_plain('equation', get_chap, @chapter.equation(node.id).number, caption)}\n" if caption_top?('equation')
+ end
+
+ result += "#{content}\n"
+
+ if node.id? && @chapter
+ caption = render_caption_inline(node.caption_node)
+ result += "#{text_formatter.format_caption_plain('equation', get_chap, @chapter.equation(node.id).number, caption)}\n" unless caption_top?('equation')
+ end
+
+ result += "\n"
+ result
+ end
+
+ def render_inline_element(type, content, node)
+ method_name = "render_inline_#{type}"
+ if respond_to?(method_name, true)
+ send(method_name, type, content, node)
+ else
+ # For unknown inline elements (typically reference types), return content as-is
+ # Reference types (list, img, table, hd, column, etc.) have their content already resolved
+ content || ''
+ end
+ end
+
+ def visit_text(node)
+ node.content || ''
+ end
+
+ def visit_reference(node)
+ node.content || ''
+ end
+
+ def visit_footnote(node)
+ footnote_id = node.id
+ content = render_children(node)
+ footnote_number = @chapter&.footnote(footnote_id)&.number || '??'
+
+ "注#{footnote_number} #{content}\n"
+ end
+
+ def visit_embed(node)
+ # Check if content should be output for this renderer
+ return '' unless node.targeted_for?('plaintext') || node.targeted_for?('text')
+
+ # Get content
+ content = node.content || ''
+
+ # Process \n based on embed type
+ case node.embed_type
+ when :inline, :raw
+ # For inline and raw embeds, convert \\n to actual newlines
+ content = content.gsub('\\n', "\n")
+ end
+
+ # For block embeds, add trailing newline
+ node.embed_type == :block ? content + "\n" : content
+ end
+
+ # Inline rendering methods
+ def render_inline_fn(_type, _content, node)
+ fn_id = node.target_item_id
+ return '' unless fn_id && @chapter
+
+ footnote_number = @chapter.footnote(fn_id).number
+ " 注#{footnote_number} "
+ rescue ReVIEW::KeyError
+ ''
+ end
+
+ def render_inline_kw(_type, _content, node)
+ if node.args.length >= 2
+ word = node.args[0]
+ alt = node.args[1].strip
+ "#{word}（#{alt}）"
+ else
+ node.args.first || ''
+ end
+ end
+
+ def render_inline_href(_type, _content, node)
+ args = node.args || []
+ if args.length >= 2
+ url = args[0]
+ label = args[1]
+ "#{label}（#{url}）"
+ else
+ args.first || ''
+ end
+ end
+
+ def render_inline_ruby(_type, _content, node)
+ # Ruby base text only, ignore ruby annotation
+ node.args.first || ''
+ end
+
+ def render_inline_br(_type, _content, _node)
+ "\n"
+ end
+
+ def render_inline_raw(_type, _content, node)
+ # Convert \n to actual newlines like PLAINTEXTBuilder
+ if node.targeted_for?('plaintext') || node.targeted_for?('text')
+ (node.content || '').gsub('\\n', "\n")
+ else
+ ''
+ end
+ end
+
+ def render_inline_embed(_type, _content, node)
+ # Convert \n to actual newlines like PLAINTEXTBuilder
+ if node.targeted_for?('plaintext') || node.targeted_for?('text')
+ (node.content || '').gsub('\\n', "\n")
+ else
+ ''
+ end
+ end
+
+ def render_inline_hidx(_type, _content, _node)
+ ''
+ end
+
+ def render_inline_icon(_type, _content, _node)
+ ''
+ end
+
+ def render_inline_comment(_type, _content, _node)
+ ''
+ end
+
+ def render_inline_balloon(_type, content, _node)
+ "←#{content}"
+ end
+
+ def render_inline_uchar(_type, content, _node)
+ [content.to_i(16)].pack('U')
+ end
+
+ def render_inline_bib(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ data.item_number.to_s
+ end
+
+ def render_inline_hd(_type, _content, node)
+ # Headline reference
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ text_formatter.format_reference(:headline, data)
+ end
+
+ def render_inline_labelref(_type, _content, _node)
+ '●'
+ end
+
+ alias_method :render_inline_ref, :render_inline_labelref
+
+ def render_inline_pageref(_type, _content, _node)
+ '●ページ'
+ end
+
+ def render_inline_chap(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ text_formatter.format_chapter_number_full(data.chapter_number, data.chapter_type).to_s
+ end
+
+ def render_inline_chapref(_type, _content, node)
+ ref_node = node.children.first
+ unless ref_node.reference_node? && ref_node.resolved?
+ raise 'BUG: Reference should be resolved at AST construction time'
+ end
+
+ data = ref_node.resolved_data
+ text_formatter.format_reference(:chapter, data)
+ end
+
+ def render_inline_default(_type, content, _node)
+ content
+ end
+
+ # Default inline rendering - just return content
+ alias_method :render_inline_b, :render_inline_default
+ alias_method :render_inline_strong, :render_inline_default
+ alias_method :render_inline_i, :render_inline_default
+ alias_method :render_inline_em, :render_inline_default
+ alias_method :render_inline_tt, :render_inline_default
+ alias_method :render_inline_code, :render_inline_default
+ alias_method :render_inline_ttb, :render_inline_default
+ alias_method :render_inline_ttbold, :render_inline_default
+ alias_method :render_inline_tti, :render_inline_default
+ alias_method :render_inline_ttibold, :render_inline_default
+ alias_method :render_inline_u, :render_inline_default
+ alias_method :render_inline_bou, :render_inline_default
+ alias_method :render_inline_keytop, :render_inline_default
+ alias_method :render_inline_m, :render_inline_default
+ alias_method :render_inline_ami, :render_inline_default
+ alias_method :render_inline_sup, :render_inline_default
+ alias_method :render_inline_sub, :render_inline_default
+ alias_method :render_inline_hint, :render_inline_default
+ alias_method :render_inline_maru, :render_inline_default
+ alias_method :render_inline_idx, :render_inline_default
+ alias_method :render_inline_ins, :render_inline_default
+ alias_method :render_inline_del, :render_inline_default
+ alias_method :render_inline_tcy, :render_inline_default
+
+ # Helper methods
+ def render_caption_inline(caption_node)
+ return '' unless caption_node
+
+ content = render_children(caption_node)
+ # Join lines like visit_paragraph does
+ lines = content.split("\n")
+ lines.join
+ end
+
+ def headline_prefix(level)
+ return '' unless @chapter
+ return '' unless config['secnolevel'] && config['secnolevel'] > 0
+
+ # Generate headline prefix like PLAINTEXTBuilder
+ case level
+ when 1
+ if @chapter.number
+ "第#{@chapter.number}章 "
+ else
+ ''
+ end
+ when 2, 3, 4, 5
+ # For subsections, use section counter if available
+ ''
+ else # rubocop:disable Lint/DuplicateBranch
+ ''
+ end
+ end
+
+ def generate_list_header(id, caption)
+ return caption unless id && @chapter
+
+ list_item = @chapter.list(id)
+ text_formatter.format_caption_plain('list', get_chap, list_item.number, caption)
+ rescue ReVIEW::KeyError
+ caption
+ end
+
+ def generate_table_header(id, caption)
+ return caption unless id && @chapter
+
+ table_item = @chapter.table(id)
+ text_formatter.format_caption_plain('table', get_chap, table_item.number, caption)
+ rescue ReVIEW::KeyError
+ caption
+ end
+
+ def render_imgtable(node)
+ result = +''
+ caption = render_caption_inline(node.caption_node)
+
+ result += "\n"
+ if node.id && !caption.empty?
+ result += generate_table_header(node.id, caption) + "\n"
+ result += "\n"
+ end
+ result += "\n"
+
+ result
+ end
+
+ def get_chap(chapter = @chapter)
+ return nil unless chapter
+ return nil unless config['secnolevel'] && config['secnolevel'] > 0
+ return nil if chapter.number.nil? || chapter.number.to_s.empty?
+
+ if chapter.is_a?(ReVIEW::Book::Part)
+ text_formatter.format_part_short(chapter)
+ else
+ chapter.format_number(nil)
+ end
+ end
+
+ def over_secnolevel?(n, _chapter = @chapter)
+ secnolevel = config['secnolevel'] || 0
+ secnolevel >= n.to_s.split('.').size
+ end
+
+ def escape(str)
+ # Plaintext doesn't need escaping
+ str.to_s
+ end
+ end
+ end
+end
diff --git a/lib/review/renderer/rendering_context.rb b/lib/review/renderer/rendering_context.rb
new file mode 100644
index 000000000..93c6c20a1
--- /dev/null
+++ b/lib/review/renderer/rendering_context.rb
@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2025 Kenshi Muto, Masayoshi Takahashi
+#
+# This program is free software.
+# You can distribute or modify this program under the terms of
+# the GNU LGPL, Lesser General Public License version 2.1.
+
+require_relative 'footnote_collector'
+
+module ReVIEW
+ module Renderer
+ # RenderingContext - Manages rendering state and context for AST renderers
+ #
+ # This class provides automatic scope management for rendering contexts,
+ # replacing the manual @doc_status flag management with a cleaner,
+ # context-aware approach.
+ #
+ # Key responsibilities:
+ # - Track current rendering context (table, caption, minicolumn, etc.)
+ # - Manage parent-child context relationships for nested structures
+ # - Determine when footnotes require special handling (footnotetext vs footnote)
+ # - Collect and process footnotes within problematic contexts
+ # - Provide automatic cleanup when contexts end
+ class RenderingContext
+ attr_reader :context_type, :parent_context, :footnote_collector
+
+ # Context types that require footnotetext instead of direct footnote
+ FOOTNOTETEXT_REQUIRED_CONTEXTS = %i[table caption minicolumn column dt].freeze
+
+ def initialize(context_type, parent_context = nil)
+ @context_type = context_type
+ @parent_context = parent_context
+ @footnote_collector = FootnoteCollector.new
+ end
+
+ # Determines if footnotes in this context require footnotetext handling
+ # @return [Boolean] true if footnotetext is required
+ def requires_footnotetext?
+ footnotetext_context? || parent_requires_footnotetext?
+ end
+
+ # Check if this specific context requires footnotetext
+ # @return [Boolean] true if this context type requires footnotetext
+ def footnotetext_context?
+ FOOTNOTETEXT_REQUIRED_CONTEXTS.include?(@context_type)
+ end
+
+ # Create and yield a child context, ensuring proper cleanup
+ # @param child_type [Symbol] the type of child context
+ # @yield [RenderingContext] the child context
+ # @return [Object] the result of the block
+ def with_child_context(child_type)
+ child_context = RenderingContext.new(child_type, self)
+
+ yield(child_context)
+ end
+
+ # Add a footnote to this context's collector
+ # @param footnote_node [AST::FootnoteNode] the footnote node
+ # @param footnote_number [Integer] the footnote number
+ def collect_footnote(footnote_node, footnote_number)
+ @footnote_collector.add(footnote_node, footnote_number)
+ end
+
+ # Get a string representation for debugging
+ # @return [String] string representation
+ def to_s
+ context_chain = ancestors.map(&:context_type)
+ "RenderingContext[#{context_chain.join(' > ')}]"
+ end
+
+ # Get all ancestors (including self) in order from root to current
+ # @return [Array<RenderingContext>] array of contexts
+ def ancestors
+ Enumerator.produce(self, &:parent_context).take_while(&:itself).reverse
+ end
+
+ private
+
+ # Check if parent context requires footnotetext
+ # @return [Boolean] true if any parent requires footnotetext
+ def parent_requires_footnotetext?
+ @parent_context&.requires_footnotetext? || false
+ end
+ end
+ end
+end
diff --git a/lib/review/renderer/text_formatter.rb b/lib/review/renderer/text_formatter.rb
new file mode 100644
index 000000000..5920347f4
--- /dev/null
+++ b/lib/review/renderer/text_formatter.rb
@@ -0,0 +1,512 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2025 Kenshi Muto, Masayoshi Takahashi
+#
+# This program is free software.
+# You can distribute or modify this program under the terms of
+# the GNU LGPL, Lesser General Public License version 2.1.
+
+require 'review/i18n'
+
+module ReVIEW
+ module Renderer
+ # TextFormatter - Centralized text formatting and I18n service
+ #
+ # This class consolidates all text formatting and internationalization logic
+ # that was previously scattered across Renderer, InlineElementHandler, Formatter,
+ # and ResolvedData classes.
+ #
+ # Design principles:
+ # - Single responsibility: All I18n and text generation in one place
+ # - Format-agnostic core with format-specific decorations
+ # - Reusable from Renderer, InlineElementHandler, and ResolvedData
+ class TextFormatter
+ attr_reader :config, :chapter
+
+ # Initialize formatter
+ # @param config [Hash] Configuration hash
+ # @param chapter [Chapter, nil] Current chapter (optional, used for HTML reference links)
+ def initialize(config:, chapter: nil)
+ @config = config
+ @chapter = chapter
+ end
+
+ # Format a numbered item's caption for HTML/LaTeX (e.g., "図1.1: キャプション")
+ # Uses format_number_header (with colon) + caption_prefix
+ # @param label_key [String] I18n key for the label (e.g., 'image', 'table', 'list')
+ # @param chapter_number [String, nil] Chapter number (e.g., "第1章")
+ # @param item_number [Integer] Item number within chapter
+ # @param caption_text [String, nil] Caption text
+ # @return [String] Formatted caption
+ def format_caption(label_key, chapter_number, item_number, caption_text = nil)
+ label = I18n.t(label_key)
+ number_text = format_number_header(chapter_number, item_number)
+ separator = I18n.t('caption_prefix')
+
+ base = "#{label}#{number_text}"
+ return base if caption_text.nil? || caption_text.empty?
+
+ "#{base}#{separator}#{caption_text}"
+ end
+
+ # Format a numbered item's caption for IDGXML/TOP/TEXT (e.g., "図1.1 キャプション")
+ # Uses format_number (without colon) + caption_separator
+ # @param label_key [String] I18n key for the label (e.g., 'image', 'table', 'list')
+ # @param chapter_number [String, nil] Chapter number (e.g., "第1章")
+ # @param item_number [Integer] Item number within chapter
+ # @param caption_text [String, nil] Caption text
+ # @return [String] Formatted caption
+ def format_caption_plain(label_key, chapter_number, item_number, caption_text = nil)
+ label = I18n.t(label_key)
+ number_text = format_number(chapter_number, item_number)
+ separator = caption_separator
+
+ base = "#{label}#{number_text}"
+ return base if caption_text.nil? || caption_text.empty?
+
+ "#{base}#{separator}#{caption_text}"
+ end
+
+ # Format just the number part (e.g., "1.1" or "1")
+ # @param chapter_number [String, nil] Chapter number
+ # @param item_number [Integer] Item number
+ # @return [String] Formatted number
+ def format_number(chapter_number, item_number)
+ if chapter_number && !chapter_number.to_s.empty?
+ I18n.t('format_number', [chapter_number, item_number])
+ else
+ I18n.t('format_number_without_chapter', [item_number])
+ end
+ end
+
+ # Format number for caption header (HTML/LaTeX style)
+ # Used in block elements (//image, //table, //list, //equation) caption headers
+ # @param chapter_number [String, nil] Chapter number
+ # @param item_number [Integer] Item number
+ # @return [String] Formatted number for header
+ def format_number_header(chapter_number, item_number)
+ if chapter_number && !chapter_number.to_s.empty?
+ I18n.t('format_number_header', [chapter_number, item_number])
+ else
+ I18n.t('format_number_header_without_chapter', [item_number])
+ end
+ end
+
+ # Format a reference as plain text (without format-specific decorations)
+ # This method returns pure text suitable for wrapping with HTML tags, LaTeX commands, etc.
+ # @param type [Symbol] Reference type (:image, :table, :list, :equation, etc.)
+ # @param data [ResolvedData] Resolved reference data
+ # @return [String] Plain text reference (e.g., "図1.1", "表2.3")
+ def format_reference_text(type, data)
+ case type
+ when :image
+ format_numbered_reference_text('image', data)
+ when :table
+ format_numbered_reference_text('table', data)
+ when :list
+ format_numbered_reference_text('list', data)
+ when :equation
+ format_numbered_reference_text('equation', data)
+ when :footnote
+ format_footnote_reference_text(data)
+ when :endnote
+ format_endnote_reference_text(data)
+ when :chapter
+ format_chapter_reference_text(data)
+ when :headline
+ format_headline_reference_text(data)
+ when :column
+ format_column_reference_text(data)
+ when :bibpaper
+ format_bibpaper_reference_text(data)
+ when :word
+ data.word_content.to_s
+ else
+ raise ArgumentError, "Unknown reference type: #{type}"
+ end
+ end
+
+ # Format a reference to an item (with format-specific decorations)
+ # Used by LaTeX, IDGXML, TOP, and TEXT renderers
+ # @param type [Symbol] Reference type (:image, :table, :list, :equation, etc.)
+ # @param data [ResolvedData] Resolved reference data
+ # @return [String] Formatted reference
+ def format_reference(type, data)
+ case type
+ when :image
+ format_image_reference(data)
+ when :table
+ format_table_reference(data)
+ when :list
+ format_list_reference(data)
+ when :equation
+ format_equation_reference(data)
+ when :footnote
+ format_footnote_reference(data)
+ when :endnote
+ format_endnote_reference(data)
+ when :chapter
+ format_chapter_reference(data)
+ when :headline
+ format_headline_reference(data)
+ when :column
+ format_column_reference(data)
+ when :bibpaper
+ format_bibpaper_reference(data)
+ when :word
+ format_word_reference(data)
+ else
+ raise ArgumentError, "Unknown reference type: #{type}"
+ end
+ end
+
+ # Format chapter number with I18n (long form, e.g., "第1章", "Appendix A", "Part I")
+ # Used for @<chap>, @<chapref>, @<title> references
+ # @param raw_number [Integer, nil] Raw chapter number from chapter.number
+ # @param chapter_type [Symbol, nil] Chapter type (:chapter, :appendix, :part, :predef)
+ # @return [String] Formatted chapter number
+ def format_chapter_number_full(raw_number, chapter_type)
+ return '' unless raw_number
+
+ case chapter_type
+ when :chapter
+ I18n.t('chapter', raw_number)
+ when :appendix
+ I18n.t('appendix', raw_number)
+ when :part
+ I18n.t('part', raw_number)
+ else # :predef and others
+ raw_number.to_s
+ end
+ end
+
+ # Format chapter number without heading (short form, e.g., "1", "A", "I")
+ # Used for figure/table/list references where format is "図2.1" not "図第2章.1"
+ # Matches Chapter#format_number(false) behavior
+ # @param raw_number [Integer, nil] Raw chapter number from chapter.number
+ # @param chapter_type [Symbol, nil] Chapter type (:chapter, :appendix, :part, :predef)
+ # @return [String] Short form chapter number
+ def format_chapter_number_short(raw_number, chapter_type)
+ return '' unless raw_number
+
+ case chapter_type
+ when :chapter, :part, :predef
+ # For chapters, parts, and predef: just return the number as-is
+ raw_number.to_s
+ when :appendix
+ # For appendix: extract format from 'appendix' I18n key and create 'appendix_without_heading'
+ # This replicates the logic from Chapter#format_number(false)
+ i18n_appendix = I18n.get('appendix')
+ fmt = i18n_appendix.scan(/%\w{1,3}/).first || '%s'
+ I18n.update('appendix_without_heading' => fmt)
+ I18n.t('appendix_without_heading', raw_number)
+ else # rubocop:disable Lint/DuplicateBranch
+ raw_number.to_s
+ end
+ end
+
+ # Format footnote reference mark
+ # @param number [Integer] Footnote number
+ # @return [String] Formatted footnote mark
+ def format_footnote_mark(number)
+ I18n.t('html_footnote_refmark', number)
+ end
+
+ # Format endnote reference mark
+ # @param number [Integer] Endnote number
+ # @return [String] Formatted endnote mark
+ def format_endnote_mark(number)
+ I18n.t('html_endnote_refmark', number)
+ end
+
+ # Format footnote text mark (used in footnote body)
+ # @param number [Integer] Footnote number
+ # @return [String] Formatted footnote text mark
+ def format_footnote_textmark(number)
+ I18n.t('html_footnote_textmark', number)
+ end
+
+ # Format endnote text mark (used in endnote body)
+ # @param number [Integer] Endnote number
+ # @return [String] Formatted endnote text mark
+ def format_endnote_textmark(number)
+ I18n.t('html_endnote_textmark', number)
+ end
+
+ # Format footnote back mark (back link)
+ # @return [String] Formatted footnote back mark
+ def format_footnote_backmark
+ I18n.t('html_footnote_backmark')
+ end
+
+ # Format part short label (e.g., "第I部")
+ # @param chapter [Chapter] Chapter object
+ # @return [String] Formatted part short label
+ def format_part_short(chapter)
+ I18n.t('part_short', chapter.number)
+ end
+
+ # Format numberless image label
+ # @return [String] Numberless image label
+ def format_numberless_image
+ I18n.t('numberless_image')
+ end
+
+ # Format caption prefix
+ # @return [String] Caption prefix string
+ def format_caption_prefix
+ prefix = I18n.t('caption_prefix')
+ prefix == 'caption_prefix' ? ' ' : prefix
+ end
+
+ # Format column reference from ResolvedData
+ # @param data [ResolvedData] Resolved column reference data
+ # @return [String] Formatted column reference
+ def format_column_reference(data)
+ # caption_text is always plain text from caption_node.to_inline_text
+ I18n.t('column', data.caption_text)
+ end
+
+ # Format column label with I18n
+ # Takes already-rendered caption (in target format)
+ # Used by InlineElementHandlers for format-specific rendering
+ # @param caption [String] Already rendered caption
+ # @return [String] Formatted column label
+ def format_column_label(caption)
+ I18n.t('column', caption)
+ end
+
+ # Format label marker for labelref/ref inline elements
+ # @param idref [String] Reference ID
+ # @return [String] Formatted label marker
+ def format_label_marker(idref)
+ I18n.t('label_marker') + idref.to_s
+ end
+
+ # Format headline quote
+ # @param full_number [String, nil] Full section number (e.g., "1.2.3")
+ # @param caption_text [String] Caption text (already rendered in target format)
+ # @return [String] Formatted headline quote
+ def format_headline_quote(full_number, caption_text)
+ if full_number
+ I18n.t('hd_quote', [full_number, caption_text])
+ else
+ I18n.t('hd_quote_without_number', caption_text)
+ end
+ end
+
+ # Format image quote (IDGXML specific)
+ # @param caption_text [String] Caption text
+ # @return [String] Formatted image quote
+ def format_image_quote(caption_text)
+ I18n.t('image_quote', caption_text)
+ end
+
+ private
+
+ # Format numbered reference (image, table, list) using common logic
+ # @param label_key [String] I18n key for the label (e.g., 'image', 'table', 'list')
+ # @param data [ResolvedData] Resolved reference data
+ # @param html_css_class [String] CSS class for HTML output (unused, kept for compatibility)
+ # @return [String] Formatted reference without caption (e.g., "図1.1")
+ def format_numbered_reference(label_key, data, _html_css_class)
+ # Use short form of chapter number for figure/table/list references
+ chapter_number_short = format_chapter_number_short(data.chapter_number, data.chapter_type)
+
+ format_caption_plain(label_key, chapter_number_short, data.item_number, nil)
+ end
+
+ # Format image reference
+ def format_image_reference(data)
+ format_numbered_reference('image', data, 'imgref')
+ end
+
+ # Format table reference
+ def format_table_reference(data)
+ format_numbered_reference('table', data, 'tableref')
+ end
+
+ # Format list reference
+ def format_list_reference(data)
+ format_numbered_reference('list', data, 'listref')
+ end
+
+ # Format equation reference
+ # @param data [ResolvedData] Resolved reference data
+ # @return [String] Formatted reference without caption (e.g., "式3.1")
+ def format_equation_reference(data)
+ # Use short form of chapter number for equation references
+ chapter_number_short = format_chapter_number_short(data.chapter_number, data.chapter_type)
+
+ # Return reference without caption text
+ format_caption_plain('equation', chapter_number_short, data.item_number)
+ end
+
+ # Format footnote reference
+ def format_footnote_reference(data)
+ # For all formats - return plain number without markup
+ data.item_number.to_s
+ end
+
+ # Format endnote reference
+ def format_endnote_reference(data)
+ # For all formats - return plain number without markup
+ data.item_number.to_s
+ end
+
+ # Format chapter reference
+ def format_chapter_reference(data)
+ chapter_title = data.chapter_title
+
+ # Use full form of chapter number for chapter references
+ chapter_number_full = format_chapter_number_full(data.chapter_number, data.chapter_type)
+
+ if chapter_title && !chapter_number_full.empty?
+ I18n.t('chapter_quote', [chapter_number_full, chapter_title])
+ elsif chapter_title
+ I18n.t('chapter_quote_without_number', chapter_title)
+ elsif !chapter_number_full.empty?
+ chapter_number_full
+ else
+ data.item_id || ''
+ end
+ end
+
+ # Format headline reference
+ def format_headline_reference(data)
+ caption = data.caption_text
+ headline_numbers = Array(data.headline_number).compact
+
+ if !headline_numbers.empty?
+ # Use short form of chapter number for headline references
+ chapter_number_short = format_chapter_number_short(data.chapter_number, data.chapter_type)
+
+ # Build full number with chapter number if available
+ number_str = if chapter_number_short.empty?
+ headline_numbers.join('.')
+ else
+ ([chapter_number_short] + headline_numbers).join('.')
+ end
+ I18n.t('hd_quote', [number_str, caption])
+ elsif !caption.empty?
+ I18n.t('hd_quote_without_number', caption)
+ else
+ data.item_id || ''
+ end
+ end
+
+ # Format bibpaper reference
+ def format_bibpaper_reference(data)
+ # For all formats - return plain reference without markup
+ "[#{data.item_number}]"
+ end
+
+ # Format word reference
+ def format_word_reference(data)
+ data.word_content.to_s
+ end
+
+ # Get caption separator
+ def caption_separator
+ separator = I18n.t('caption_prefix_idgxml')
+ if separator == 'caption_prefix_idgxml'
+ # Fallback to regular caption prefix
+ fallback = I18n.t('caption_prefix')
+ fallback == 'caption_prefix' ? ' ' : fallback
+ else
+ separator
+ end
+ end
+
+ # Check if string is numeric
+ def numeric_string?(value)
+ value.to_s.match?(/\A-?\d+\z/)
+ end
+
+ # Format numbered reference as plain text (image, table, list, equation)
+ # @param label_key [String] I18n key for the label (e.g., 'image', 'table', 'list')
+ # @param data [ResolvedData] Resolved reference data
+ # @return [String] Plain text reference (e.g., "図1.1", "表2.3")
+ def format_numbered_reference_text(label_key, data)
+ # Use short form of chapter number for figure/table/list references
+ chapter_number_short = format_chapter_number_short(data.chapter_number, data.chapter_type)
+ label = I18n.t(label_key)
+ number_text = format_number(chapter_number_short, data.item_number)
+ "#{label}#{number_text}"
+ end
+
+ # Format footnote reference as plain text
+ # @param data [ResolvedData] Resolved reference data
+ # @return [String] Plain text reference
+ def format_footnote_reference_text(data)
+ data.item_number.to_s
+ end
+
+ # Format endnote reference as plain text
+ # @param data [ResolvedData] Resolved reference data
+ # @return [String] Plain text reference
+ def format_endnote_reference_text(data)
+ data.item_number.to_s
+ end
+
+ # Format chapter reference as plain text
+ # @param data [ResolvedData] Resolved reference data
+ # @return [String] Plain text reference
+ def format_chapter_reference_text(data)
+ chapter_title = data.chapter_title
+
+ # Use full form of chapter number for chapter references
+ chapter_number_full = format_chapter_number_full(data.chapter_number, data.chapter_type)
+
+ if chapter_title && !chapter_number_full.empty?
+ I18n.t('chapter_quote', [chapter_number_full, chapter_title])
+ elsif chapter_title
+ I18n.t('chapter_quote_without_number', chapter_title)
+ elsif !chapter_number_full.empty?
+ chapter_number_full
+ else
+ data.item_id || ''
+ end
+ end
+
+ # Format headline reference as plain text
+ # @param data [ResolvedData] Resolved reference data
+ # @return [String] Plain text reference
+ def format_headline_reference_text(data)
+ caption = data.caption_text
+ headline_numbers = Array(data.headline_number).compact
+
+ if !headline_numbers.empty?
+ # Use short form of chapter number for headline references
+ chapter_number_short = format_chapter_number_short(data.chapter_number, data.chapter_type)
+
+ # Build full number with chapter number if available
+ number_str = if chapter_number_short.empty?
+ headline_numbers.join('.')
+ else
+ ([chapter_number_short] + headline_numbers).join('.')
+ end
+ I18n.t('hd_quote', [number_str, caption])
+ elsif !caption.empty?
+ I18n.t('hd_quote_without_number', caption)
+ else
+ data.item_id || ''
+ end
+ end
+
+ # Format column reference as plain text
+ # @param data [ResolvedData] Resolved reference data
+ # @return [String] Plain text reference
+ def format_column_reference_text(data)
+ I18n.t('column', data.caption_text)
+ end
+
+ # Format bibpaper reference as plain text
+ # @param data [ResolvedData] Resolved reference data
+ # @return [String] Plain text reference
+ def format_bibpaper_reference_text(data)
+ "[#{data.item_number}]"
+ end
+ end
+ end
+end
diff --git a/lib/review/renderer/top_renderer.rb b/lib/review/renderer/top_renderer.rb
new file mode 100644
index 000000000..baa8fef8e
--- /dev/null
+++ b/lib/review/renderer/top_renderer.rb
@@ -0,0 +1,882 @@
+# frozen_string_literal: true
+
+# Copyright (c) 2025 Kenshi Muto, Masayoshi Takahashi
+#
+# This program is free software.
+# You can distribute or modify this program under the terms of
+# the GNU LGPL, Lesser General Public License version 2.1.
+
+require 'review/textutils'
+require 'review/loggable'
+require 'review/i18n'
+require_relative 'base'
+
+module ReVIEW
+ module Renderer
+ class TopRenderer < Base
+ include ReVIEW::TextUtils
+ include ReVIEW::Loggable
+
+ # Japanese titles for different block types (matching TOPBuilder)
+ TITLES = {
+ list: 'リスト',
+ listnum: '連番付きリスト',
+ emlist: 'インラインリスト',
+ emlistnum: '連番付きインラインリスト',
+ cmd: 'コマンド',
+ quote: '引用',
+ source: 'ソースコード',
+ table: '表',
+ emtable: 'インライン表',
+ imgtable: '画像付き表',
+ image: '図',
+ indepimage: '独立図',
+ numberlessimage: '番号なし図',
+ icon: 'アイコン',
+ note: 'ノート',
+ memo: 'メモ',
+ tip: 'TIP',
+ info: 'インフォ',
+ warning: '警告',
+ important: '重要',
+ caution: '注意',
+ notice: '注記',
+ lead: 'リード',
+ read: 'リード',
+ flushright: '右寄せ',
+ centering: '中央揃え',
+ texequation: 'TeX式'
+ }.freeze
+
+ def initialize(chapter)
+ super
+ @minicolumn_stack = []
+ @table_row_separator_count = 0
+ @first_line_number = 1
+ @rendering_context = nil
+
+ # Ensure locale strings are available
+ I18n.setup(config['language'] || 'ja')
+ end
+
+ # Format type for this renderer
+ # @return [Symbol] Format type :top
+ def format_type
+ :top
+ end
+
+ def target_name
+ 'top'
+ end
+
+ def visit_document(node)
+ render_children(node)
+ end
+
+ def visit_headline(node)
+ level = node.level
+ caption = render_caption_inline(node.caption_node)
+
+ # Use headline prefix if available
+ prefix = generate_headline_prefix(level)
+ "■H#{level}■#{prefix}#{caption}\n"
+ end
+
+ def visit_paragraph(node)
+ content = render_children(node).chomp
+ return '' if content.empty?
+
+ "#{content}\n"
+ end
+
+ def visit_list(node)
+ result = +''
+
+ case node.list_type
+ when :ul
+ node.children.each do |item|
+ result += visit_unordered_list_item(item)
+ end
+ when :ol
+ node.children.each_with_index do |item, index|
+ result += visit_ordered_list_item(item, index + 1)
+ end
+ when :dl
+ node.children.each do |item|
+ result += visit_definition_item(item)
+ end
+ end
+
+ result
+ end
+
+ def visit_unordered_list_item(node)
+ # Separate text content from nested lists
+ text_content = +''
+ nested_lists = +''
+
+ node.children.each do |child|
+ if child.class.name.include?('ListNode')
+ # This is a nested list - render it separately
+ nested_lists += visit(child)
+ else
+ # This is regular content
+ text_content += visit(child)
+ end
+ end
+
+ text_content = text_content.chomp
+
+ # Use level for nested indentation (TOP style uses tabs for each level)
+ level = node.level || 1
+ indent = "\t" * (level - 1)
+
+ result = "#{indent}●\t#{text_content}\n"
+
+ # Add any nested lists after the item
+ result += nested_lists
+ result
+ end
+
+ def visit_ordered_list_item(node, number)
+ # Separate text content from nested lists
+ text_content = +''
+ nested_lists = +''
+
+ node.children.each do |child|
+ if child.class.name.include?('ListNode')
+ # This is a nested list - render it separately
+ nested_lists += visit(child)
+ else
+ # This is regular content
+ text_content += visit(child)
+ end
+ end
+
+ text_content = text_content.chomp
+
+ # Use level for nested indentation
+ level = node.level || 1
+ indent = "\t" * (level - 1)
+
+ result = "#{indent}#{number}\t#{text_content}\n"
+
+ # Add any nested lists after the item
+ result += nested_lists
+ result
+ end
+
+ def visit_item(node)
+ # Handle list items that come directly without parent list context
+ content = render_children(node).chomp
+ "●\t#{content}\n"
+ end
+
+ def visit_definition_item(node)
+ # Handle definition term - use term_children (AST structure)
+ term = if node.term_children && !node.term_children.empty?
+ node.term_children.map { |child| visit(child) }.join
+ else
+ '' # No term available
+ end
+
+ # Handle definition content (all children are definition content)
+ definition = if node.children && !node.children.empty?
+ node.children.map { |child| visit(child) }.join
+ end
+
+ result = "#{term}☆\n"
+ result += "\t#{definition}\n" if definition
+
+ result
+ end
+
+ # Common code block rendering method used by all code block types
+ def render_code_block_common(node)
+ result = +''
+ # Convert code_type to symbol if it's not already
+ code_type = node.code_type.to_sym
+ block_title = TITLES[code_type] || TITLES[:list]
+
+ result += "\n"
+ result += "◆→開始:#{block_title}←◆\n"
+
+ # Add caption if present
+ caption = render_caption_inline(node.caption_node)
+ unless caption.empty?
+ result += if node.id && (code_type == :list || code_type == :listnum)
+ # For list/listnum, use I18n formatting to match TOPBuilder
+ format_list_caption(node.id, caption)
+ elsif node.id
+ "■#{node.id}■#{caption}\n"
+ else
+ "■#{caption}\n"
+ end
+ result += "\n"
+ end
+
+ # Add line numbers if needed
+ if node.line_numbers
+ code_content = render_children(node).chomp
+ lines = code_content.split("\n")
+ lines.each_with_index do |line, i|
+ line_num = (@first_line_number + i).to_s.rjust(2)
+ result += "#{line_num}: #{line}\n"
+ end
+ else
+ code_content = render_children(node)
+ # Remove trailing newline if present to avoid double newlines
+ code_content = code_content.chomp if code_content.end_with?("\n")
+ result += code_content
+ result += "\n"
+ end
+
+ result += "\n"
+ result += "◆→終了:#{block_title}←◆\n"
+ result += "\n"
+
+ result
+ end
+
+ # Individual code block type visitors that delegate to common method
+ def visit_code_block_list(node)
+ render_code_block_common(node)
+ end
+
+ def visit_code_block_listnum(node)
+ render_code_block_common(node)
+ end
+
+ def visit_code_block_emlist(node)
+ render_code_block_common(node)
+ end
+
+ def visit_code_block_emlistnum(node)
+ render_code_block_common(node)
+ end
+
+ def visit_code_block_cmd(node)
+ render_code_block_common(node)
+ end
+
+ def visit_code_block_source(node)
+ render_code_block_common(node)
+ end
+
+ def visit_code_line(node)
+ render_children(node) + "\n"
+ end
+
+ def visit_table(node)
+ result = +''
+ @table_row_separator_count = 0
+
+ result += "\n"
+ result += "◆→開始:#{TITLES[:table]}←◆\n"
+
+ # Add caption if present
+ caption = render_caption_inline(node.caption_node)
+ unless caption.empty?
+ result += if node.id
+ # Use I18n formatting to match TOPBuilder
+ format_table_caption(node.id, caption)
+ else
+ "■#{caption}\n"
+ end
+ result += "\n"
+ end
+
+ # Process table content
+ result += render_children(node)
+
+ result += "◆→終了:#{TITLES[:table]}←◆\n"
+ result += "\n"
+
+ result
+ end
+
+ def visit_table_row(node)
+ cells = []
+ node.children.each do |cell|
+ cell_content = render_children(cell)
+ # Skip separator rows (rows that contain only dashes)
+ unless /^-+$/.match?(cell_content.strip)
+ cells << cell_content
+ end
+ end
+
+ # Only process non-empty rows
+ return '' if cells.empty? || cells.all? { |cell| cell.strip.empty? }
+
+ result = cells.join("\t") + "\n"
+
+ # Add separator after header rows
+ @table_row_separator_count += 1
+ # Check if this should be treated as header (simplified logic)
+ if @table_row_separator_count == 1 && should_add_table_separator?
+ result += "#{'-' * 12}\n"
+ end
+
+ result
+ end
+
+ def visit_table_cell(node)
+ content = render_children(node)
+
+ # Apply bold formatting for header cells if configured (matches TOPBuilder)
+ if node.cell_type == :th && should_format_table_header?
+ "★#{content}☆"
+ else
+ content
+ end
+ end
+
+ def visit_image(node)
+ result = +''
+
+ result += "\n"
+ result += "◆→開始:#{TITLES[:image]}←◆\n"
+
+ # Add caption if present
+ caption = render_caption_inline(node.caption_node)
+ unless caption.empty?
+ result += if node.id
+ # Use I18n formatting to match TOPBuilder
+ format_image_caption(node.id, caption)
+ else
+ "■#{caption}\n"
+ end
+ result += "\n"
+ end
+
+ # Add image path with metrics
+ image_path = node.id
+ metrics = format_image_metrics(node)
+ result += "◆→#{image_path}#{metrics}←◆\n"
+
+ result += "◆→終了:#{TITLES[:image]}←◆\n"
+ result += "\n"
+
+ result
+ end
+
+ def visit_minicolumn(node)
+ result = +''
+ minicolumn_title = TITLES[node.minicolumn_type.to_sym] || node.minicolumn_type.to_s
+
+ @minicolumn_stack.push(node.minicolumn_type)
+
+ result += "\n"
+ result += "◆→開始:#{minicolumn_title}←◆\n"
+
+ # Add caption if present
+ caption = render_caption_inline(node.caption_node)
+ unless caption.empty?
+ result += "■#{caption}\n"
+ result += "\n"
+ end
+
+ result += render_children(node)
+
+ result += "◆→終了:#{minicolumn_title}←◆\n"
+ result += "\n"
+
+ @minicolumn_stack.pop
+
+ result
+ end
+
+ def visit_column(node)
+ result = +''
+ caption = render_caption_inline(node.caption_node)
+
+ result += "\n"
+ result += "#{caption}\n" unless caption.empty?
+ result += render_children(node)
+ result += "\n"
+
+ result
+ end
+
+ # visit_block is now handled by Base renderer with dynamic method dispatch
+
+ def visit_block_quote(node)
+ result = +''
+
+ result += "\n"
+ result += "◆→開始:#{TITLES[:quote]}←◆\n"
+ result += render_children(node)
+ result += "◆→終了:#{TITLES[:quote]}←◆\n"
+ result += "\n"
+
+ result
+ end
+
+ def visit_generic_block(node)
+ block_title = TITLES[node.block_type.to_sym] || node.block_type.to_s
+ result = +''
+
+ result += "\n"
+ result += "◆→開始:#{block_title}←◆\n"
+ result += render_children(node)
+ result += "◆→終了:#{block_title}←◆\n"
+ result += "\n"
+
+ result
+ end
+
+ # Block elements from todo-top.md
+
+ def visit_block_lead(node)
+ result = +''
+ result += "\n◆→開始:#{TITLES[:lead]}←◆\n"
+ result += render_children(node)
+ result += "◆→終了:#{TITLES[:lead]}←◆\n\n"
+ result
+ end
+
+ alias_method :visit_block_read, :visit_block_lead
+
+ def visit_block_flushright(node)
+ result = +''
+ result += "\n◆→開始:#{TITLES[:flushright]}←◆\n"
+ result += render_children(node)
+ result += "◆→終了:#{TITLES[:flushright]}←◆\n\n"
+ result
+ end
+
+ def visit_block_centering(node)
+ result = +''
+ result += "\n◆→開始:#{TITLES[:centering]}←◆\n"
+ result += render_children(node)
+ result += "◆→終了:#{TITLES[:centering]}←◆\n\n"
+ result
+ end
+
+ def visit_block_blankline(_node)
+ "\n"
+ end
+
+ def visit_tex_equation(node)
+ result = +''
+ result += "\n◆→開始:#{TITLES[:texequation]}←◆\n"
+ result += node.content if node.respond_to?(:content)
+ result += render_children(node) unless node.respond_to?(:content)
+ result += "\n◆→終了:#{TITLES[:texequation]}←◆\n\n"
+ result
+ end
+
+ def visit_block_emtable(node)
+ result = +''
+ @table_row_separator_count = 0
+
+ result += "\n"
+ result += "◆→開始:#{TITLES[:emtable]}←◆\n"
+
+ # Add caption if present
+ caption = render_caption_inline(node.caption_node)
+ unless caption.empty?
+ result += "■#{caption}\n"
+ result += "\n"
+ end
+
+ # Process table content
+ result += render_children(node)
+
+ result += "◆→終了:#{TITLES[:emtable]}←◆\n"
+ result += "\n"
+
+ result
+ end
+
+ def visit_block_imgtable(node)
+ result = +''
+
+ result += "\n"
+ result += "◆→開始:#{TITLES[:table]}←◆\n"
+
+ # Add caption if present
+ caption = render_caption_inline(node.caption_node)
+ unless caption.empty?
+ result += if node.id
+ # Use I18n formatting to match TOPBuilder
+ format_table_caption(node.id, caption)
+ else
+ "■#{caption}\n"
+ end
+ result += "\n"
+ end
+
+ # Add image path with metrics
+ image_path = node.id
+ metrics = format_image_metrics(node)
+ result += "◆→#{image_path}#{metrics}←◆\n"
+
+ result += "◆→終了:#{TITLES[:table]}←◆\n"
+ result += "\n"
+
+ result
+ end
+
+ def render_inline_element(type, content, node) # rubocop:disable Metrics/CyclomaticComplexity
+ case type
+ when :b, :strong
+ "★#{content}☆"
+ when :i, :em
+ "▲#{content}☆"
+ when :code, :tt
+ "△#{content}☆"
+ when :ttb, :ttbold
+ "★#{content}☆◆→等幅フォント太字←◆"
+ when :tti
+ "▲#{content}☆◆→等幅フォントイタ←◆"
+ when :u
+ "＠#{content}＠◆→＠〜＠部分に下線←◆"
+ when :ami
+ "#{content}◆→DTP連絡:「#{content}」に網カケ←◆"
+ when :bou
+ "#{content}◆→DTP連絡:「#{content}」に傍点←◆"
+ when :keytop
+ "#{content}◆→キートップ#{content}←◆"
+ when :idx
+ "#{content}◆→索引項目:#{content}←◆"
+ when :hidx
+ "◆→索引項目:#{content}←◆"
+ when :balloon
+ "\t←#{content}"
+ when :m
+ "◆→TeX式ここから←◆#{content}◆→TeX式ここまで←◆"
+ when :ins
+ "◆→開始:挿入表現←◆#{content}◆→終了:挿入表現←◆"
+ when :del
+ "◆→開始:削除表現←◆#{content}◆→終了:削除表現←◆"
+ when :tcy
+ "◆→開始:回転←◆#{content}◆→終了:縦回転←◆"
+ when :maru
+ "#{content}◆→丸数字#{content}←◆"
+ when :hint
+ "◆→ヒントスタイルここから←◆#{content}◆→ヒントスタイルここまで←◆"
+ when :sup
+ "#{content}◆→DTP連絡:「#{content}」は上付き←◆"
+ when :sub
+ "#{content}◆→DTP連絡:「#{content}」は下付き←◆"
+ when :br
+ "\n"
+ when :href
+ render_href(node, content)
+ when :url # rubocop:disable Lint/DuplicateBranch
+ "△#{content}☆"
+ when :fn
+ render_footnote_ref(node, content)
+ when :ruby
+ render_ruby(node, content)
+ when :comment
+ render_comment(node, content)
+ when :raw
+ render_raw(node, content)
+ when :labelref
+ render_labelref(node, content)
+ when :pageref
+ render_pageref(node, content)
+ else
+ content
+ end
+ end
+
+ def visit_footnote(node)
+ footnote_id = node.id
+ content = render_children(node).chomp
+ footnote_number = get_footnote_number(footnote_id)
+
+ "【注#{footnote_number}】#{content}\n"
+ end
+
+ def visit_text(node)
+ node.content || ''
+ end
+
+ def visit_reference(node)
+ format_resolved_reference(node.resolved_data)
+ end
+
+ private
+
+ def generate_headline_prefix(level)
+ # Generate headline prefix based on chapter structure
+ # Similar to TOPBuilder's headline_prefix method
+ secnolevel = config['secnolevel'] || 2
+
+ if level > secnolevel || @chapter.nil?
+ return ''
+ end
+
+ case level
+ when 1
+ # Chapter level: just the chapter number
+ if @chapter.number
+ "#{@chapter.number} "
+ else
+ ''
+ end
+ when 2, 3, 4, 5, 6
+ # Section levels: use counter from chapter
+ if @chapter.number
+ # Get section counter from chapter if available
+ # For now, return empty string as section counter needs proper implementation
+ # This matches the behavior of TOPBuilder which uses @sec_counter
+ end
+ ''
+ else
+ ''
+ end
+ end
+
+ def should_add_table_separator?
+ # Add separator when th_bold is not enabled (matches TOPBuilder logic)
+ # TOPBuilder adds separator when: !@book.config['textmaker'] || !@book.config['textmaker']['th_bold']
+ !config&.dig('textmaker', 'th_bold')
+ end
+
+ def should_format_table_header?
+ # Check config for header formatting
+ config&.dig('textmaker', 'th_bold') || false
+ end
+
+ def format_image_metrics(node)
+ # Format image metrics if present
+ metrics = +''
+ if node.metric
+ metrics = "、#{node.metric}"
+ end
+ metrics
+ end
+
+ # Format list caption using I18n (matches TOPBuilder)
+ def format_list_caption(id, caption_text)
+ return "■#{caption_text}\n" unless @chapter
+
+ begin
+ list_item = @chapter.list(id)
+ chapter_number = @chapter.number
+ item_number = list_item.number
+
+ # Use TextFormatter to generate caption
+ formatted = text_formatter.format_caption_plain('list', chapter_number, item_number, caption_text)
+ "#{formatted}\n"
+ rescue KeyError, NoMethodError
+ # Fallback if list not found or chapter doesn't have list index
+ "■#{id}■#{caption_text}\n"
+ end
+ end
+
+ # Format table caption using I18n (matches TOPBuilder)
+ def format_table_caption(id, caption_text)
+ return "■#{caption_text}\n" unless @chapter
+
+ begin
+ table_item = @chapter.table(id)
+ chapter_number = @chapter.number
+ item_number = table_item.number
+
+ # Use TextFormatter to generate caption
+ formatted = text_formatter.format_caption_plain('table', chapter_number, item_number, caption_text)
+ "#{formatted}\n"
+ rescue KeyError, NoMethodError
+ # Fallback if table not found or chapter doesn't have table index
+ "■#{id}■#{caption_text}\n"
+ end
+ end
+
+ # Format image caption using I18n (matches TOPBuilder)
+ def format_image_caption(id, caption_text)
+ return "■#{caption_text}\n" unless @chapter
+
+ begin
+ image_item = @chapter.image(id)
+ chapter_number = @chapter.number
+ item_number = image_item.number
+
+ # Use TextFormatter to generate caption
+ formatted = text_formatter.format_caption_plain('image', chapter_number, item_number, caption_text)
+ "#{formatted}\n"
+ rescue KeyError, NoMethodError
+ # Fallback if image not found or chapter doesn't have image index
+ "■#{id}■#{caption_text}\n"
+ end
+ end
+
+ def render_caption_inline(caption_node)
+ caption_node ? render_children(caption_node) : ''
+ end
+
+ def render_href(node, content)
+ args = node.args || []
+ if args.length >= 2
+ url = args[0]
+ label = args[1]
+ "#{label}（△#{url}☆）"
+ else
+ "△#{content}☆"
+ end
+ end
+
+ def render_footnote_ref(node, content)
+ args = node.args || []
+ footnote_id = args.first || content
+ footnote_number = get_footnote_number(footnote_id)
+ "【注#{footnote_number}】"
+ end
+
+ def render_ruby(node, content)
+ args = node.args || []
+ if args.length >= 2
+ base = args[0]
+ ruby = args[1]
+ "#{base}◆→DTP連絡:「#{base}」に「#{ruby}」とルビ←◆"
+ else
+ content
+ end
+ end
+
+ def render_comment(_node, content)
+ # Only render in draft mode
+ if config['draft']
+ "◆→#{content}←◆"
+ else
+ ''
+ end
+ end
+
+ def render_raw(node, content)
+ args = node.args || []
+ if args.any?
+ format = args.first
+ if format == 'top'
+ content
+ else
+ '' # Ignore raw content for other formats
+ end
+ else
+ content
+ end
+ end
+
+ def render_labelref(node, content)
+ args = node.args || []
+ label_id = args.first || content
+ "「◆→#{label_id}←◆」"
+ end
+
+ def render_pageref(node, content)
+ args = node.args || []
+ label_id = args.first || content
+ "●ページ◆→#{label_id}←◆"
+ end
+
+ # Format resolved reference based on ResolvedData
+ # Gets plain text from TextFormatter and wraps it with TOP-specific markup
+ def format_resolved_reference(data)
+ # Get plain text from TextFormatter (no TOP markup)
+ plain_text = text_formatter.format_reference(data.reference_type, data)
+
+ # Wrap with TOP-specific markup based on reference type
+ case data.reference_type
+ when :footnote
+ # For footnote, use 【注】 markup
+ number = data.item_number || data.item_id
+ "【注#{number}】"
+ when :endnote
+ # For endnote, use 【後注】 markup
+ number = data.item_number || data.item_id
+ "【後注#{number}】"
+ else
+ # For other types, return plain text as-is
+ plain_text
+ end
+ end
+
+ def visit_block_label(_node)
+ # Labels are not rendered in TOP format
+ ''
+ end
+
+ def visit_block_printendnotes(_node)
+ # Print all endnotes collected in the chapter
+ return '' unless @chapter
+ return '' if @chapter.endnotes.size == 0
+
+ result = +''
+ @chapter.endnotes.each do |en|
+ # Format: (number) content
+ number = en.number
+ content_text = en.content || ''
+ result += "(#{number}) #{content_text}\n"
+ end
+ result
+ end
+
+ def visit_block_bibpaper(node)
+ id = node.args[0]
+ caption_text = node.args[1]
+
+ result = +''
+ if id && @chapter
+ begin
+ bibpaper_number = @chapter.bibpaper(id).number
+ result += "[#{bibpaper_number}]"
+ rescue KeyError
+ result += "[#{id}]"
+ end
+ end
+
+ # Render caption with inline elements if it has a caption_node
+ if node.respond_to?(:caption_node) && node.caption_node
+ caption = render_caption_inline(node.caption_node)
+ result += " #{caption}\n"
+ elsif caption_text
+ result += " #{caption_text}\n"
+ else
+ result += "\n"
+ end
+
+ # Render body content
+ content = render_children(node)
+ result += "#{content}\n" unless content.strip.empty?
+
+ result
+ end
+
+ def visit_embed(node)
+ # Check if content should be output for this renderer
+ # TOP format accepts 'top' and 'text' as target builders
+ return '' unless node.targeted_for?('top') || node.targeted_for?('text')
+
+ # Get content
+ content = node.content || ''
+
+ # Process \n based on embed type
+ case node.embed_type
+ when :inline, :raw
+ # For inline and raw embeds, convert \\n to actual newlines
+ content = content.gsub('\\n', "\n")
+ end
+
+ # For block embeds, add trailing newline
+ node.embed_type == :block ? content + "\n" : content
+ end
+
+ def get_footnote_number(footnote_id)
+ # Use chapter's footnote numbering (matches TOPBuilder)
+ return 1 unless @chapter
+
+ begin
+ footnote = @chapter.footnote(footnote_id)
+ footnote&.number || 1
+ rescue KeyError
+ # Fallback if footnote not found
+ 1
+ end
+ end
+ end
+ end
+end
diff --git a/lib/review/snapshot_location.rb b/lib/review/snapshot_location.rb
index 17eb22a35..e9d971ed9 100644
--- a/lib/review/snapshot_location.rb
+++ b/lib/review/snapshot_location.rb
@@ -21,6 +21,21 @@ def string
"#{@filename}:#{@lineno}"
end
+ def to_h
+ {
+ filename: filename,
+ lineno: lineno
+ }
+ end
+
+ # Format location information for error messages
+ # Returns a string like " at line 42 in chapter01.re"
+ def format_for_error
+ info = " at line #{@lineno}"
+ info += " in #{@filename}" if @filename
+ info
+ end
+
alias_method :to_s, :string
def snapshot
diff --git a/lib/review/textutils.rb b/lib/review/textutils.rb
index 34904dfe9..bb2bc045a 100644
--- a/lib/review/textutils.rb
+++ b/lib/review/textutils.rb
@@ -10,6 +10,7 @@
#
require 'nkf'
require 'digest'
+require 'unicode/eaw'
module ReVIEW
module TextUtils
diff --git a/review.gemspec b/review.gemspec
index 31d6d451a..c6b75c445 100644
--- a/review.gemspec
+++ b/review.gemspec
@@ -31,7 +31,9 @@ Gem::Specification.new do |gem|
gem.add_dependency('rubyzip')
gem.add_dependency('tty-logger')
gem.add_development_dependency('chunky_png')
+ gem.add_development_dependency('diff-lcs')
gem.add_development_dependency('math_ml')
+ gem.add_development_dependency('nokogiri')
gem.add_development_dependency('playwright-runner')
gem.add_development_dependency('pygments.rb')
gem.add_development_dependency('rake')
diff --git a/samples/debug-book/edge_cases_test.re b/samples/debug-book/edge_cases_test.re
index 15f691735..151468b2b 100644
--- a/samples/debug-book/edge_cases_test.re
+++ b/samples/debug-book/edge_cases_test.re
@@ -277,6 +277,8 @@ class ValidationError extends Error {
対策として@<list>{empty_and_special_cases}で示したnullチェックが重要。
//}
+//blankline
+
== まとめ
このエッジケーステストでは以下を検証:
diff --git a/test/README.md b/test/README.md
new file mode 100644
index 000000000..ca47af1cf
--- /dev/null
+++ b/test/README.md
@@ -0,0 +1,179 @@
+# Re:VIEWプロジェクト テストファイル一覧
+
+このドキュメントは、Re:VIEWプロジェクトのテストファイルの概要を説明します。
+
+## テストファイルのカテゴリー
+
+### AST（抽象構文木）関連テスト
+
+| ファイル名 | 説明 |
+|-----------|------|
+| `test_ast_basic.rb` | AST基本ノード（Node、HeadlineNode）の作成と基本機能のテスト |
+| `test_ast_inline.rb` | インライン要素（TextNode等）のAST表現のテスト |
+| `test_ast_inline_structure.rb` | インライン構造の詳細なASTテスト |
+| `test_ast_comprehensive_inline.rb` | インライン要素の包括的なASTテスト |
+| `test_ast_embed.rb` | 埋め込み要素のASTテスト |
+| `test_ast_lists.rb` | リスト要素のAST表現のテスト |
+| `test_ast_comprehensive.rb` | AST機能の包括的なテスト |
+| `test_ast_json_serialization.rb` | ASTのJSON形式へのシリアライズ機能のテスト |
+| `test_ast_json_verification.rb` | ASTのJSON検証機能のテスト |
+| `test_ast_review_generator.rb` | ASTからRe:VIEW形式への逆変換のテスト |
+| `test_ast_bidirectional_conversion.rb` | ASTの双方向変換（Re:VIEW↔AST）のテスト |
+| `test_ast_analyzer.rb` | AST解析機能のテスト |
+| `test_ast_indexer.rb` | AST索引機能のテスト |
+| `test_ast_indexer_pure.rb` | AST索引機能の単体テスト |
+| `test_ast_structure_debug.rb` | AST構造のデバッグ機能のテスト |
+| `test_full_ast_mode.rb` | 完全ASTモードのテスト |
+
+### ビルダー関連テスト
+
+| ファイル名 | 説明 |
+|-----------|------|
+| `test_builder.rb` | 基底Builderクラスの基本機能テスト |
+| `test_htmlbuilder.rb` | HTML出力ビルダーの機能テスト |
+| `test_latexbuilder.rb` | LaTeX出力ビルダーの機能テスト |
+| `test_latexbuilder_v2.rb` | LaTeXビルダーのバージョン2機能テスト |
+| `test_markdownbuilder.rb` | Markdown出力ビルダーの機能テスト |
+| `test_plaintextbuilder.rb` | プレーンテキスト出力ビルダーのテスト |
+| `test_idgxmlbuilder.rb` | InDesign XML出力ビルダーのテスト |
+| `test_topbuilder.rb` | TOP（テキスト）出力ビルダーのテスト |
+| `test_rstbuilder.rb` | reStructuredText出力ビルダーのテスト |
+| `test_md2inaobuilder.rb` | Markdown→InDesign形式変換ビルダーのテスト |
+| `test_indexbuilder.rb` | 索引ビルダーの機能テスト |
+| `test_jsonbuilder.rb` | JSON出力ビルダーのテスト |
+
+### レンダラー関連テスト
+
+| ファイル名 | 説明 |
+|-----------|------|
+| `test_html_renderer.rb` | HTMLレンダラーのテスト |
+| `test_latex_renderer.rb` | LaTeXレンダラーのテスト |
+| `test_html_renderer_builder_comparison.rb` | HTMLレンダラーとビルダーの比較テスト |
+| `test_latex_renderer_builder_comparison.rb` | LaTeXレンダラーとビルダーの比較テスト |
+
+### コンパイラ・パーサー関連テスト
+
+| ファイル名 | 説明 |
+|-----------|------|
+| `test_compiler.rb` | Re:VIEWソースコードのコンパイラ機能テスト |
+| `test_preprocessor.rb` | プリプロセッサ（#@mapfile等）の機能テスト |
+| `test_converter.rb` | 形式変換コンバーターのテスト |
+| `test_list_parser.rb` | リスト要素のパーサーテスト |
+| `test_caption_parser.rb` | キャプションパーサーのテスト |
+| `test_caption_node.rb` | キャプションノードのテスト |
+| `test_caption_inline_integration.rb` | キャプションとインライン要素の統合テスト |
+
+### 書籍構造関連テスト
+
+| ファイル名 | 説明 |
+|-----------|------|
+| `test_book.rb` | 書籍全体の構造と管理機能のテスト |
+| `test_book_chapter.rb` | 章（Chapter）クラスの機能テスト |
+| `test_book_part.rb` | 部（Part）クラスの機能テスト |
+| `test_catalog.rb` | カタログ（章構成）機能のテスト |
+| `test_index.rb` | 索引機能のテスト |
+
+### メーカー（生成器）関連テスト
+
+| ファイル名 | 説明 |
+|-----------|------|
+| `test_epubmaker.rb` | EPUB生成機能のテスト |
+| `test_epub3maker.rb` | EPUB3生成機能のテスト |
+| `test_pdfmaker.rb` | PDF生成機能のテスト |
+| `test_makerhelper.rb` | メーカー共通ヘルパー機能のテスト |
+
+### コマンドラインツール関連テスト
+
+| ファイル名 | 説明 |
+|-----------|------|
+| `test_epubmaker_cmd.rb` | review-epubmakerコマンドのテスト |
+| `test_pdfmaker_cmd.rb` | review-pdfmakerコマンドのテスト |
+| `test_textmaker_cmd.rb` | review-textmakerコマンドのテスト |
+| `test_idgxmlmaker_cmd.rb` | review-idgxmlmakerコマンドのテスト |
+| `test_catalog_converter_cmd.rb` | カタログ変換コマンドのテスト |
+
+### ユーティリティ関連テスト
+
+| ファイル名 | 説明 |
+|-----------|------|
+| `test_textutils.rb` | テキスト処理ユーティリティのテスト |
+| `test_htmlutils.rb` | HTML処理ユーティリティのテスト |
+| `test_image_finder.rb` | 画像ファイル検索機能のテスト |
+| `test_location.rb` | ソースコード位置情報のテスト |
+| `test_lineinput.rb` | 行入力処理のテスト |
+| `test_logger.rb` | ログ出力機能のテスト |
+| `test_yamlloader.rb` | YAML設定ファイル読み込みのテスト |
+| `test_template.rb` | テンプレート処理機能のテスト |
+| `test_sec_counter.rb` | セクション番号カウンターのテスト |
+| `test_zip_exporter.rb` | ZIP形式エクスポート機能のテスト |
+
+### 設定・国際化関連テスト
+
+| ファイル名 | 説明 |
+|-----------|------|
+| `test_configure.rb` | 設定機能のテスト |
+| `test_i18n.rb` | 国際化（多言語対応）機能のテスト |
+| `test_extentions_hash.rb` | ハッシュ拡張機能のテスト |
+
+### その他の機能テスト
+
+| ファイル名 | 説明 |
+|-----------|------|
+| `test_review_ext.rb` | review-ext.rb拡張機能のテスト |
+| `test_tocprinter.rb` | 目次出力機能のテスト |
+| `test_htmltoc.rb` | HTML目次生成機能のテスト |
+| `test_webtocprinter.rb` | Web用目次出力機能のテスト |
+| `test_reviewheaderlistener.rb` | ヘッダー情報リスナーのテスト |
+| `test_update.rb` | 更新機能のテスト |
+| `test_img_math.rb` | 数式画像処理のテスト |
+| `test_img_graph.rb` | グラフ画像処理のテスト |
+| `test_project_integration.rb` | プロジェクト統合テスト |
+| `test_dumper.rb` | ダンプ機能のテスト |
+| `test_helper.rb` | テストヘルパー機能 |
+
+### ブロック・インライン処理関連テスト
+
+| ファイル名 | 説明 |
+|-----------|------|
+| `test_block_processor_inline.rb` | ブロック内インライン処理のテスト |
+| `test_code_block_debug.rb` | コードブロックのデバッグ機能テスト |
+| `test_code_block_inline_processing.rb` | コードブロック内インライン処理のテスト |
+| `test_code_block_original_text.rb` | コードブロックの元テキスト保持機能のテスト |
+| `test_original_text_integration.rb` | 元テキスト統合機能のテスト |
+| `test_new_block_commands.rb` | 新しいブロックコマンドのテスト |
+| `test_column_sections.rb` | コラムセクション機能のテスト |
+| `test_list_ast_processor.rb` | リストAST処理のテスト |
+| `test_nested_list_builder.rb` | ネストしたリストのビルド機能のテスト |
+
+## テストの実行方法
+
+全テストを実行する場合：
+```bash
+bundle exec rake test
+```
+
+特定のテストファイルを実行する場合：
+```bash
+bundle exec ruby test/test_[ファイル名].rb
+```
+
+特定のパターンにマッチするテストを実行する場合：
+```bash
+bundle exec rake test[pattern]
+```
+
+## テストの構成
+
+各テストファイルは基本的に以下の構造になっています：
+
+1. `test/test_helper.rb` を require
+2. Test::Unit::TestCase を継承したテストクラスを定義
+3. `setup` メソッドで初期化処理
+4. `test_` で始まるメソッドで個別のテストケースを定義
+
+## 追加情報
+
+- テストは Ruby の Test::Unit フレームワークを使用
+- モックやスタブには適宜 minitest/mock を使用
+- テストデータは `test/assets/` ディレクトリに配置
+- カバレッジ測定には SimpleCov を使用（`bundle exec rake coverage`）
\ No newline at end of file
diff --git a/test/ast/caption_parser_helper.rb b/test/ast/caption_parser_helper.rb
new file mode 100644
index 000000000..91c2da3bf
--- /dev/null
+++ b/test/ast/caption_parser_helper.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+# Test helper class for parsing captions
+class CaptionParserHelper
+ def self.parse(caption, location: nil, inline_processor: nil)
+ new(location: location, inline_processor: inline_processor).parse(caption)
+ end
+
+ def initialize(location: nil, inline_processor: nil)
+ @location = location
+ @inline_processor = inline_processor
+ end
+
+ def parse(caption)
+ return nil if caption.nil? || caption == ''
+ return caption if caption.is_a?(ReVIEW::AST::CaptionNode)
+
+ parse_string(caption)
+ end
+
+ private
+
+ def parse_string(caption)
+ require 'review/ast/caption_node'
+ require 'review/ast/text_node'
+
+ caption_node = ReVIEW::AST::CaptionNode.new(location: @location)
+ if @inline_processor && caption.include?('@<')
+ @inline_processor.parse_inline_elements(caption, caption_node)
+ else
+ caption_node.add_child(ReVIEW::AST::TextNode.new(location: @location, content: caption))
+ end
+ caption_node
+ end
+end
diff --git a/test/ast/diff/test_markdown.rb b/test/ast/diff/test_markdown.rb
new file mode 100644
index 000000000..4cf2e775e
--- /dev/null
+++ b/test/ast/diff/test_markdown.rb
@@ -0,0 +1,178 @@
+# frozen_string_literal: true
+
+require_relative '../../test_helper'
+require 'review/ast/diff/markdown'
+
+class TestMarkdownDiff < Test::Unit::TestCase
+ def setup
+ @differ = ReVIEW::AST::Diff::Markdown.new
+ end
+
+ def test_equal_identical_strings
+ left = "# Heading\n\nParagraph"
+ right = "# Heading\n\nParagraph"
+
+ result = @differ.compare(left, right)
+ assert(result.equal?)
+ assert(result.same_hash?)
+ assert(!result.different?)
+ end
+
+ def test_different_content
+ left = '# Heading 1'
+ right = '# Heading 2'
+
+ result = @differ.compare(left, right)
+ assert(!result.equal?)
+ assert(result.different?)
+ end
+
+ def test_normalize_whitespace
+ left = "# Heading\n\nParagraph text"
+ right = "# Heading \n\n Paragraph text "
+
+ result = @differ.compare(left, right)
+ assert(result.equal?, 'Should normalize whitespace differences')
+ end
+
+ def test_normalize_blank_lines
+ left = "# Heading\n\nParagraph"
+ right = "# Heading\n\n\n\nParagraph"
+
+ result = @differ.compare(left, right)
+ assert(result.equal?, 'Should normalize multiple blank lines')
+ end
+
+ def test_normalize_list_markers
+ left = "* Item 1\n* Item 2"
+ right = "- Item 1\n+ Item 2"
+
+ result = @differ.compare(left, right)
+ assert(result.equal?, 'Should normalize list markers to *')
+ end
+
+ def test_normalize_heading_spacing
+ left = '# Heading'
+ right = '#Heading'
+
+ result = @differ.compare(left, right)
+ assert(result.equal?, 'Should normalize heading spacing')
+ end
+
+ def test_normalize_heading_trailing_hashes
+ left = '# Heading'
+ right = '# Heading #'
+
+ result = @differ.compare(left, right)
+ assert(result.equal?, 'Should remove trailing # from headings')
+ end
+
+ def test_pretty_diff_output
+ left = "# Heading 1\n\nParagraph"
+ right = "# Heading 2\n\nParagraph"
+
+ result = @differ.compare(left, right)
+ diff_output = result.pretty_diff
+
+ assert_match(/Heading 1/, diff_output)
+ assert_match(/Heading 2/, diff_output)
+ end
+
+ def test_quick_equality_check
+ left = '# Heading'
+ right = '# Heading '
+
+ assert(@differ.equal?(left, right), 'Should have quick equality check')
+ end
+
+ def test_diff_method
+ left = 'Line 1'
+ right = 'Line 2'
+
+ diff_output = @differ.diff(left, right)
+ assert(!diff_output.empty?, 'Should return diff output')
+ end
+
+ def test_empty_strings
+ left = ''
+ right = ''
+
+ result = @differ.compare(left, right)
+ assert(result.equal?)
+ end
+
+ def test_nil_handling
+ left = nil
+ right = ''
+
+ result = @differ.compare(left, right)
+ assert(result.equal?, 'nil and empty string should be equivalent')
+ end
+
+ def test_complex_markdown_document
+ left = <<~MD
+ # Main Heading
+
+ This is a paragraph with **bold** and *italic*.
+
+ * List item 1
+ * List item 2
+
+ ## Section
+
+ Another paragraph.
+ MD
+
+ right = <<~MD
+ # Main Heading
+
+ This is a paragraph with **bold** and *italic*.
+
+ - List item 1
+ + List item 2
+
+ ##Section
+
+ Another paragraph.
+ MD
+
+ result = @differ.compare(left, right)
+ assert(result.equal?, 'Should handle complex documents with normalization')
+ end
+
+ def test_code_blocks_preserved
+ left = <<~MD
+ ```ruby
+ def hello
+ puts "world"
+ end
+ ```
+ MD
+
+ right = <<~MD
+ ```ruby
+ def hello
+ puts "world"
+ end
+ ```
+ MD
+
+ result = @differ.compare(left, right)
+ assert(result.equal?)
+ end
+
+ def test_disable_normalization_options
+ differ = ReVIEW::AST::Diff::Markdown.new(
+ ignore_whitespace: false,
+ ignore_blank_lines: false,
+ normalize_headings: false,
+ normalize_lists: false
+ )
+
+ left = '# Heading'
+ right = '#Heading'
+
+ result = differ.compare(left, right)
+ assert(!result.equal?, 'Should not normalize when options disabled')
+ end
+end
diff --git a/test/ast/diff/test_node.rb b/test/ast/diff/test_node.rb
new file mode 100644
index 000000000..0a89b8095
--- /dev/null
+++ b/test/ast/diff/test_node.rb
@@ -0,0 +1,164 @@
+# frozen_string_literal: true
+
+require_relative '../../test_helper'
+require 'review/ast'
+require 'review/ast/diff/node'
+
+class TestASTDiffNode < Test::Unit::TestCase
+ def setup
+ @comparator = ReVIEW::AST::Diff::Node.new
+ @location = ReVIEW::SnapshotLocation.new('test.re', 1)
+ end
+
+ def test_compare_identical_text_nodes
+ node1 = ReVIEW::AST::TextNode.new(location: @location, content: 'Hello')
+ node2 = ReVIEW::AST::TextNode.new(location: @location, content: 'Hello')
+
+ result = @comparator.compare(node1, node2)
+ assert_true(result.equal?)
+ assert_equal('AST nodes are equivalent', result.to_s)
+ end
+
+ def test_compare_different_text_nodes
+ node1 = ReVIEW::AST::TextNode.new(location: @location, content: 'Hello')
+ node2 = ReVIEW::AST::TextNode.new(location: @location, content: 'World')
+
+ result = @comparator.compare(node1, node2)
+ assert_false(result.equal?)
+ assert_match(/text content mismatch/, result.to_s)
+ end
+
+ def test_compare_nil_nodes
+ result = @comparator.compare(nil, nil)
+ assert_true(result.equal?)
+ end
+
+ def test_compare_nil_vs_non_nil
+ node1 = ReVIEW::AST::TextNode.new(location: @location, content: 'Hello')
+ result = @comparator.compare(node1, nil)
+ assert_false(result.equal?)
+ assert_match(/node2 is nil/, result.to_s)
+ end
+
+ def test_compare_different_node_types
+ node1 = ReVIEW::AST::TextNode.new(location: @location, content: 'Hello')
+ node2 = ReVIEW::AST::ParagraphNode.new(location: @location)
+
+ result = @comparator.compare(node1, node2)
+ assert_false(result.equal?)
+ assert_match(/node types differ/, result.to_s)
+ end
+
+ def test_compare_headlines_with_same_attributes
+ caption1 = ReVIEW::AST::CaptionNode.new(location: @location)
+ caption1.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Title'))
+
+ caption2 = ReVIEW::AST::CaptionNode.new(location: @location)
+ caption2.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Title'))
+
+ node1 = ReVIEW::AST::HeadlineNode.new(location: @location, level: 2, label: 'intro', caption_node: caption1)
+ node2 = ReVIEW::AST::HeadlineNode.new(location: @location, level: 2, label: 'intro', caption_node: caption2)
+
+ result = @comparator.compare(node1, node2)
+ assert_true(result.equal?)
+ end
+
+ def test_compare_headlines_with_different_levels
+ caption1 = ReVIEW::AST::CaptionNode.new(location: @location)
+ caption1.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Title'))
+
+ caption2 = ReVIEW::AST::CaptionNode.new(location: @location)
+ caption2.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Title'))
+
+ node1 = ReVIEW::AST::HeadlineNode.new(location: @location, level: 2, label: 'intro', caption_node: caption1)
+ node2 = ReVIEW::AST::HeadlineNode.new(location: @location, level: 3, label: 'intro', caption_node: caption2)
+
+ result = @comparator.compare(node1, node2)
+ assert_false(result.equal?)
+ assert_match(/headline level mismatch/, result.to_s)
+ end
+
+ def test_compare_nodes_with_children
+ para1 = ReVIEW::AST::ParagraphNode.new(location: @location)
+ para1.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Hello'))
+ para1.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'World'))
+
+ para2 = ReVIEW::AST::ParagraphNode.new(location: @location)
+ para2.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Hello'))
+ para2.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'World'))
+
+ result = @comparator.compare(para1, para2)
+ assert_true(result.equal?)
+ end
+
+ def test_compare_nodes_with_different_child_count
+ para1 = ReVIEW::AST::ParagraphNode.new(location: @location)
+ para1.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Hello'))
+
+ para2 = ReVIEW::AST::ParagraphNode.new(location: @location)
+ para2.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Hello'))
+ para2.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'World'))
+
+ result = @comparator.compare(para1, para2)
+ assert_false(result.equal?)
+ assert_match(/children count mismatch/, result.to_s)
+ end
+
+ def test_compare_code_blocks_with_lang
+ code1 = ReVIEW::AST::CodeBlockNode.new(location: @location, id: 'sample', lang: 'ruby')
+ code2 = ReVIEW::AST::CodeBlockNode.new(location: @location, id: 'sample', lang: 'ruby')
+
+ result = @comparator.compare(code1, code2)
+ assert_true(result.equal?)
+ end
+
+ def test_compare_code_blocks_with_different_lang
+ code1 = ReVIEW::AST::CodeBlockNode.new(location: @location, id: 'sample', lang: 'ruby')
+ code2 = ReVIEW::AST::CodeBlockNode.new(location: @location, id: 'sample', lang: 'python')
+
+ result = @comparator.compare(code1, code2)
+ assert_false(result.equal?)
+ assert_match(/code block lang mismatch/, result.to_s)
+ end
+
+ def test_compare_inline_nodes
+ inline1 = ReVIEW::AST::InlineNode.new(location: @location, inline_type: 'b')
+ inline2 = ReVIEW::AST::InlineNode.new(location: @location, inline_type: 'b')
+
+ result = @comparator.compare(inline1, inline2)
+ assert_true(result.equal?)
+ end
+
+ def test_compare_inline_nodes_different_type
+ inline1 = ReVIEW::AST::InlineNode.new(location: @location, inline_type: 'b')
+ inline2 = ReVIEW::AST::InlineNode.new(location: @location, inline_type: 'i')
+
+ result = @comparator.compare(inline1, inline2)
+ assert_false(result.equal?)
+ assert_match(/inline type mismatch/, result.to_s)
+ end
+
+ def test_comparison_result_with_path
+ node1 = ReVIEW::AST::TextNode.new(location: @location, content: 'Hello')
+ node2 = ReVIEW::AST::TextNode.new(location: @location, content: 'World')
+
+ result = @comparator.compare(node1, node2, 'custom.path')
+ assert_false(result.equal?)
+ assert_match(/custom\.path/, result.to_s)
+ end
+
+ def test_multiple_differences
+ para1 = ReVIEW::AST::ParagraphNode.new(location: @location)
+ para1.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Hello'))
+ para1.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'World'))
+
+ para2 = ReVIEW::AST::ParagraphNode.new(location: @location)
+ para2.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Goodbye'))
+ para2.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Moon'))
+
+ result = @comparator.compare(para1, para2)
+ assert_false(result.equal?)
+ # Should have 2 differences (one for each child)
+ assert_equal(2, result.differences.size)
+ end
+end
diff --git a/test/ast/test_ast_basic.rb b/test/ast/test_ast_basic.rb
new file mode 100644
index 000000000..5fba05224
--- /dev/null
+++ b/test/ast/test_ast_basic.rb
@@ -0,0 +1,109 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast'
+require 'review/htmlbuilder'
+require 'review/compiler'
+require 'review/book'
+require 'review/book/chapter'
+
+class TestASTBasic < Test::Unit::TestCase
+ def setup
+ @config = ReVIEW::Configure.values
+ @config['language'] = 'ja'
+ @book = ReVIEW::Book::Base.new(config: @config)
+ @log_io = StringIO.new
+ ReVIEW.logger = ReVIEW::Logger.new(@log_io)
+ ReVIEW::I18n.setup(@config['language'])
+ end
+
+ def test_ast_node_creation
+ node = ReVIEW::AST::ParagraphNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+ assert_equal [], node.children
+ assert_nil(node.parent)
+ assert_equal nil, node.location.filename
+ assert_equal 0, node.location.lineno
+ end
+
+ def test_headline_node
+ location = ReVIEW::SnapshotLocation.new(nil, 0)
+ node = ReVIEW::AST::HeadlineNode.new(
+ location: location,
+ level: 1,
+ label: 'test-label',
+ caption_node: CaptionParserHelper.parse('Test Headline', location: location)
+ )
+
+ hash = node.to_h
+ assert_equal 'HeadlineNode', hash[:type]
+ assert_equal 1, hash[:level]
+ assert_equal 'test-label', hash[:label]
+ expected_location = { filename: nil, lineno: 0 }
+ assert_equal({ children: [{ content: 'Test Headline', location: expected_location, type: 'TextNode' }], location: expected_location, type: 'CaptionNode' }, hash[:caption_node])
+ assert_equal 'Test Headline', node.caption_text
+ end
+
+ def test_paragraph_node
+ node = ReVIEW::AST::ParagraphNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+ text_node = ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'This is a test paragraph.')
+ node.add_child(text_node)
+
+ hash = node.to_h
+ assert_equal 'ParagraphNode', hash[:type]
+ # Check that the text content is in the children
+ assert_equal 1, hash[:children].size
+ assert_equal 'This is a test paragraph.', hash[:children][0][:content]
+ end
+
+ def test_ast_compilation_basic
+ chapter_content = <<~EOB
+ = Test Chapter
+
+ This is a test paragraph.
+
+ == Section 1
+
+ Another paragraph here.
+ EOB
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new)
+ chapter.content = chapter_content
+
+ compiler = ReVIEW::AST::Compiler.new
+ ast_result = compiler.compile_to_ast(chapter)
+
+ assert_not_nil(ast_result)
+ assert_equal ReVIEW::AST::DocumentNode, ast_result.class
+ assert ast_result.children.any?
+
+ options = ReVIEW::AST::JSONSerializer::Options.new(pretty: true)
+ json_result = ReVIEW::AST::JSONSerializer.serialize(ast_result, options)
+
+ parsed = JSON.parse(json_result)
+ assert parsed.is_a?(Hash)
+ assert_equal 'DocumentNode', parsed['type']
+ assert parsed.key?('children')
+ end
+
+ def test_json_output_format
+ location = ReVIEW::SnapshotLocation.new(nil, 0)
+ node = ReVIEW::AST::DocumentNode.new(location: location)
+ child_node = ReVIEW::AST::HeadlineNode.new(
+ location: location,
+ level: 1,
+ caption_node: CaptionParserHelper.parse('Test', location: location)
+ )
+
+ node.add_child(child_node)
+
+ json_str = node.to_json
+ parsed = JSON.parse(json_str)
+
+ assert_equal 'DocumentNode', parsed['type']
+ assert_equal 1, parsed['children'].size
+ assert_equal 'HeadlineNode', parsed['children'][0]['type']
+ assert_equal 1, parsed['children'][0]['level']
+ expected_location = { 'filename' => nil, 'lineno' => 0 }
+ assert_equal({ 'children' => [{ 'content' => 'Test', 'location' => expected_location, 'type' => 'TextNode' }], 'location' => expected_location, 'type' => 'CaptionNode' }, parsed['children'][0]['caption_node'])
+ end
+end
diff --git a/test/ast/test_ast_bidirectional_conversion.rb b/test/ast/test_ast_bidirectional_conversion.rb
new file mode 100644
index 000000000..07a2c80bd
--- /dev/null
+++ b/test/ast/test_ast_bidirectional_conversion.rb
@@ -0,0 +1,383 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast'
+require 'review/ast/compiler'
+require 'review/ast/diff/node'
+require 'review/ast/json_serializer'
+require 'review/ast/review_generator'
+require 'review/book'
+require 'review/book/chapter'
+require 'json'
+require 'stringio'
+
+class TestASTBidirectionalConversion < Test::Unit::TestCase
+ def setup
+ @config = ReVIEW::Configure.values
+ @config['secnolevel'] = 2
+ @config['language'] = 'ja'
+ @book = ReVIEW::Book::Base.new(config: @config)
+ @log_io = StringIO.new
+ ReVIEW.logger = ReVIEW::Logger.new(@log_io)
+ ReVIEW::I18n.setup(@config['language'])
+ @generator = ReVIEW::AST::ReVIEWGenerator.new
+ end
+
+ def test_simple_round_trip_conversion
+ # Test if caption serialization is now fixed with CaptionNode.to_h method
+
+ content = <<~EOB
+ = Test Chapter
+
+ This is a simple paragraph.
+ EOB
+
+ # Step 1: Re:VIEW -> AST
+ ast_root = compile_to_ast(content)
+ assert_not_nil(ast_root)
+
+ # Step 2: AST -> JSON
+ json_string = ReVIEW::AST::JSONSerializer.serialize(ast_root)
+ assert_not_nil(json_string)
+ parsed_json = JSON.parse(json_string)
+ assert_equal 'DocumentNode', parsed_json['type']
+
+ # Step 3: JSON -> AST
+ regenerated_ast = ReVIEW::AST::JSONSerializer.deserialize(json_string)
+ assert_not_nil(regenerated_ast)
+ assert_equal 'ReVIEW::AST::DocumentNode', regenerated_ast.class.name
+
+ # Step 4: AST -> Re:VIEW
+ regenerated_content = @generator.generate(regenerated_ast)
+ assert_not_nil(regenerated_content)
+
+ # Verify basic structure is preserved
+ assert_match(/= Test Chapter/, regenerated_content)
+ assert_match(/This is a simple paragraph/, regenerated_content)
+ end
+
+ def test_inline_elements_round_trip
+ # Caption serialization is now fixed
+
+ content = <<~EOB
+ = Inline Test
+
+ This has @<b>{bold} and @<i>{italic} text.
+ EOB
+
+ original_ast = compile_to_ast(content)
+ json_string = ReVIEW::AST::JSONSerializer.serialize(original_ast)
+ regenerated_ast = ReVIEW::AST::JSONSerializer.deserialize(json_string)
+ regenerated_content = @generator.generate(regenerated_ast)
+
+ # Check that inline elements are preserved
+ assert_match(/@<b>\{bold\}/, regenerated_content)
+ assert_match(/@<i>\{italic\}/, regenerated_content)
+ end
+
+ def test_list_round_trip
+ content = <<~EOB
+ = List Test
+
+ * Item 1
+ * Item 2
+ ** Item 2-1
+ ** Item 2-2
+ * Item 3
+ ** Item 3-1
+ ** Item 3-2
+ EOB
+
+ original_ast = compile_to_ast(content)
+ json_string = ReVIEW::AST::JSONSerializer.serialize(original_ast)
+ regenerated_ast = ReVIEW::AST::JSONSerializer.deserialize(json_string)
+ regenerated_content = @generator.generate(regenerated_ast)
+
+ # Check that list structure is preserved with nested items
+ assert_match(/\* Item 1/, regenerated_content)
+ assert_match(/\* Item 2/, regenerated_content)
+ assert_match(/\* Item 3/, regenerated_content)
+
+ # For nested items, they might be rendered differently (e.g., as part of parent item)
+ # So let's check they exist in the content somehow
+ assert_match(/Item 2-1/, regenerated_content)
+ assert_match(/Item 2-2/, regenerated_content)
+ assert_match(/Item 3-1/, regenerated_content)
+ assert_match(/Item 3-2/, regenerated_content)
+
+ # Verify that list items appear in order
+ _lines = regenerated_content.split("\n")
+
+ # Find all occurrences of items in the content
+ item1_index = regenerated_content.index('Item 1')
+ item2_index = regenerated_content.index('Item 2')
+ item2_1_index = regenerated_content.index('Item 2-1')
+ item2_2_index = regenerated_content.index('Item 2-2')
+ item3_index = regenerated_content.index('Item 3')
+ item3_1_index = regenerated_content.index('Item 3-1')
+ item3_2_index = regenerated_content.index('Item 3-2')
+
+ # Check all items were found
+ assert_not_nil(item1_index, 'Item 1 not found')
+ assert_not_nil(item2_index, 'Item 2 not found')
+ assert_not_nil(item2_1_index, 'Item 2-1 not found')
+ assert_not_nil(item2_2_index, 'Item 2-2 not found')
+ assert_not_nil(item3_index, 'Item 3 not found')
+ assert_not_nil(item3_1_index, 'Item 3-1 not found')
+ assert_not_nil(item3_2_index, 'Item 3-2 not found')
+
+ # Check correct ordering
+ assert item1_index < item2_index, 'Item 1 should come before Item 2'
+ assert item2_index < item2_1_index, 'Item 2 should come before Item 2-1'
+ assert item2_1_index < item2_2_index, 'Item 2-1 should come before Item 2-2'
+ assert item2_2_index < item3_index, 'Item 2-2 should come before Item 3'
+ assert item3_index < item3_1_index, 'Item 3 should come before Item 3-1'
+ assert item3_1_index < item3_2_index, 'Item 3-1 should come before Item 3-2'
+ end
+
+ def test_code_block_round_trip
+ content = <<~EOB
+ = Code Test
+
+ //list[sample][Sample @<b>{Code}][ruby]{
+ puts "Hello"
+ def greet
+ puts "Hi"
+ end
+ //}
+ EOB
+
+ original_ast = compile_to_ast(content)
+ json_string = ReVIEW::AST::JSONSerializer.serialize(original_ast)
+ regenerated_ast = ReVIEW::AST::JSONSerializer.deserialize(json_string)
+ regenerated_content = @generator.generate(regenerated_ast)
+
+ # Check that code block structure is preserved
+ assert_match(%r{//list\[sample\]\[Sample @<b>\{Code\}\]}, regenerated_content)
+ assert_match(/puts "Hello"/, regenerated_content)
+ assert_match(/def greet/, regenerated_content)
+ end
+
+ def test_table_round_trip
+ content = <<~EOB
+ = Table Test
+
+ //table[table1][Sample Table]{
+ Name Age
+ ------------
+ Alice 25
+ Bob 30
+ //}
+ EOB
+
+ original_ast = compile_to_ast(content)
+ json_string = ReVIEW::AST::JSONSerializer.serialize(original_ast)
+ regenerated_ast = ReVIEW::AST::JSONSerializer.deserialize(json_string)
+ regenerated_content = @generator.generate(regenerated_ast)
+
+ # Check that table structure is preserved (caption will be JSON but table content should work)
+ assert_match(%r{//table\[table1\]}, regenerated_content) # ID should be preserved
+ assert_match(/Name\s+Age/, regenerated_content)
+ assert_match(/Alice\s+25/, regenerated_content)
+ assert_match(/Bob\s+30/, regenerated_content)
+
+ # Verify table structure
+ assert_match(/------------/, regenerated_content) # Table separator
+ assert_match(%r{//\}}, regenerated_content) # Table end
+ end
+
+ def test_image_round_trip
+ content = <<~EOB
+ = Image Test
+
+ //image[sample_image][Sample Image @<b>{Caption}]{
+ //}
+ EOB
+
+ original_ast = compile_to_ast(content)
+ json_string = ReVIEW::AST::JSONSerializer.serialize(original_ast)
+ regenerated_ast = ReVIEW::AST::JSONSerializer.deserialize(json_string)
+ regenerated_content = @generator.generate(regenerated_ast)
+
+ # Check that image structure is preserved
+ assert_match(%r{//image\[sample_image\]}, regenerated_content) # ID should be preserved
+ assert_match(/Sample Image/, regenerated_content) # Caption content should be preserved
+ assert_match(/@<b>\{Caption\}/, regenerated_content) # Inline elements in caption should be preserved
+ end
+
+ def test_image_with_options_round_trip
+ content = <<~EOB
+ = Image with Options Test
+
+ //image[scaled_image][Scaled Image][scale=0.5]{
+ //}
+ EOB
+
+ original_ast = compile_to_ast(content)
+ json_string = ReVIEW::AST::JSONSerializer.serialize(original_ast)
+ regenerated_ast = ReVIEW::AST::JSONSerializer.deserialize(json_string)
+ regenerated_content = @generator.generate(regenerated_ast)
+
+ # Check that image with options structure is preserved
+ assert_match(%r{//image\[scaled_image\]}, regenerated_content) # ID should be preserved
+ assert_match(/Scaled Image/, regenerated_content) # Caption should be preserved
+ assert_match(/scale=0\.5/, regenerated_content) # Options should be preserved
+ end
+
+ def test_complex_structure_round_trip
+ content = <<~EOB
+ = Complex Test
+
+ This is a paragraph with @<b>{bold} text.
+
+ 1. First item
+ 2. Second item with @<i>{italic}
+
+ //list[code1][Code Example]{
+ puts "Hello"
+ //}
+
+ //table[data][Data Table]{
+ Key Value
+ ----
+ A 1
+ //}
+ EOB
+
+ original_ast = compile_to_ast(content)
+ json_string = ReVIEW::AST::JSONSerializer.serialize(original_ast)
+ regenerated_ast = ReVIEW::AST::JSONSerializer.deserialize(json_string)
+ regenerated_content = @generator.generate(regenerated_ast)
+
+ # Verify multiple elements are preserved (skip headline check due to caption issue)
+ assert_match(/@<b>\{bold\}/, regenerated_content)
+ assert_match(/1\. First item/, regenerated_content)
+ assert_match(/@<i>\{italic\}/, regenerated_content)
+ assert_match(%r{//list\[code1\]}, regenerated_content) # Code block ID preserved
+ assert_match(%r{//table\[data\]}, regenerated_content) # Table ID preserved
+ assert_match(/puts "Hello"/, regenerated_content) # Code content preserved
+ assert_match(/Key\s+Value/, regenerated_content) # Table content preserved
+ end
+
+ def test_json_structure_consistency
+ content = <<~EOB
+ = Structure Test
+
+ Simple paragraph.
+ EOB
+
+ # Test with default serialization options
+ original_ast = compile_to_ast(content)
+
+ # Serialize and deserialize
+ options = ReVIEW::AST::JSONSerializer::Options.new
+ json = ReVIEW::AST::JSONSerializer.serialize(original_ast, options)
+ regenerated_ast = ReVIEW::AST::JSONSerializer.deserialize(json)
+ regenerated_content = @generator.generate(regenerated_ast)
+
+ # Should produce similar Re:VIEW output
+ assert_match(/= Structure Test/, regenerated_content)
+ assert_match(/Simple paragraph/, regenerated_content)
+ end
+
+ def test_basic_ast_serialization_works
+ # This test verifies that basic AST creation and JSON serialization works
+ content = 'Simple text paragraph.'
+
+ original_ast = compile_to_ast(content)
+ assert_not_nil(original_ast)
+ assert_equal 'ReVIEW::AST::DocumentNode', original_ast.class.name
+
+ # Test JSON serialization
+ json_string = ReVIEW::AST::JSONSerializer.serialize(original_ast)
+ assert_not_nil(json_string)
+ parsed = JSON.parse(json_string)
+ assert_equal 'DocumentNode', parsed['type']
+
+ # Test JSON deserialization
+ regenerated_ast = ReVIEW::AST::JSONSerializer.deserialize(json_string)
+ assert_not_nil(regenerated_ast)
+ assert_equal 'ReVIEW::AST::DocumentNode', regenerated_ast.class.name
+ end
+
+ # Test all .re files in samples/syntax-book and samples/debug-book directories
+ # The test verifies AST-level equivalence through roundtrip conversion:
+ # Original.re -> AST1 -> JSON -> AST2 -> Re:VIEW -> AST3
+ # AST1 and AST3 should be structurally equivalent
+ def test_sample_files_roundtrip
+ sample_files = [
+ 'samples/syntax-book/appA.re',
+ 'samples/syntax-book/bib.re',
+ 'samples/syntax-book/ch01.re',
+ 'samples/syntax-book/ch02.re',
+ 'samples/syntax-book/ch03.re',
+ 'samples/syntax-book/part2.re',
+ 'samples/syntax-book/pre01.re',
+ 'samples/debug-book/advanced_features.re',
+ 'samples/debug-book/comprehensive.re',
+ 'samples/debug-book/edge_cases_test.re',
+ 'samples/debug-book/extreme_features.re',
+ 'samples/debug-book/multicontent_test.re'
+ ]
+
+ sample_files.each do |file_path|
+ next unless File.exist?(file_path)
+
+ # Step 1: Re:VIEW -> AST1
+ original_ast = compile_from_file(file_path)
+ assert_not_nil(original_ast, "Failed to compile #{file_path}")
+
+ # Step 2: AST1 -> JSON
+ json_string = ReVIEW::AST::JSONSerializer.serialize(original_ast)
+ assert_not_nil(json_string, "Failed to serialize #{file_path}")
+
+ # Step 3: JSON -> AST2
+ regenerated_ast = ReVIEW::AST::JSONSerializer.deserialize(json_string)
+ assert_not_nil(regenerated_ast, "Failed to deserialize #{file_path}")
+
+ # Step 4: AST2 -> Re:VIEW
+ regenerated_content = @generator.generate(regenerated_ast)
+ assert_not_nil(regenerated_content, "Failed to generate Re:VIEW from #{file_path}")
+
+ # Step 5: Re:VIEW -> AST3
+ begin
+ basename = File.basename(file_path, '.re')
+ reparsed_ast = compile_to_ast(regenerated_content, basename, file_path)
+ assert_not_nil(reparsed_ast, "Failed to reparse regenerated content from #{file_path}")
+
+ # Step 6: Compare AST1 and AST3 for structural equivalence
+ assert_ast_equivalent(original_ast, reparsed_ast, "AST mismatch for #{file_path}")
+ rescue StandardError => e
+ flunk("Roundtrip failed for #{file_path}: #{e.message}")
+ end
+ end
+ end
+
+ private
+
+ def compile_to_ast(content, basename = 'test', file_path = 'test.re')
+ compiler = ReVIEW::AST::Compiler.new
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, basename, file_path, StringIO.new(content))
+
+ # Skip reference resolution to avoid chapter lookup errors in isolated tests
+ compiler.compile_to_ast(chapter, reference_resolution: false)
+ end
+
+ def compile_from_file(file_path)
+ content = File.read(file_path)
+ basename = File.basename(file_path, '.re')
+ compiler = ReVIEW::AST::Compiler.new
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, basename, file_path, StringIO.new(content))
+
+ # Skip reference resolution to avoid chapter lookup errors in isolated tests
+ compiler.compile_to_ast(chapter, reference_resolution: false)
+ end
+
+ # Compare two AST nodes for structural equivalence
+ # Ignores location information and focuses on node types, attributes, and structure
+ def assert_ast_equivalent(node1, node2, message = 'AST nodes are not equivalent')
+ comparator = ReVIEW::AST::Diff::Node.new
+ result = comparator.compare(node1, node2)
+ assert(result.equal?, "#{message}\n#{result}")
+ end
+end
diff --git a/test/ast/test_ast_code_block_node.rb b/test/ast/test_ast_code_block_node.rb
new file mode 100644
index 000000000..9535b3261
--- /dev/null
+++ b/test/ast/test_ast_code_block_node.rb
@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/snapshot_location'
+require 'review/ast/code_block_node'
+require 'review/ast/paragraph_node'
+require 'review/ast/text_node'
+require 'review/ast/inline_node'
+require 'review/ast/json_serializer'
+require 'review/ast/compiler'
+require 'review/ast/review_generator'
+require 'review/configure'
+require 'review/book'
+require 'review/i18n'
+require 'stringio'
+
+class TestASTCodeBlockNode < Test::Unit::TestCase
+ def setup
+ @config = ReVIEW::Configure.values
+ @config['language'] = 'ja'
+ @book = ReVIEW::Book::Base.new(config: @config)
+ @location = create_test_location
+ ReVIEW::I18n.setup(@config['language'])
+ end
+
+ def create_test_location
+ ReVIEW::SnapshotLocation.new('test.re', 5)
+ end
+
+ def test_code_block_node_original_text_preservation
+ lines = ['puts @<b>{hello}', 'puts "world"']
+ original_text = lines.join("\n")
+
+ code_block = ReVIEW::AST::CodeBlockNode.new(
+ location: @location,
+ id: 'sample',
+ original_text: original_text
+ )
+
+ assert_equal original_text, code_block.original_text
+ assert_equal lines, code_block.original_lines
+ end
+
+ def test_code_block_node_processed_lines
+ code_block = ReVIEW::AST::CodeBlockNode.new(
+ location: @location,
+ id: 'sample',
+ original_text: 'puts @<b>{hello}'
+ )
+
+ processed = code_block.processed_lines
+ assert_equal 0, processed.size
+
+ original = code_block.original_lines
+ assert_equal 1, original.size
+ assert_equal 'puts @<b>{hello}', original[0]
+ end
+
+ def test_original_lines_and_processed_lines
+ original_text = 'puts @<b>{hello}'
+
+ code_block = ReVIEW::AST::CodeBlockNode.new(
+ location: @location,
+ original_text: original_text
+ )
+
+ assert_equal ['puts @<b>{hello}'], code_block.original_lines
+
+ processed = code_block.processed_lines
+ assert_equal 0, processed.size
+ end
+
+ def test_ast_node_to_review_syntax
+ generator = ReVIEW::AST::ReVIEWGenerator.new
+
+ text_node = ReVIEW::AST::TextNode.new(location: @location, content: 'hello world')
+ assert_equal 'hello world', generator.generate(text_node)
+
+ inline_node = ReVIEW::AST::InlineNode.new(location: @location, inline_type: :b, args: ['bold text'])
+ assert_equal '@<b>{bold text}', generator.generate(inline_node)
+ end
+
+ def test_code_block_with_ast_compiler_integration
+ source = <<~EOS
+ //list[sample][Sample Code]{
+ puts @<b>{hello}
+ puts "world"
+ //}
+ EOS
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(source))
+
+ compiler = ReVIEW::AST::Compiler.new
+ ast_root = compiler.compile_to_ast(chapter)
+
+ code_block = find_code_block_in_ast(ast_root)
+ assert_not_nil(code_block)
+ assert_instance_of(ReVIEW::AST::CodeBlockNode, code_block)
+
+ assert_include(code_block.original_text, 'puts @<b>{hello}')
+ assert_include(code_block.original_text, 'puts "world"')
+
+ original_lines = code_block.original_lines
+ assert_equal 2, original_lines.size
+ assert_equal 'puts @<b>{hello}', original_lines[0]
+ assert_equal 'puts "world"', original_lines[1]
+ end
+
+ def test_render_ast_node_as_plain_text_with_text_node
+ text_node = ReVIEW::AST::TextNode.new(location: @location, content: 'hello world')
+
+ result = render_ast_node_as_plain_text_helper(text_node)
+ assert_equal 'hello world', result
+ end
+
+ def test_render_ast_node_as_plain_text_with_inline_node
+ text_node = ReVIEW::AST::TextNode.new(location: @location, content: 'bold text')
+ inline_node = ReVIEW::AST::InlineNode.new(location: @location, inline_type: :b)
+ inline_node.add_child(text_node)
+
+ result = render_ast_node_as_plain_text_helper(inline_node)
+ assert_equal '@<b>{bold text}', result
+ end
+
+ def test_render_ast_node_as_plain_text_with_paragraph_containing_inline
+ paragraph = create_test_paragraph
+
+ result = render_ast_node_as_plain_text_helper(paragraph)
+ assert_equal 'puts @<b>{hello}', result
+ end
+
+ def test_render_ast_node_as_plain_text_with_complex_inline
+ bold_text = ReVIEW::AST::TextNode.new(location: @location, content: 'bold')
+ bold_inline = ReVIEW::AST::InlineNode.new(location: @location, inline_type: :b)
+ bold_inline.add_child(bold_text)
+
+ italic_text1 = ReVIEW::AST::TextNode.new(location: @location, content: 'italic ')
+ italic_inline = ReVIEW::AST::InlineNode.new(location: @location, inline_type: :i)
+ italic_inline.add_child(italic_text1)
+ italic_inline.add_child(bold_inline)
+
+ paragraph = ReVIEW::AST::ParagraphNode.new(location: @location)
+ paragraph.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'This is '))
+ paragraph.add_child(italic_inline)
+ paragraph.add_child(ReVIEW::AST::TextNode.new(location: @location, content: ' text'))
+
+ result = render_ast_node_as_plain_text_helper(paragraph)
+ assert_equal 'This is @<i>{italic @<b>{bold}} text', result
+ end
+
+ def test_code_block_node_inheritance_from_base_node
+ code_block = ReVIEW::AST::CodeBlockNode.new(
+ location: @location,
+ original_text: 'test content'
+ )
+
+ assert_respond_to(code_block, :original_text)
+ assert_equal 'test content', code_block.original_text
+
+ assert_respond_to(code_block, :location)
+ assert_respond_to(code_block, :children)
+ assert_equal @location, code_block.location
+ end
+
+ def test_original_text_preservation
+ code_block1 = ReVIEW::AST::CodeBlockNode.new(
+ location: @location,
+ original_text: 'original content'
+ )
+ assert_equal 'original content', code_block1.original_text
+ assert_equal ['original content'], code_block1.original_lines
+
+ code_block2 = ReVIEW::AST::CodeBlockNode.new(
+ location: @location,
+ original_text: nil
+ )
+ assert_nil(code_block2.original_text)
+ assert_equal [], code_block2.original_lines
+ end
+
+ def test_serialize_properties_includes_original_text
+ caption_node = ReVIEW::AST::CaptionNode.new(location: @location)
+ caption_node.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Test Caption'))
+
+ code_block = ReVIEW::AST::CodeBlockNode.new(
+ location: @location,
+ id: 'test',
+ caption_node: caption_node,
+ original_text: 'puts hello'
+ )
+
+ hash = {}
+ options = ReVIEW::AST::JSONSerializer::Options.new
+
+ assert_nothing_raised do
+ code_block.send(:serialize_properties, hash, options)
+ end
+
+ assert_equal 'test', hash[:id]
+ assert_instance_of(Hash, hash[:caption_node])
+ assert_equal 'CaptionNode', hash[:caption_node][:type]
+ assert_equal 1, hash[:caption_node][:children].size
+ assert_equal 'TextNode', hash[:caption_node][:children][0][:type]
+ assert_equal 'Test Caption', hash[:caption_node][:children][0][:content]
+ end
+
+ private
+
+ def create_test_paragraph
+ text_node = ReVIEW::AST::TextNode.new(location: @location, content: 'hello')
+ inline_node = ReVIEW::AST::InlineNode.new(location: @location, inline_type: :b)
+ inline_node.add_child(text_node)
+
+ paragraph = ReVIEW::AST::ParagraphNode.new(location: @location)
+ paragraph.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'puts '))
+ paragraph.add_child(inline_node)
+
+ paragraph
+ end
+
+ def find_code_block_in_ast(node)
+ return node if node.is_a?(ReVIEW::AST::CodeBlockNode)
+
+ if node.children
+ node.children.each do |child|
+ result = find_code_block_in_ast(child)
+ return result if result
+ end
+ end
+
+ nil
+ end
+
+ # Helper method to render AST node as plain text (replacement for deleted method)
+ def render_ast_node_as_plain_text_helper(node)
+ case node
+ when ReVIEW::AST::TextNode
+ node.content
+ when ReVIEW::AST::InlineNode
+ content = node.children.map { |child| render_ast_node_as_plain_text_helper(child) }.join
+ "@<#{node.inline_type}>{#{content}}"
+ when ReVIEW::AST::ParagraphNode
+ node.children.map { |child| render_ast_node_as_plain_text_helper(child) }.join
+ else
+ if node.respond_to?(:children)
+ node.children.map { |child| render_ast_node_as_plain_text_helper(child) }.join
+ else
+ ''
+ end
+ end
+ end
+end
diff --git a/test/ast/test_ast_complex_integration.rb b/test/ast/test_ast_complex_integration.rb
new file mode 100644
index 000000000..a85d618d1
--- /dev/null
+++ b/test/ast/test_ast_complex_integration.rb
@@ -0,0 +1,333 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast'
+require 'review/ast/compiler'
+require 'review/renderer/html_renderer'
+require 'review/renderer/latex_renderer'
+require 'review/configure'
+require 'review/book'
+require 'review/book/chapter'
+require 'review/ast/json_serializer'
+require 'json'
+
+class TestASTComplexIntegration < Test::Unit::TestCase
+ def setup
+ @config = ReVIEW::Configure.values
+ @config['secnolevel'] = 3
+ @config['language'] = 'ja'
+
+ @book = ReVIEW::Book::Base.new(config: @config)
+ @log_io = StringIO.new
+ ReVIEW.logger = ReVIEW::Logger.new(@log_io)
+ ReVIEW::I18n.setup(@config['language'])
+ end
+
+ def test_nested_structures_with_inline_elements
+ content = <<~EOB
+ = Complex Document Structure
+
+ == Section with Lists and Code
+
+ This paragraph has @<b>{bold} and @<i>{italic} text.
+
+ === Nested Lists Test
+
+ * First level item with @<code>{inline code}
+ * Second level with @<ruby>{漢字,かんじ} text
+ * Third level item
+ * Back to first level with @<href>{http://example.com,link}
+
+ 1. Ordered list item with @<kw>{HTTP,Protocol}
+ 1. Nested ordered item
+ 1. Another nested item with @<tt>{typewriter}
+ 2. Second ordered item
+
+ === Code Blocks with Complex Content
+
+ //list[complex-code][Complex Code Example][ruby]{
+ def process_data(input)
+ # Process with @<b>{bold} annotation
+ result = input.map { |item| transform(item) }
+ logger.info("Processed @<fn>{processing-note} items")
+ result
+ end
+ //}
+
+ === Tables with Inline Elements
+
+ //table[data-table][Sample Data]{
+ Name Description Status
+ ----------------
+ @<b>{Primary} Main data source @<i>{Active}
+ @<code>{Secondary} Backup source @<tt>{Standby}
+ //}
+
+ == Multiple Block Types
+
+ === Note Blocks
+
+ //note[important-note][Important Notice]{
+ This note contains @<b>{important} information with @<code>{code examples}.
+
+ * Nested list in note
+ * Another item with @<href>{http://docs.example.com,documentation}
+ //}
+
+ === Embedded Blocks
+
+ //embed[latex]{
+ \\begin{equation}
+ E = mc^2 \\quad \\text{with @<i>{emphasis}}
+ \\end{equation}
+ //}
+
+ === Column Blocks
+
+ //column[side-info][Side Information]{
+ This column has @<ruby>{専門,せんもん} terminology and @<kw>{API,Application Programming Interface}.
+
+ //list[column-code][Code in Column][javascript]{
+ const data = await fetch('/api/data');
+ console.log("Fetched @<fn>{data-note} records");
+ //}
+ //}
+
+ == Cross-References and Footnotes
+
+ See @<list>{complex-code} for implementation details.
+ Refer to @<table>{data-table} for data structure.
+
+ This text has footnotes@<fn>{footnote1} and more references@<fn>{footnote2}.
+
+ //footnote[footnote1][First footnote with @<b>{formatting}]
+ //footnote[footnote2][Second footnote with @<code>{code}]
+ //footnote[processing-note][Processing footnote]
+ //footnote[data-note][Data note]
+ EOB
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'complex', 'complex.re', StringIO.new(content))
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(chapter)
+
+ assert_not_nil(ast_root, 'AST root should be created')
+ assert_equal('DocumentNode', ast_root.class.name.split('::').last)
+
+ node_counts = count_node_types(ast_root)
+
+ assert(node_counts['HeadlineNode'] >= 4, "Should have multiple headlines, got #{node_counts['HeadlineNode']}")
+ assert(node_counts['ParagraphNode'] >= 4, "Should have multiple paragraphs, got #{node_counts['ParagraphNode']}")
+ assert(node_counts['CodeBlockNode'] >= 2, "Should have multiple code blocks, got #{node_counts['CodeBlockNode']}")
+ assert(node_counts['TableNode'] >= 1, "Should have tables, got #{node_counts['TableNode']}")
+ assert(node_counts['InlineNode'] >= 10, "Should have many inline elements, got #{node_counts['InlineNode']}")
+ assert(node_counts['ListNode'] >= 1, "Should have lists, got #{node_counts['ListNode']}")
+
+ html_renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_result = html_renderer.render(ast_root)
+
+ assert(html_result.include?('<h1>'), 'Should have h1 tags')
+ assert(html_result.include?('<h2>'), 'Should have h2 tags')
+ assert(html_result.include?('<h3>'), 'Should have h3 tags')
+ assert(html_result.include?('<b>'), 'Should have bold tags')
+ assert(html_result.include?('<i>'), 'Should have italic tags')
+ assert(html_result.include?('<code'), 'Should have code tags')
+ assert(html_result.include?('<ul>'), 'Should have unordered lists')
+ assert(html_result.include?('<ol>'), 'Should have ordered lists')
+ assert(html_result.include?('<table>'), 'Should have tables')
+ assert(html_result.include?('<ruby>'), 'Should have ruby tags')
+
+ latex_renderer = ReVIEW::Renderer::LatexRenderer.new(chapter)
+ latex_result = latex_renderer.render(ast_root)
+
+ assert(latex_result.include?('\\chapter'), 'Should have chapter commands')
+ assert(latex_result.include?('\\section'), 'Should have section commands')
+ assert(latex_result.include?('\\subsection'), 'Should have subsection commands')
+ assert(latex_result.include?('\\textbf') || latex_result.include?('\\reviewbold'), 'Should have bold commands')
+ assert(latex_result.include?('\\textit') || latex_result.include?('\\reviewit'), 'Should have italic commands')
+ assert(latex_result.include?('\\begin{itemize}'), 'Should have itemize environments')
+ assert(latex_result.include?('\\begin{enumerate}'), 'Should have enumerate environments')
+ assert(latex_result.include?('\\begin{table}'), 'Should have table environments')
+
+ inline_nodes = collect_inline_nodes(ast_root)
+ list_refs = inline_nodes.select { |node| node.inline_type == :list }
+ table_refs = inline_nodes.select { |node| node.inline_type == :table }
+ footnote_refs = inline_nodes.select { |node| node.inline_type == :fn }
+
+ assert(list_refs.size >= 1, 'Should have list references')
+ assert(table_refs.size >= 1, 'Should have table references')
+ assert(footnote_refs.size >= 2, 'Should have footnote references')
+ end
+
+ def test_performance_with_large_complex_document
+ content = generate_large_complex_document(50)
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'large', 'large.re', StringIO.new)
+ chapter.content = content
+
+ start_time = Time.now
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(chapter)
+ ast_time = Time.now - start_time
+
+ start_time = Time.now
+ html_renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_result = html_renderer.render(ast_root)
+ html_time = Time.now - start_time
+
+ start_time = Time.now
+ latex_renderer = ReVIEW::Renderer::LatexRenderer.new(chapter)
+ latex_result = latex_renderer.render(ast_root)
+ latex_time = Time.now - start_time
+
+ # Performance assertions (these are reasonable limits for CI)
+ assert(ast_time < 5.0, "AST compilation should be under 5 seconds, took #{ast_time}")
+ assert(html_time < 3.0, "HTML rendering should be under 3 seconds, took #{html_time}")
+ assert(latex_time < 3.0, "LaTeX rendering should be under 3 seconds, took #{latex_time}")
+
+ assert(html_result.length > 10000, 'HTML output should be substantial')
+ assert(latex_result.length > 10000, 'LaTeX output should be substantial')
+ assert(html_result.include?('<h2>'), 'HTML should contain section headers')
+ assert(latex_result.include?('\\section'), 'LaTeX should contain section commands')
+ end
+
+ def test_error_handling_with_malformed_content
+ malformed_content = <<~EOB
+ = Test Document
+
+ This has unclosed @<b>{bold text
+
+ //list[broken-list][Broken Code]{
+ def broken_function
+ # Missing closing brace
+ //}
+
+ === Missing Table End
+
+ //table[broken-table][Test]{
+ Header1 Header2
+ -----------
+ Data1 Data2
+ # Missing //}
+
+ Regular paragraph continues here.
+ EOB
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'malformed', 'malformed.re', StringIO.new)
+ chapter.content = malformed_content
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+
+ assert_raises(ReVIEW::AST::InlineTokenizeError) do
+ ast_compiler.compile_to_ast(chapter)
+ end
+ end
+
+ def test_memory_usage_with_deep_nesting
+ content = generate_deeply_nested_document(10)
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'nested', 'nested.re', StringIO.new)
+ chapter.content = content
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(chapter)
+
+ max_depth = calculate_max_depth(ast_root)
+ assert(max_depth >= 5, "Should handle deep nesting, max depth: #{max_depth}")
+
+ html_renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_result = html_renderer.render(ast_root)
+
+ nested_ul_count = html_result.scan(/<ul[^>]*>/).length
+ assert(nested_ul_count >= 1, "Should have nested lists, found #{nested_ul_count}")
+ end
+
+ private
+
+ def count_node_types(node, counts = Hash.new(0))
+ counts[node.class.name.split('::').last] += 1
+
+ if node.children
+ node.children.each { |child| count_node_types(child, counts) }
+ end
+
+ counts
+ end
+
+ def collect_inline_nodes(node, inline_nodes = [])
+ if node.class.name.include?('InlineNode')
+ inline_nodes << node
+ end
+
+ if node.children
+ node.children.each { |child| collect_inline_nodes(child, inline_nodes) }
+ end
+
+ inline_nodes
+ end
+
+ def generate_large_complex_document(section_count)
+ content = "= Large Complex Document\n\n"
+
+ (1..section_count).each do |i|
+ content += <<~SECTION
+ == Section #{i}
+
+ This is section #{i} with @<b>{bold} and @<i>{italic} text.
+ It also contains @<code>{code_#{i}} and @<ruby>{漢字#{i},かんじ#{i}}.
+
+ === Subsection #{i}.1
+
+ * List item #{i}.1 with @<href>{http://example#{i}.com,link#{i}}
+ * List item #{i}.2 with @<kw>{Term#{i},Description#{i}}
+ * Nested item #{i}.2.1
+ * Nested item #{i}.2.2
+
+ //list[code-#{i}][Code Example #{i}][ruby]{
+ def method_#{i}(param)
+ # Processing with @<b>{annotation #{i}}
+ result = process(param)
+ puts "Result @<fn>{note-#{i}}: \#{result}"
+ end
+ //}
+
+ //footnote[note-#{i}][Footnote #{i} with @<code>{code reference}]
+
+ SECTION
+ end
+
+ content
+ end
+
+ def generate_deeply_nested_document(max_depth)
+ content = "= Deeply Nested Document\n\n"
+
+ content += " * Level 1 item with @<b>{bold 1} text\n"
+ (2..max_depth).each do |level|
+ indent = ' ' * level
+ content += "#{indent}* Level #{level} item with @<code>{code_#{level}}\n"
+ end
+
+ content += "\n== Section with Complex Nesting\n\n"
+
+ (1..5).each do |level|
+ indent = ' ' * level
+ content += "#{indent}: Term #{level} with @<i>{italic #{level}}\n"
+ content += "#{indent} Definition #{level} with @<ruby>{漢字#{level},かんじ#{level}}\n"
+ end
+
+ content
+ end
+
+ def calculate_max_depth(node, current_depth = 0)
+ max_depth = current_depth
+
+ if node.children
+ node.children.each do |child|
+ child_depth = calculate_max_depth(child, current_depth + 1)
+ max_depth = [max_depth, child_depth].max
+ end
+ end
+
+ max_depth
+ end
+end
diff --git a/test/ast/test_ast_comprehensive.rb b/test/ast/test_ast_comprehensive.rb
new file mode 100644
index 000000000..11a451fc8
--- /dev/null
+++ b/test/ast/test_ast_comprehensive.rb
@@ -0,0 +1,263 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast'
+require 'review/ast/compiler'
+require 'review/renderer/html_renderer'
+require 'review/configure'
+require 'review/book'
+require 'review/book/chapter'
+
+class TestASTComprehensive < Test::Unit::TestCase
+ def setup
+ @config = ReVIEW::Configure.values
+ @config['secnolevel'] = 2
+ @config['language'] = 'ja'
+ @book = ReVIEW::Book::Base.new(config: @config)
+ @log_io = StringIO.new
+ ReVIEW.logger = ReVIEW::Logger.new(@log_io)
+ ReVIEW::I18n.setup(@config['language'])
+ end
+
+ def test_code_blocks_ast_processing
+ content = <<~EOB
+ = Code Examples
+
+ Normal list with ID:
+
+ //list[sample][Sample Code][ruby]{
+ puts "Hello, World!"
+ def greeting
+ "Hello"
+ end
+ //}
+
+ Embedded list without ID:
+
+ //emlist[Ruby Example][ruby]{
+ puts "Embedded example"
+ //}
+
+ Numbered list:
+
+ //listnum[numbered][Numbered Example][python]{
+ print("Hello")
+ print("World")
+ //}
+
+ Command example:
+
+ //cmd[Terminal Commands]{
+ ls -la
+ cd /home
+ //}
+ EOB
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(chapter)
+
+ code_blocks = ast_root.children.select { |n| n.is_a?(ReVIEW::AST::CodeBlockNode) }
+ assert_equal 4, code_blocks.size
+
+ list_block = code_blocks.find { |n| n.id == 'sample' }
+ assert_not_nil(list_block)
+ assert_equal 'Sample Code', list_block.caption_text
+ assert_equal 'ruby', list_block.lang
+ assert_equal false, list_block.line_numbers
+
+ emlist_block = code_blocks.find { |n| n.caption_text == 'Ruby Example' && n.id.nil? }
+ assert_not_nil(emlist_block)
+ assert_equal 'ruby', emlist_block.lang
+
+ listnum_block = code_blocks.find { |n| n.id == 'numbered' }
+ assert_not_nil(listnum_block)
+ assert_equal true, listnum_block.line_numbers
+
+ cmd_block = code_blocks.find { |n| n.lang == 'shell' }
+ assert_not_nil(cmd_block)
+ assert_equal 'Terminal Commands', cmd_block.caption_text
+ end
+
+ def test_table_ast_processing
+ content = <<~EOB
+ = Tables
+
+ //table[envvars][Environment Variables]{
+ Name Meaning
+ ------------
+ PATH Command directories
+ HOME User home directory
+ LANG Default locale
+ //}
+
+ //emtable[Simple Table]{
+ Col1 Col2
+ A B
+ C D
+ //}
+ EOB
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(chapter)
+
+ table_nodes = ast_root.children.select { |n| n.is_a?(ReVIEW::AST::TableNode) }
+ assert_equal 2, table_nodes.size
+
+ main_table = table_nodes.find { |n| n.id == 'envvars' }
+ assert_not_nil(main_table)
+ assert_equal 'Environment Variables', main_table.caption_text
+ assert_equal 1, main_table.header_rows.size
+ assert_equal 3, main_table.body_rows.size
+ end
+
+ def test_image_ast_processing
+ content = <<~EOB
+ = Images
+
+ //image[diagram][System Diagram][scale=0.5]{
+ ASCII art or description here
+ //}
+
+ //indepimage[logo][Company Logo]
+
+ EOB
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(chapter)
+
+ image_nodes = ast_root.children.select { |n| n.is_a?(ReVIEW::AST::ImageNode) }
+ assert_equal 2, image_nodes.size
+
+ main_image = image_nodes.find { |n| n.id == 'diagram' }
+ assert_not_nil(main_image)
+ assert_equal 'System Diagram', main_image.caption_text
+ assert_equal 'scale=0.5', main_image.metric
+
+ indep_image = image_nodes.find { |n| n.id == 'logo' }
+ assert_not_nil(indep_image)
+ assert_equal 'Company Logo', indep_image.caption_text
+ end
+
+ def test_special_inline_elements_ast_processing
+ content = <<~EOB
+ = Special Inline Elements
+
+ This paragraph contains @<ruby>{漢字,かんじ} with ruby annotation.
+
+ Visit @<href>{https://example.com, Example Site} for more information.
+
+ The @<kw>{HTTP, HyperText Transfer Protocol} is a protocol.
+
+ Simple @<b>{bold} and @<code>{code} elements.
+
+ Unicode character: @<uchar>{2603} (snowman).
+ EOB
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(chapter)
+
+ paragraph_nodes = ast_root.children.select { |n| n.is_a?(ReVIEW::AST::ParagraphNode) }
+
+ ruby_para = paragraph_nodes[0]
+ ruby_node = ruby_para.children.find { |n| n.is_a?(ReVIEW::AST::InlineNode) && n.inline_type == :ruby }
+ assert_not_nil(ruby_node)
+ assert_equal ['漢字', 'かんじ'], ruby_node.args
+
+ href_para = paragraph_nodes[1]
+ href_node = href_para.children.find { |n| n.is_a?(ReVIEW::AST::InlineNode) && n.inline_type == :href }
+ assert_not_nil(href_node)
+ assert_equal ['https://example.com', 'Example Site'], href_node.args
+
+ kw_para = paragraph_nodes[2]
+ kw_node = kw_para.children.find { |n| n.is_a?(ReVIEW::AST::InlineNode) && n.inline_type == :kw }
+ assert_not_nil(kw_node)
+ assert_equal ['HTTP', 'HyperText Transfer Protocol'], kw_node.args
+
+ simple_para = paragraph_nodes[3]
+ bold_node = simple_para.children.find { |n| n.is_a?(ReVIEW::AST::InlineNode) && n.inline_type == :b }
+ code_node = simple_para.children.find { |n| n.is_a?(ReVIEW::AST::InlineNode) && n.inline_type == :code }
+ assert_not_nil(bold_node)
+ assert_not_nil(code_node)
+
+ uchar_para = paragraph_nodes[4]
+ uchar_node = uchar_para.children.find { |n| n.is_a?(ReVIEW::AST::InlineNode) && n.inline_type == :uchar }
+ assert_not_nil(uchar_node)
+ assert_equal ['2603'], uchar_node.args
+ end
+
+ def test_comprehensive_output_compatibility
+ content = <<~EOB
+ = Comprehensive Test
+
+ Intro with @<b>{bold} text.
+
+ * List item with @<code>{code}
+ * Another item
+
+ //list[example][Code Example]{
+ puts "Hello"
+ //}
+
+ //table[data][Data Table]{
+ Name Value
+ ------------
+ A 1
+ B 2
+ //}
+
+ Text with @<ruby>{日本語,にほんご} and @<href>{http://example.com}.
+
+ 1. Numbered item
+ 2. Another numbered item
+
+ //quote{
+ This is a quote with @<i>{italic} text.
+ //}
+
+ Final paragraph.
+ EOB
+
+ chapter_ast = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new)
+ chapter_ast.content = content
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(chapter_ast)
+
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter_ast)
+ result_ast = renderer.render(ast_root)
+
+ ['<h1>', '<ul>', '<ol>', '<table>', '<blockquote>'].each do |tag|
+ assert(result_ast.include?(tag), "AST/Renderer system should produce #{tag}")
+ end
+
+ ['<b>', '<code', '<i>'].each do |tag|
+ assert(result_ast.include?(tag), "AST/Renderer system should produce #{tag}")
+ end
+
+ assert_not_nil(ast_root, 'Should have AST root')
+ assert_equal(ReVIEW::AST::DocumentNode, ast_root.class)
+
+ headline_nodes = ast_root.children.select { |n| n.is_a?(ReVIEW::AST::HeadlineNode) }
+ assert_equal(1, headline_nodes.size, 'Should have one headline')
+
+ paragraph_nodes = ast_root.children.select { |n| n.is_a?(ReVIEW::AST::ParagraphNode) }
+ assert(paragraph_nodes.size >= 3, 'Should have multiple paragraphs')
+
+ list_nodes = ast_root.children.select { |n| n.is_a?(ReVIEW::AST::ListNode) }
+ assert_equal(2, list_nodes.size, 'Should have unordered and ordered lists')
+
+ code_block_nodes = ast_root.children.select { |n| n.is_a?(ReVIEW::AST::CodeBlockNode) }
+ assert_equal(1, code_block_nodes.size, 'Should have one code block')
+
+ table_nodes = ast_root.children.select { |n| n.is_a?(ReVIEW::AST::TableNode) }
+ assert_equal(1, table_nodes.size, 'Should have one table')
+ end
+end
diff --git a/test/ast/test_ast_comprehensive_inline.rb b/test/ast/test_ast_comprehensive_inline.rb
new file mode 100644
index 000000000..1f9e5130a
--- /dev/null
+++ b/test/ast/test_ast_comprehensive_inline.rb
@@ -0,0 +1,352 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast'
+require 'review/ast/compiler'
+require 'review/renderer/html_renderer'
+require 'review/configure'
+require 'review/book'
+require 'review/book/chapter'
+
+class TestASTComprehensiveInline < Test::Unit::TestCase
+ def setup
+ @config = ReVIEW::Configure.values
+ @config['secnolevel'] = 2
+ @config['language'] = 'ja'
+ @config['dictionary'] = {
+ 'glossary' => 'glossary',
+ 'abbreviations' => 'abbreviations'
+ }
+ @book = ReVIEW::Book::Base.new(config: @config)
+ @log_io = StringIO.new
+ ReVIEW.logger = ReVIEW::Logger.new(@log_io)
+ ReVIEW::I18n.setup(@config['language'])
+ end
+
+ def test_advanced_inline_elements_ast_processing
+ content = <<~EOB
+ = Advanced Inline Elements
+
+ This paragraph tests @<b>{bold} text and @<i>{italic} text.
+
+ Basic formatting: @<code>{code} and @<tt>{typewriter}.
+
+ Ruby text: @<ruby>{漢字,かんじ} and @<kw>{HTTP,Protocol}.
+
+ Links: @<href>{http://example.com,example} text.
+
+ Simple inline elements without references.
+ EOB
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(chapter)
+
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_result = renderer.render(ast_root)
+
+ assert(html_result.include?('bold'), 'HTML should include bold content')
+ assert(html_result.include?('italic'), 'HTML should include italic content')
+ assert(html_result.include?('code'), 'HTML should include code content')
+
+ paragraph_nodes = ast_root.children.select { |n| n.is_a?(ReVIEW::AST::ParagraphNode) }
+
+ first_para = paragraph_nodes[0]
+ b_node = first_para.children.find { |n| n.is_a?(ReVIEW::AST::InlineNode) && n.inline_type == :b }
+ i_node = first_para.children.find { |n| n.is_a?(ReVIEW::AST::InlineNode) && n.inline_type == :i }
+ assert_not_nil(b_node)
+ assert_equal ['bold'], b_node.args
+ assert_not_nil(i_node)
+ assert_equal ['italic'], i_node.args
+
+ second_para = paragraph_nodes[1]
+ code_node = second_para.children.find { |n| n.is_a?(ReVIEW::AST::InlineNode) && n.inline_type == :code }
+ tt_node = second_para.children.find { |n| n.is_a?(ReVIEW::AST::InlineNode) && n.inline_type == :tt }
+ assert_not_nil(code_node)
+ assert_not_nil(tt_node)
+ assert_equal ['code'], code_node.args
+ assert_equal ['typewriter'], tt_node.args
+
+ third_para = paragraph_nodes[2]
+ ruby_node = third_para.children.find { |n| n.is_a?(ReVIEW::AST::InlineNode) && n.inline_type == :ruby }
+ kw_node = third_para.children.find { |n| n.is_a?(ReVIEW::AST::InlineNode) && n.inline_type == :kw }
+ assert_not_nil(ruby_node)
+ assert_not_nil(kw_node)
+ assert_equal ['漢字', 'かんじ'], ruby_node.args
+ assert_equal ['HTTP', 'Protocol'], kw_node.args
+
+ fourth_para = paragraph_nodes[3]
+ href_node = fourth_para.children.find { |n| n.is_a?(ReVIEW::AST::InlineNode) && n.inline_type == :href }
+ assert_not_nil(href_node)
+ assert_equal ['http://example.com', 'example'], href_node.args
+ end
+
+ def test_inline_elements_in_paragraphs_with_ast_renderer
+ content = <<~EOB
+ = Inline Elements Test
+
+ This paragraph has @<b>{bold} and @<i>{italic} formatting.
+
+ Another paragraph with @<code>{code} and @<tt>{typewriter} text.
+
+ Special elements: @<ruby>{漢字,かんじ} and @<href>{http://example.com, Link}.
+
+ Keywords: @<kw>{HTTP, Protocol} and formatting.
+
+ Final paragraph with normal text.
+ EOB
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new)
+ chapter.content = content
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(chapter)
+
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_result = renderer.render(ast_root)
+
+ assert(html_result.include?('bold'), 'HTML should include bold content')
+ assert(html_result.include?('italic'), 'HTML should include italic content')
+ assert(html_result.include?('code'), 'HTML should include code content')
+ assert(html_result.include?('typewriter'), 'HTML should include typewriter content')
+ assert(html_result.include?('漢字'), 'HTML should include ruby content')
+ assert(html_result.include?('example.com'), 'HTML should include href content')
+ assert(html_result.include?('HTTP'), 'HTML should include kw content')
+
+ paragraph_nodes = ast_root.children.select { |n| n.is_a?(ReVIEW::AST::ParagraphNode) }
+ assert(paragraph_nodes.size >= 4, 'Should have multiple paragraphs processed via AST')
+
+ inline_paragraphs = paragraph_nodes.select do |para|
+ para.children.any?(ReVIEW::AST::InlineNode)
+ end
+ assert(inline_paragraphs.size >= 3, 'Should have paragraphs with inline elements')
+
+ all_inline_types = []
+ inline_paragraphs.each do |para|
+ para.children.each do |child|
+ if child.is_a?(ReVIEW::AST::InlineNode)
+ all_inline_types << child.inline_type
+ end
+ end
+ end
+
+ expected_types = %i[b i code tt ruby href kw]
+ expected_types.each do |type|
+ assert(all_inline_types.include?(type), "Should have inline type: #{type}")
+ end
+ end
+
+ def test_ast_output_structure_verification
+ content = <<~EOB
+ = AST Structure Test
+
+ This paragraph contains @<b>{bold} text and @<code>{code} elements.
+
+ Another paragraph with @<href>{https://example.com, example link}.
+
+ Final paragraph with normal text only.
+ EOB
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new)
+ chapter.content = content
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(chapter)
+
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_result = renderer.render(ast_root)
+
+ assert(html_result.include?('<h1>'), 'HTML should contain h1 tag for headlines')
+ assert(html_result.include?('<p>'), 'HTML should contain p tag for paragraphs')
+ assert(html_result.include?('AST Structure Test'), 'HTML should include headline caption')
+ assert(html_result.include?('bold'), 'HTML should include inline content')
+ assert(html_result.include?('code'), 'HTML should include inline content')
+ assert(html_result.include?('example.com'), 'HTML should include href content')
+
+ assert_not_nil(ast_root, 'Should have AST root')
+ assert_equal(ReVIEW::AST::DocumentNode, ast_root.class)
+
+ headline_nodes = ast_root.children.select { |n| n.is_a?(ReVIEW::AST::HeadlineNode) }
+ assert_equal(1, headline_nodes.size, 'Should have one headline')
+ assert_equal('AST Structure Test', headline_nodes.first.caption_text)
+
+ paragraph_nodes = ast_root.children.select { |n| n.is_a?(ReVIEW::AST::ParagraphNode) }
+ assert_equal(3, paragraph_nodes.size, 'Should have three paragraphs')
+
+ inline_paragraphs = paragraph_nodes.select do |para|
+ para.children.any?(ReVIEW::AST::InlineNode)
+ end
+ assert_equal(2, inline_paragraphs.size, 'Should have two paragraphs with inline elements')
+ end
+
+ def test_raw_content_processing_with_embed_blocks
+ content = <<~EOB
+ = Raw Content Test
+
+ Before embed block.
+
+ //embed[html]{
+ <div class="custom">Raw HTML content</div>
+ <script>console.log('test');</script>
+ //}
+
+ Middle paragraph with @<b>{bold} text.
+
+ //embed[css]{
+ .custom { color: red; }
+ //}
+
+ After embed blocks.
+ EOB
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new)
+ chapter.content = content
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(chapter)
+
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_result = renderer.render(ast_root)
+
+ assert(html_result.include?('Raw Content Test'), 'HTML should include headline')
+ assert(html_result.include?('Before embed block'), 'HTML should include content before embed')
+ assert(html_result.include?('After embed blocks'), 'HTML should include content after embed')
+ assert(html_result.include?('bold'), 'HTML should include inline content')
+
+ assert_not_nil(ast_root, 'Should have AST root')
+
+ embed_nodes = ast_root.children.select { |n| n.is_a?(ReVIEW::AST::EmbedNode) }
+ assert_equal(2, embed_nodes.size, 'Should have two embed nodes')
+
+ html_embed = embed_nodes.find { |n| n.target_builders&.include?('html') }
+ assert_not_nil(html_embed, 'Should have HTML embed node')
+ assert_equal(:block, html_embed.embed_type, 'Should be block embed type')
+ assert(html_embed.content.include?('custom'), 'Should contain custom class')
+ assert(html_embed.content.include?('console.log'), 'Should contain script')
+
+ css_embed = embed_nodes.find { |n| n.target_builders&.include?('css') }
+ assert_not_nil(css_embed, 'Should have CSS embed node')
+ assert(css_embed.content.include?('color: red'), 'Should contain CSS rule')
+
+ paragraph_nodes = ast_root.children.select { |n| n.is_a?(ReVIEW::AST::ParagraphNode) }
+ assert(paragraph_nodes.size >= 3, 'Should have multiple paragraphs')
+
+ middle_para = paragraph_nodes.find do |para|
+ para.children.any? { |child| child.is_a?(ReVIEW::AST::InlineNode) && child.inline_type == :b }
+ end
+ assert_not_nil(middle_para, 'Should have paragraph with bold inline element')
+ end
+
+ def test_raw_single_command_processing
+ content = <<~EOB
+ = Raw Command Test
+
+ Before raw command.
+
+ //raw[|html|<div class="inline-raw">Inline raw content</div>]
+
+ Middle paragraph with @<b>{bold} text.
+
+ //raw[|latex|\\textbf{LaTeX raw content}]
+
+ After raw commands.
+ EOB
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new)
+ chapter.content = content
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(chapter)
+
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_result = renderer.render(ast_root)
+
+ assert(html_result.include?('Raw Command Test'), 'HTML should include headline')
+ assert(html_result.include?('Before raw command'), 'HTML should include before paragraph')
+ assert(html_result.include?('After raw commands'), 'HTML should include after paragraph')
+ assert(html_result.include?('bold'), 'HTML should include inline content')
+
+ assert_not_nil(ast_root, 'Should have AST root')
+
+ headline_nodes = ast_root.children.select { |n| n.is_a?(ReVIEW::AST::HeadlineNode) }
+ assert_equal(1, headline_nodes.size, 'Should have one headline')
+
+ paragraph_nodes = ast_root.children.select { |n| n.is_a?(ReVIEW::AST::ParagraphNode) }
+ assert(paragraph_nodes.size >= 3, 'Should have multiple paragraphs processed via AST')
+
+ middle_para = paragraph_nodes.find do |para|
+ para.children.any? { |child| child.is_a?(ReVIEW::AST::InlineNode) && child.inline_type == :b }
+ end
+ assert_not_nil(middle_para, 'Should have paragraph with bold inline element')
+
+ before_para = paragraph_nodes.find do |para|
+ para.children.any? { |child| child.is_a?(ReVIEW::AST::TextNode) && child.content.include?('Before raw command') }
+ end
+ assert_not_nil(before_para, 'Should have before paragraph in AST')
+
+ after_para = paragraph_nodes.find do |para|
+ para.children.any? { |child| child.is_a?(ReVIEW::AST::TextNode) && child.content.include?('After raw commands') }
+ end
+ assert_not_nil(after_para, 'Should have after paragraph in AST')
+ end
+
+ def test_comprehensive_inline_compatibility
+ content = <<~EOB
+ = Comprehensive Inline Test
+
+ Text with @<b>{bold}, @<i>{italic}, @<code>{code}, and @<ruby>{漢字,かんじ}.
+
+ Advanced: @<href>{http://example.com, Link} and @<kw>{Term, Description}.
+
+ Words: @<w>{glossary} and @<wb>{abbreviations}.
+ EOB
+
+ chapter_ast = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new)
+ chapter_ast.content = content
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(chapter_ast)
+
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter_ast)
+ html_result_ast = renderer.render(ast_root)
+
+ assert(html_result_ast.include?('bold'), 'HTML should include bold content')
+ assert(html_result_ast.include?('italic'), 'HTML should include italic content')
+ assert(html_result_ast.include?('code'), 'HTML should include code content')
+ assert(html_result_ast.include?('glossary'), 'HTML should include word expansion content')
+
+ paragraph_nodes = ast_root.children.select { |n| n.is_a?(ReVIEW::AST::ParagraphNode) }
+
+ inline_types = []
+ paragraph_nodes.each do |para|
+ para.children.each do |child|
+ if child.is_a?(ReVIEW::AST::InlineNode)
+ inline_types << child.inline_type
+ end
+ end
+ end
+
+ expected_types = %i[b i code ruby href kw w wb]
+ expected_types.each do |type|
+ assert(inline_types.include?(type), "Should have inline type: #{type}")
+ end
+
+ simple_content = <<~EOB
+ = Simple Test
+
+ Text with @<b>{bold} and @<i>{italic}.
+ EOB
+
+ chapter_simple = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new)
+ chapter_simple.content = simple_content
+
+ simple_ast = ast_compiler.compile_to_ast(chapter_simple)
+ simple_renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter_simple)
+ result_simple = simple_renderer.render(simple_ast)
+
+ ['<b>', '<i>'].each do |tag|
+ assert(result_simple.include?(tag), "AST/Renderer system should produce #{tag}")
+ end
+ end
+end
diff --git a/test/ast/test_ast_dl_block.rb b/test/ast/test_ast_dl_block.rb
new file mode 100644
index 000000000..cc801fcac
--- /dev/null
+++ b/test/ast/test_ast_dl_block.rb
@@ -0,0 +1,281 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/configure'
+require 'review/book'
+require 'review/i18n'
+require 'review/ast'
+require 'review/ast/compiler'
+require 'review/ast/block_processor'
+require 'review/logger'
+
+class TestASTDlBlock < Test::Unit::TestCase
+ def setup
+ @config = ReVIEW::Configure.values
+ @config['secnolevel'] = 2
+ @config['language'] = 'ja'
+ @book = ReVIEW::Book::Base.new(config: @config)
+ @log_io = StringIO.new
+ ReVIEW.logger = ReVIEW::Logger.new(@log_io)
+ @compiler = ReVIEW::AST::Compiler.new
+ end
+
+ def create_chapter(content)
+ ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ end
+
+ def test_dl_with_dt_dd_blocks
+ input = <<~REVIEW
+ //dl{
+
+ //dt{
+ API (Application Programming Interface)
+ //}
+ //dd{
+ アプリケーションプログラミングインターフェースの略称。
+ ソフトウェアコンポーネント同士が相互に機能を利用するための規約。
+
+ //list[api-example][API呼び出し例]{
+ response = api.get('/users/123')
+ user_data = JSON.parse(response.body)
+ //}
+
+ 詳細は公式ドキュメントを参照してください。
+ //}
+
+ //dt{
+ REST (Representational State Transfer)
+ //}
+ //dd{
+ RESTfulなWebサービスの設計原則。HTTPプロトコルを使用し、
+ リソースをURIで識別します。
+
+ 主な特徴：
+ * ステートレス通信
+ * 統一インターフェース
+ * キャッシュ可能
+ * 階層的システム
+
+ //table[rest-methods][RESTメソッド一覧]{
+ メソッド 用途 冪等性
+ ------------
+ GET リソース取得 あり
+ POST リソース作成 なし
+ PUT リソース更新 あり
+ DELETE リソース削除 あり
+ //}
+ //}
+
+ //dt{
+ JSON (JavaScript Object Notation)
+ //}
+ //dd{
+ 軽量なデータ交換フォーマット。
+
+ //list[json-sample][JSONサンプル]{
+ {
+ "name": "John Doe",
+ "age": 30,
+ "email": "john@example.com"
+ }
+ //}
+ //}
+
+ //}
+ REVIEW
+
+ ast = @compiler.compile_to_ast(create_chapter(input.strip))
+
+ assert_equal ReVIEW::AST::DocumentNode, ast.class
+
+ list_node = ast.children.first
+ assert_equal ReVIEW::AST::ListNode, list_node.class
+ assert_equal :dl, list_node.list_type
+
+ dt_items = list_node.children.select(&:definition_term?)
+ dd_items = list_node.children.select(&:definition_desc?)
+
+ assert_equal 3, dt_items.size
+ assert_equal 3, dd_items.size
+
+ api_dt = dt_items[0]
+ assert_equal ReVIEW::AST::ListItemNode, api_dt.class
+ assert api_dt.definition_term?
+
+ api_dd = dd_items[0]
+ assert_equal ReVIEW::AST::ListItemNode, api_dd.class
+ assert api_dd.definition_desc?
+
+ assert api_dd.children.size > 1
+
+ api_code_block = api_dd.children.find { |child| child.is_a?(ReVIEW::AST::CodeBlockNode) }
+ assert_not_nil(api_code_block)
+ assert_equal 'api-example', api_code_block.id
+ assert_equal 'API呼び出し例', api_code_block.caption_text
+
+ rest_dd = dd_items[1]
+ assert_equal ReVIEW::AST::ListItemNode, rest_dd.class
+ assert rest_dd.definition_desc?
+
+ rest_table = rest_dd.children.find { |child| child.is_a?(ReVIEW::AST::TableNode) }
+ assert_not_nil(rest_table)
+ assert_equal 'rest-methods', rest_table.id
+ assert_equal 'RESTメソッド一覧', rest_table.caption_text
+
+ assert_equal 1, rest_table.header_rows.size
+ assert_equal 4, rest_table.body_rows.size
+
+ json_dd = dd_items[2]
+ assert_equal ReVIEW::AST::ListItemNode, json_dd.class
+ assert json_dd.definition_desc?
+
+ json_code_block = json_dd.children.find { |child| child.is_a?(ReVIEW::AST::CodeBlockNode) }
+ assert_not_nil(json_code_block)
+ assert_equal 'json-sample', json_code_block.id
+ end
+
+ def test_dl_with_multiple_dd
+ input = <<~REVIEW
+ //dl{
+
+ //dt{
+ HTTP
+ //}
+ //dd{
+ HyperText Transfer Protocolの略称。
+ //}
+ //dd{
+ Webブラウザとサーバー間の通信プロトコル。
+ //}
+ //dd{
+ ステートレスなリクエスト/レスポンス型のプロトコル。
+ //}
+
+ //dt{
+ HTTPS
+ //}
+ //dd{
+ HTTP over TLS/SSLの略称。暗号化された安全なHTTP通信。
+ //}
+
+ //}
+ REVIEW
+
+ ast = @compiler.compile_to_ast(create_chapter(input.strip))
+
+ list_node = ast.children.first
+ assert_equal :dl, list_node.list_type
+
+ dt_items = list_node.children.select(&:definition_term?)
+ dd_items = list_node.children.select(&:definition_desc?)
+
+ assert_equal 2, dt_items.size
+ assert_equal 4, dd_items.size
+
+ http_dt = dt_items[0]
+ assert http_dt.definition_term?
+
+ # Check that we have 3 consecutive dd items for HTTP
+ assert dd_items[0].definition_desc?
+ assert dd_items[1].definition_desc?
+ assert dd_items[2].definition_desc?
+
+ https_dt = dt_items[1]
+ assert https_dt.definition_term?
+
+ assert dd_items[3].definition_desc?
+ end
+
+ def test_dl_empty
+ input = <<~REVIEW
+ //dl{
+ //}
+ REVIEW
+
+ ast = @compiler.compile_to_ast(create_chapter(input.strip))
+
+ list_node = ast.children.first
+ assert_equal :dl, list_node.list_type
+ assert_equal 0, list_node.children.size
+ end
+
+ def test_dl_cannot_use_simple_text_lines
+ # This test documents that simple text lines in //dl blocks
+ # are treated as list items without proper term/definition structure
+ input = <<~REVIEW
+ //dl{
+ API
+ Application Programming Interface
+ REST
+ Representational State Transfer
+ //}
+ REVIEW
+
+ ast = @compiler.compile_to_ast(create_chapter(input.strip))
+
+ list_node = ast.children.first
+ assert_equal :dl, list_node.list_type
+
+ # Each line becomes a separate list item (not what we want)
+ # This demonstrates why //dt and //dd blocks are needed for definition lists
+ # In the current implementation, all lines are treated as items
+ assert_equal 4, list_node.children.size
+
+ # All items are simple text items (no proper term/definition structure)
+ # When using simple text lines instead of //dt and //dd blocks,
+ # empty ListItemNodes are created (without proper content parsing)
+ list_node.children.each do |item|
+ assert_equal ReVIEW::AST::ListItemNode, item.class
+ # Simple text lines in //dl blocks are not properly parsed into content,
+ # resulting in empty ListItemNodes. This demonstrates why //dt and //dd
+ # blocks are required for proper definition list structure.
+ # None of them have dt or dd type
+ assert_nil(item.item_type)
+ end
+ end
+
+ def test_dl_with_nested_content
+ input = <<~REVIEW
+ //dl{
+
+ //dt{
+ ネストしたリスト
+ //}
+ //dd{
+ 定義内にさらにリストを含む例：
+
+ * 項目1
+ * 項目2
+ ** サブ項目2.1
+ ** サブ項目2.2
+
+ //note[メモ]{
+ ネストしたリストは読みやすさを保ちながら
+ 複雑な情報を整理できます。
+ //}
+ //}
+
+ //}
+ REVIEW
+
+ ast = @compiler.compile_to_ast(create_chapter(input.strip))
+
+ list_node = ast.children.first
+ assert_equal :dl, list_node.list_type
+
+ dt_items = list_node.children.select(&:definition_term?)
+ dd_items = list_node.children.select(&:definition_desc?)
+
+ assert_equal 1, dt_items.size
+ assert_equal 1, dd_items.size
+
+ dd_item = dd_items[0]
+
+ ul_node = dd_item.children.find { |child| child.is_a?(ReVIEW::AST::ListNode) && child.list_type == :ul }
+ assert_not_nil(ul_node)
+
+ note_node = dd_item.children.find { |child| child.is_a?(ReVIEW::AST::MinicolumnNode) }
+ assert_not_nil(note_node)
+ assert_equal :note, note_node.minicolumn_type
+ end
+end
diff --git a/test/ast/test_ast_embed.rb b/test/ast/test_ast_embed.rb
new file mode 100644
index 000000000..7807b0eae
--- /dev/null
+++ b/test/ast/test_ast_embed.rb
@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast'
+require 'review/ast/compiler'
+require 'review/configure'
+require 'review/book'
+require 'review/book/chapter'
+
+class TestASTEmbed < Test::Unit::TestCase
+ def setup
+ @config = ReVIEW::Configure.values
+ @config['secnolevel'] = 2
+ @config['language'] = 'ja'
+ @book = ReVIEW::Book::Base.new(config: @config)
+ @log_io = StringIO.new
+ ReVIEW.logger = ReVIEW::Logger.new(@log_io)
+ ReVIEW::I18n.setup(@config['language'])
+ end
+
+ def test_embed_node_creation
+ node = ReVIEW::AST::EmbedNode.new(
+ location: ReVIEW::SnapshotLocation.new(nil, 0),
+ embed_type: :block,
+ target_builders: ['html'],
+ content: "content line 1\ncontent line 2"
+ )
+
+ hash = node.to_h
+ assert_equal 'EmbedNode', hash[:type]
+ assert_equal :block, hash[:embed_type]
+ assert_equal ['html'], hash[:target_builders]
+ assert_equal "content line 1\ncontent line 2", hash[:content]
+ end
+
+ def test_embed_block_ast_processing
+ content = <<~EOB
+ = Chapter Title
+
+ Normal paragraph before embed.
+
+ //embed[html]{
+ <div class="special">
+ HTML content here
+ </div>
+ //}
+
+ Paragraph after embed.
+ EOB
+
+ ast_root = compile_to_ast(content)
+
+ embed_node = ast_root.children.find { |n| n.is_a?(ReVIEW::AST::EmbedNode) }
+ assert_not_nil(embed_node, 'Should have embed node')
+ assert_equal :block, embed_node.embed_type
+ assert_equal ['html'], embed_node.target_builders
+ assert(embed_node.content.include?('<div class="special">'), 'Should contain div')
+ assert(embed_node.content.include?('HTML content here'), 'Should contain HTML content')
+ assert(embed_node.content.include?('</div>'), 'Should contain closing div')
+ end
+
+ def test_embed_block_without_arg
+ content = <<~EOB
+ //embed{
+ Raw content
+ No builder filter
+ //}
+ EOB
+
+ ast_root = compile_to_ast(content)
+
+ embed_node = ast_root.children.find { |n| n.is_a?(ReVIEW::AST::EmbedNode) }
+ assert_not_nil(embed_node)
+ assert_equal :block, embed_node.embed_type
+ assert_nil(embed_node.target_builders, 'Should have no target builders (applies to all)')
+ assert(embed_node.content.include?('Raw content'), 'Should contain raw content')
+ assert(embed_node.content.include?('No builder filter'), 'Should contain no builder filter text')
+ end
+
+ def test_inline_embed_ast_processing
+ content = <<~EOB
+ This paragraph has @<embed>{inline content} in it.
+ EOB
+
+ ast_root = compile_to_ast(content)
+
+ paragraph_node = ast_root.children.find { |n| n.is_a?(ReVIEW::AST::ParagraphNode) }
+ assert_not_nil(paragraph_node)
+
+ embed_node = paragraph_node.children.find { |n| n.is_a?(ReVIEW::AST::EmbedNode) }
+ assert_not_nil(embed_node, 'Should have inline embed node')
+ assert_equal :inline, embed_node.embed_type
+ assert_equal 'inline content', embed_node.content
+ end
+
+ def test_inline_embed_with_builder_filter
+ content = <<~EOB
+ Text with @<embed>{|html|<strong>HTML only</strong>} content.
+ EOB
+
+ ast_root = compile_to_ast(content)
+
+ paragraph_node = ast_root.children.find { |n| n.is_a?(ReVIEW::AST::ParagraphNode) }
+ embed_node = paragraph_node.children.find { |n| n.is_a?(ReVIEW::AST::EmbedNode) }
+
+ assert_not_nil(embed_node)
+ assert_equal :inline, embed_node.embed_type
+ assert_equal ['html'], embed_node.target_builders
+ assert_equal '<strong>HTML only</strong>', embed_node.content
+ end
+
+ def test_embed_output_compatibility
+ content = <<~EOB
+ Normal text @<embed>{inline embed} more text.
+
+ //embed[html]{
+ <div>Block embed content</div>
+ //}
+ EOB
+
+ ast_root = compile_to_ast(content)
+
+ paragraph_node = ast_root.children.find { |n| n.is_a?(ReVIEW::AST::ParagraphNode) }
+ block_embed_node = ast_root.children.find { |n| n.is_a?(ReVIEW::AST::EmbedNode) && n.embed_type == :block }
+
+ assert_not_nil(paragraph_node, 'Should have paragraph with inline embed')
+ assert_not_nil(block_embed_node, 'Should have block embed node')
+
+ inline_embed = paragraph_node.children.find { |n| n.is_a?(ReVIEW::AST::EmbedNode) && n.embed_type == :inline }
+ assert_not_nil(inline_embed, 'Should have inline embed in paragraph')
+ assert_equal 'inline embed', inline_embed.content
+
+ assert_equal ['html'], block_embed_node.target_builders
+ assert_equal '<div>Block embed content</div>', block_embed_node.content
+ end
+
+ def test_mixed_content_with_embed
+ content = <<~EOB
+ = Chapter with Embeds
+
+ This paragraph has @<b>{bold} and @<embed>{inline embed} elements.
+
+ //embed[html]{
+ <div class="example">
+ <p>Some HTML content</p>
+ </div>
+ //}
+
+ Another paragraph after the embed block.
+ EOB
+
+ ast_root = compile_to_ast(content)
+
+ headline_node = ast_root.children.find { |n| n.is_a?(ReVIEW::AST::HeadlineNode) }
+ paragraph_nodes = ast_root.children.select { |n| n.is_a?(ReVIEW::AST::ParagraphNode) }
+ embed_node = ast_root.children.find { |n| n.is_a?(ReVIEW::AST::EmbedNode) }
+
+ assert_not_nil(headline_node)
+ assert_equal 2, paragraph_nodes.size
+ assert_not_nil(embed_node)
+ assert_equal :block, embed_node.embed_type
+
+ first_para = paragraph_nodes[0]
+ bold_node = first_para.children.find { |n| n.is_a?(ReVIEW::AST::InlineNode) && n.inline_type == :b }
+ inline_embed_node = first_para.children.find { |n| n.is_a?(ReVIEW::AST::EmbedNode) && n.embed_type == :inline }
+
+ assert_not_nil(bold_node)
+ assert_not_nil(inline_embed_node)
+ end
+
+ private
+
+ def compile_to_ast(content)
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new)
+ chapter.content = content
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_compiler.compile_to_ast(chapter)
+ end
+end
diff --git a/test/ast/test_ast_html_diff.rb b/test/ast/test_ast_html_diff.rb
new file mode 100644
index 000000000..507a3fd1d
--- /dev/null
+++ b/test/ast/test_ast_html_diff.rb
@@ -0,0 +1,373 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast/diff/html'
+
+class ASTHTMLDiffTest < Test::Unit::TestCase
+ def setup
+ @comparator = ReVIEW::AST::Diff::Html.new
+ end
+
+ def test_same_html_same_hash
+ html1 = '<p>Hello World</p>'
+ html2 = '<p>Hello World</p>'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_different_html_different_hash
+ html1 = '<p>Hello World</p>'
+ html2 = '<p>Hello World!</p>'
+ result = @comparator.compare(html1, html2)
+ assert_false(result.same_hash?)
+ end
+
+ def test_whitespace_normalized
+ html1 = '<p>Hello World</p>'
+ html2 = '<p>Hello World</p>'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_whitespace_preserved_in_pre
+ html1 = '<pre>Hello World</pre>'
+ html2 = '<pre>Hello World</pre>'
+ result = @comparator.compare(html1, html2)
+ assert_false(result.same_hash?)
+ end
+
+ def test_comments_removed
+ # Comments are removed but text nodes remain separate
+ html1 = '<p>Hello</p><!-- comment --><p>World</p>'
+ html2 = '<p>Hello</p><p>World</p>'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_class_attribute_sorted
+ html1 = '<div class="foo bar baz">test</div>'
+ html2 = '<div class="baz foo bar">test</div>'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_class_attribute_duplicates_removed
+ html1 = '<div class="foo bar foo baz">test</div>'
+ html2 = '<div class="bar baz foo">test</div>'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_empty_class_removed
+ html1 = '<div class="">test</div>'
+ html2 = '<div>test</div>'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_attribute_names_lowercased
+ html1 = '<div ID="test">content</div>'
+ html2 = '<div id="test">content</div>'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_void_elements
+ html1 = '<p>Line 1<br>Line 2</p>'
+ html2 = '<p>Line 1<br/>Line 2</p>'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_img_void_element
+ html1 = '<img src="test.png" alt="test">'
+ html2 = '<img src="test.png" alt="test"/>'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_diff_tokens_same_content
+ html1 = '<p>Hello</p>'
+ html2 = '<p>Hello</p>'
+ result = @comparator.compare(html1, html2)
+ changes = result.changes
+ assert_equal(0, changes.count { |c| c.action != '=' })
+ end
+
+ def test_diff_tokens_text_changed
+ html1 = '<p>Hello</p>'
+ html2 = '<p>Goodbye</p>'
+ result = @comparator.compare(html1, html2)
+ changes = result.changes
+ assert(changes.any? { |c| c.action == '!' })
+ end
+
+ def test_diff_tokens_element_added
+ html1 = '<p>Hello</p>'
+ html2 = '<p>Hello</p><p>World</p>'
+ result = @comparator.compare(html1, html2)
+ changes = result.changes
+ assert(changes.any? { |c| c.action == '+' })
+ end
+
+ def test_diff_tokens_element_removed
+ html1 = '<p>Hello</p><p>World</p>'
+ html2 = '<p>Hello</p>'
+ result = @comparator.compare(html1, html2)
+ changes = result.changes
+ assert(changes.any? { |c| c.action == '-' })
+ end
+
+ def test_pretty_diff_no_changes
+ html1 = '<p>Hello</p>'
+ html2 = '<p>Hello</p>'
+ result = @comparator.compare(html1, html2)
+ pretty = result.pretty_diff
+ assert_equal '', pretty
+ end
+
+ def test_pretty_diff_with_changes
+ html1 = '<p>Hello</p>'
+ html2 = '<p>Goodbye</p>'
+ result = @comparator.compare(html1, html2)
+ pretty = result.pretty_diff
+ assert pretty.include?('Hello')
+ assert pretty.include?('Goodbye')
+ assert pretty.include?('-')
+ assert pretty.include?('+')
+ end
+
+ def test_complex_html_structure
+ html1 = <<~HTML
+ <div class="container">
+ <h1>Title</h1>
+ <p>Paragraph 1</p>
+ <ul>
+ <li>Item 1</li>
+ <li>Item 2</li>
+ </ul>
+ </div>
+ HTML
+
+ html2 = <<~HTML
+ <div class="container">
+ <h1>Title</h1>
+ <p>Paragraph 1</p>
+ <ul>
+ <li>Item 1</li>
+ <li>Item 2</li>
+ </ul>
+ </div>
+ HTML
+
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_nested_elements_with_attributes
+ html1 = '<div id="outer" class="wrapper"><span class="inner" data-value="123">Text</span></div>'
+ html2 = '<div class="wrapper" id="outer"><span data-value="123" class="inner">Text</span></div>'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_significant_whitespace_in_textarea
+ html1 = '<textarea>Line 1\n Line 2\n Line 3</textarea>'
+ html2 = '<textarea>Line 1\nLine 2\nLine 3</textarea>'
+ result = @comparator.compare(html1, html2)
+ assert_false(result.same_hash?)
+ end
+
+ def test_significant_whitespace_in_script
+ html1 = '<script>var x = 1; var y = 2;</script>'
+ html2 = '<script>var x = 1; var y = 2;</script>'
+ result = @comparator.compare(html1, html2)
+ assert_false(result.same_hash?)
+ end
+
+ def test_significant_whitespace_in_style
+ html1 = '<style>body { margin: 0; padding: 0; }</style>'
+ html2 = '<style>body { margin: 0; padding: 0; }</style>'
+ result = @comparator.compare(html1, html2)
+ assert_false(result.same_hash?)
+ end
+
+ def test_mixed_content
+ html1 = '<div>Text before <strong>bold text</strong> text after</div>'
+ html2 = '<div>Text before <strong>bold text</strong> text after</div>'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_empty_text_nodes_removed
+ html1 = '<div> <span>Text</span> </div>'
+ html2 = '<div><span>Text</span></div>'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_multiple_void_elements
+ html1 = '<div><br><hr><img src="test.png"></div>'
+ html2 = '<div><br/><hr/><img src="test.png"/></div>'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_attribute_order_normalized
+ html1 = '<div data-id="1" class="test" id="main">Content</div>'
+ html2 = '<div id="main" class="test" data-id="1">Content</div>'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_real_world_example_article
+ html1 = <<~HTML
+ <article>
+ <header>
+ <h1 class="title">My Article</h1>
+ <p class="meta">
+ Published on 2024-01-01
+ </p>
+ </header>
+ <section>
+ <p>
+ First paragraph.
+ </p>
+ <p>
+ Second paragraph with
+ <a href="link.html">a link</a>
+ .
+ </p>
+ </section>
+ </article>
+ HTML
+
+ html2 = <<~HTML
+ <article>
+ <header>
+ <h1 class="title">My Article</h1>
+ <p class="meta">Published on 2024-01-01</p>
+ </header>
+ <section>
+ <p>First paragraph.</p><p>Second paragraph with <a href="link.html">a link</a>.</p>
+ </section>
+ </article>
+ HTML
+
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_real_world_example_with_difference
+ html1 = <<~HTML
+ <article>
+ <h1>Title</h1>
+ <p>Original text.</p>
+ </article>
+ HTML
+
+ html2 = <<~HTML
+ <article>
+ <h1>Title</h1>
+ <p>Modified text.</p>
+ </article>
+ HTML
+
+ result = @comparator.compare(html1, html2)
+ assert_false(result.same_hash?)
+ pretty = result.pretty_diff
+ assert pretty.include?('Original')
+ assert pretty.include?('Modified')
+ end
+
+ def test_newlines_normalized
+ html1 = "<p>\n\n\nHello\n\n\nWorld\n\n\n</p>"
+ html2 = '<p>Hello World</p>'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_tabs_normalized
+ html1 = "<p>Hello\t\t\tWorld</p>"
+ html2 = '<p>Hello World</p>'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_leading_trailing_whitespace
+ html1 = '<p> Hello World </p>'
+ html2 = '<p>Hello World</p>'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_multiple_classes_with_whitespace
+ html1 = '<div class=" foo bar baz ">test</div>'
+ html2 = '<div class="bar baz foo">test</div>'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_nested_void_elements
+ html1 = '<div><p>Text<br>More<br>Lines</p></div>'
+ html2 = '<div><p>Text<br/>More<br/>Lines</p></div>'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_empty_attributes
+ html1 = '<input type="text" disabled>'
+ html2 = '<input disabled type="text">'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_multiple_attributes_sorted
+ html1 = '<div z="3" y="2" x="1" class="foo" id="main">test</div>'
+ html2 = '<div class="foo" id="main" x="1" y="2" z="3">test</div>'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_deeply_nested_structure
+ html1 = '<div><section><article><p><span>Text</span></p></article></section></div>'
+ html2 = '<div><section><article><p><span>Text</span></p></article></section></div>'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_self_closing_void_element_formats
+ html1 = '<meta charset="utf-8"><link rel="stylesheet" href="style.css">'
+ html2 = '<meta charset="utf-8"/><link rel="stylesheet" href="style.css"/>'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_mixed_significant_whitespace
+ html1 = '<div><pre> code </pre><p> text </p></div>'
+ html2 = '<div><pre> code </pre><p>text</p></div>'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_data_attributes
+ html1 = '<div data-id="123" data-name="test">Content</div>'
+ html2 = '<div data-name="test" data-id="123">Content</div>'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_complex_class_normalization
+ html1 = '<span class="a b a c b d">text</span>'
+ html2 = '<span class="a b c d">text</span>'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+
+ def test_boolean_attributes
+ html1 = '<input type="checkbox" checked disabled readonly>'
+ html2 = '<input checked disabled readonly type="checkbox">'
+ result = @comparator.compare(html1, html2)
+ assert_true(result.same_hash?)
+ end
+end
diff --git a/test/ast/test_ast_idgxml_maker.rb b/test/ast/test_ast_idgxml_maker.rb
new file mode 100644
index 000000000..7fe4f906c
--- /dev/null
+++ b/test/ast/test_ast_idgxml_maker.rb
@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'tmpdir'
+require 'fileutils'
+require 'review/ast/command/idgxml_maker'
+
+class ASTIdgxmlMakerTest < Test::Unit::TestCase
+ def setup
+ @tmpdir = Dir.mktmpdir
+ @old_pwd = Dir.pwd
+ end
+
+ def teardown
+ Dir.chdir(@old_pwd)
+ FileUtils.rm_rf(@tmpdir)
+ end
+
+ def test_builds_sample_book_with_renderer
+ if /mswin|mingw|cygwin/.match?(RUBY_PLATFORM)
+ omit('IDGXML build is not supported on Windows CI')
+ end
+
+ config = prepare_samplebook(@tmpdir, 'sample-book/src', nil, 'config.yml')
+ output_dir = File.join(@tmpdir, "#{config['bookname']}-idgxml")
+ target_file = File.join(output_dir, 'ch01.xml')
+
+ Dir.chdir(@tmpdir) do
+ maker = ReVIEW::AST::Command::IdgxmlMaker.new
+ maker.execute('config.yml')
+ end
+
+ assert(File.exist?(target_file), 'Expected IDGXML output file to be generated')
+
+ content = File.read(target_file)
+ assert_includes(content, '<doc xmlns:aid="http://ns.adobe.com/AdobeInDesign/4.0/">')
+ end
+end
diff --git a/test/ast/test_ast_indexer.rb b/test/ast/test_ast_indexer.rb
new file mode 100644
index 000000000..875bb4df2
--- /dev/null
+++ b/test/ast/test_ast_indexer.rb
@@ -0,0 +1,543 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast/indexer'
+require 'review/index_builder'
+require 'review/book'
+require 'review/book/chapter'
+require 'review/ast/compiler'
+require 'review/configure'
+
+class TestASTIndexer < Test::Unit::TestCase
+ def setup
+ @config = ReVIEW::Configure.values
+ @config['secnolevel'] = 2
+ @config['language'] = 'ja'
+ @book = ReVIEW::Book::Base.new(config: @config)
+
+ @log_io = StringIO.new
+ ReVIEW.logger = ReVIEW::Logger.new(@log_io)
+
+ @chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test_chapter', 'test_chapter.re', StringIO.new)
+ ReVIEW::I18n.setup(@config['language'])
+ end
+
+ def test_basic_index_building
+ source = <<~EOS
+ = Chapter Title
+
+ Basic paragraph with text.
+
+ //list[sample-code][Sample Code Caption][ruby]{
+ puts "hello world"
+ //}
+
+ //table[sample-table][Sample Table Caption]{
+ Header 1 Header 2
+ ------------
+ Cell 1 Cell 2
+ //}
+
+ //image[sample-image][Sample Image Caption]
+
+ Text with @<fn>{footnote1} and @<eq>{equation1}.
+
+ //footnote[footnote1][Footnote content]
+
+ //texequation[equation1]{
+ E = mc^2
+ //}
+
+ //footnote[footnote1][Footnote content]
+
+ //texequation[equation1]{
+ E = mc^2
+ //}
+ EOS
+
+ ast_root = compile_to_ast(source)
+
+ indexer = ReVIEW::AST::Indexer.new(@chapter)
+ indexer.build_indexes(ast_root)
+
+ list_item = indexer.list_index['sample-code']
+ assert_not_nil(list_item)
+ assert_equal 1, list_item.number
+ assert_equal 'sample-code', list_item.id
+
+ assert_equal 1, indexer.table_index.size
+ table_item = indexer.table_index['sample-table']
+ assert_not_nil(table_item)
+ assert_equal 1, table_item.number
+ assert_equal 'sample-table', table_item.id
+ assert_equal 'Sample Table Caption', table_item.caption_node&.to_inline_text
+
+ assert_equal 1, indexer.image_index.size
+ image_item = indexer.image_index['sample-image']
+ assert_not_nil(image_item)
+ assert_equal 1, image_item.number
+ assert_equal 'sample-image', image_item.id
+ assert_equal 'Sample Image Caption', image_item.caption_node&.to_inline_text
+
+ assert_equal 1, indexer.footnote_index.size
+ footnote_item = indexer.footnote_index['footnote1']
+ assert_not_nil(footnote_item)
+ assert_equal 1, footnote_item.number
+ assert_equal 'footnote1', footnote_item.id
+
+ equation_item = indexer.equation_index['equation1']
+ assert_not_nil(equation_item)
+ assert_equal 'equation1', equation_item.id
+ end
+
+ def test_headline_index_building
+ source = <<~EOS
+ = Chapter Title
+
+ == Section 1{sec1}
+
+ Basic text.
+
+ == Section 2{sec2}
+
+ More text.
+
+ === Subsection 2.1{subsec21}
+
+ Subsection content.
+ EOS
+
+ ast_root = compile_to_ast(source)
+
+ indexer = ReVIEW::AST::Indexer.new(@chapter)
+ indexer.build_indexes(ast_root)
+
+ assert_not_nil(indexer.headline_index)
+ assert indexer.headline_index.size >= 2
+
+ sec1_item = indexer.headline_index['sec1']
+ assert_not_nil(sec1_item)
+ assert_equal 'sec1', sec1_item.id
+ assert_equal [1], sec1_item.number
+
+ sec2_item = indexer.headline_index['sec2']
+ assert_not_nil(sec2_item)
+ assert_equal 'sec2', sec2_item.id
+ assert_equal [2], sec2_item.number
+
+ subsec_item = indexer.headline_index['sec2|subsec21']
+ assert_not_nil(subsec_item)
+ assert_equal 'sec2|subsec21', subsec_item.id
+ assert_equal [2, 1], subsec_item.number
+ end
+
+ def test_minicolumn_index_building
+ source = <<~EOS
+ = Chapter Title
+
+ //note[Note Caption]{
+ This is a note with @<fn>{note-footnote}.
+ //}
+
+ //memo[Memo Caption]{
+ This is a memo with @<bib>{bibitem1}.
+ //}
+
+ //footnote[note-footnote][Note footnote]
+
+ //bibpaper[bibitem1][Bib item content]
+ EOS
+
+ ast_root = compile_to_ast(source)
+
+ indexer = ReVIEW::AST::Indexer.new(@chapter)
+ indexer.build_indexes(ast_root)
+
+ assert_equal 1, indexer.footnote_index.size
+ footnote_item = indexer.footnote_index['note-footnote']
+ assert_not_nil(footnote_item)
+ assert_equal 'note-footnote', footnote_item.id
+
+ assert_equal 1, indexer.bibpaper_index.size
+ bib_item = indexer.bibpaper_index['bibitem1']
+ assert_not_nil(bib_item)
+ assert_equal 'bibitem1', bib_item.id
+ end
+
+ def test_table_inline_elements
+ source = <<~EOS
+ = Chapter Title
+
+ //table[inline-table][Table with inline elements]{
+ Header @<b>{Bold} @<i>{Italic} Header
+ ------------
+ Cell with @<fn>{table-fn} @<eq>{table-eq}
+ //}
+
+ //footnote[table-fn][Table footnote]
+
+ //texequation[table-eq]{
+ x = y
+ //}
+ EOS
+
+ ast_root = compile_to_ast(source)
+
+ indexer = ReVIEW::AST::Indexer.new(@chapter)
+ indexer.build_indexes(ast_root)
+
+ assert_equal 1, indexer.table_index.size
+ table_item = indexer.table_index['inline-table']
+ assert_not_nil(table_item)
+
+ assert_equal 1, indexer.footnote_index.size
+ footnote_item = indexer.footnote_index['table-fn']
+ assert_not_nil(footnote_item)
+ assert_equal 'table-fn', footnote_item.id
+
+ assert_equal 1, indexer.equation_index.size
+ equation_item = indexer.equation_index['table-eq']
+ assert_not_nil(equation_item)
+ assert_equal 'table-eq', equation_item.id
+ end
+
+ def test_code_block_inline_elements
+ source = <<~EOS
+ = Chapter Title
+
+ //list[code-with-inline][Code with inline elements][ruby]{
+ puts @<b>{bold code}
+ # Comment with @<fn>{code-fn}
+ //}
+
+ //footnote[code-fn][Footnote from code block]
+ EOS
+
+ ast_root = compile_to_ast(source)
+
+ indexer = ReVIEW::AST::Indexer.new(@chapter)
+ indexer.build_indexes(ast_root)
+
+ assert_equal 1, indexer.list_index.size
+ list_item = indexer.list_index['code-with-inline']
+ assert_not_nil(list_item)
+
+ assert_equal 1, indexer.footnote_index.size
+ footnote_item = indexer.footnote_index['code-fn']
+ assert_not_nil(footnote_item)
+ assert_equal 'code-fn', footnote_item.id
+ end
+
+ def test_empty_ast
+ test_chapter = ReVIEW::Book::Chapter.new(@book, 1, 'empty_test', 'empty_test.re', StringIO.new)
+ indexer = ReVIEW::AST::Indexer.new(test_chapter)
+ result = indexer.build_indexes(nil)
+
+ assert_equal indexer, result
+ assert_equal 0, indexer.list_index.size
+ assert_equal 0, indexer.table_index.size
+ assert_equal 0, indexer.image_index.size
+ assert_equal 0, indexer.footnote_index.size
+ assert_equal 0, indexer.equation_index.size
+ end
+
+ def test_indexes_method
+ source = <<~EOS
+ = Chapter Title
+
+ //list[sample][Sample]{
+ code
+ //}
+ EOS
+
+ ast_root = compile_to_ast(source)
+
+ indexer = ReVIEW::AST::Indexer.new(@chapter)
+ indexer.build_indexes(ast_root)
+
+ indexes = indexer.indexes
+ assert_kind_of(Hash, indexes)
+
+ expected_keys = %i[
+ list table equation footnote endnote
+ image icon numberless_image indepimage
+ headline column bibpaper
+ ]
+
+ expected_keys.each do |key|
+ assert indexes.key?(key), "Should contain #{key} index"
+ end
+
+ assert_equal 1, indexes[:list].size
+ assert_not_nil(indexes[:list]['sample'])
+ end
+
+ def test_id_validation_warnings
+ source = <<~EOS
+ = Chapter Title
+
+ //list[invalid#id][Invalid ID with #]{
+ code
+ //}
+
+ //table[.starts_with_dot][ID starting with dot]{
+ data
+ //}
+
+ Text with @<fn>{space id} and @<eq>{id with$pecial}.
+
+ //footnote[space id][Footnote with space id]
+
+ //texequation[id with$pecial]{
+ z = 1
+ //}
+ EOS
+
+ original_stderr = $stderr
+ captured_stderr = StringIO.new
+ $stderr = captured_stderr
+
+ begin
+ ast_root = compile_to_ast(source)
+
+ indexer = ReVIEW::AST::Indexer.new(@chapter)
+ indexer.build_indexes(ast_root)
+
+ warnings = captured_stderr.string
+ assert_include(warnings, 'deprecated ID: `#` in `invalid#id`')
+ assert_include(warnings, 'deprecated ID: `.starts_with_dot` begins from `.`')
+ assert_include(warnings, 'deprecated ID: ` ` in `space id`')
+ assert_include(warnings, 'deprecated ID: `$` in `id with$pecial`')
+ ensure
+ $stderr = original_stderr
+ end
+ end
+
+ def test_column_index_building
+ source = <<~EOS
+ = Chapter Title
+
+ Regular paragraph.
+
+ ===[column]{col1} Column Title
+
+ Column content with @<fn>{col-footnote}.
+
+ ===[/column]
+
+ More content.
+
+ //footnote[col-footnote][Column footnote content]
+ EOS
+
+ ast_root = compile_to_ast(source)
+
+ indexer = ReVIEW::AST::Indexer.new(@chapter)
+ indexer.build_indexes(ast_root)
+
+ assert_equal 1, indexer.column_index.size
+ column_item = indexer.column_index['col1']
+ assert_not_nil(column_item)
+ assert_equal 'col1', column_item.id
+ assert_equal 'Column Title', column_item.caption_node&.to_inline_text
+
+ assert_equal 1, indexer.footnote_index.size
+ footnote_item = indexer.footnote_index['col-footnote']
+ assert_not_nil(footnote_item)
+ assert_equal 'col-footnote', footnote_item.id
+ end
+
+ def test_endnote_index_building
+ source = <<~EOS
+ = Chapter Title
+
+ Text with @<endnote>{endnote1} reference.
+
+ //endnote[endnote1][Endnote content here]
+ EOS
+
+ ast_root = compile_to_ast(source)
+
+ indexer = ReVIEW::AST::Indexer.new(@chapter)
+ indexer.build_indexes(ast_root)
+
+ assert_equal 1, indexer.endnote_index.size
+ endnote_item = indexer.endnote_index['endnote1']
+ assert_not_nil(endnote_item)
+ assert_equal 1, endnote_item.number
+ assert_equal 'endnote1', endnote_item.id
+ end
+
+ def test_icon_index_building
+ source = <<~EOS
+ = Chapter Title
+
+ Text with @<icon>{user-icon} and @<icon>{settings-icon}.
+ EOS
+
+ ast_root = compile_to_ast(source)
+
+ indexer = ReVIEW::AST::Indexer.new(@chapter)
+ indexer.build_indexes(ast_root)
+
+ assert_equal 2, indexer.icon_index.size
+
+ icon1 = indexer.icon_index['user-icon']
+ assert_not_nil(icon1)
+ assert_equal 1, icon1.number
+ assert_equal 'user-icon', icon1.id
+
+ icon2 = indexer.icon_index['settings-icon']
+ assert_not_nil(icon2)
+ assert_equal 2, icon2.number
+ assert_equal 'settings-icon', icon2.id
+ end
+
+ def test_imgtable_index_building
+ source = <<~EOS
+ = Chapter Title
+
+ //imgtable[table-image][Table as Image Caption]{
+ dummy content
+ //}
+ EOS
+
+ ast_root = compile_to_ast(source)
+
+ indexer = ReVIEW::AST::Indexer.new(@chapter)
+ indexer.build_indexes(ast_root)
+
+ assert_equal 1, indexer.table_index.size
+ table_item = indexer.table_index['table-image']
+ assert_not_nil(table_item)
+ assert_equal 'table-image', table_item.id
+
+ assert_equal 1, indexer.indepimage_index.size
+ indep_item = indexer.indepimage_index['table-image']
+ assert_not_nil(indep_item)
+ assert_equal 'table-image', indep_item.id
+ end
+
+ def test_bibpaper_block_index_building
+ source = <<~EOS
+ = Chapter Title
+
+ Citation @<bib>{ref1} in text.
+
+ //bibpaper[ref1][Author Name, "Book Title", Publisher, 2024]
+ EOS
+
+ ast_root = compile_to_ast(source)
+
+ indexer = ReVIEW::AST::Indexer.new(@chapter)
+ indexer.build_indexes(ast_root)
+
+ assert_equal 1, indexer.bibpaper_index.size
+ bib_item = indexer.bibpaper_index['ref1']
+ assert_not_nil(bib_item)
+ assert_equal 'ref1', bib_item.id
+ assert_equal 'Author Name, "Book Title", Publisher, 2024', bib_item.caption_node&.to_inline_text
+ end
+
+ def test_caption_inline_elements
+ source = <<~EOS
+ = Chapter Title
+
+ //list[code-id][Caption with @<fn>{cap-fn} and @<bib>{cap-bib}]{
+ code content
+ //}
+
+ //footnote[cap-fn][Caption footnote]
+ //bibpaper[cap-bib][Bibliography in caption]
+ EOS
+
+ ast_root = compile_to_ast(source)
+
+ indexer = ReVIEW::AST::Indexer.new(@chapter)
+ indexer.build_indexes(ast_root)
+
+ assert_equal 1, indexer.list_index.size
+
+ assert_equal 1, indexer.footnote_index.size
+ footnote_item = indexer.footnote_index['cap-fn']
+ assert_not_nil(footnote_item)
+ assert_equal 'cap-fn', footnote_item.id
+
+ assert_equal 1, indexer.bibpaper_index.size
+ bib_item = indexer.bibpaper_index['cap-bib']
+ assert_not_nil(bib_item)
+ assert_equal 'cap-bib', bib_item.id
+ end
+
+ def test_headline_caption_inline_elements
+ source = <<~EOS
+ = Chapter Title
+
+ =={sec1} Section with @<fn>{head-fn} in title
+
+ Content here.
+
+ //footnote[head-fn][Headline footnote]
+ EOS
+
+ ast_root = compile_to_ast(source)
+
+ indexer = ReVIEW::AST::Indexer.new(@chapter)
+ indexer.build_indexes(ast_root)
+
+ assert_not_nil(indexer.headline_index['sec1'])
+
+ assert_equal 1, indexer.footnote_index.size
+ footnote_item = indexer.footnote_index['head-fn']
+ assert_not_nil(footnote_item)
+ assert_equal 'head-fn', footnote_item.id
+ end
+
+ def test_index_for_method
+ source = <<~EOS
+ = Chapter Title
+
+ //list[sample][Sample]{
+ code
+ //}
+
+ //table[tbl][Table]{
+ data
+ //}
+ EOS
+
+ ast_root = compile_to_ast(source)
+
+ indexer = ReVIEW::AST::Indexer.new(@chapter)
+ indexer.build_indexes(ast_root)
+
+ assert_equal indexer.list_index, indexer.index_for(:list)
+ assert_equal indexer.table_index, indexer.index_for(:table)
+ assert_equal indexer.image_index, indexer.index_for(:image)
+ assert_equal indexer.footnote_index, indexer.index_for(:footnote)
+ assert_equal indexer.endnote_index, indexer.index_for(:endnote)
+ assert_equal indexer.equation_index, indexer.index_for(:equation)
+ assert_equal indexer.headline_index, indexer.index_for(:headline)
+ assert_equal indexer.column_index, indexer.index_for(:column)
+ assert_equal indexer.bibpaper_index, indexer.index_for(:bibpaper)
+ assert_equal indexer.icon_index, indexer.index_for(:icon)
+ assert_equal indexer.indepimage_index, indexer.index_for(:indepimage)
+ assert_equal indexer.numberless_image_index, indexer.index_for(:numberless_image)
+
+ assert_raise(ArgumentError) do
+ indexer.index_for(:unknown_type)
+ end
+ end
+
+ private
+
+ def compile_to_ast(content)
+ @chapter.content = content
+
+ @book.generate_indexes
+ @chapter.generate_indexes
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_compiler.compile_to_ast(@chapter)
+ end
+end
diff --git a/test/ast/test_ast_indexer_pure.rb b/test/ast/test_ast_indexer_pure.rb
new file mode 100644
index 000000000..6bf5eff20
--- /dev/null
+++ b/test/ast/test_ast_indexer_pure.rb
@@ -0,0 +1,334 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast/indexer'
+require 'review/book'
+require 'review/book/chapter'
+require 'review/ast/compiler'
+
+class TestASTIndexerPure < Test::Unit::TestCase
+ def setup
+ @config = ReVIEW::Configure.values
+ @config['secnolevel'] = 2
+ @config['language'] = 'ja'
+ @book = ReVIEW::Book::Base.new(config: @config)
+
+ @log_io = StringIO.new
+ ReVIEW.logger = ReVIEW::Logger.new(@log_io)
+
+ @chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test_chapter', 'test_chapter.re', StringIO.new)
+ ReVIEW::I18n.setup(@config['language'])
+ end
+
+ def test_basic_index_building
+ source = <<~EOS
+ = Chapter Title
+
+ Basic paragraph with text.
+
+ //list[sample-code][Sample Code Caption][ruby]{
+ puts "hello world"
+ //}
+
+ //table[sample-table][Sample Table Caption]{
+ Header 1 Header 2
+ ------------
+ Cell 1 Cell 2
+ //}
+
+ //image[sample-image][Sample Image Caption]
+
+ Text with @<fn>{footnote1} and @<eq>{equation1}.
+
+ //footnote[footnote1][Footnote content]
+
+ //texequation[equation1]{
+ E = mc^2
+ //}
+
+ //footnote[footnote1][Footnote content]
+
+ //texequation[equation1]{
+ E = mc^2
+ //}
+ EOS
+
+ @chapter.content = source
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(@chapter)
+
+ indexer = ReVIEW::AST::Indexer.new(@chapter)
+ indexer.build_indexes(ast_root)
+
+ list_item = indexer.list_index['sample-code']
+ assert_not_nil(list_item)
+ assert_equal 1, list_item.number
+ assert_equal 'sample-code', list_item.id
+
+ assert_equal 1, indexer.table_index.size
+ table_item = indexer.table_index['sample-table']
+ assert_not_nil(table_item)
+ assert_equal 1, table_item.number
+ assert_equal 'sample-table', table_item.id
+ assert_equal 'Sample Table Caption', table_item.caption_node&.to_inline_text
+
+ assert_equal 1, indexer.image_index.size
+ image_item = indexer.image_index['sample-image']
+ assert_not_nil(image_item)
+ assert_equal 1, image_item.number
+ assert_equal 'sample-image', image_item.id
+ assert_equal 'Sample Image Caption', image_item.caption_node&.to_inline_text
+
+ assert_equal 1, indexer.footnote_index.size
+ footnote_item = indexer.footnote_index['footnote1']
+ assert_not_nil(footnote_item)
+ assert_equal 1, footnote_item.number
+ assert_equal 'footnote1', footnote_item.id
+
+ equation_item = indexer.equation_index['equation1']
+ assert_not_nil(equation_item)
+ assert_equal 'equation1', equation_item.id
+ end
+
+ def test_headline_index_building
+ source = <<~EOS
+ = Chapter Title
+
+ =={sec1} Section 1
+
+ Basic text.
+
+ =={sec2} Section 2
+
+ More text.
+
+ ==={subsec21} Subsection 2.1
+
+ Subsection content.
+ EOS
+
+ @chapter.content = source
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(@chapter)
+
+ indexer = ReVIEW::AST::Indexer.new(@chapter)
+ indexer.build_indexes(ast_root)
+
+ assert_not_nil(indexer.headline_index)
+ assert indexer.headline_index.size >= 2
+
+ sec1_item = indexer.headline_index['sec1']
+ assert_not_nil(sec1_item)
+ assert_equal 'sec1', sec1_item.id
+ assert_equal [1], sec1_item.number
+
+ sec2_item = indexer.headline_index['sec2']
+ assert_not_nil(sec2_item)
+ assert_equal 'sec2', sec2_item.id
+ assert_equal [2], sec2_item.number
+
+ subsec_item = indexer.headline_index['sec2|subsec21']
+ assert_not_nil(subsec_item)
+ assert_equal 'sec2|subsec21', subsec_item.id
+ assert_equal [2, 1], subsec_item.number
+ end
+
+ def test_minicolumn_index_building
+ source = <<~EOS
+ = Chapter Title
+
+ //note[Note Caption]{
+ This is a note with @<fn>{note-footnote}.
+ //}
+
+ //memo[Memo Caption]{
+ This is a memo with @<bib>{bibitem1}.
+ //}
+
+ //footnote[note-footnote][Note footnote]
+
+ //bibpaper[bibitem1][Bib item content]
+ EOS
+
+ @chapter.content = source
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(@chapter)
+
+ indexer = ReVIEW::AST::Indexer.new(@chapter)
+ indexer.build_indexes(ast_root)
+
+ assert_equal 1, indexer.footnote_index.size
+ footnote_item = indexer.footnote_index['note-footnote']
+ assert_not_nil(footnote_item)
+ assert_equal 'note-footnote', footnote_item.id
+
+ assert_equal 1, indexer.bibpaper_index.size
+ bib_item = indexer.bibpaper_index['bibitem1']
+ assert_not_nil(bib_item)
+ assert_equal 'bibitem1', bib_item.id
+ end
+
+ def test_table_inline_elements
+ source = <<~EOS
+ = Chapter Title
+
+ //table[inline-table][Table with inline elements]{
+ Header @<b>{Bold} @<i>{Italic} Header
+ ------------
+ Cell with @<fn>{table-fn} @<eq>{table-eq}
+ //}
+
+ //footnote[table-fn][Table footnote]
+
+ //texequation[table-eq]{
+ x = y
+ //}
+ EOS
+
+ @chapter.content = source
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(@chapter)
+
+ indexer = ReVIEW::AST::Indexer.new(@chapter)
+ indexer.build_indexes(ast_root)
+
+ assert_equal 1, indexer.table_index.size
+ table_item = indexer.table_index['inline-table']
+ assert_not_nil(table_item)
+
+ assert_equal 1, indexer.footnote_index.size
+ footnote_item = indexer.footnote_index['table-fn']
+ assert_not_nil(footnote_item)
+ assert_equal 'table-fn', footnote_item.id
+
+ assert_equal 1, indexer.equation_index.size
+ equation_item = indexer.equation_index['table-eq']
+ assert_not_nil(equation_item)
+ assert_equal 'table-eq', equation_item.id
+ end
+
+ def test_code_block_inline_elements
+ source = <<~EOS
+ = Chapter Title
+
+ //list[code-with-inline][Code with inline elements][ruby]{
+ puts @<b>{bold code}
+ # Comment with @<fn>{code-fn}
+ //}
+
+ //footnote[code-fn][Footnote from code block]
+ EOS
+
+ @chapter.content = source
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(@chapter)
+
+ indexer = ReVIEW::AST::Indexer.new(@chapter)
+ indexer.build_indexes(ast_root)
+
+ assert_equal 1, indexer.list_index.size
+ list_item = indexer.list_index['code-with-inline']
+ assert_not_nil(list_item)
+
+ assert_equal 1, indexer.footnote_index.size
+ footnote_item = indexer.footnote_index['code-fn']
+ assert_not_nil(footnote_item)
+ assert_equal 'code-fn', footnote_item.id
+ end
+
+ def test_empty_ast
+ test_chapter = ReVIEW::Book::Chapter.new(@book, 1, 'empty_test', 'empty_test.re', StringIO.new)
+ indexer = ReVIEW::AST::Indexer.new(test_chapter)
+ result = indexer.build_indexes(nil)
+
+ assert_equal indexer, result
+ assert_equal 0, indexer.list_index.size
+ assert_equal 0, indexer.table_index.size
+ assert_equal 0, indexer.image_index.size
+ assert_equal 0, indexer.footnote_index.size
+ assert_equal 0, indexer.equation_index.size
+ end
+
+ def test_indexes_method
+ source = <<~EOS
+ = Chapter Title
+
+ //list[sample][Sample]{
+ code
+ //}
+ EOS
+
+ @chapter.content = source
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(@chapter)
+
+ indexer = ReVIEW::AST::Indexer.new(@chapter)
+ indexer.build_indexes(ast_root)
+
+ indexes = indexer.indexes
+ assert_kind_of(Hash, indexes)
+
+ expected_keys = %i[
+ list table equation footnote endnote
+ image icon numberless_image indepimage
+ headline column bibpaper
+ ]
+
+ expected_keys.each do |key|
+ assert indexes.key?(key), "Should contain #{key} index"
+ end
+
+ assert_equal 1, indexes[:list].size
+ assert_not_nil(indexes[:list]['sample'])
+ end
+
+ def test_id_validation_warnings
+ source = <<~EOS
+ = Chapter Title
+
+ //list[invalid#id][Invalid ID with #]{
+ code
+ //}
+
+ //table[.starts_with_dot][ID starting with dot]{
+ data
+ //}
+
+ Text with @<fn>{space id} and @<eq>{id with$pecial}.
+
+ //footnote[space id][Footnote with space id]
+
+ //texequation[id with$pecial]{
+ z = 1
+ //}
+ EOS
+
+ @chapter.content = source
+
+ original_stderr = $stderr
+ captured_stderr = StringIO.new
+ $stderr = captured_stderr
+
+ begin
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(@chapter)
+
+ indexer = ReVIEW::AST::Indexer.new(@chapter)
+ indexer.build_indexes(ast_root)
+
+ warnings = captured_stderr.string
+ assert_include(warnings, 'deprecated ID: `#` in `invalid#id`')
+ assert_include(warnings, 'deprecated ID: `.starts_with_dot` begins from `.`')
+ assert_include(warnings, 'deprecated ID: ` ` in `space id`')
+ assert_include(warnings, 'deprecated ID: `$` in `id with$pecial`')
+ ensure
+ $stderr = original_stderr
+ end
+ end
+end
diff --git a/test/ast/test_ast_inline.rb b/test/ast/test_ast_inline.rb
new file mode 100644
index 000000000..7f968d231
--- /dev/null
+++ b/test/ast/test_ast_inline.rb
@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast'
+require 'review/ast/compiler'
+require 'review/configure'
+require 'review/book'
+require 'review/book/chapter'
+
+class TestASTInline < Test::Unit::TestCase
+ def setup
+ @config = ReVIEW::Configure.values
+ @config['secnolevel'] = 2
+ @config['language'] = 'ja'
+ @book = ReVIEW::Book::Base.new(config: @config)
+ @log_io = StringIO.new
+ ReVIEW.logger = ReVIEW::Logger.new(@log_io)
+ ReVIEW::I18n.setup(@config['language'])
+ end
+
+ def test_text_node_creation
+ node = ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'Hello world')
+
+ hash = node.to_h
+ assert_equal 'TextNode', hash[:type]
+ assert_equal 'Hello world', hash[:content]
+ end
+
+ def test_inline_node_creation
+ node = ReVIEW::AST::InlineNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0),
+ inline_type: :b,
+ args: ['bold text'])
+
+ hash = node.to_h
+ assert_equal 'InlineNode', hash[:type]
+ assert_equal :b, hash[:inline_type]
+ assert_equal ['bold text'], hash[:args]
+ end
+
+ def test_simple_inline_parsing
+ content = <<~EOB
+ This is @<b>{bold text} in a paragraph.
+ EOB
+
+ ast_root = compile_to_ast(content)
+ # Check that paragraph node exists and has children
+ paragraph_node = ast_root.children.find { |n| n.is_a?(ReVIEW::AST::ParagraphNode) }
+ assert_not_nil(paragraph_node)
+ assert(paragraph_node.children.any?, 'Paragraph should have inline children')
+
+ # Check for text and inline nodes
+ text_nodes = paragraph_node.children.select { |n| n.is_a?(ReVIEW::AST::TextNode) }
+ inline_nodes = paragraph_node.children.select { |n| n.is_a?(ReVIEW::AST::InlineNode) }
+
+ assert(text_nodes.any?, 'Should have text nodes')
+ assert(inline_nodes.any?, 'Should have inline nodes')
+
+ # Check inline node details
+ bold_node = inline_nodes.find { |n| n.inline_type == :b }
+ assert_not_nil(bold_node, 'Should have bold inline node')
+ assert_equal :b, bold_node.inline_type
+ end
+
+ def test_multiple_inline_elements
+ content = <<~EOB
+ Text with @<b>{bold} and @<i>{italic} elements.
+ EOB
+
+ ast_root = compile_to_ast(content)
+ paragraph_node = ast_root.children.find { |n| n.is_a?(ReVIEW::AST::ParagraphNode) }
+ assert_not_nil(paragraph_node)
+
+ # Check for both bold and italic inline nodes
+ inline_nodes = paragraph_node.children.select { |n| n.is_a?(ReVIEW::AST::InlineNode) }
+ assert_equal 2, inline_nodes.size
+
+ bold_node = inline_nodes.find { |n| n.inline_type == :b }
+ italic_node = inline_nodes.find { |n| n.inline_type == :i }
+
+ assert_not_nil(bold_node, 'Should have bold inline node')
+ assert_not_nil(italic_node, 'Should have italic inline node')
+ assert_equal :b, bold_node.inline_type
+ assert_equal :i, italic_node.inline_type
+ end
+
+ def test_inline_output_compatibility
+ content = <<~EOB
+ This is @<b>{bold} and @<code>{inline code} text.
+ EOB
+
+ ast_root = compile_to_ast(content)
+
+ paragraph_node = ast_root.children.find { |n| n.is_a?(ReVIEW::AST::ParagraphNode) }
+ assert_not_nil(paragraph_node, 'Should have paragraph node')
+
+ # Check inline elements in AST
+ inline_nodes = paragraph_node.children.select { |n| n.is_a?(ReVIEW::AST::InlineNode) }
+ assert_equal(2, inline_nodes.size, 'Should have two inline elements')
+
+ bold_node = inline_nodes.find { |n| n.inline_type == :b }
+ code_node = inline_nodes.find { |n| n.inline_type == :code }
+
+ assert_not_nil(bold_node, 'Should have bold inline node')
+ assert_not_nil(code_node, 'Should have code inline node')
+ assert_equal(['bold'], bold_node.args)
+ assert_equal(['inline code'], code_node.args)
+ end
+
+ def test_mixed_content_parsing
+ content = <<~EOB
+ = Chapter Title
+
+ Normal paragraph with @<b>{bold text}.
+
+ Another paragraph with @<code>{code} and @<i>{italic}.
+ EOB
+
+ ast_root = compile_to_ast(content)
+ # Check headline
+ headline_node = ast_root.children.find { |n| n.is_a?(ReVIEW::AST::HeadlineNode) }
+ assert_not_nil(headline_node)
+ assert_equal 'Chapter Title', headline_node.caption_text
+
+ # Check paragraphs with inline elements
+ paragraph_nodes = ast_root.children.select { |n| n.is_a?(ReVIEW::AST::ParagraphNode) }
+ assert_equal 2, paragraph_nodes.size
+
+ # First paragraph should have bold inline
+ first_para = paragraph_nodes[0]
+ bold_node = first_para.children.find { |n| n.is_a?(ReVIEW::AST::InlineNode) && n.inline_type == :b }
+ assert_not_nil(bold_node)
+
+ # Second paragraph should have code and italic inlines
+ second_para = paragraph_nodes[1]
+ code_node = second_para.children.find { |n| n.is_a?(ReVIEW::AST::InlineNode) && n.inline_type == :code }
+ italic_node = second_para.children.find { |n| n.is_a?(ReVIEW::AST::InlineNode) && n.inline_type == :i }
+ assert_not_nil(code_node)
+ assert_not_nil(italic_node)
+ end
+
+ private
+
+ def compile_to_ast(content)
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new)
+ chapter.content = content
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_compiler.compile_to_ast(chapter)
+ end
+end
diff --git a/test/ast/test_ast_inline_structure.rb b/test/ast/test_ast_inline_structure.rb
new file mode 100644
index 000000000..a4b4e4339
--- /dev/null
+++ b/test/ast/test_ast_inline_structure.rb
@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast'
+require 'review/ast/compiler'
+require 'review/configure'
+require 'review/book'
+require 'review/book/chapter'
+
+class TestASTInlineStructure < Test::Unit::TestCase
+ def setup
+ @config = ReVIEW::Configure.values
+ @config['secnolevel'] = 2
+ @config['language'] = 'ja'
+ @book = ReVIEW::Book::Base.new(config: @config)
+ @log_io = StringIO.new
+ ReVIEW.logger = ReVIEW::Logger.new(@log_io)
+ ReVIEW::I18n.setup(@config['language'])
+ end
+
+ def test_inline_element_ast_structure
+ content = <<~EOB
+ = Test Chapter
+
+ Simple inline: @<b>{bold} and @<code>{code}.
+
+ Ruby annotation: @<ruby>{漢字,かんじ}.
+
+ References: @<href>{http://example.com, Link Text}.
+
+ Keywords: @<kw>{Term, Description}.
+
+ Heading ref: @<hd>{section}.
+
+ Cross-refs: @<chap>{intro}, @<sec>{overview}.
+
+ Word files: @<w>{words} and @<wb>{words2}.
+
+ Complex ref: @<img>{figure1} and @<table>{data1}.
+ EOB
+
+ ast_root = compile_to_ast(content)
+
+ assert_not_nil(ast_root)
+ assert_equal(ReVIEW::AST::DocumentNode, ast_root.class)
+
+ paragraph_nodes = ast_root.children.select { |n| n.is_a?(ReVIEW::AST::ParagraphNode) }
+ assert_equal(8, paragraph_nodes.size)
+
+ simple_para = paragraph_nodes[0]
+ bold_node = find_inline_node(simple_para, :b)
+ code_node = find_inline_node(simple_para, :code)
+ assert_not_nil(bold_node)
+ assert_not_nil(code_node)
+ assert_equal(['bold'], bold_node.args)
+ assert_equal(['code'], code_node.args)
+
+ ruby_para = paragraph_nodes[1]
+ ruby_node = find_inline_node(ruby_para, :ruby)
+ assert_not_nil(ruby_node)
+ assert_equal(['漢字', 'かんじ'], ruby_node.args)
+
+ href_para = paragraph_nodes[2]
+ href_node = find_inline_node(href_para, :href)
+ assert_not_nil(href_node)
+ assert_equal(['http://example.com', 'Link Text'], href_node.args)
+
+ kw_para = paragraph_nodes[3]
+ kw_node = find_inline_node(kw_para, :kw)
+ assert_not_nil(kw_node)
+ assert_equal(['Term', 'Description'], kw_node.args)
+
+ hd_para = paragraph_nodes[4]
+ hd_node = find_inline_node(hd_para, :hd)
+ assert_not_nil(hd_node)
+ assert_equal(['section'], hd_node.args)
+
+ cross_para = paragraph_nodes[5]
+ chap_node = find_inline_node(cross_para, :chap)
+ sec_node = find_inline_node(cross_para, :sec)
+ assert_not_nil(chap_node)
+ assert_not_nil(sec_node)
+ assert_equal(['intro'], chap_node.args)
+ assert_equal(['overview'], sec_node.args)
+
+ word_para = paragraph_nodes[6]
+ w_node = find_inline_node(word_para, :w)
+ wb_node = find_inline_node(word_para, :wb)
+ assert_not_nil(w_node)
+ assert_not_nil(wb_node)
+ assert_equal(['words'], w_node.args)
+ assert_equal(['words2'], wb_node.args)
+
+ ref_para = paragraph_nodes[7]
+ img_node = find_inline_node(ref_para, :img)
+ table_node = find_inline_node(ref_para, :table)
+ assert_not_nil(img_node)
+ assert_not_nil(table_node)
+ assert_equal(['figure1'], img_node.args)
+ assert_equal(['data1'], table_node.args)
+ end
+
+ def test_pipe_separated_inline_elements
+ content = <<~EOB
+ = Test Chapter
+
+ Heading with chapter: @<hd>{chapter1|Introduction}.
+
+ Image with chapter: @<img>{chap1|figure1}.
+
+ List with chapter: @<list>{chap2|sample1}.
+
+ Equation with chapter: @<eq>{chap3|formula1}.
+
+ Table with chapter: @<table>{chap4|data1}.
+ EOB
+
+ ast_root = compile_to_ast(content)
+ paragraph_nodes = ast_root.children.select { |n| n.is_a?(ReVIEW::AST::ParagraphNode) }
+
+ hd_para = paragraph_nodes[0]
+ hd_node = find_inline_node(hd_para, :hd)
+ assert_not_nil(hd_node)
+ assert_equal(['chapter1', 'Introduction'], hd_node.args)
+
+ img_para = paragraph_nodes[1]
+ img_node = find_inline_node(img_para, :img)
+ assert_not_nil(img_node)
+ assert_equal(['chap1', 'figure1'], img_node.args)
+
+ list_para = paragraph_nodes[2]
+ list_node = find_inline_node(list_para, :list)
+ assert_not_nil(list_node)
+ assert_equal(['chap2', 'sample1'], list_node.args)
+
+ eq_para = paragraph_nodes[3]
+ eq_node = find_inline_node(eq_para, :eq)
+ assert_not_nil(eq_node)
+ assert_equal(['chap3', 'formula1'], eq_node.args)
+
+ table_para = paragraph_nodes[4]
+ table_node = find_inline_node(table_para, :table)
+ assert_not_nil(table_node)
+ assert_equal(['chap4', 'data1'], table_node.args)
+ end
+
+ def test_newly_added_inline_commands
+ content = <<~EOB
+ = Test Chapter
+
+ Label references: @<labelref>{label1} and @<ref>{label2}.
+ EOB
+
+ ast_root = compile_to_ast(content)
+ paragraph_nodes = ast_root.children.select { |n| n.is_a?(ReVIEW::AST::ParagraphNode) }
+
+ label_para = paragraph_nodes[0]
+ labelref_node = find_inline_node(label_para, :labelref)
+ ref_node = find_inline_node(label_para, :ref)
+ assert_not_nil(labelref_node)
+ assert_not_nil(ref_node)
+ assert_equal(['label1'], labelref_node.args)
+ assert_equal(['label2'], ref_node.args)
+ end
+
+ private
+
+ def find_inline_node(paragraph, inline_type)
+ paragraph.children.find do |child|
+ child.is_a?(ReVIEW::AST::InlineNode) && child.inline_type == inline_type
+ end
+ end
+
+ def compile_to_ast(content)
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new)
+ chapter.content = content
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_compiler.compile_to_ast(chapter, reference_resolution: false)
+ end
+end
diff --git a/test/ast/test_ast_json_serialization.rb b/test/ast/test_ast_json_serialization.rb
new file mode 100644
index 000000000..f50aaedc2
--- /dev/null
+++ b/test/ast/test_ast_json_serialization.rb
@@ -0,0 +1,855 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast'
+require 'review/ast/json_serializer'
+require 'review/ast/code_line_node'
+require 'review/ast/table_row_node'
+require 'review/ast/table_cell_node'
+require 'json'
+
+class TestASTJSONSerialization < Test::Unit::TestCase
+ include ReVIEW
+
+ def setup
+ @location = SnapshotLocation.new('test.re', 42)
+ end
+
+ def test_basic_node_serialization
+ # Test with a concrete node class instead of abstract Node
+ node = AST::ParagraphNode.new(location: @location)
+ json = node.to_json
+ parsed = JSON.parse(json)
+
+ assert_equal 'ParagraphNode', parsed['type']
+ assert_equal 'test.re', parsed['location']['filename']
+ assert_equal 42, parsed['location']['lineno']
+ assert_equal [], parsed['children']
+ end
+
+ def test_headline_node_serialization
+ node = AST::HeadlineNode.new(
+ location: @location,
+ level: 1,
+ label: 'intro',
+ caption_node: CaptionParserHelper.parse('Introduction', location: @location)
+ )
+
+ json = node.to_json
+ parsed = JSON.parse(json)
+
+ assert_equal 'HeadlineNode', parsed['type']
+ assert_equal 1, parsed['level']
+ assert_equal 'intro', parsed['label']
+ expected_caption_node = {
+ 'children' => [{ 'content' => 'Introduction',
+ 'location' => { 'filename' => 'test.re', 'lineno' => 42 },
+ 'type' => 'TextNode' }],
+ 'location' => { 'filename' => 'test.re', 'lineno' => 42 },
+ 'type' => 'CaptionNode'
+ }
+ assert_equal expected_caption_node, parsed['caption_node']
+ end
+
+ def test_paragraph_with_inline_elements
+ para = AST::ParagraphNode.new(location: @location)
+
+ # Add text node
+ text1 = AST::TextNode.new(
+ location: @location,
+ content: 'This is '
+ )
+ para.add_child(text1)
+
+ # Add inline node
+ inline = AST::InlineNode.new(
+ location: @location,
+ inline_type: :b,
+ args: ['bold']
+ )
+
+ inline_text = AST::TextNode.new(
+ location: @location,
+ content: 'bold'
+ )
+ inline.add_child(inline_text)
+
+ para.add_child(inline)
+
+ # Add more text
+ text2 = AST::TextNode.new(
+ location: @location,
+ content: ' text.'
+ )
+ para.add_child(text2)
+
+ json = para.to_json
+ parsed = JSON.parse(json)
+
+ assert_equal 'ParagraphNode', parsed['type']
+ assert_equal 3, parsed['children'].size
+
+ # Check first text node
+ assert_equal 'TextNode', parsed['children'][0]['type']
+ assert_equal 'This is ', parsed['children'][0]['content']
+
+ # Check inline node
+ inline_node = parsed['children'][1]
+ assert_equal 'InlineNode', inline_node['type']
+ assert_equal 'b', inline_node['inline_type']
+ assert_equal ['bold'], inline_node['args']
+ assert_equal 1, inline_node['children'].size
+ assert_equal 'bold', inline_node['children'][0]['content']
+
+ # Check last text node
+ assert_equal 'TextNode', parsed['children'][2]['type']
+ assert_equal ' text.', parsed['children'][2]['content']
+ end
+
+ def test_code_block_node_serialization
+ lines_text = "def hello\n puts \"world\"\nend"
+ node = AST::CodeBlockNode.new(
+ location: @location,
+ id: 'example',
+ caption_node: CaptionParserHelper.parse('Example Code', location: @location),
+ lang: 'ruby',
+ original_text: lines_text,
+ line_numbers: true
+ )
+
+ # Add code line nodes to represent the structure
+ ['def hello', ' puts "world"', 'end'].each_with_index do |line, index|
+ line_node = AST::CodeLineNode.new(
+ location: @location,
+ line_number: index + 1
+ )
+ line_node.add_child(AST::TextNode.new(location: @location, content: line))
+ node.add_child(line_node)
+ end
+
+ json = node.to_json
+ parsed = JSON.parse(json)
+
+ assert_equal 'CodeBlockNode', parsed['type']
+ assert_equal 'example', parsed['id']
+ expected_caption = {
+ 'type' => 'CaptionNode',
+ 'location' => { 'filename' => 'test.re', 'lineno' => 42 },
+ 'children' => [
+ {
+ 'type' => 'TextNode',
+ 'content' => 'Example Code',
+ 'location' => { 'filename' => 'test.re', 'lineno' => 42 }
+ }
+ ]
+ }
+ assert_equal expected_caption, parsed['caption_node']
+ assert_equal 'ruby', parsed['lang']
+ assert_equal lines_text, parsed['original_text']
+ assert_equal true, parsed['line_numbers']
+ assert_equal 3, parsed['children'].size # Check we have 3 code line nodes
+ end
+
+ def test_table_node_serialization
+ node = AST::TableNode.new(
+ location: @location,
+ id: 'data',
+ caption_node: CaptionParserHelper.parse('Sample Data', location: @location)
+ )
+
+ # Add header row
+ header_row = AST::TableRowNode.new(location: @location, row_type: :header)
+ ['Name', 'Age'].each do |cell_content|
+ cell = AST::TableCellNode.new(location: @location)
+ cell.add_child(AST::TextNode.new(location: @location, content: cell_content))
+ header_row.add_child(cell)
+ end
+ node.add_header_row(header_row)
+
+ # Add body rows
+ [['Alice', '25'], ['Bob', '30']].each do |row_data|
+ body_row = AST::TableRowNode.new(location: @location, row_type: :body)
+ row_data.each do |cell_content|
+ cell = AST::TableCellNode.new(location: @location)
+ cell.add_child(AST::TextNode.new(location: @location, content: cell_content))
+ body_row.add_child(cell)
+ end
+ node.add_body_row(body_row)
+ end
+
+ json = node.to_json
+ parsed = JSON.parse(json)
+
+ assert_equal 'TableNode', parsed['type']
+ assert_equal 'data', parsed['id']
+ expected_caption = {
+ 'type' => 'CaptionNode',
+ 'location' => { 'filename' => 'test.re', 'lineno' => 42 },
+ 'children' => [
+ {
+ 'type' => 'TextNode',
+ 'content' => 'Sample Data',
+ 'location' => { 'filename' => 'test.re', 'lineno' => 42 }
+ }
+ ]
+ }
+ assert_equal expected_caption, parsed['caption_node']
+ assert_equal 1, parsed['header_rows'].size # Check we have 1 header row
+ assert_equal 2, parsed['body_rows'].size # Check we have 2 body rows
+ end
+
+ def test_list_node_serialization
+ list = AST::ListNode.new(
+ location: @location,
+ list_type: :ul
+ )
+
+ item1 = AST::ListItemNode.new(
+ location: @location,
+ level: 1
+ )
+ text1 = AST::TextNode.new(location: @location, content: 'First item')
+ item1.add_child(text1)
+ list.add_child(item1)
+
+ item2 = AST::ListItemNode.new(
+ location: @location,
+ level: 1
+ )
+ text2 = AST::TextNode.new(location: @location, content: 'Second item')
+ item2.add_child(text2)
+ list.add_child(item2)
+
+ json = list.to_json
+ parsed = JSON.parse(json)
+
+ assert_equal 'ListNode', parsed['type']
+ assert_equal 'ul', parsed['list_type']
+ assert_equal 2, parsed['children'].size
+ # Check that text content is in the children of each list item
+ assert_equal 1, parsed['children'][0]['children'].size
+ assert_equal 'First item', parsed['children'][0]['children'][0]['content']
+ assert_equal 1, parsed['children'][1]['children'].size
+ assert_equal 'Second item', parsed['children'][1]['children'][0]['content']
+ end
+
+ def test_embed_node_serialization
+ node = AST::EmbedNode.new(
+ location: @location,
+ embed_type: :block,
+ target_builders: ['html'],
+ content: "<div>HTML content</div>\n<p>Paragraph</p>"
+ )
+
+ json = node.to_json
+ parsed = JSON.parse(json)
+
+ assert_equal 'EmbedNode', parsed['type']
+ assert_equal 'block', parsed['embed_type']
+ assert_equal ['html'], parsed['target_builders']
+ assert_equal "<div>HTML content</div>\n<p>Paragraph</p>", parsed['content']
+ end
+
+ def test_document_node_serialization
+ doc = AST::DocumentNode.new(
+ location: @location
+ )
+
+ headline = AST::HeadlineNode.new(
+ location: @location,
+ level: 1,
+ caption_node: CaptionParserHelper.parse('Chapter 1', location: @location)
+ )
+ doc.add_child(headline)
+
+ para = AST::ParagraphNode.new(
+ location: @location
+ )
+ para_text = AST::TextNode.new(location: @location, content: 'Test paragraph')
+ para.add_child(para_text)
+ doc.add_child(para)
+
+ json = doc.to_json
+ parsed = JSON.parse(json)
+
+ assert_equal 'DocumentNode', parsed['type']
+ assert_equal 2, parsed['children'].size
+ assert_equal 'HeadlineNode', parsed['children'][0]['type']
+ assert_equal 'ParagraphNode', parsed['children'][1]['type']
+ end
+
+ def test_custom_json_serializer_basic
+ node = AST::HeadlineNode.new(
+ location: @location,
+ level: 2,
+ caption_node: CaptionParserHelper.parse('Section Title', location: @location)
+ )
+
+ options = AST::JSONSerializer::Options.new
+ json = AST::JSONSerializer.serialize(node, options)
+ parsed = JSON.parse(json)
+
+ assert_equal 'HeadlineNode', parsed['type']
+ assert_equal 2, parsed['level']
+ expected_caption = {
+ 'children' => [{ 'content' => 'Section Title',
+ 'location' => { 'filename' => 'test.re', 'lineno' => 42 },
+ 'type' => 'TextNode' }],
+ 'location' => { 'filename' => 'test.re', 'lineno' => 42 },
+ 'type' => 'CaptionNode'
+ }
+ assert_equal expected_caption, parsed['caption_node']
+ end
+
+ def test_custom_json_serializer_without_location
+ node = AST::HeadlineNode.new(
+ location: @location,
+ level: 2,
+ caption_node: CaptionParserHelper.parse('Section Title', location: @location)
+ )
+
+ options = AST::JSONSerializer::Options.new
+ options.include_location = false
+
+ json = AST::JSONSerializer.serialize(node, options)
+ parsed = JSON.parse(json)
+
+ assert_equal 'HeadlineNode', parsed['type']
+ assert_equal 2, parsed['level']
+ expected_caption = {
+ 'children' => [{ 'content' => 'Section Title', 'type' => 'TextNode' }],
+ 'type' => 'CaptionNode'
+ }
+ assert_equal expected_caption, parsed['caption_node']
+ assert_nil(parsed['location'])
+ end
+
+ def test_custom_json_serializer_compact
+ node = AST::HeadlineNode.new(
+ location: @location,
+ level: 2,
+ caption_node: CaptionParserHelper.parse('Section Title', location: @location)
+ )
+
+ options = AST::JSONSerializer::Options.new
+ options.pretty = false
+ options.include_location = false
+
+ json = AST::JSONSerializer.serialize(node, options)
+
+ # Compact JSON should not have newlines
+ assert_not_include(json, "\n")
+
+ parsed = JSON.parse(json)
+ assert_equal 'HeadlineNode', parsed['type']
+ end
+
+ def test_json_schema_structure
+ schema = AST::JSONSerializer.json_schema
+
+ assert_equal 'http://json-schema.org/draft-07/schema#', schema['$schema']
+ assert_equal 'ReVIEW AST JSON Schema', schema['title']
+ assert_equal 'object', schema['type']
+ assert_include(schema['required'], 'type')
+
+ # Check enum values for type
+ type_enum = schema['properties']['type']['enum']
+ assert_include(type_enum, 'DocumentNode')
+ assert_include(type_enum, 'HeadlineNode')
+ assert_include(type_enum, 'ParagraphNode')
+ assert_include(type_enum, 'InlineNode')
+ end
+
+ def test_complex_nested_structure
+ # Create a complex document structure
+ doc = AST::DocumentNode.new(
+ location: @location
+ )
+
+ # Add headline
+ headline = AST::HeadlineNode.new(
+ location: @location,
+ level: 1,
+ caption_node: CaptionParserHelper.parse('Introduction', location: @location)
+ )
+ doc.add_child(headline)
+
+ # Add paragraph with inline elements
+ para = AST::ParagraphNode.new(
+ location: @location
+ )
+
+ text1 = AST::TextNode.new(
+ location: @location,
+ content: 'This paragraph has '
+ )
+ para.add_child(text1)
+
+ inline = AST::InlineNode.new(
+ location: @location,
+ inline_type: :code,
+ args: ['inline code']
+ )
+
+ inline_text = AST::TextNode.new(
+ location: @location,
+ content: 'inline code'
+ )
+ inline.add_child(inline_text)
+ para.add_child(inline)
+
+ text2 = AST::TextNode.new(
+ location: @location,
+ content: ' elements.'
+ )
+ para.add_child(text2)
+
+ doc.add_child(para)
+
+ # Add code block
+ code = AST::CodeBlockNode.new(
+ location: @location,
+ id: 'example',
+ caption_node: CaptionParserHelper.parse('Code Example', location: @location),
+ lang: 'ruby',
+ original_text: 'puts "Hello, World!"'
+ )
+
+ # Add code line node
+ line_node = AST::CodeLineNode.new(location: @location)
+ line_node.add_child(AST::TextNode.new(location: @location, content: 'puts "Hello, World!"'))
+ code.add_child(line_node)
+ doc.add_child(code)
+
+ # Serialize and verify
+ json = doc.to_json
+ parsed = JSON.parse(json)
+
+ assert_equal 'DocumentNode', parsed['type']
+ assert_equal 3, parsed['children'].size
+
+ # Check headline
+ headline_json = parsed['children'][0]
+ assert_equal 'HeadlineNode', headline_json['type']
+ assert_equal 1, headline_json['level']
+ assert_equal({ 'children' =>
+ [{ 'content' => 'Introduction',
+ 'location' => { 'filename' => 'test.re', 'lineno' => 42 },
+ 'type' => 'TextNode' }],
+ 'location' => { 'filename' => 'test.re', 'lineno' => 42 },
+ 'type' => 'CaptionNode' }, headline_json['caption_node'])
+
+ # Check paragraph with inline elements
+ para_json = parsed['children'][1]
+ assert_equal 'ParagraphNode', para_json['type']
+ assert_equal 3, para_json['children'].size
+
+ inline_json = para_json['children'][1]
+ assert_equal 'InlineNode', inline_json['type']
+ assert_equal 'code', inline_json['inline_type']
+ assert_equal ['inline code'], inline_json['args']
+
+ # Check code block
+ code_json = parsed['children'][2]
+ assert_equal 'CodeBlockNode', code_json['type']
+ assert_equal 'example', code_json['id']
+ expected_caption = {
+ 'type' => 'CaptionNode',
+ 'location' => { 'filename' => 'test.re', 'lineno' => 42 },
+ 'children' => [
+ {
+ 'type' => 'TextNode',
+ 'content' => 'Code Example',
+ 'location' => { 'filename' => 'test.re', 'lineno' => 42 }
+ }
+ ]
+ }
+ assert_equal expected_caption, code_json['caption_node']
+ assert_equal 'ruby', code_json['lang']
+ assert_equal 'puts "Hello, World!"', code_json['original_text']
+ assert_equal 1, code_json['children'].size # Check we have 1 code line node
+ end
+
+ def test_include_location_option_with_true
+ # Test that location information is included when include_location is true (default)
+ paragraph = AST::ParagraphNode.new(location: @location)
+ text_node = AST::TextNode.new(location: @location, content: 'Test content')
+ paragraph.add_child(text_node)
+
+ options = AST::JSONSerializer::Options.new(include_location: true)
+ json = AST::JSONSerializer.serialize(paragraph, options)
+ parsed = JSON.parse(json)
+
+ # Check that location is included in parent node
+ assert_not_nil(parsed['location'], 'location should be included when include_location is true')
+ assert_equal 'test.re', parsed['location']['filename']
+ assert_equal 42, parsed['location']['lineno']
+
+ # Check that location is included in child nodes
+ assert_equal 1, parsed['children'].size
+ child = parsed['children'][0]
+ assert_not_nil(child['location'], 'location should be included in child nodes when include_location is true')
+ assert_equal 'test.re', child['location']['filename']
+ assert_equal 42, child['location']['lineno']
+ end
+
+ def test_include_location_option_with_false
+ # Test that location information is excluded when include_location is false
+ paragraph = AST::ParagraphNode.new(location: @location)
+ text_node = AST::TextNode.new(location: @location, content: 'Test content')
+ paragraph.add_child(text_node)
+
+ options = AST::JSONSerializer::Options.new(include_location: false)
+ json = AST::JSONSerializer.serialize(paragraph, options)
+ parsed = JSON.parse(json)
+
+ # Check that location is not included in parent node
+ assert_nil(parsed['location'], 'location should not be included when include_location is false')
+
+ # Check that location is not included in child nodes
+ assert_equal 1, parsed['children'].size
+ child = parsed['children'][0]
+ assert_nil(child['location'], 'location should not be included in child nodes when include_location is false')
+ end
+
+ def test_include_location_with_complex_tree
+ # Test include_location with a more complex node tree
+ headline = AST::HeadlineNode.new(
+ location: @location,
+ level: 1,
+ caption_node: CaptionParserHelper.parse('Test Headline', location: @location)
+ )
+
+ # Test with include_location = true
+ options_with_location = AST::JSONSerializer::Options.new(include_location: true)
+ json_with_location = AST::JSONSerializer.serialize(headline, options_with_location)
+ parsed_with_location = JSON.parse(json_with_location)
+
+ assert_not_nil(parsed_with_location['location'])
+ assert_not_nil(parsed_with_location['caption_node']['location'])
+ caption_children = parsed_with_location['caption_node']['children']
+ assert_equal 1, caption_children.size
+ assert_not_nil(caption_children[0]['location'])
+
+ # Test with include_location = false
+ options_without_location = AST::JSONSerializer::Options.new(include_location: false)
+ json_without_location = AST::JSONSerializer.serialize(headline, options_without_location)
+ parsed_without_location = JSON.parse(json_without_location)
+
+ assert_nil(parsed_without_location['location'])
+ assert_nil(parsed_without_location['caption_node']['location'])
+ caption_children = parsed_without_location['caption_node']['children']
+ assert_equal 1, caption_children.size
+ assert_nil(caption_children[0]['location'])
+ end
+
+ def test_footnote_node_serialization
+ # Create a footnote node with children
+ footnote = AST::FootnoteNode.new(
+ location: @location,
+ id: 'fn1',
+ footnote_type: :footnote
+ )
+
+ text = AST::TextNode.new(
+ location: @location,
+ content: 'This is a footnote text.'
+ )
+ footnote.add_child(text)
+
+ # Serialize to JSON
+ json = footnote.to_json
+ parsed = JSON.parse(json)
+
+ # Verify serialization
+ assert_equal 'FootnoteNode', parsed['type']
+ assert_equal 'fn1', parsed['id']
+ # footnote_type is omitted when it's :footnote (default)
+ assert_nil(parsed['footnote_type'])
+ assert_equal 1, parsed['children'].size
+ assert_equal 'TextNode', parsed['children'][0]['type']
+ assert_equal 'This is a footnote text.', parsed['children'][0]['content']
+
+ # Test deserialization
+ deserialized = AST::JSONSerializer.deserialize(json)
+ assert_instance_of(AST::FootnoteNode, deserialized)
+ assert_equal 'fn1', deserialized.id
+ assert_equal :footnote, deserialized.footnote_type
+ assert_equal 1, deserialized.children.size
+ assert_equal 'This is a footnote text.', deserialized.children[0].content
+ end
+
+ def test_footnote_node_endnote_serialization
+ # Create an endnote node
+ endnote = AST::FootnoteNode.new(
+ location: @location,
+ id: 'en1',
+ footnote_type: :endnote
+ )
+
+ text = AST::TextNode.new(
+ location: @location,
+ content: 'This is an endnote.'
+ )
+ endnote.add_child(text)
+
+ # Serialize to JSON
+ json = endnote.to_json
+ parsed = JSON.parse(json)
+
+ # Verify serialization - endnote type should be included
+ assert_equal 'FootnoteNode', parsed['type']
+ assert_equal 'en1', parsed['id']
+ assert_equal 'endnote', parsed['footnote_type']
+
+ # Test deserialization
+ deserialized = AST::JSONSerializer.deserialize(json)
+ assert_instance_of(AST::FootnoteNode, deserialized)
+ assert_equal 'en1', deserialized.id
+ assert_equal :endnote, deserialized.footnote_type
+ end
+
+ def test_reference_node_unresolved_serialization
+ # Create an unresolved reference node
+ ref = AST::ReferenceNode.new(
+ 'img1',
+ nil,
+ location: @location
+ )
+
+ # Serialize to JSON
+ json = ref.to_json
+ parsed = JSON.parse(json)
+
+ # Verify serialization
+ assert_equal 'ReferenceNode', parsed['type']
+ assert_equal 'img1', parsed['content']
+ assert_equal 'img1', parsed['ref_id']
+ assert_nil(parsed['context_id'])
+ assert_nil(parsed['resolved_data'])
+
+ # Test deserialization
+ deserialized = AST::JSONSerializer.deserialize(json)
+ assert_instance_of(AST::ReferenceNode, deserialized)
+ assert_equal 'img1', deserialized.ref_id
+ assert_nil(deserialized.context_id)
+ assert_nil(deserialized.resolved_data)
+ assert_equal false, deserialized.resolved?
+ end
+
+ def test_reference_node_with_context_serialization
+ # Create a cross-chapter reference node
+ ref = AST::ReferenceNode.new(
+ 'img1',
+ 'chapter2',
+ location: @location
+ )
+
+ # Serialize to JSON
+ json = ref.to_json
+ parsed = JSON.parse(json)
+
+ # Verify serialization
+ assert_equal 'ReferenceNode', parsed['type']
+ assert_equal 'chapter2|img1', parsed['content']
+ assert_equal 'img1', parsed['ref_id']
+ assert_equal 'chapter2', parsed['context_id']
+
+ # Test deserialization
+ deserialized = AST::JSONSerializer.deserialize(json)
+ assert_instance_of(AST::ReferenceNode, deserialized)
+ assert_equal 'img1', deserialized.ref_id
+ assert_equal 'chapter2', deserialized.context_id
+ assert_equal true, deserialized.cross_chapter?
+ end
+
+ def test_reference_node_with_image_reference_serialization
+ # Create resolved image reference
+ caption_node = CaptionParserHelper.parse('Sample Image', location: @location)
+ resolved_data = AST::ResolvedData.image(
+ chapter_number: 1, chapter_type: :chapter,
+ item_number: '2',
+ item_id: 'img1',
+ caption_node: caption_node
+ )
+
+ ref = AST::ReferenceNode.new(
+ 'img1',
+ nil,
+ location: @location,
+ resolved_data: resolved_data
+ )
+
+ # Serialize to JSON
+ json = ref.to_json
+ parsed = JSON.parse(json)
+
+ # Verify serialization
+ assert_equal 'ReferenceNode', parsed['type']
+ assert_equal 'img1', parsed['ref_id']
+ assert_not_nil(parsed['resolved_data'])
+ assert_equal 'ImageReference', parsed['resolved_data']['type']
+ assert_equal 1, parsed['resolved_data']['chapter_number']
+ assert_equal '2', parsed['resolved_data']['item_number']
+ assert_equal 'img1', parsed['resolved_data']['item_id']
+ assert_equal 'CaptionNode', parsed['resolved_data']['caption_node']['type']
+
+ # Test deserialization
+ deserialized = AST::JSONSerializer.deserialize(json)
+ assert_instance_of(AST::ReferenceNode, deserialized)
+ assert_equal true, deserialized.resolved?
+ assert_instance_of(AST::ResolvedData::ImageReference, deserialized.resolved_data)
+ assert_equal 1, deserialized.resolved_data.chapter_number
+ assert_equal '2', deserialized.resolved_data.item_number
+ assert_equal 'img1', deserialized.resolved_data.item_id
+ assert_instance_of(AST::CaptionNode, deserialized.resolved_data.caption_node)
+ end
+
+ def test_reference_node_with_table_reference_serialization
+ # Create resolved table reference
+ resolved_data = AST::ResolvedData.table(
+ chapter_number: 2, chapter_type: :chapter,
+ item_number: '1',
+ item_id: 'table1',
+ chapter_id: 'ch2'
+ )
+
+ ref = AST::ReferenceNode.new(
+ 'table1',
+ 'ch2',
+ location: @location,
+ resolved_data: resolved_data
+ )
+
+ json = ref.to_json
+ parsed = JSON.parse(json)
+
+ assert_equal 'TableReference', parsed['resolved_data']['type']
+ assert_equal 2, parsed['resolved_data']['chapter_number']
+ assert_equal '1', parsed['resolved_data']['item_number']
+ assert_equal 'ch2', parsed['resolved_data']['chapter_id']
+
+ # Test deserialization
+ deserialized = AST::JSONSerializer.deserialize(json)
+ assert_instance_of(AST::ResolvedData::TableReference, deserialized.resolved_data)
+ assert_equal 2, deserialized.resolved_data.chapter_number
+ end
+
+ def test_reference_node_with_chapter_reference_serialization
+ # Create resolved chapter reference
+ resolved_data = AST::ResolvedData.chapter(
+ chapter_number: 3, chapter_type: :chapter,
+ chapter_id: 'ch3',
+ item_id: 'ch3',
+ chapter_title: 'Advanced Topics'
+ )
+
+ ref = AST::ReferenceNode.new(
+ 'ch3',
+ nil,
+ location: @location,
+ resolved_data: resolved_data
+ )
+
+ json = ref.to_json
+ parsed = JSON.parse(json)
+
+ assert_equal 'ChapterReference', parsed['resolved_data']['type']
+ assert_equal 3, parsed['resolved_data']['chapter_number']
+ assert_equal 'ch3', parsed['resolved_data']['chapter_id']
+ assert_equal 'Advanced Topics', parsed['resolved_data']['chapter_title']
+
+ # Test deserialization
+ deserialized = AST::JSONSerializer.deserialize(json)
+ assert_instance_of(AST::ResolvedData::ChapterReference, deserialized.resolved_data)
+ assert_equal 3, deserialized.resolved_data.chapter_number
+ assert_equal 'Advanced Topics', deserialized.resolved_data.chapter_title
+ end
+
+ def test_reference_node_with_headline_reference_serialization
+ # Create resolved headline reference
+ caption_node = CaptionParserHelper.parse('Section Title', location: @location)
+ resolved_data = AST::ResolvedData.headline(
+ headline_number: [1, 2, 3],
+ item_id: 'sec123',
+ chapter_id: 'ch1',
+ chapter_number: 1, chapter_type: :chapter,
+ caption_node: caption_node
+ )
+
+ ref = AST::ReferenceNode.new(
+ 'sec123',
+ nil,
+ location: @location,
+ resolved_data: resolved_data
+ )
+
+ json = ref.to_json
+ parsed = JSON.parse(json)
+
+ assert_equal 'HeadlineReference', parsed['resolved_data']['type']
+ assert_equal [1, 2, 3], parsed['resolved_data']['headline_number']
+ assert_equal 'sec123', parsed['resolved_data']['item_id']
+ assert_equal 'ch1', parsed['resolved_data']['chapter_id']
+ assert_equal 1, parsed['resolved_data']['chapter_number']
+
+ # Test deserialization
+ deserialized = AST::JSONSerializer.deserialize(json)
+ assert_instance_of(AST::ResolvedData::HeadlineReference, deserialized.resolved_data)
+ assert_equal [1, 2, 3], deserialized.resolved_data.headline_number
+ end
+
+ def test_reference_node_with_footnote_reference_serialization
+ # Create resolved footnote reference
+ resolved_data = AST::ResolvedData.footnote(
+ item_number: 5,
+ item_id: 'fn5'
+ )
+
+ ref = AST::ReferenceNode.new(
+ 'fn5',
+ nil,
+ location: @location,
+ resolved_data: resolved_data
+ )
+
+ json = ref.to_json
+ parsed = JSON.parse(json)
+
+ assert_equal 'FootnoteReference', parsed['resolved_data']['type']
+ assert_equal 5, parsed['resolved_data']['item_number']
+ assert_equal 'fn5', parsed['resolved_data']['item_id']
+
+ # Test deserialization
+ deserialized = AST::JSONSerializer.deserialize(json)
+ assert_instance_of(AST::ResolvedData::FootnoteReference, deserialized.resolved_data)
+ assert_equal 5, deserialized.resolved_data.item_number
+ end
+
+ def test_reference_node_with_word_reference_serialization
+ # Create resolved word reference
+ resolved_data = AST::ResolvedData.word(
+ word_content: 'important term',
+ item_id: 'term1'
+ )
+
+ ref = AST::ReferenceNode.new(
+ 'term1',
+ nil,
+ location: @location,
+ resolved_data: resolved_data
+ )
+
+ json = ref.to_json
+ parsed = JSON.parse(json)
+
+ assert_equal 'WordReference', parsed['resolved_data']['type']
+ assert_equal 'important term', parsed['resolved_data']['word_content']
+ assert_equal 'term1', parsed['resolved_data']['item_id']
+
+ # Test deserialization
+ deserialized = AST::JSONSerializer.deserialize(json)
+ assert_instance_of(AST::ResolvedData::WordReference, deserialized.resolved_data)
+ assert_equal 'important term', deserialized.resolved_data.word_content
+ end
+end
diff --git a/test/ast/test_ast_json_verification.rb b/test/ast/test_ast_json_verification.rb
new file mode 100755
index 000000000..655664127
--- /dev/null
+++ b/test/ast/test_ast_json_verification.rb
@@ -0,0 +1,214 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review'
+require 'review/ast/json_serializer'
+require 'review/compiler'
+require 'review/htmlbuilder'
+require 'review/book'
+require 'review/book/chapter'
+require 'review/configure'
+require 'json'
+require 'stringio'
+require 'fileutils'
+require 'tmpdir'
+
+class ASTJSONVerificationTest < Test::Unit::TestCase
+ def setup
+ @fixtures_dir = File.join(__dir__, '..', '..', 'samples', 'debug-book')
+ @test_files = Dir.glob(File.join(@fixtures_dir, '*.re')).sort
+
+ @tmpdir = Dir.mktmpdir('ast_json_verification')
+ @output_dir = @tmpdir
+
+ ReVIEW::I18n.setup('ja')
+
+ # Initialize Book and Config for real Chapter usage
+ @config = ReVIEW::Configure.values
+ @config['language'] = 'ja'
+ @book = ReVIEW::Book::Base.new(config: @config)
+
+ @test_results = {}
+ end
+
+ def teardown
+ FileUtils.rm_rf(@tmpdir) if @tmpdir && File.exist?(@tmpdir)
+ end
+
+ def test_all_verification_files
+ @test_files.each do |file_path|
+ basename = File.basename(file_path, '.re')
+ content = File.read(file_path)
+ test_file_ast_compatibility(basename, content)
+ end
+ end
+
+ def test_structure_consistency
+ # Test that AST compilation produces consistent JSON structure
+ @test_files.each do |file_path|
+ basename = File.basename(file_path, '.re')
+ content = File.read(file_path)
+
+ ast_json = compile_to_json(content, 'ast')
+ ast_data = JSON.parse(ast_json)
+
+ assert_equal 'DocumentNode', ast_data['type'], "AST mode should create DocumentNode for #{basename}"
+ assert ast_data.key?('children'), "AST mode should have children array for #{basename}"
+
+ next unless content.strip.length > 50 # Arbitrary threshold for non-trivial content
+
+ assert ast_data['children'].any?, "AST mode should have children for non-trivial content in #{basename}"
+ assert_nil(ast_data['error'], "AST compilation should not have errors for #{basename}: #{ast_data['error']}")
+ end
+ end
+
+ def test_element_coverage
+ # Test that all major Re:VIEW elements are properly represented in JSON
+ coverage_test_file = File.join(@fixtures_dir, 'extreme_features.re')
+ content = File.read(coverage_test_file)
+
+ ast_json = compile_to_json(content, 'ast')
+ ast_data = JSON.parse(ast_json)
+
+ element_types = extract_all_element_types(ast_data)
+
+ expected_types = %w[DocumentNode HeadlineNode ParagraphNode CodeBlockNode InlineNode TextNode]
+ # Optional types that may appear depending on content: TableNode ImageNode MinicolumnNode BlockNode
+
+ expected_types.each do |expected_type|
+ assert element_types.include?(expected_type), "Expected element type #{expected_type} not found in AST JSON. Found types: #{element_types.join(', ')}"
+ end
+ end
+
+ def test_inline_element_preservation
+ # Test that inline elements are properly preserved in AST mode
+ inline_test_file = File.join(@fixtures_dir, 'comprehensive.re')
+ content = File.read(inline_test_file)
+
+ ast_json = compile_to_json(content, 'ast')
+ ast_data = JSON.parse(ast_json)
+
+ ast_inline_count = count_element_type(ast_data, 'InlineNode')
+ assert ast_inline_count > 0, "AST mode should preserve inline structure. Found: #{ast_inline_count} inline nodes"
+ assert_nil(ast_data['error'], "AST compilation should not have errors: #{ast_data['error']}")
+ end
+
+ def test_caption_node_usage
+ # Test that captions are represented as CaptionNode objects, not plain strings
+ # This is critical for AST/Renderer architecture
+ test_file = File.join(@fixtures_dir, 'comprehensive.re')
+ content = File.read(test_file)
+
+ ast_json = compile_to_json(content, 'ast')
+ ast_data = JSON.parse(ast_json)
+
+ captioned_nodes = find_nodes_with_captions(ast_data)
+ assert captioned_nodes.any?, 'Should find at least one node with caption'
+
+ captioned_nodes.each do |node|
+ node_type = node['type']
+ assert node.key?('caption_node'), "#{node_type} should have 'caption_node' field"
+
+ caption_node = node['caption_node']
+ assert_not_nil(caption_node, "#{node_type} caption_node should not be nil")
+ assert_equal 'CaptionNode', caption_node['type'], "#{node_type} caption_node should be CaptionNode"
+
+ assert caption_node.key?('children'), 'CaptionNode should have children array'
+ assert caption_node['children'].is_a?(Array), 'CaptionNode children should be an array'
+ end
+ end
+
+ private
+
+ def test_file_ast_compatibility(basename, content)
+ json_output = compile_to_json(content, 'ast')
+ output_file = File.join(@output_dir, "#{basename}_ast.json")
+ File.write(output_file, json_output)
+
+ begin
+ json_data = JSON.parse(json_output)
+ result = {
+ success: true,
+ json_data: json_data,
+ output_file: output_file,
+ size: json_output.length,
+ children_count: json_data['children']&.length || 0,
+ has_error: json_data.key?('error')
+ }
+ rescue JSON::ParserError => e
+ result = {
+ success: false,
+ error: e.message,
+ output_file: output_file
+ }
+ end
+
+ @test_results[basename] = { 'ast' => result }
+
+ assert result[:success], "AST mode failed to produce valid JSON for #{basename}: #{result[:error]}"
+
+ if result[:success]
+ if content.strip.length > 10
+ assert result[:children_count] > 0, "AST mode produced empty content for #{basename}"
+ end
+
+ assert !result[:has_error], "AST compilation had errors for #{basename}: #{result[:json_data]['error']}"
+ end
+ end
+
+ def compile_to_json(content, mode, _config = nil)
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+
+ chapter.generate_indexes
+ @book.generate_indexes
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_result = ast_compiler.compile_to_ast(chapter)
+
+ if ast_result
+ options = ReVIEW::AST::JSONSerializer::Options.new(pretty: true)
+ ReVIEW::AST::JSONSerializer.serialize(ast_result, options)
+ else
+ JSON.pretty_generate({ 'type' => 'DocumentNode', 'children' => [] })
+ end
+ rescue StandardError => e
+ # Return error information in JSON format for debugging
+ JSON.pretty_generate({
+ 'type' => 'DocumentNode',
+ 'children' => [],
+ 'error' => e.message,
+ 'mode' => mode
+ })
+ end
+
+ def extract_all_element_types(data, types = Set.new)
+ if data.is_a?(Hash)
+ types.add(data['type']) if data['type']
+ data.each_value { |value| extract_all_element_types(value, types) }
+ elsif data.is_a?(Array)
+ data.each { |item| extract_all_element_types(item, types) }
+ end
+ types
+ end
+
+ def count_element_type(data, target_type, count = 0)
+ if data.is_a?(Hash)
+ count += 1 if data['type'] == target_type
+ data.each_value { |value| count = count_element_type(value, target_type, count) }
+ elsif data.is_a?(Array)
+ data.each { |item| count = count_element_type(item, target_type, count) }
+ end
+ count
+ end
+
+ def find_nodes_with_captions(data, nodes = [])
+ if data.is_a?(Hash)
+ nodes << data if data.key?('caption_node')
+ data.each_value { |value| find_nodes_with_captions(value, nodes) }
+ elsif data.is_a?(Array)
+ data.each { |item| find_nodes_with_captions(item, nodes) }
+ end
+ nodes
+ end
+end
diff --git a/test/ast/test_ast_line_break_handling.rb b/test/ast/test_ast_line_break_handling.rb
new file mode 100644
index 000000000..cb3a462cc
--- /dev/null
+++ b/test/ast/test_ast_line_break_handling.rb
@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review'
+require 'review/ast'
+require 'review/ast/compiler'
+require 'review/configure'
+require 'review/book'
+require 'review/i18n'
+require 'stringio'
+
+class TestASTLineBreakHandling < Test::Unit::TestCase
+ def setup
+ @config = ReVIEW::Configure.values
+ @config['secnolevel'] = 2
+ @config['language'] = 'ja'
+ @book = ReVIEW::Book::Base.new(config: @config)
+ @log_io = StringIO.new
+ ReVIEW.logger = ReVIEW::Logger.new(@log_io)
+ ReVIEW::I18n.setup(@config['language'])
+ end
+
+ def create_chapter(content)
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new)
+ chapter.content = content
+ chapter
+ end
+
+ def test_single_line_paragraph
+ content = 'これは一行のテストです。'
+ compiler = ReVIEW::AST::Compiler.new
+ ast_root = compiler.compile_to_ast(create_chapter(content))
+
+ # Should have one paragraph with one text node
+ assert_equal 1, ast_root.children.length
+ paragraph = ast_root.children.first
+ assert_instance_of(ReVIEW::AST::ParagraphNode, paragraph)
+
+ assert_equal 1, paragraph.children.length
+ text_node = paragraph.children.first
+ assert_instance_of(ReVIEW::AST::TextNode, text_node)
+ assert_equal 'これは一行のテストです。', text_node.content
+ end
+
+ def test_single_paragraph_with_line_break
+ content = "この文章は改行が含まれています。\nしかし同じ段落のはずです。"
+ compiler = ReVIEW::AST::Compiler.new
+ ast_root = compiler.compile_to_ast(create_chapter(content))
+
+ # Should have one paragraph with one text node
+ assert_equal 1, ast_root.children.length, 'Should have exactly one paragraph'
+ paragraph = ast_root.children.first
+ assert_instance_of(ReVIEW::AST::ParagraphNode, paragraph)
+
+ assert_equal 1, paragraph.children.length, 'Paragraph should have exactly one text node'
+ text_node = paragraph.children.first
+ assert_instance_of(ReVIEW::AST::TextNode, text_node)
+
+ # The key assertion: should preserve single line break, not double
+ expected_content = "この文章は改行が含まれています。\nしかし同じ段落のはずです。"
+ assert_equal expected_content, text_node.content,
+ 'Single line break should be preserved as single line break'
+ end
+
+ def test_two_paragraphs_with_empty_line
+ content = "最初の段落です。\n\n次の段落です。"
+ compiler = ReVIEW::AST::Compiler.new
+ ast_root = compiler.compile_to_ast(create_chapter(content))
+
+ # Should have two paragraphs
+ assert_equal 2, ast_root.children.length, 'Should have exactly two paragraphs'
+
+ # First paragraph
+ paragraph1 = ast_root.children[0]
+ assert_instance_of(ReVIEW::AST::ParagraphNode, paragraph1)
+ assert_equal 1, paragraph1.children.length
+ text1 = paragraph1.children.first
+ assert_instance_of(ReVIEW::AST::TextNode, text1)
+ assert_equal '最初の段落です。', text1.content
+
+ # Second paragraph
+ paragraph2 = ast_root.children[1]
+ assert_instance_of(ReVIEW::AST::ParagraphNode, paragraph2)
+ assert_equal 1, paragraph2.children.length
+ text2 = paragraph2.children.first
+ assert_instance_of(ReVIEW::AST::TextNode, text2)
+ assert_equal '次の段落です。', text2.content
+ end
+
+ def test_multiple_single_line_breaks
+ content = "行1\n行2\n行3"
+ compiler = ReVIEW::AST::Compiler.new
+ ast_root = compiler.compile_to_ast(create_chapter(content))
+
+ # Should have one paragraph
+ assert_equal 1, ast_root.children.length, 'Should have exactly one paragraph'
+ paragraph = ast_root.children.first
+ assert_instance_of(ReVIEW::AST::ParagraphNode, paragraph)
+
+ assert_equal 1, paragraph.children.length
+ text_node = paragraph.children.first
+ assert_instance_of(ReVIEW::AST::TextNode, text_node)
+
+ # Should preserve single line breaks
+ expected_content = "行1\n行2\n行3"
+ assert_equal expected_content, text_node.content,
+ 'Multiple single line breaks should be preserved'
+ end
+
+ def test_mixed_single_and_double_line_breaks
+ content = "段落1の行1\n段落1の行2\n\n段落2の行1\n段落2の行2"
+ compiler = ReVIEW::AST::Compiler.new
+ ast_root = compiler.compile_to_ast(create_chapter(content))
+
+ # Should have two paragraphs
+ assert_equal 2, ast_root.children.length, 'Should have exactly two paragraphs'
+
+ # First paragraph should preserve single line breaks
+ paragraph1 = ast_root.children[0]
+ text1 = paragraph1.children.first
+ assert_equal "段落1の行1\n段落1の行2", text1.content
+
+ # Second paragraph should preserve single line breaks
+ paragraph2 = ast_root.children[1]
+ text2 = paragraph2.children.first
+ assert_equal "段落2の行1\n段落2の行2", text2.content
+ end
+end
diff --git a/test/ast/test_ast_lists.rb b/test/ast/test_ast_lists.rb
new file mode 100644
index 000000000..3ec87f43e
--- /dev/null
+++ b/test/ast/test_ast_lists.rb
@@ -0,0 +1,267 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast'
+require 'review/ast/compiler'
+require 'review/configure'
+require 'review/book'
+require 'review/book/chapter'
+
+class TestASTLists < Test::Unit::TestCase
+ def setup
+ @config = ReVIEW::Configure.values
+ @config['secnolevel'] = 2
+ @config['language'] = 'ja'
+ @book = ReVIEW::Book::Base.new(config: @config)
+ @log_io = StringIO.new
+ ReVIEW.logger = ReVIEW::Logger.new(@log_io)
+ ReVIEW::I18n.setup(@config['language'])
+ end
+
+ def test_unordered_list_ast_processing
+ content = <<~EOB
+ = Chapter Title
+
+ Before list.
+
+ * First item
+ * Second item with @<b>{bold}
+ ** Nested item
+ * Third item
+
+ After list.
+ EOB
+
+ ast_root = compile_to_ast(content)
+ list_node = ast_root.children.find { |n| n.is_a?(ReVIEW::AST::ListNode) }
+ assert_not_nil(list_node, 'Should have list node')
+ assert_equal :ul, list_node.list_type
+
+ assert_equal 3, list_node.children.size
+
+ first_item = list_node.children[0]
+ assert_equal 1, first_item.level
+
+ second_item = list_node.children[1]
+ assert_equal 1, second_item.level
+ bold_node = second_item.children.find { |n| n.is_a?(ReVIEW::AST::InlineNode) && n.inline_type == :b }
+ assert_not_nil(bold_node)
+
+ nested_list = second_item.children.find { |n| n.is_a?(ReVIEW::AST::ListNode) }
+ assert_not_nil(nested_list, 'Second item should have nested list')
+ assert_equal :ul, nested_list.list_type
+ assert_equal 1, nested_list.children.size
+
+ nested_item = nested_list.children[0]
+ assert_equal 2, nested_item.level
+
+ third_item = list_node.children[2]
+ assert_equal 1, third_item.level
+ end
+
+ def test_ordered_list_ast_processing
+ content = <<~EOB
+ Numbered list:
+
+ 1. First item
+ 2. Second item
+ 3. Third item with @<code>{code}
+
+ End of list.
+ EOB
+
+ ast_root = compile_to_ast(content)
+ list_node = ast_root.children.find { |n| n.is_a?(ReVIEW::AST::ListNode) }
+ assert_not_nil(list_node)
+ assert_equal :ol, list_node.list_type
+ assert_equal 3, list_node.children.size
+
+ first_item = list_node.children[0]
+ assert_equal 1, first_item.number
+
+ third_item = list_node.children[2]
+ assert_equal 3, third_item.number
+ code_node = third_item.children.find { |n| n.is_a?(ReVIEW::AST::InlineNode) && n.inline_type == :code }
+ assert_not_nil(code_node)
+ end
+
+ def test_definition_list_ast_processing
+ content = <<~EOB
+ Definition list:
+
+ : Alpha
+ DEC の作っていた RISC CPU。
+ 浮動小数点数演算が速い。
+ : POWER
+ IBM とモトローラが共同製作した RISC CPU。
+ 派生として POWER PC がある。
+
+ After definitions.
+ EOB
+
+ ast_root = compile_to_ast(content)
+ list_node = ast_root.children.find { |n| n.is_a?(ReVIEW::AST::ListNode) }
+ assert_not_nil(list_node)
+ assert_equal :dl, list_node.list_type
+ assert_equal 2, list_node.children.size
+
+ first_def = list_node.children[0]
+ assert_equal 1, first_def.level
+ assert(first_def.children.any?)
+
+ second_def = list_node.children[1]
+ assert_equal 1, second_def.level
+ assert(second_def.children.any?)
+ end
+
+ def test_list_output_compatibility
+ content = <<~EOB
+ Lists test:
+
+ * Unordered item 1
+ * Unordered item with @<b>{bold} text
+
+ 1. Ordered item 1
+ 2. Ordered item 2
+
+ : Term
+ Definition
+
+ End.
+ EOB
+
+ ast_root = compile_to_ast(content)
+ paragraph_nodes = ast_root.children.select { |n| n.is_a?(ReVIEW::AST::ParagraphNode) }
+ list_nodes = ast_root.children.select { |n| n.is_a?(ReVIEW::AST::ListNode) }
+
+ assert_equal 2, paragraph_nodes.size
+ assert_equal 3, list_nodes.size
+
+ ul_node = list_nodes.find { |n| n.list_type == :ul }
+ ol_node = list_nodes.find { |n| n.list_type == :ol }
+ dl_node = list_nodes.find { |n| n.list_type == :dl }
+
+ assert_not_nil(ul_node)
+ assert_not_nil(ol_node)
+ assert_not_nil(dl_node)
+
+ bold_item = ul_node.children.find do |item|
+ item.children.any? { |child| child.is_a?(ReVIEW::AST::InlineNode) && child.inline_type == :b }
+ end
+ assert_not_nil(bold_item)
+ end
+
+ def test_deep_nested_list_ast_processing
+ content = <<~EOB
+ = Deep Nesting Test
+
+ * Level 1 Item A
+ ** Level 2 Item A1
+ *** Level 3 Item A1a
+ *** Level 3 Item A1b
+ ** Level 2 Item A2
+ * Level 1 Item B
+ ** Level 2 Item B1
+ *** Level 3 Item B1a
+ **** Level 4 Item B1a-i
+ **** Level 4 Item B1a-ii
+ *** Level 3 Item B1b
+ ** Level 2 Item B2
+ * Level 1 Item C
+ EOB
+
+ ast_root = compile_to_ast(content)
+ main_list = ast_root.children.find { |n| n.is_a?(ReVIEW::AST::ListNode) }
+ assert_not_nil(main_list, 'Should have main list node')
+ assert_equal :ul, main_list.list_type
+ assert_equal 3, main_list.children.size
+
+ item_a = main_list.children[0]
+ assert_equal 1, item_a.level
+ nested_list_a = item_a.children.find { |n| n.is_a?(ReVIEW::AST::ListNode) }
+ assert_not_nil(nested_list_a, 'Item A should have nested list')
+ assert_equal 2, nested_list_a.children.size
+
+ item_a1 = nested_list_a.children[0]
+ assert_equal 2, item_a1.level
+ nested_list_a1 = item_a1.children.find { |n| n.is_a?(ReVIEW::AST::ListNode) }
+ assert_not_nil(nested_list_a1, 'Item A1 should have nested list')
+ assert_equal 2, nested_list_a1.children.size
+
+ item_a1a = nested_list_a1.children[0]
+ item_a1b = nested_list_a1.children[1]
+ assert_equal 3, item_a1a.level
+ assert_equal 3, item_a1b.level
+
+ item_b = main_list.children[1]
+ assert_equal 1, item_b.level
+ nested_list_b = item_b.children.find { |n| n.is_a?(ReVIEW::AST::ListNode) }
+ assert_not_nil(nested_list_b, 'Item B should have nested list')
+
+ item_b1 = nested_list_b.children[0]
+ nested_list_b1 = item_b1.children.find { |n| n.is_a?(ReVIEW::AST::ListNode) }
+ assert_not_nil(nested_list_b1)
+ item_b1a = nested_list_b1.children[0]
+ nested_list_b1a = item_b1a.children.find { |n| n.is_a?(ReVIEW::AST::ListNode) }
+ assert_not_nil(nested_list_b1a, 'Should have Level 4 nesting')
+ assert_equal 2, nested_list_b1a.children.size
+
+ item_b1a_i = nested_list_b1a.children[0]
+ item_b1a_ii = nested_list_b1a.children[1]
+ assert_equal 4, item_b1a_i.level
+ assert_equal 4, item_b1a_ii.level
+ end
+
+ def test_mixed_nested_ordered_unordered_lists
+ content = <<~EOB
+ = Mixed List Types
+
+ 1. Ordered Item 1
+ 2. Ordered Item 2
+
+ * Unordered Item 1
+ ** Nested unordered
+ *** Deep unordered
+ * Unordered Item 2
+ ** Another nested
+ EOB
+
+ ast_root = compile_to_ast(content)
+ list_nodes = ast_root.children.select { |n| n.is_a?(ReVIEW::AST::ListNode) }
+ assert_operator(list_nodes.size, :>=, 2, 'Should have multiple lists for different types')
+
+ ol_nodes = list_nodes.select { |n| n.list_type == :ol }
+ ul_nodes = list_nodes.select { |n| n.list_type == :ul }
+
+ assert_equal(1, ol_nodes.size, 'Should have one ordered list')
+ assert_equal(1, ul_nodes.size, 'Should have one unordered list')
+
+ first_ol = ol_nodes[0]
+ assert_equal(2, first_ol.children.size, 'Ordered list should have 2 items')
+
+ first_ul = ul_nodes[0]
+ assert_equal(2, first_ul.children.size, 'Unordered list should have 2 top-level items')
+
+ first_ul_item = first_ul.children[0]
+ nested_ul = first_ul_item.children.find { |child| child.is_a?(ReVIEW::AST::ListNode) }
+ assert_not_nil(nested_ul, 'First unordered item should have nested list')
+
+ nested_item = nested_ul.children[0]
+ deep_nested = nested_item.children.find { |child| child.is_a?(ReVIEW::AST::ListNode) }
+ assert_not_nil(deep_nested, 'Should have 3-level nesting')
+ assert_equal(3, deep_nested.children[0].level)
+ end
+
+ private
+
+ def compile_to_ast(content)
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new)
+ chapter.content = content
+
+ @book.generate_indexes
+ chapter.generate_indexes
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_compiler.compile_to_ast(chapter)
+ end
+end
diff --git a/test/ast/test_ast_review_generator.rb b/test/ast/test_ast_review_generator.rb
new file mode 100644
index 000000000..f35a65d52
--- /dev/null
+++ b/test/ast/test_ast_review_generator.rb
@@ -0,0 +1,607 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast'
+require 'review/ast/review_generator'
+require 'review/ast/code_line_node'
+require 'review/ast/table_row_node'
+require 'review/ast/table_cell_node'
+require 'review/ast/reference_node'
+require 'review/ast/footnote_node'
+
+class TestASTReVIEWGenerator < Test::Unit::TestCase
+ def setup
+ @generator = ReVIEW::AST::ReVIEWGenerator.new
+ @location = ReVIEW::SnapshotLocation.new('test.re', 1)
+ end
+
+ def test_empty_document
+ doc = ReVIEW::AST::DocumentNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+ result = @generator.generate(doc)
+ assert_equal '', result
+ end
+
+ def test_headline
+ doc = ReVIEW::AST::DocumentNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+
+ # Create caption node
+ caption_node = ReVIEW::AST::CaptionNode.new(location: @location)
+ caption_node.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Introduction'))
+
+ headline = ReVIEW::AST::HeadlineNode.new(
+ location: @location,
+ level: 2,
+ label: 'intro',
+ caption_node: caption_node
+ )
+ doc.add_child(headline)
+
+ result = @generator.generate(doc)
+ assert_equal "=={intro} Introduction\n\n", result
+ end
+
+ def test_paragraph_with_text
+ doc = ReVIEW::AST::DocumentNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+ para = ReVIEW::AST::ParagraphNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+ para.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'Hello, world!'))
+ doc.add_child(para)
+
+ result = @generator.generate(doc)
+ assert_equal "Hello, world!\n\n", result
+ end
+
+ def test_inline_elements
+ doc = ReVIEW::AST::DocumentNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+ para = ReVIEW::AST::ParagraphNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+
+ para.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'This is '))
+
+ bold = ReVIEW::AST::InlineNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), inline_type: :b)
+ bold.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'bold'))
+ para.add_child(bold)
+
+ para.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: ' text.'))
+ doc.add_child(para)
+
+ result = @generator.generate(doc)
+ assert_equal "This is @<b>{bold} text.\n\n", result
+ end
+
+ def test_code_block_with_id
+ doc = ReVIEW::AST::DocumentNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+
+ # Create caption node
+ caption_node = ReVIEW::AST::CaptionNode.new(location: @location)
+ caption_node.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Hello Example'))
+
+ code = ReVIEW::AST::CodeBlockNode.new(
+ location: @location,
+ id: 'hello',
+ caption_node: caption_node,
+ original_text: "def hello\n puts \"Hello\"\nend",
+ lang: 'ruby'
+ )
+
+ # Add code line nodes
+ ['def hello', ' puts "Hello"', 'end'].each do |line|
+ line_node = ReVIEW::AST::CodeLineNode.new(location: @location)
+ line_node.add_child(ReVIEW::AST::TextNode.new(location: @location, content: line))
+ code.add_child(line_node)
+ end
+
+ doc.add_child(code)
+
+ result = @generator.generate(doc)
+ expected = <<~EOB
+ //list[hello][Hello Example][ruby]{
+ def hello
+ puts "Hello"
+ end
+ //}
+
+ EOB
+ assert_equal expected, result
+ end
+
+ def test_code_block_without_id
+ doc = ReVIEW::AST::DocumentNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+ code = ReVIEW::AST::CodeBlockNode.new(
+ location: @location,
+ original_text: 'echo "Hello"',
+ lang: 'sh'
+ )
+
+ # Add code line node
+ line_node = ReVIEW::AST::CodeLineNode.new(location: @location)
+ line_node.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'echo "Hello"'))
+ code.add_child(line_node)
+
+ doc.add_child(code)
+
+ result = @generator.generate(doc)
+ expected = <<~EOB
+ //emlist[][sh]{
+ echo "Hello"
+ //}
+
+ EOB
+ assert_equal expected, result
+ end
+
+ def test_unordered_list
+ doc = ReVIEW::AST::DocumentNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+ list = ReVIEW::AST::ListNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), list_type: :ul)
+
+ item1 = ReVIEW::AST::ListItemNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), level: 1)
+ item1.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'First item'))
+ list.add_child(item1)
+
+ item2 = ReVIEW::AST::ListItemNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), level: 1)
+ item2.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'Second item'))
+ list.add_child(item2)
+
+ doc.add_child(list)
+
+ result = @generator.generate(doc)
+ expected = " * First item\n * Second item\n\n"
+ assert_equal expected, result
+ end
+
+ def test_table
+ doc = ReVIEW::AST::DocumentNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+
+ # Create caption node
+ caption_node = ReVIEW::AST::CaptionNode.new(location: @location)
+ caption_node.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Sample Table'))
+
+ table = ReVIEW::AST::TableNode.new(
+ location: @location,
+ id: 'sample',
+ caption_node: caption_node
+ )
+
+ # Add header row
+ header_row = ReVIEW::AST::TableRowNode.new(location: @location, row_type: :header)
+ ['Name', 'Age'].each do |cell_content|
+ cell = ReVIEW::AST::TableCellNode.new(location: @location, cell_type: :th)
+ cell.add_child(ReVIEW::AST::TextNode.new(location: @location, content: cell_content))
+ header_row.add_child(cell)
+ end
+ table.add_header_row(header_row)
+
+ # Add body rows
+ [['Alice', '25'], ['Bob', '30']].each do |row_data|
+ body_row = ReVIEW::AST::TableRowNode.new(location: @location, row_type: :body)
+ row_data.each_with_index do |cell_content, index|
+ # First cell in body rows is typically a header (row header)
+ cell_type = index == 0 ? :th : :td
+ cell = ReVIEW::AST::TableCellNode.new(location: @location, cell_type: cell_type)
+ cell.add_child(ReVIEW::AST::TextNode.new(location: @location, content: cell_content))
+ body_row.add_child(cell)
+ end
+ table.add_body_row(body_row)
+ end
+
+ doc.add_child(table)
+
+ result = @generator.generate(doc)
+ expected = <<~EOB
+ //table[sample][Sample Table]{
+ Name Age
+ ------------
+ Alice 25
+ Bob 30
+ //}
+
+ EOB
+ assert_equal expected, result
+ end
+
+ def test_image
+ doc = ReVIEW::AST::DocumentNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+
+ # Create caption node
+ caption_node = ReVIEW::AST::CaptionNode.new(location: @location)
+ caption_node.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Sample Figure'))
+
+ image = ReVIEW::AST::ImageNode.new(
+ location: @location,
+ id: 'figure1',
+ caption_node: caption_node
+ )
+ doc.add_child(image)
+
+ result = @generator.generate(doc)
+ assert_equal "//image[figure1][Sample Figure]\n\n", result
+ end
+
+ def test_minicolumn
+ doc = ReVIEW::AST::DocumentNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+
+ # Create caption node
+ caption_node = ReVIEW::AST::CaptionNode.new(location: @location)
+ caption_node.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Important Note'))
+
+ minicolumn = ReVIEW::AST::MinicolumnNode.new(
+ location: @location,
+ minicolumn_type: :note,
+ caption_node: caption_node
+ )
+ para = ReVIEW::AST::ParagraphNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+ para.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'This is a note.'))
+ minicolumn.add_child(para)
+ doc.add_child(minicolumn)
+
+ result = @generator.generate(doc)
+ expected = <<~EOB
+ //note[Important Note]{
+ This is a note.
+
+ //}
+
+ EOB
+ assert_equal expected, result
+ end
+
+ def test_complex_document
+ doc = ReVIEW::AST::DocumentNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+
+ # Headline with caption
+ h1_caption = ReVIEW::AST::CaptionNode.new(location: @location)
+ h1_caption.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Chapter 1'))
+
+ h1 = ReVIEW::AST::HeadlineNode.new(location: @location, level: 1, caption_node: h1_caption)
+ doc.add_child(h1)
+
+ # Paragraph with inline
+ para = ReVIEW::AST::ParagraphNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+ para.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'This is '))
+ code_inline = ReVIEW::AST::InlineNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), inline_type: :code)
+ code_inline.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'inline code'))
+ para.add_child(code_inline)
+ para.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: '.'))
+ h1.add_child(para)
+
+ # Code block
+ code = ReVIEW::AST::CodeBlockNode.new(
+ location: @location,
+ id: 'example',
+ original_text: 'puts "Hello, Re:VIEW!"'
+ )
+
+ # Add code line node
+ line_node = ReVIEW::AST::CodeLineNode.new(location: @location)
+ line_node.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'puts "Hello, Re:VIEW!"'))
+ code.add_child(line_node)
+
+ h1.add_child(code)
+
+ result = @generator.generate(doc)
+ expected = <<~EOB
+ = Chapter 1
+
+ This is @<code>{inline code}.
+
+ //list[example]{
+ puts "Hello, Re:VIEW!"
+ //}
+
+ EOB
+ assert_equal expected, result
+ end
+
+ def test_inline_with_args
+ doc = ReVIEW::AST::DocumentNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+ para = ReVIEW::AST::ParagraphNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+
+ # href with URL
+ href = ReVIEW::AST::InlineNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), inline_type: :href, args: ['https://example.com'])
+ para.add_child(href)
+
+ doc.add_child(para)
+
+ result = @generator.generate(doc)
+ assert_equal "@<href>{https://example.com}\n\n", result
+ end
+
+ def test_ordered_list
+ doc = ReVIEW::AST::DocumentNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+ list = ReVIEW::AST::ListNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), list_type: :ol)
+
+ item1 = ReVIEW::AST::ListItemNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), level: 1, number: 1)
+ item1.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'First'))
+ list.add_child(item1)
+
+ item2 = ReVIEW::AST::ListItemNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), level: 1, number: 2)
+ item2.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'Second'))
+ list.add_child(item2)
+
+ doc.add_child(list)
+
+ result = @generator.generate(doc)
+ expected = " 1. First\n 2. Second\n\n"
+ assert_equal expected, result
+ end
+
+ def test_definition_list
+ doc = ReVIEW::AST::DocumentNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+ list = ReVIEW::AST::ListNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), list_type: :dl)
+
+ item = ReVIEW::AST::ListItemNode.new(
+ location: ReVIEW::SnapshotLocation.new(nil, 0),
+ level: 1,
+ term_children: [ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'Term')]
+ )
+ item.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'Definition of the term'))
+ list.add_child(item)
+
+ doc.add_child(list)
+
+ result = @generator.generate(doc)
+ expected = <<~EOB
+ : Term
+ Definition of the term
+
+ EOB
+ assert_equal expected, result
+ end
+
+ def test_empty_paragraph_skipped
+ doc = ReVIEW::AST::DocumentNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+
+ # Non-empty paragraph
+ para1 = ReVIEW::AST::ParagraphNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+ para1.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'Content'))
+ doc.add_child(para1)
+
+ # Empty paragraph (should be skipped)
+ para2 = ReVIEW::AST::ParagraphNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+ doc.add_child(para2)
+
+ # Another non-empty paragraph
+ para3 = ReVIEW::AST::ParagraphNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+ para3.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'More content'))
+ doc.add_child(para3)
+
+ result = @generator.generate(doc)
+ expected = <<~EOB
+ Content
+
+ More content
+
+ EOB
+ assert_equal expected, result
+ end
+
+ def test_nested_unordered_list
+ doc = ReVIEW::AST::DocumentNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+ list = ReVIEW::AST::ListNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), list_type: :ul)
+
+ # First item with nested list
+ item1 = ReVIEW::AST::ListItemNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), level: 1)
+ item1.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'Item 1'))
+
+ # Nested list
+ nested_list = ReVIEW::AST::ListNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), list_type: :ul)
+ nested_item1 = ReVIEW::AST::ListItemNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), level: 2)
+ nested_item1.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'Nested 1'))
+ nested_list.add_child(nested_item1)
+
+ nested_item2 = ReVIEW::AST::ListItemNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), level: 2)
+ nested_item2.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'Nested 2'))
+ nested_list.add_child(nested_item2)
+
+ item1.add_child(nested_list)
+ list.add_child(item1)
+
+ # Second top-level item
+ item2 = ReVIEW::AST::ListItemNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), level: 1)
+ item2.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'Item 2'))
+ list.add_child(item2)
+
+ doc.add_child(list)
+
+ result = @generator.generate(doc)
+ expected = " * Item 1\n ** Nested 1\n ** Nested 2\n * Item 2\n\n"
+ assert_equal expected, result
+ end
+
+ def test_nested_ordered_list
+ doc = ReVIEW::AST::DocumentNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+ list = ReVIEW::AST::ListNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), list_type: :ol)
+
+ # First item with nested list
+ item1 = ReVIEW::AST::ListItemNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), level: 1, number: 1)
+ item1.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'First'))
+
+ # Nested ordered list
+ nested_list = ReVIEW::AST::ListNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), list_type: :ol)
+ nested_item1 = ReVIEW::AST::ListItemNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), level: 2, number: 1)
+ nested_item1.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'Nested First'))
+ nested_list.add_child(nested_item1)
+
+ item1.add_child(nested_list)
+ list.add_child(item1)
+
+ # Second top-level item
+ item2 = ReVIEW::AST::ListItemNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), level: 1, number: 2)
+ item2.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'Second'))
+ list.add_child(item2)
+
+ doc.add_child(list)
+
+ result = @generator.generate(doc)
+ expected = " 1. First\n 1. Nested First\n 2. Second\n\n"
+ assert_equal expected, result
+ end
+
+ def test_reference_node
+ doc = ReVIEW::AST::DocumentNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+ para = ReVIEW::AST::ParagraphNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+
+ # ReferenceNode is typically a child of InlineNode, but can also be standalone
+ reference = ReVIEW::AST::ReferenceNode.new('fig1', nil, location: @location)
+ para.add_child(reference)
+
+ doc.add_child(para)
+
+ result = @generator.generate(doc)
+ # ReferenceNode should output its content (the ref_id)
+ assert_equal "fig1\n\n", result
+ end
+
+ def test_footnote_node
+ doc = ReVIEW::AST::DocumentNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+
+ # FootnoteNode with content
+ footnote = ReVIEW::AST::FootnoteNode.new(location: @location, id: 'note1')
+ footnote.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'This is a footnote'))
+
+ doc.add_child(footnote)
+
+ result = @generator.generate(doc)
+ # FootnoteNode should be rendered as //footnote[id][content]
+ assert_equal "//footnote[note1][This is a footnote]\n\n", result
+ end
+
+ # Edge case tests
+ def test_empty_list
+ doc = ReVIEW::AST::DocumentNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+ list = ReVIEW::AST::ListNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), list_type: :ul)
+ doc.add_child(list)
+
+ result = @generator.generate(doc)
+ # Empty list should produce empty string
+ assert_equal '', result
+ end
+
+ def test_multiple_inline_elements
+ doc = ReVIEW::AST::DocumentNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+ para = ReVIEW::AST::ParagraphNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+
+ para.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'Text with '))
+
+ bold = ReVIEW::AST::InlineNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), inline_type: :b)
+ bold.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'bold'))
+ para.add_child(bold)
+
+ para.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: ' and '))
+
+ italic = ReVIEW::AST::InlineNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), inline_type: :i)
+ italic.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'italic'))
+ para.add_child(italic)
+
+ para.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: ' and '))
+
+ code = ReVIEW::AST::InlineNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), inline_type: :code)
+ code.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'code'))
+ para.add_child(code)
+
+ para.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: '.'))
+
+ doc.add_child(para)
+
+ result = @generator.generate(doc)
+ assert_equal "Text with @<b>{bold} and @<i>{italic} and @<code>{code}.\n\n", result
+ end
+
+ def test_deeply_nested_list
+ doc = ReVIEW::AST::DocumentNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+ list = ReVIEW::AST::ListNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), list_type: :ul)
+
+ # Level 1
+ item1 = ReVIEW::AST::ListItemNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), level: 1)
+ item1.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'Level 1'))
+
+ # Level 2
+ list2 = ReVIEW::AST::ListNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), list_type: :ul)
+ item2 = ReVIEW::AST::ListItemNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), level: 2)
+ item2.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'Level 2'))
+
+ # Level 3
+ list3 = ReVIEW::AST::ListNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), list_type: :ul)
+ item3 = ReVIEW::AST::ListItemNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), level: 3)
+ item3.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'Level 3'))
+ list3.add_child(item3)
+
+ item2.add_child(list3)
+ list2.add_child(item2)
+ item1.add_child(list2)
+ list.add_child(item1)
+ doc.add_child(list)
+
+ result = @generator.generate(doc)
+ assert_equal " * Level 1\n ** Level 2\n *** Level 3\n\n", result
+ end
+
+ def test_code_block_without_original_text
+ doc = ReVIEW::AST::DocumentNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+
+ # CodeBlockNode without original_text (reconstructed from AST)
+ code = ReVIEW::AST::CodeBlockNode.new(
+ location: @location,
+ id: 'sample',
+ lang: 'ruby'
+ )
+
+ # Add code line nodes
+ ['line 1', 'line 2', 'line 3'].each do |line|
+ line_node = ReVIEW::AST::CodeLineNode.new(location: @location)
+ line_node.add_child(ReVIEW::AST::TextNode.new(location: @location, content: line))
+ code.add_child(line_node)
+ end
+
+ doc.add_child(code)
+
+ result = @generator.generate(doc)
+ expected = <<~EOB
+ //list[sample][][ruby]{
+ line 1
+ line 2
+ line 3
+ //}
+
+ EOB
+ assert_equal expected, result
+ end
+
+ def test_image_with_metric
+ doc = ReVIEW::AST::DocumentNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+
+ caption_node = ReVIEW::AST::CaptionNode.new(location: @location)
+ caption_node.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Scaled Image'))
+
+ image = ReVIEW::AST::ImageNode.new(
+ location: @location,
+ id: 'figure1',
+ caption_node: caption_node,
+ metric: 'scale=0.5'
+ )
+ doc.add_child(image)
+
+ result = @generator.generate(doc)
+ assert_equal "//image[figure1][Scaled Image][scale=0.5]\n\n", result
+ end
+
+ def test_column
+ doc = ReVIEW::AST::DocumentNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+
+ caption_node = ReVIEW::AST::CaptionNode.new(location: @location)
+ caption_node.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Column Title'))
+
+ column = ReVIEW::AST::ColumnNode.new(
+ location: @location,
+ level: 2,
+ caption_node: caption_node
+ )
+
+ para = ReVIEW::AST::ParagraphNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0))
+ para.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'Column content.'))
+ column.add_child(para)
+
+ doc.add_child(column)
+
+ result = @generator.generate(doc)
+ assert_equal "==[column] Column Title\n\nColumn content.\n\n==[/column]\n\n", result
+ end
+end
diff --git a/test/ast/test_ast_structure_debug.rb b/test/ast/test_ast_structure_debug.rb
new file mode 100644
index 000000000..3fd86b6c2
--- /dev/null
+++ b/test/ast/test_ast_structure_debug.rb
@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+# Debug test to understand AST structure issues with inline elements
+
+require_relative '../test_helper'
+require 'review/ast/compiler'
+require 'review/ast/json_serializer'
+require 'review/book'
+require 'review/book/chapter'
+require 'json'
+
+class TestASTStructureDebug < Test::Unit::TestCase
+ def setup
+ @config = ReVIEW::Configure.values
+ @config['secnolevel'] = 2
+ @config['language'] = 'ja'
+ @book = ReVIEW::Book::Base.new(config: @config)
+
+ @log_io = StringIO.new
+ ReVIEW.logger = ReVIEW::Logger.new(@log_io)
+
+ @chapter = ReVIEW::Book::Chapter.new(@book, 1, 'debug_chapter', 'debug_chapter.re', StringIO.new)
+ ReVIEW::I18n.setup(@config['language'])
+ end
+
+ def test_minicolumn_ast_structure
+ source = <<~EOS
+ = Chapter Title
+
+ //note[Note Caption]{
+ This is a note with @<fn>{footnote1}.
+ //}
+
+ //footnote[footnote1][Footnote in note]
+ EOS
+
+ @chapter.content = source
+
+ # Build AST without builder rendering
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(@chapter)
+
+ # Serialize AST to examine structure
+ json_str = ReVIEW::AST::JSONSerializer.serialize(ast_root)
+ ast = JSON.parse(json_str)
+
+ # Find minicolumn node
+ minicolumn = ast['children'].find { |node| node['type'] == 'MinicolumnNode' }
+ assert_not_nil(minicolumn)
+
+ # Check if inline elements are properly parsed
+ has_inline_node = minicolumn['children'].any? do |child|
+ child['type'] == 'InlineNode' ||
+ (child['children'] && child['children'].any? { |grandchild| grandchild['type'] == 'InlineNode' })
+ end
+
+ assert_true(has_inline_node, 'Minicolumn should contain inline elements')
+ end
+
+ def test_table_ast_structure
+ source = <<~EOS
+ = Chapter Title
+
+ //table[test-table][Test Table]{
+ Header @<b>{Bold} Normal Header
+ ------------
+ Cell with @<fn>{table-fn} Normal Cell
+ //}
+
+ //footnote[table-fn][Footnote in table]
+ EOS
+
+ @chapter.content = source
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(@chapter)
+
+ # Serialize AST to examine structure
+ json_str = ReVIEW::AST::JSONSerializer.serialize(ast_root)
+ ast = JSON.parse(json_str)
+
+ # Find table node
+ table = ast['children'].find { |node| node['type'] == 'TableNode' }
+ assert_not_nil(table)
+
+ # Check actual table structure (header_rows vs headers)
+ table.keys.grep(/header|row/)
+
+ # Verify table structure has header_rows and body_rows (correct AST structure)
+ assert_not_nil(table['header_rows'] || table['headers'])
+ assert_not_nil(table['body_rows'] || table['rows'])
+
+ # Check for inline elements in table cells using correct structure
+ headers = table['header_rows'] || table['headers'] || []
+ rows = table['body_rows'] || table['rows'] || []
+
+ headers.any? do |header|
+ header['children']&.any? { |cell| cell['type'] == 'InlineNode' }
+ end
+
+ rows.any? do |row|
+ row['children']&.any? { |cell| cell['type'] == 'InlineNode' }
+ end
+
+ # Table should have structure and may contain inline elements
+ assert_true(headers.any? || rows.any?, 'Table should have headers or rows')
+ # NOTE: Inline element check is optional as it depends on content
+ end
+
+ def test_paragraph_ast_structure
+ source = <<~EOS
+ = Chapter Title
+
+ This is a paragraph with @<fn>{footnote1} and @<b>{bold text}.
+
+ //footnote[footnote1][Paragraph footnote]
+ EOS
+
+ @chapter.content = source
+
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(@chapter)
+
+ # Serialize AST to examine structure
+ json_str = ReVIEW::AST::JSONSerializer.serialize(ast_root)
+ ast = JSON.parse(json_str)
+
+ # Find paragraph node
+ paragraph = ast['children'].find { |node| node['type'] == 'ParagraphNode' }
+ assert_not_nil(paragraph)
+
+ # Verify paragraph contains inline elements
+ has_inline_elements = paragraph['children'].any? { |child| child['type'] == 'InlineNode' }
+ assert_true(has_inline_elements, 'Paragraph should contain inline elements')
+
+ # Verify specific inline elements exist
+ inline_types = paragraph['children'].select { |child| child['type'] == 'InlineNode' }.map { |node| node['inline_type'] }
+ assert_includes(inline_types, 'fn', 'Should contain footnote inline element')
+ assert_includes(inline_types, 'b', 'Should contain bold inline element')
+ end
+end
diff --git a/test/ast/test_auto_id_generation.rb b/test/ast/test_auto_id_generation.rb
new file mode 100644
index 000000000..9d9ec997d
--- /dev/null
+++ b/test/ast/test_auto_id_generation.rb
@@ -0,0 +1,275 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast/compiler'
+require 'review/renderer/html_renderer'
+require 'review/book'
+require 'stringio'
+
+class TestAutoIdGeneration < Test::Unit::TestCase
+ def setup
+ @book = ReVIEW::Book::Base.new(config: ReVIEW::Configure.values)
+ @config = @book.config
+ @compiler = ReVIEW::AST::Compiler.new
+
+ ReVIEW::I18n.setup(@config['language'])
+ end
+
+ def test_nonum_headline_auto_id_generation
+ content = <<~REVIEW
+ = Chapter
+
+ ===[nonum] First Unnumbered
+ ===[nonum] Second Unnumbered
+ REVIEW
+
+ chapter = create_chapter(content)
+ ast_root = @compiler.compile_to_ast(chapter)
+
+ # Find nonum headlines
+ headlines = find_all_nodes(ast_root, ReVIEW::AST::HeadlineNode)
+ nonum_headlines = headlines.select(&:nonum?)
+
+ assert_equal 2, nonum_headlines.size, 'Should have 2 nonum headlines'
+
+ # Verify auto_id is generated for both
+ assert_not_nil(nonum_headlines[0].auto_id, 'First nonum should have auto_id')
+ assert_not_nil(nonum_headlines[1].auto_id, 'Second nonum should have auto_id')
+
+ # Verify auto_id format: chapter_name_nonumN
+ assert_match(/^test_nonum\d+$/, nonum_headlines[0].auto_id, 'First auto_id should match format')
+ assert_match(/^test_nonum\d+$/, nonum_headlines[1].auto_id, 'Second auto_id should match format')
+
+ # Verify auto_ids are different (sequential)
+ assert_not_equal(nonum_headlines[0].auto_id, nonum_headlines[1].auto_id,
+ 'Each nonum headline should have unique auto_id')
+ end
+
+ def test_notoc_headline_auto_id_generation
+ content = <<~REVIEW
+ = Chapter
+
+ ===[notoc] First NotInTOC
+ ===[notoc] Second NotInTOC
+ REVIEW
+
+ chapter = create_chapter(content)
+ ast_root = @compiler.compile_to_ast(chapter)
+
+ headlines = find_all_nodes(ast_root, ReVIEW::AST::HeadlineNode)
+ notoc_headlines = headlines.select(&:notoc?)
+
+ assert_equal 2, notoc_headlines.size
+ assert_not_nil(notoc_headlines[0].auto_id)
+ assert_not_nil(notoc_headlines[1].auto_id)
+ assert_not_equal(notoc_headlines[0].auto_id, notoc_headlines[1].auto_id)
+ end
+
+ def test_nodisp_headline_auto_id_generation
+ content = <<~REVIEW
+ = Chapter
+
+ ===[nodisp] Hidden Section
+ REVIEW
+
+ chapter = create_chapter(content)
+ ast_root = @compiler.compile_to_ast(chapter)
+
+ headlines = find_all_nodes(ast_root, ReVIEW::AST::HeadlineNode)
+ nodisp_headline = headlines.find(&:nodisp?)
+
+ assert_not_nil(nodisp_headline, 'Should find nodisp headline')
+ assert_not_nil(nodisp_headline.auto_id, 'Nodisp headline should have auto_id')
+ assert_match(/^test_nonum\d+$/, nodisp_headline.auto_id)
+ end
+
+ def test_headline_with_label_no_auto_id
+ content = <<~REVIEW
+ = Chapter
+
+ ===[nonum]{custom-label} Labeled Headline
+ REVIEW
+
+ chapter = create_chapter(content)
+ ast_root = @compiler.compile_to_ast(chapter)
+
+ headlines = find_all_nodes(ast_root, ReVIEW::AST::HeadlineNode)
+ labeled_headline = headlines.find { |h| h.label == 'custom-label' }
+
+ assert_not_nil(labeled_headline, 'Should find labeled headline')
+ # When label is provided, auto_id should still be nil (not needed)
+ assert_nil(labeled_headline.auto_id, 'Labeled headline should not have auto_id')
+ end
+
+ def test_mixed_nonum_headlines_sequential_numbering
+ content = <<~REVIEW
+ = Chapter
+
+ ===[nonum] First
+ === Regular Section
+ ===[nonum] Second
+ ===[notoc] Third
+ REVIEW
+
+ chapter = create_chapter(content)
+ ast_root = @compiler.compile_to_ast(chapter)
+
+ headlines = find_all_nodes(ast_root, ReVIEW::AST::HeadlineNode)
+ special_headlines = headlines.select { |h| h.nonum? || h.notoc? || h.nodisp? }
+
+ # All special headlines should have auto_id
+ assert_equal 3, special_headlines.size
+ special_headlines.each do |h|
+ assert_not_nil(h.auto_id, "Headline '#{h.caption_text}' should have auto_id")
+ end
+
+ # Extract numbers from auto_ids
+ numbers = special_headlines.map { |h| h.auto_id.match(/\d+$/)[0].to_i }
+
+ # Numbers should be sequential (1, 2, 3)
+ assert_equal [1, 2, 3], numbers, 'Auto_id numbers should be sequential'
+ end
+
+ def test_column_auto_id_generation
+ content = <<~REVIEW
+ = Chapter
+
+ ===[column] First Column
+
+ Content
+
+ ===[/column]
+
+ ===[column] Second Column
+
+ Content
+
+ ===[/column]
+ REVIEW
+
+ chapter = create_chapter(content)
+ ast_root = @compiler.compile_to_ast(chapter)
+
+ columns = find_all_nodes(ast_root, ReVIEW::AST::ColumnNode)
+
+ assert_equal 2, columns.size, 'Should have 2 columns'
+
+ # Verify auto_id is generated for both
+ assert_not_nil(columns[0].auto_id, 'First column should have auto_id')
+ assert_not_nil(columns[1].auto_id, 'Second column should have auto_id')
+
+ # Verify auto_id format: column-N
+ assert_equal 'column-1', columns[0].auto_id, 'First column auto_id should be column-1'
+ assert_equal 'column-2', columns[1].auto_id, 'Second column auto_id should be column-2'
+ end
+
+ def test_column_with_label_still_has_auto_id
+ content = <<~REVIEW
+ = Chapter
+
+ ===[column]{custom-col} Labeled Column
+
+ Content
+
+ ===[/column]
+ REVIEW
+
+ chapter = create_chapter(content)
+ ast_root = @compiler.compile_to_ast(chapter)
+
+ columns = find_all_nodes(ast_root, ReVIEW::AST::ColumnNode)
+ column = columns.first
+
+ assert_not_nil(column, 'Should find column')
+ assert_equal 'custom-col', column.label, 'Column should have label'
+ # Columns ALWAYS get auto_id (used for anchor in HTML)
+ assert_equal 'column-1', column.auto_id, 'Column should have auto_id even with label'
+ end
+
+ def test_html_renderer_uses_auto_id_for_nonum
+ content = <<~REVIEW
+ = Chapter
+
+ ===[nonum] Unnumbered Section
+
+ Content here.
+ REVIEW
+
+ chapter = create_chapter(content)
+ chapter.generate_indexes
+ @book.generate_indexes
+
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html = renderer.render_body(ast_root)
+
+ # HTML should contain h3 with auto_id
+ assert_match(/<h3 id="test_nonum1">/, html, 'Should use auto_id in HTML id attribute')
+ end
+
+ def test_html_renderer_uses_auto_id_for_column
+ content = <<~REVIEW
+ = Chapter
+
+ ===[column] Test Column
+
+ Column content.
+
+ ===[/column]
+ REVIEW
+
+ chapter = create_chapter(content)
+ chapter.generate_indexes
+ @book.generate_indexes
+
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html = renderer.render_body(ast_root)
+
+ # HTML should contain anchor with auto_id
+ assert_match(/<a id="column-1">/, html, 'Should use auto_id in column anchor')
+ end
+
+ def test_html_renderer_multiple_nonum_unique_ids
+ content = <<~REVIEW
+ = Chapter
+
+ ===[nonum] First
+
+ ===[nonum] Second
+
+ ===[nonum] Third
+ REVIEW
+
+ chapter = create_chapter(content)
+ chapter.generate_indexes
+ @book.generate_indexes
+
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html = renderer.render_body(ast_root)
+
+ # Each should have unique ID
+ assert_match(/<h3 id="test_nonum1">/, html)
+ assert_match(/<h3 id="test_nonum2">/, html)
+ assert_match(/<h3 id="test_nonum3">/, html)
+
+ # Verify no duplicate IDs
+ id_matches = html.scan(/id="test_nonum\d+"/)
+ assert_equal 3, id_matches.size
+ assert_equal 3, id_matches.uniq.size, 'All IDs should be unique'
+ end
+
+ private
+
+ def create_chapter(content)
+ ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ end
+
+ # Recursively find all nodes of a specific type in the AST
+ def find_all_nodes(node, node_class, results = [])
+ results << node if node.is_a?(node_class)
+ node.children.each { |child| find_all_nodes(child, node_class, results) } if node.respond_to?(:children)
+ results
+ end
+end
diff --git a/test/ast/test_block_data.rb b/test/ast/test_block_data.rb
new file mode 100644
index 000000000..747031046
--- /dev/null
+++ b/test/ast/test_block_data.rb
@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast/block_data'
+require 'review/snapshot_location'
+
+class TestBlockData < Test::Unit::TestCase
+ include ReVIEW::AST
+
+ def setup
+ @location = ReVIEW::SnapshotLocation.new('test.re', 42)
+ end
+
+ def test_basic_initialization
+ block_data = BlockData.new(name: :list, args: ['id', 'caption'], location: @location)
+
+ assert_equal :list, block_data.name
+ assert_equal ['id', 'caption'], block_data.args
+ assert_equal [], block_data.lines
+ assert_equal [], block_data.nested_blocks
+ assert_equal @location, block_data.location
+ end
+
+ def test_initialization_with_all_parameters
+ nested_block = BlockData.new(name: :note, args: ['warning'], location: @location)
+
+ block_data = BlockData.new(
+ name: :minicolumn,
+ args: ['title'],
+ lines: ['content line 1', 'content line 2'],
+ nested_blocks: [nested_block],
+ location: @location
+ )
+
+ assert_equal :minicolumn, block_data.name
+ assert_equal ['title'], block_data.args
+ assert_equal ['content line 1', 'content line 2'], block_data.lines
+ assert_equal 1, block_data.nested_blocks.size
+ assert_equal nested_block, block_data.nested_blocks.first
+ assert_equal @location, block_data.location
+ end
+
+ def test_nested_blocks
+ block_data = BlockData.new(name: :list, location: @location)
+ assert_false(block_data.nested_blocks?)
+
+ nested_block = BlockData.new(name: :note, location: @location)
+ block_data_with_nested = BlockData.new(
+ name: :minicolumn,
+ nested_blocks: [nested_block],
+ location: @location
+ )
+ assert_true(block_data_with_nested.nested_blocks?)
+ end
+
+ def test_line_count
+ block_data = BlockData.new(name: :list, location: @location)
+ assert_equal 0, block_data.line_count
+
+ block_data_with_lines = BlockData.new(
+ name: :list,
+ lines: ['line1', 'line2', 'line3'],
+ location: @location
+ )
+ assert_equal 3, block_data_with_lines.line_count
+ end
+
+ def test_content
+ block_data = BlockData.new(name: :list, location: @location)
+ assert_false(block_data.content?)
+
+ block_data_with_content = BlockData.new(
+ name: :list,
+ lines: ['content'],
+ location: @location
+ )
+ assert_true(block_data_with_content.content?)
+ end
+
+ def test_arg_method
+ block_data = BlockData.new(
+ name: :list,
+ args: ['id', 'caption', 'lang'],
+ location: @location
+ )
+
+ assert_equal 'id', block_data.arg(0)
+ assert_equal 'caption', block_data.arg(1)
+ assert_equal 'lang', block_data.arg(2)
+
+ assert_nil(block_data.arg(3))
+ assert_nil(block_data.arg(-1))
+ assert_nil(block_data.arg(nil))
+ end
+
+ def test_arg_method_with_no_args
+ block_data = BlockData.new(name: :list, location: @location)
+ assert_nil(block_data.arg(0))
+ end
+
+ def test_inspect
+ block_data = BlockData.new(
+ name: :list,
+ args: ['id', 'caption'],
+ lines: ['line1', 'line2'],
+ nested_blocks: [BlockData.new(name: :note, location: @location)],
+ location: @location
+ )
+
+ inspect_str = block_data.inspect
+ assert_include(inspect_str, 'BlockData')
+ assert_include(inspect_str, 'name=list')
+ assert_include(inspect_str, 'args=["id", "caption"]')
+ assert_include(inspect_str, 'lines=2')
+ assert_include(inspect_str, 'nested=1')
+ end
+end
diff --git a/test/ast/test_block_processor_error_messages.rb b/test/ast/test_block_processor_error_messages.rb
new file mode 100644
index 000000000..a12da63d3
--- /dev/null
+++ b/test/ast/test_block_processor_error_messages.rb
@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast/compiler'
+require 'review/configure'
+require 'review/book'
+require 'review/i18n'
+
+class TestBlockProcessorErrorMessages < Test::Unit::TestCase
+ def setup
+ @config = ReVIEW::Configure.values
+ @config['language'] = 'ja'
+ @book = ReVIEW::Book::Base.new(config: @config)
+ @log_io = StringIO.new
+ ReVIEW.logger = ReVIEW::Logger.new(@log_io)
+ ReVIEW::I18n.setup(@config['language'])
+ end
+
+ def test_unknown_block_command_error_message
+ content = "= Chapter\n\n//unknown_command{\ncontent\n//}"
+
+ chapter = ReVIEW::Book::Chapter.new(
+ @book,
+ 1,
+ 'test',
+ 'sample.re',
+ StringIO.new(content)
+ )
+
+ error = assert_raises(ReVIEW::CompileError) do
+ compiler = ReVIEW::AST::Compiler.for_chapter(chapter)
+ compiler.compile_to_ast(chapter)
+ end
+
+ # Verify error message contains expected information
+ assert_match(%r{Unknown block command: //unknown}, error.message)
+ assert_match(/at line 3/, error.message)
+ assert_match(/in sample\.re/, error.message)
+ end
+
+ def test_invalid_table_row_error_message
+ content = "= Chapter\n\n//table[id][caption]{\n\n//}"
+
+ chapter = ReVIEW::Book::Chapter.new(
+ @book,
+ 1,
+ 'test',
+ 'table_test.re',
+ StringIO.new(content)
+ )
+
+ error = assert_raises(ReVIEW::CompileError) do
+ compiler = ReVIEW::AST::Compiler.for_chapter(chapter)
+ compiler.compile_to_ast(chapter)
+ end
+
+ # Verify error message contains expected information
+ assert_match(/Invalid table row: empty line or no tab-separated cells/, error.message)
+ assert_match(/at line 3/, error.message)
+ assert_match(/in table_test\.re/, error.message)
+ end
+
+ # NOTE: The unknown code block type test is harder to trigger in practice
+ # since CODE_BLOCK_CONFIGS covers most common types, and it would require
+ # internal method access that changes based on implementation details.
+
+ def test_error_message_formatting
+ content = "= Chapter\n\n//invalid_block{\ncontent\n//}"
+
+ chapter = ReVIEW::Book::Chapter.new(
+ @book,
+ 1,
+ 'test',
+ 'format_test.re',
+ StringIO.new(content)
+ )
+
+ error = assert_raises(ReVIEW::CompileError) do
+ compiler = ReVIEW::AST::Compiler.for_chapter(chapter)
+ compiler.compile_to_ast(chapter)
+ end
+
+ # Test the general format of location info
+ assert_match(/at line 3/, error.message)
+ assert_match(/in \w+\.re/, error.message)
+ end
+end
diff --git a/test/ast/test_block_processor_inline.rb b/test/ast/test_block_processor_inline.rb
new file mode 100644
index 000000000..76f5c5fd7
--- /dev/null
+++ b/test/ast/test_block_processor_inline.rb
@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/snapshot_location'
+require 'review/ast/code_block_node'
+require 'review/ast/paragraph_node'
+require 'review/ast/text_node'
+require 'review/ast/inline_node'
+require 'review/ast/caption_node'
+require 'review/ast/table_node'
+require 'review/ast/image_node'
+require 'review/ast/code_line_node'
+require 'review/ast/compiler'
+
+class TestBlockProcessorInline < Test::Unit::TestCase
+ def setup
+ @location = ReVIEW::SnapshotLocation.new('test.re', 10)
+ compiler = ReVIEW::AST::Compiler.new
+ @inline_processor = compiler.inline_processor
+ end
+
+ def test_code_block_node_original_text_attribute
+ code_block = ReVIEW::AST::CodeBlockNode.new(
+ location: @location,
+ original_text: 'test content'
+ )
+
+ assert_respond_to(code_block, :original_text)
+ assert_equal 'test content', code_block.original_text
+ end
+
+ def test_code_block_node_original_text_method
+ code_block1 = ReVIEW::AST::CodeBlockNode.new(
+ location: @location,
+ original_text: 'original content'
+ )
+ assert_equal 'original content', code_block1.original_text
+ assert_equal ['original content'], code_block1.original_lines
+
+ code_block2 = ReVIEW::AST::CodeBlockNode.new(
+ location: @location,
+ original_text: "line1\nline2"
+ )
+ assert_equal "line1\nline2", code_block2.original_text
+ assert_equal ['line1', 'line2'], code_block2.original_lines
+ end
+
+ def test_original_and_processed_lines_methods
+ # Test original_lines and processed_lines methods
+ original_text = 'puts @<b>{hello}'
+
+ code_block = ReVIEW::AST::CodeBlockNode.new(
+ location: @location,
+ original_text: original_text
+ )
+
+ # Create a code line with inline processing
+ line_node = ReVIEW::AST::CodeLineNode.new(location: @location)
+ text_node1 = ReVIEW::AST::TextNode.new(location: @location, content: 'puts ')
+ inline_node = ReVIEW::AST::InlineNode.new(location: @location, inline_type: :b)
+ inline_node.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'hello'))
+ line_node.add_child(text_node1)
+ line_node.add_child(inline_node)
+ code_block.add_child(line_node)
+
+ # Test original_lines (for builders that don't need inline processing)
+ assert_equal ['puts @<b>{hello}'], code_block.original_lines
+
+ # Test processed_lines (for builders that need inline processing)
+ processed = code_block.processed_lines
+ assert_equal 1, processed.size
+ assert_equal 'puts @<b>{hello}', processed[0]
+ end
+
+ def test_processed_lines_method
+ code_block = ReVIEW::AST::CodeBlockNode.new(
+ location: @location,
+ original_text: 'puts hello'
+ )
+
+ # Create a simple code line
+ line_node = ReVIEW::AST::CodeLineNode.new(location: @location)
+ text_node = ReVIEW::AST::TextNode.new(location: @location, content: 'puts hello')
+ line_node.add_child(text_node)
+ code_block.add_child(line_node)
+
+ assert_respond_to(code_block, :processed_lines)
+ processed = code_block.processed_lines
+ assert_equal 1, processed.size
+ assert_equal 'puts hello', processed[0]
+ end
+
+ # Caption tests
+ def test_code_block_with_simple_caption
+ # Test CodeBlockNode with simple text caption
+ caption_node = ReVIEW::AST::CaptionNode.new(location: @location)
+ caption_node.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Simple Caption'))
+
+ code_block = ReVIEW::AST::CodeBlockNode.new(
+ location: @location,
+ caption_node: caption_node,
+ original_text: 'code line'
+ )
+
+ assert_not_nil(code_block.caption_text)
+ assert_instance_of(ReVIEW::AST::CaptionNode, code_block.caption_node)
+ assert_equal 'Simple Caption', code_block.caption_text
+ end
+
+ def test_code_block_with_inline_caption
+ caption_markup_text = 'Code with @<b>{bold} text'
+ caption_node = CaptionParserHelper.parse(
+ caption_markup_text,
+ location: @location,
+ inline_processor: @inline_processor
+ )
+
+ code_block = ReVIEW::AST::CodeBlockNode.new(
+ location: @location,
+ caption_node: caption_node,
+ original_text: 'code line'
+ )
+
+ assert_not_nil(code_block.caption_text)
+ assert_instance_of(ReVIEW::AST::CaptionNode, code_block.caption_node)
+ assert_equal true, code_block.caption_node.contains_inline?
+ assert_equal 'Code with bold text', code_block.caption_text
+ end
+
+ def test_table_node_with_caption
+ caption_node = ReVIEW::AST::CaptionNode.new(location: @location)
+ caption_node.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Table Caption'))
+
+ table = ReVIEW::AST::TableNode.new(
+ location: @location,
+ caption_node: caption_node
+ )
+
+ assert_not_nil(table.caption_text)
+ assert_instance_of(ReVIEW::AST::CaptionNode, table.caption_node)
+ assert_equal 'Table Caption', table.caption_text
+ end
+
+ def test_image_node_with_caption
+ caption = 'Figure @<i>{1}: Sample'
+ caption_node = CaptionParserHelper.parse(
+ caption,
+ location: @location,
+ inline_processor: @inline_processor
+ )
+
+ image = ReVIEW::AST::ImageNode.new(
+ location: @location,
+ id: 'fig1',
+ caption_node: caption_node
+ )
+
+ assert_instance_of(ReVIEW::AST::CaptionNode, image.caption_node)
+ assert_equal true, image.caption_node.contains_inline?
+ assert_equal 'Figure 1: Sample', image.caption_text
+ end
+
+ def test_caption_node_creation_directly
+ # Simple string
+ caption_node1 = CaptionParserHelper.parse('Simple text', location: @location)
+ assert_instance_of(ReVIEW::AST::CaptionNode, caption_node1)
+ assert_equal 'Simple text', caption_node1.to_inline_text
+ assert_equal 1, caption_node1.children.size
+ assert_instance_of(ReVIEW::AST::TextNode, caption_node1.children.first)
+
+ # Nil caption
+ caption_node2 = CaptionParserHelper.parse(nil, location: @location)
+ assert_nil(caption_node2)
+
+ # Empty string
+ caption_node3 = CaptionParserHelper.parse('', location: @location)
+ assert_nil(caption_node3)
+
+ # Already a CaptionNode
+ existing_caption_node = ReVIEW::AST::CaptionNode.new(location: @location)
+ existing_caption_node.add_child(ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'Existing'))
+ caption_node4 = CaptionParserHelper.parse(existing_caption_node, location: @location)
+ assert_equal existing_caption_node, caption_node4
+ end
+
+ def test_caption_with_multiple_nodes
+ caption = 'Text with @<b>{bold} content'
+ caption_node = CaptionParserHelper.parse(
+ caption,
+ location: @location,
+ inline_processor: @inline_processor
+ )
+
+ assert_instance_of(ReVIEW::AST::CaptionNode, caption_node)
+ assert_operator(caption_node.children.size, :>=, 1)
+ assert_equal true, caption_node.contains_inline?
+ assert_equal 'Text with bold content', caption_node.to_inline_text
+ end
+
+ def test_empty_caption_handling
+ code_block = ReVIEW::AST::CodeBlockNode.new(
+ location: @location,
+ caption_node: nil,
+ original_text: 'code'
+ )
+ assert_nil(code_block.caption_node)
+ assert_equal('', code_block.caption_text)
+
+ table = ReVIEW::AST::TableNode.new(
+ location: @location,
+ caption_node: nil
+ )
+ assert_nil(table.caption_node)
+ assert_equal('', table.caption_text)
+ end
+
+ def test_caption_markup_text_compatibility
+ caption_with_markup = 'Caption with @<b>{bold} and @<i>{italic}'
+ caption_node = CaptionParserHelper.parse(
+ caption_with_markup,
+ location: @location,
+ inline_processor: @inline_processor
+ )
+
+ code_block = ReVIEW::AST::CodeBlockNode.new(
+ location: @location,
+ caption_node: caption_node,
+ original_text: 'code'
+ )
+
+ assert_instance_of(ReVIEW::AST::CaptionNode, code_block.caption_node)
+ assert_equal true, code_block.caption_node.contains_inline?
+ assert_equal 'Caption with bold and italic', code_block.caption_text
+ end
+
+ private
+
+ def create_test_paragraph
+ # Create paragraph: puts @<b>{hello}
+ text_node = ReVIEW::AST::TextNode.new(location: @location, content: 'hello')
+ inline_node = ReVIEW::AST::InlineNode.new(location: @location, inline_type: :b)
+ inline_node.add_child(text_node)
+
+ paragraph = ReVIEW::AST::ParagraphNode.new(location: @location)
+ paragraph.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'puts '))
+ paragraph.add_child(inline_node)
+
+ paragraph
+ end
+end
diff --git a/test/ast/test_block_processor_integration.rb b/test/ast/test_block_processor_integration.rb
new file mode 100644
index 000000000..aca57de34
--- /dev/null
+++ b/test/ast/test_block_processor_integration.rb
@@ -0,0 +1,303 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast/compiler'
+require 'review/ast/block_processor'
+require 'review/ast/block_data'
+require 'review/book'
+require 'review/book/chapter'
+require 'stringio'
+
+class TestBlockProcessorIntegration < Test::Unit::TestCase
+ include ReVIEW
+
+ def setup
+ @config = Configure.values
+ @config['language'] = 'ja'
+ @book = Book::Base.new
+ @book.config = @config
+ @log_io = StringIO.new
+ ReVIEW.logger = ReVIEW::Logger.new(@log_io)
+ I18n.setup(@config['language'])
+ end
+
+ def test_simple_block_processing
+ content = <<~EOB
+ = Test Chapter
+
+ //list[example][サンプルコード]{
+ def hello
+ puts "world"
+ end
+ //}
+
+ 段落テキスト
+ EOB
+
+ chapter = Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new)
+ chapter.content = content
+
+ compiler = AST::Compiler.new
+ ast = compiler.compile_to_ast(chapter)
+
+ assert_equal AST::DocumentNode, ast.class
+ assert_equal 3, ast.children.size
+
+ headline = ast.children[0]
+ assert_equal AST::HeadlineNode, headline.class
+ assert_equal 1, headline.level
+
+ code_block = ast.children[1]
+ assert_equal AST::CodeBlockNode, code_block.class
+ assert_equal 'example', code_block.id
+ assert_equal :list, code_block.code_type
+ assert_equal 3, code_block.children.size # 3 lines of code
+
+ paragraph = ast.children[2]
+ assert_equal AST::ParagraphNode, paragraph.class
+ end
+
+ def test_nested_block_processing
+ content = <<~EOB
+ = Test Chapter
+
+ //note[注意]{
+ これは注意書きです。
+
+ //list[nested][ネストしたコード]{
+ def nested_method
+ puts "nested"
+ end
+ //}
+
+ 注意書きの続き。
+ //}
+ EOB
+
+ chapter = Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new)
+ chapter.content = content
+
+ compiler = AST::Compiler.new
+ ast = compiler.compile_to_ast(chapter)
+
+ assert_equal AST::DocumentNode, ast.class
+ assert_equal 2, ast.children.size
+
+ headline = ast.children[0]
+ assert_equal AST::HeadlineNode, headline.class
+
+ minicolumn = ast.children[1]
+ assert_equal AST::MinicolumnNode, minicolumn.class
+ assert_equal :note, minicolumn.minicolumn_type
+
+ assert(minicolumn.children.any?(AST::CodeBlockNode))
+
+ nested_code = minicolumn.children.find { |child| child.is_a?(AST::CodeBlockNode) }
+ assert_equal 'nested', nested_code.id
+ assert_equal :list, nested_code.code_type
+ end
+
+ def test_multiple_nested_blocks
+ content = <<~EOB
+ //box[テストボックス]{
+ ボックスの説明
+
+ //list[code1][最初のコード]{
+ puts "first"
+ //}
+
+ 中間テキスト
+
+ //list[code2][二番目のコード]{
+ puts "second"
+ //}
+
+ 最後のテキスト
+ //}
+ EOB
+
+ chapter = Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new)
+ chapter.content = content
+
+ compiler = AST::Compiler.new
+ ast = compiler.compile_to_ast(chapter)
+
+ box_block = ast.children[0]
+ assert_equal AST::BlockNode, box_block.class
+ assert_equal :box, box_block.block_type
+
+ code_blocks = box_block.children.select { |child| child.is_a?(AST::CodeBlockNode) }
+ assert_equal 2, code_blocks.size
+ assert_equal 'code1', code_blocks[0].id
+ assert_equal 'code2', code_blocks[1].id
+ end
+
+ def test_block_error_handling_unclosed_block
+ content = <<~EOB
+ //list[example][サンプル]{
+ def hello
+ puts "world"
+ # //} が欠けている
+ EOB
+
+ chapter = Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new)
+ chapter.content = content
+
+ compiler = AST::Compiler.new
+
+ assert_raise(CompileError) do
+ compiler.compile_to_ast(chapter)
+ end
+ end
+
+ def test_block_error_handling_invalid_syntax
+ content = <<~EOB
+ //invalid_command_name{
+ content
+ //}
+ EOB
+
+ chapter = Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new)
+ chapter.content = content
+
+ compiler = AST::Compiler.new
+
+ assert_raise(CompileError) do
+ compiler.compile_to_ast(chapter)
+ end
+ end
+
+ def test_block_error_handling_nested_block_error
+ content = <<~EOB
+ //note[注意]{
+ 正常なテキスト
+
+ //list[broken][壊れたコード]{
+ def method
+ # //} が欠けている - ネストエラー
+
+ //}
+ EOB
+
+ chapter = Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new)
+ chapter.content = content
+
+ compiler = AST::Compiler.new
+
+ error = assert_raise(CompileError) do
+ compiler.compile_to_ast(chapter)
+ end
+
+ assert_include(error.message.downcase, 'unclosed')
+ end
+
+ def test_image_block_processing
+ content = <<~EOB
+ //image[sample][サンプル画像][scale=0.5]{
+ //}
+ EOB
+
+ chapter = Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new)
+ chapter.content = content
+
+ compiler = AST::Compiler.new
+ ast = compiler.compile_to_ast(chapter)
+
+ image_node = ast.children[0]
+ assert_equal AST::ImageNode, image_node.class
+ assert_equal 'sample', image_node.id
+ assert_equal 'scale=0.5', image_node.metric
+ assert_equal :image, image_node.image_type
+ end
+
+ def test_table_block_processing
+ content = <<~EOB
+ //table[data][サンプルデータ]{
+ 名前 年齢
+ ------------
+ Alice 25
+ Bob 30
+ //}
+ EOB
+
+ chapter = Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new)
+ chapter.content = content
+
+ compiler = AST::Compiler.new
+ ast = compiler.compile_to_ast(chapter)
+
+ table_node = ast.children[0]
+ assert_equal AST::TableNode, table_node.class
+ assert_equal 'data', table_node.id
+ assert_equal :table, table_node.table_type
+ assert_equal 1, table_node.header_rows.size
+ assert_equal 2, table_node.body_rows.size
+ end
+
+ def test_minicolumn_with_structured_content
+ content = <<~EOB
+ //tip[ヒント]{
+ 基本的なヒント
+
+ * リスト項目1
+ * リスト項目2
+
+ 追加説明
+ //}
+ EOB
+
+ chapter = Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new)
+ chapter.content = content
+
+ compiler = AST::Compiler.new
+ ast = compiler.compile_to_ast(chapter)
+
+ tip_node = ast.children[0]
+ assert_equal AST::MinicolumnNode, tip_node.class
+ assert_equal :tip, tip_node.minicolumn_type
+
+ assert(tip_node.children.any?(AST::ParagraphNode))
+ assert(tip_node.children.any?(AST::ListNode))
+ end
+
+ def test_embed_block_processing
+ content = <<~EOB
+ //embed[html]{
+ <div class="custom">
+ <p>HTML content</p>
+ </div>
+ //}
+ EOB
+
+ chapter = Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new)
+ chapter.content = content
+
+ compiler = AST::Compiler.new
+ ast = compiler.compile_to_ast(chapter)
+
+ embed_node = ast.children[0]
+ assert_equal AST::EmbedNode, embed_node.class
+ assert_equal :block, embed_node.embed_type
+ assert_equal ['html'], embed_node.target_builders
+ assert(embed_node.content.lines.count >= 3, 'Should have at least 3 lines of content')
+ end
+
+ def test_texequation_block_processing
+ content = <<~EOB
+ //texequation[eq1][数式]{
+ E = mc^2
+ //}
+ EOB
+
+ chapter = Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new)
+ chapter.content = content
+
+ compiler = AST::Compiler.new
+ ast = compiler.compile_to_ast(chapter)
+
+ equation_node = ast.children[0]
+ assert_equal AST::TexEquationNode, equation_node.class
+ assert_equal 'eq1', equation_node.id
+ assert_include(equation_node.content, 'E = mc^2')
+ end
+end
diff --git a/test/ast/test_block_processor_table_driven.rb b/test/ast/test_block_processor_table_driven.rb
new file mode 100644
index 000000000..f6710c5ef
--- /dev/null
+++ b/test/ast/test_block_processor_table_driven.rb
@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast/compiler'
+require 'review/ast/block_processor'
+require 'review/ast/block_data'
+require 'review/book'
+require 'review/book/chapter'
+require 'stringio'
+
+class TestBlockProcessorTableDriven < Test::Unit::TestCase
+ include ReVIEW
+
+ def setup
+ @config = Configure.values
+ @config['language'] = 'ja'
+ @book = Book::Base.new
+ @book.config = @config
+ @log_io = StringIO.new
+ ReVIEW.logger = ReVIEW::Logger.new(@log_io)
+ I18n.setup(@config['language'])
+
+ @compiler = AST::Compiler.new
+ @processor = @compiler.block_processor
+ end
+
+ def test_block_command_table_coverage
+ AST::BlockProcessor::BLOCK_COMMAND_TABLE.each do |command, method_name|
+ assert @processor.respond_to?(method_name, true),
+ "Handler method #{method_name} for command #{command} does not exist"
+ end
+ end
+
+ def test_registered_commands
+ registered = @processor.registered_commands
+
+ expected_commands = %i[list image table note embed texequation]
+ expected_commands.each do |cmd|
+ assert_include(registered, cmd, "Command #{cmd} should be registered by default")
+ end
+ end
+
+ def test_dynamic_handler_registration
+ @processor.register_block_handler(:custom_test, :build_complex_block_ast)
+
+ assert_include(@processor.registered_commands, :custom_test)
+ assert_equal :build_complex_block_ast, @processor.instance_variable_get(:@dynamic_command_table)[:custom_test]
+ end
+
+ def test_custom_block_processing
+ @processor.register_block_handler(:custom_box, :build_complex_block_ast)
+
+ content = <<~EOB
+ = Test Chapter
+
+ //custom_box[title]{
+ Custom content
+ //}
+ EOB
+
+ chapter = Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new)
+ chapter.content = content
+
+ error = assert_raise(CompileError) do
+ @compiler.compile_to_ast(chapter)
+ end
+
+ assert_include(error.message, 'Unknown block command: //custom')
+ end
+
+ def test_unknown_command_error
+ location = SnapshotLocation.new('test.re', 1)
+ block_data = AST::BlockData.new(
+ name: :unknown_command,
+ args: [],
+ lines: [],
+ location: location
+ )
+
+ error = assert_raise(CompileError) do
+ @processor.send(:process_block_command, block_data)
+ end
+
+ assert_include(error.message, 'Unknown block command: //unknown_command')
+ assert_include(error.message, 'test.re')
+ end
+
+ def test_table_driven_vs_case_statement_equivalence
+ test_commands = %i[list image table note embed texequation box]
+
+ test_commands.each do |command|
+ content = case command # rubocop:disable Style/HashLikeCase
+ when :list
+ <<~EOB
+ //list[test][テスト]{
+ puts "test"
+ //}
+ EOB
+ when :image
+ <<~EOB
+ //image[test][テスト画像]{
+ //}
+ EOB
+ when :table
+ <<~EOB
+ //table[test][テストテーブル]{
+ Name Age
+ Alice 25
+ //}
+ EOB
+ when :note
+ <<~EOB
+ //note[テスト注意]{
+ 注意内容
+ //}
+ EOB
+ when :embed
+ <<~EOB
+ //embed[html]{
+ <div>test</div>
+ //}
+ EOB
+ when :texequation
+ <<~EOB
+ //texequation[eq1][数式]{
+ E = mc^2
+ //}
+ EOB
+ when :box
+ <<~EOB
+ //box[テストボックス]{
+ ボックス内容
+ //}
+ EOB
+ end
+
+ chapter = Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new)
+ chapter.content = content
+
+ assert_nothing_raised("Command #{command} should be processed without error") do
+ @compiler.compile_to_ast(chapter)
+ end
+ end
+ end
+
+ def test_handler_method_existence
+ AST::BlockProcessor::BLOCK_COMMAND_TABLE.each do |command, handler|
+ assert @processor.respond_to?(handler, true),
+ "Handler method #{handler} for command //#{command} does not exist"
+ end
+ end
+
+ def test_code_block_category_consistency
+ code_commands = %i[list listnum emlist emlistnum cmd source]
+ code_commands.each do |cmd|
+ assert_equal :build_code_block_ast, AST::BlockProcessor::BLOCK_COMMAND_TABLE[cmd],
+ "Code command #{cmd} should use build_code_block_ast handler"
+ end
+ end
+
+ def test_minicolumn_category_consistency
+ minicolumn_commands = %i[note memo tip info warning important caution notice]
+ minicolumn_commands.each do |cmd|
+ assert_equal :build_minicolumn_ast, AST::BlockProcessor::BLOCK_COMMAND_TABLE[cmd],
+ "Minicolumn command #{cmd} should use build_minicolumn_ast handler"
+ end
+ end
+
+ def test_extension_example
+ @processor.register_block_handler(:callout, :build_complex_block_ast)
+
+ assert_include(@processor.registered_commands, :callout)
+
+ assert_equal :build_complex_block_ast, @processor.instance_variable_get(:@dynamic_command_table)[:callout]
+ end
+end
diff --git a/test/ast/test_caption_inline_integration.rb b/test/ast/test_caption_inline_integration.rb
new file mode 100644
index 000000000..cfd509e2a
--- /dev/null
+++ b/test/ast/test_caption_inline_integration.rb
@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/snapshot_location'
+require 'review/ast/caption_node'
+require 'review/ast/code_block_node'
+require 'review/ast/text_node'
+require 'review/ast/inline_node'
+
+class TestCaptionInlineIntegration < Test::Unit::TestCase
+ def setup
+ @location = ReVIEW::SnapshotLocation.new('test.re', 1)
+ end
+
+ def test_simple_caption_behavior_in_code_block
+ # Test that simple captions become CaptionNode in CodeBlockNode
+ caption_node = ReVIEW::AST::CaptionNode.new(location: @location)
+ caption_node.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Simple Caption'))
+
+ code_block = ReVIEW::AST::CodeBlockNode.new(
+ location: @location,
+ caption_node: caption_node
+ )
+
+ assert_equal 'Simple Caption', code_block.caption_text
+ assert_instance_of(ReVIEW::AST::CaptionNode, code_block.caption_node)
+ assert_equal 'Simple Caption', code_block.caption_text
+ end
+
+ def test_caption_node_behavior_in_code_block
+ # Test that CaptionNode works correctly in CodeBlockNode
+ caption_node = ReVIEW::AST::CaptionNode.new(location: @location)
+ caption_node.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Caption with '))
+
+ inline_node = ReVIEW::AST::InlineNode.new(location: @location, inline_type: :b)
+ inline_node.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'bold'))
+ caption_node.add_child(inline_node)
+
+ caption_node.add_child(ReVIEW::AST::TextNode.new(location: @location, content: ' text'))
+
+ code_block = ReVIEW::AST::CodeBlockNode.new(
+ location: @location,
+ caption_node: caption_node
+ )
+
+ assert_equal 'Caption with bold text', code_block.caption_text
+ assert_instance_of(ReVIEW::AST::CaptionNode, code_block.caption_node)
+ end
+
+ def test_empty_caption_handling
+ # Test empty captions
+ code_block = ReVIEW::AST::CodeBlockNode.new(
+ location: @location
+ )
+
+ assert_equal('', code_block.caption_text)
+ end
+
+ def test_nil_caption_handling
+ # Test when caption is not provided
+ code_block = ReVIEW::AST::CodeBlockNode.new(
+ location: @location
+ )
+
+ assert_equal('', code_block.caption_text)
+ end
+end
diff --git a/test/ast/test_caption_node.rb b/test/ast/test_caption_node.rb
new file mode 100644
index 000000000..ab4421cbe
--- /dev/null
+++ b/test/ast/test_caption_node.rb
@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/snapshot_location'
+require 'review/ast/caption_node'
+require 'review/ast/text_node'
+require 'review/ast/inline_node'
+
+class TestCaptionNode < Test::Unit::TestCase
+ def setup
+ @location = ReVIEW::SnapshotLocation.new('test.re', 1)
+ end
+
+ def test_caption_node_initialization
+ caption = ReVIEW::AST::CaptionNode.new(location: @location)
+ assert_instance_of(ReVIEW::AST::CaptionNode, caption)
+ assert_equal @location, caption.location
+ assert_empty(caption.children)
+ end
+
+ def test_empty_caption
+ caption = ReVIEW::AST::CaptionNode.new(location: @location)
+ assert caption.empty?
+ assert_equal false, caption.contains_inline?
+ end
+
+ def test_simple_text_caption
+ caption = ReVIEW::AST::CaptionNode.new(location: @location)
+ text_node = ReVIEW::AST::TextNode.new(location: @location, content: 'Simple caption')
+ caption.add_child(text_node)
+
+ assert_equal false, caption.empty?
+ assert_equal false, caption.contains_inline?
+
+ # Verify structure
+ assert_equal 1, caption.children.size
+ assert_instance_of(ReVIEW::AST::TextNode, caption.children[0])
+ assert_equal 'Simple caption', caption.children[0].content
+ end
+
+ def test_caption_with_inline_elements
+ caption = ReVIEW::AST::CaptionNode.new(location: @location)
+
+ # Add text: "Caption with "
+ caption.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Caption with '))
+
+ # Add inline: @<b>{bold text}
+ inline_node = ReVIEW::AST::InlineNode.new(location: @location, inline_type: :b)
+ inline_node.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'bold text'))
+ caption.add_child(inline_node)
+
+ # Add more text: " content"
+ caption.add_child(ReVIEW::AST::TextNode.new(location: @location, content: ' content'))
+
+ assert_equal false, caption.empty?
+ assert_equal true, caption.contains_inline?
+
+ # Verify structure: "Caption with @<b>{bold text} content"
+ assert_equal 3, caption.children.size
+ assert_instance_of(ReVIEW::AST::TextNode, caption.children[0])
+ assert_equal 'Caption with ', caption.children[0].content
+ assert_instance_of(ReVIEW::AST::InlineNode, caption.children[1])
+ assert_equal :b, caption.children[1].inline_type
+ assert_equal 1, caption.children[1].children.size
+ assert_equal 'bold text', caption.children[1].children[0].content
+ assert_instance_of(ReVIEW::AST::TextNode, caption.children[2])
+ assert_equal ' content', caption.children[2].content
+ end
+
+ def test_caption_with_nested_inline
+ caption = ReVIEW::AST::CaptionNode.new(location: @location)
+
+ # Create: Text @<i>{italic @<b>{bold}} more
+ text1 = ReVIEW::AST::TextNode.new(location: @location, content: 'Text ')
+ caption.add_child(text1)
+
+ # Create nested inline: @<i>{italic @<b>{bold}}
+ bold_text = ReVIEW::AST::TextNode.new(location: @location, content: 'bold')
+ bold_inline = ReVIEW::AST::InlineNode.new(location: @location, inline_type: :b)
+ bold_inline.add_child(bold_text)
+
+ italic_text = ReVIEW::AST::TextNode.new(location: @location, content: 'italic ')
+ italic_inline = ReVIEW::AST::InlineNode.new(location: @location, inline_type: :i)
+ italic_inline.add_child(italic_text)
+ italic_inline.add_child(bold_inline)
+ caption.add_child(italic_inline)
+
+ text2 = ReVIEW::AST::TextNode.new(location: @location, content: ' more')
+ caption.add_child(text2)
+
+ assert_equal true, caption.contains_inline?
+
+ # Verify structure: "Text @<i>{italic @<b>{bold}} more"
+ assert_equal 3, caption.children.size
+ assert_instance_of(ReVIEW::AST::TextNode, caption.children[0])
+ assert_equal 'Text ', caption.children[0].content
+
+ # Check nested inline structure
+ assert_instance_of(ReVIEW::AST::InlineNode, caption.children[1])
+ assert_equal :i, caption.children[1].inline_type
+ assert_equal 2, caption.children[1].children.size
+ assert_equal 'italic ', caption.children[1].children[0].content
+
+ # Check inner inline
+ inner_inline = caption.children[1].children[1]
+ assert_instance_of(ReVIEW::AST::InlineNode, inner_inline)
+ assert_equal :b, inner_inline.inline_type
+ assert_equal 1, inner_inline.children.size
+ assert_equal 'bold', inner_inline.children[0].content
+
+ assert_instance_of(ReVIEW::AST::TextNode, caption.children[2])
+ assert_equal ' more', caption.children[2].content
+ end
+
+ def test_caption_serialization_simple
+ caption = ReVIEW::AST::CaptionNode.new(location: @location)
+ text_node = ReVIEW::AST::TextNode.new(location: @location, content: 'Simple caption')
+ caption.add_child(text_node)
+
+ # Simple text caption should serialize as children array for compatibility
+ result = caption.to_h
+ expected = {
+ type: 'CaptionNode',
+ location: { filename: 'test.re', lineno: 1 },
+ children: [
+ {
+ type: 'TextNode',
+ content: 'Simple caption',
+ location: { filename: 'test.re', lineno: 1 }
+ }
+ ]
+ }
+ assert_equal expected, result
+ end
+
+ def test_caption_serialization_complex
+ caption = ReVIEW::AST::CaptionNode.new(location: @location)
+ caption.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Caption with '))
+
+ inline_node = ReVIEW::AST::InlineNode.new(location: @location, inline_type: :b)
+ inline_node.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'bold'))
+ caption.add_child(inline_node)
+
+ # Complex caption should serialize as node structure
+ result = caption.to_h
+ assert_instance_of(Hash, result)
+ assert_equal 'CaptionNode', result[:type]
+ assert_equal 2, result[:children].size
+ end
+
+ def test_empty_whitespace_caption
+ caption = ReVIEW::AST::CaptionNode.new(location: @location)
+ text_node = ReVIEW::AST::TextNode.new(location: @location, content: ' ')
+ caption.add_child(text_node)
+
+ # Whitespace-only caption should be considered empty
+ assert_equal true, caption.empty?
+ end
+
+ def test_to_inline_text_simple
+ caption = ReVIEW::AST::CaptionNode.new(location: @location)
+ text_node = ReVIEW::AST::TextNode.new(location: @location, content: 'Simple caption')
+ caption.add_child(text_node)
+
+ assert_equal 'Simple caption', caption.to_inline_text
+ end
+
+ def test_to_inline_text_with_inline
+ caption = ReVIEW::AST::CaptionNode.new(location: @location)
+ caption.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Caption with '))
+
+ inline_node = ReVIEW::AST::InlineNode.new(location: @location, inline_type: :b)
+ inline_node.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'bold text'))
+ caption.add_child(inline_node)
+
+ caption.add_child(ReVIEW::AST::TextNode.new(location: @location, content: ' content'))
+
+ # Markup should be removed: "Caption with @<b>{bold text} content" -> "Caption with bold text content"
+ assert_equal 'Caption with bold text content', caption.to_inline_text
+ end
+
+ def test_to_inline_text_with_nested_inline
+ caption = ReVIEW::AST::CaptionNode.new(location: @location)
+ caption.add_child(ReVIEW::AST::TextNode.new(location: @location, content: 'Text '))
+
+ # Create nested inline: @<i>{italic @<b>{bold}}
+ bold_text = ReVIEW::AST::TextNode.new(location: @location, content: 'bold')
+ bold_inline = ReVIEW::AST::InlineNode.new(location: @location, inline_type: :b)
+ bold_inline.add_child(bold_text)
+
+ italic_text = ReVIEW::AST::TextNode.new(location: @location, content: 'italic ')
+ italic_inline = ReVIEW::AST::InlineNode.new(location: @location, inline_type: :i)
+ italic_inline.add_child(italic_text)
+ italic_inline.add_child(bold_inline)
+ caption.add_child(italic_inline)
+
+ caption.add_child(ReVIEW::AST::TextNode.new(location: @location, content: ' more'))
+
+ # Nested markup should be removed: "Text @<i>{italic @<b>{bold}} more" -> "Text italic bold more"
+ assert_equal 'Text italic bold more', caption.to_inline_text
+ end
+
+ def test_to_inline_text_empty
+ caption = ReVIEW::AST::CaptionNode.new(location: @location)
+ assert_equal '', caption.to_inline_text
+ end
+end
diff --git a/test/ast/test_caption_parser.rb b/test/ast/test_caption_parser.rb
new file mode 100644
index 000000000..5604b56ec
--- /dev/null
+++ b/test/ast/test_caption_parser.rb
@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/snapshot_location'
+require 'review/ast/caption_node'
+require 'review/ast/text_node'
+require 'review/ast/inline_node'
+require 'review/ast/compiler'
+
+class TestCaptionParser < Test::Unit::TestCase
+ def setup
+ @location = ReVIEW::SnapshotLocation.new('test.re', 1)
+ end
+
+ def test_parser_initialization
+ parser = CaptionParserHelper.new(location: @location)
+ assert_instance_of(CaptionParserHelper, parser)
+ end
+
+ def test_parse_nil_returns_nil
+ parser = CaptionParserHelper.new(location: @location)
+ assert_nil(parser.parse(nil))
+ end
+
+ def test_parse_empty_string_returns_nil
+ parser = CaptionParserHelper.new(location: @location)
+ assert_nil(parser.parse(''))
+ end
+
+ def test_parse_existing_caption_node_returns_same
+ parser = CaptionParserHelper.new(location: @location)
+ caption_node = ReVIEW::AST::CaptionNode.new(location: @location)
+
+ result = parser.parse(caption_node)
+ assert_equal caption_node, result
+ end
+
+ def test_parse_simple_string_without_inline_processor
+ parser = CaptionParserHelper.new(location: @location)
+ result = parser.parse('Simple Caption')
+
+ assert_instance_of(ReVIEW::AST::CaptionNode, result)
+ assert_equal 1, result.children.size
+ assert_instance_of(ReVIEW::AST::TextNode, result.children.first)
+ assert_equal 'Simple Caption', result.children.first.content
+ assert_equal 'Simple Caption', result.to_inline_text
+ end
+
+ def test_parse_string_with_inline_markup_without_processor
+ parser = CaptionParserHelper.new(location: @location)
+ result = parser.parse('Caption with @<b>{bold}')
+
+ assert_instance_of(ReVIEW::AST::CaptionNode, result)
+ assert_equal 1, result.children.size
+ assert_instance_of(ReVIEW::AST::TextNode, result.children.first)
+ assert_equal 'Caption with @<b>{bold}', result.children.first.content
+ assert_equal 'Caption with @<b>{bold}', result.to_inline_text
+ assert_equal false, result.contains_inline?
+ end
+
+ def test_parse_with_inline_processor
+ # Create a real inline processor from AST::Compiler
+ compiler = ReVIEW::AST::Compiler.new
+ inline_processor = compiler.inline_processor
+
+ parser = CaptionParserHelper.new(
+ location: @location,
+ inline_processor: inline_processor
+ )
+ result = parser.parse('Caption with @<b>{bold}')
+
+ assert_instance_of(ReVIEW::AST::CaptionNode, result)
+ assert_operator(result.children.size, :>=, 1)
+ assert_equal true, result.contains_inline?
+ # Real inline processor parses the markup, so to_inline_text extracts text content
+ assert_match(/Caption with.*bold/, result.to_inline_text)
+ end
+
+ def test_factory_method_delegates_to_parser
+ result = CaptionParserHelper.parse('Test Caption', location: @location)
+
+ assert_instance_of(ReVIEW::AST::CaptionNode, result)
+ assert_equal 'Test Caption', result.to_inline_text
+ end
+end
diff --git a/test/ast/test_code_block_debug.rb b/test/ast/test_code_block_debug.rb
new file mode 100644
index 000000000..cdcd0373d
--- /dev/null
+++ b/test/ast/test_code_block_debug.rb
@@ -0,0 +1,289 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast/compiler'
+require 'review/ast/json_serializer'
+require 'review/book'
+require 'review/book/chapter'
+require 'json'
+
+class TestCodeBlockDebug < Test::Unit::TestCase
+ def setup
+ @config = ReVIEW::Configure.values
+ @config['secnolevel'] = 2
+ @config['language'] = 'ja'
+
+ @book = ReVIEW::Book::Base.new(config: @config)
+
+ @log_io = StringIO.new
+ ReVIEW.logger = ReVIEW::Logger.new(@log_io)
+
+ @chapter = ReVIEW::Book::Chapter.new(@book, 1, 'debug_chapter', 'debug_chapter.re', StringIO.new)
+ ReVIEW::I18n.setup(@config['language'])
+ end
+
+ def test_code_block_ast_structure
+ source = <<~EOS
+ = Chapter Title
+
+ //list[test-code][Test Code][ruby]{
+ puts @<b>{bold code}
+ # Comment with @<fn>{code-fn}
+ //}
+ EOS
+
+ @chapter.content = source
+
+ # Build AST without builder rendering
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(@chapter, reference_resolution: false)
+
+ # Serialize AST to examine structure
+ json_str = ReVIEW::AST::JSONSerializer.serialize(ast_root)
+ ast = JSON.parse(json_str)
+
+ # === Code Block AST Structure ===
+ result = JSON.pretty_generate(ast)
+ expected0 = <<~EXPECTED.chomp
+ {
+ "type": "DocumentNode",
+ "location": {
+ "filename": "debug_chapter.re",
+ "lineno": 1
+ },
+ "children": [
+ {
+ "type": "HeadlineNode",
+ "location": {
+ "filename": "debug_chapter.re",
+ "lineno": 1
+ },
+ "level": 1,
+ "label": null,
+ "caption_node": {
+ "type": "CaptionNode",
+ "location": {
+ "filename": "debug_chapter.re",
+ "lineno": 1
+ },
+ "children": [
+ {
+ "type": "TextNode",
+ "location": {
+ "filename": "debug_chapter.re",
+ "lineno": 1
+ },
+ "content": "Chapter Title"
+ }
+ ]
+ }
+ },
+ {
+ "type": "CodeBlockNode",
+ "location": {
+ "filename": "debug_chapter.re",
+ "lineno": 3
+ },
+ "id": "test-code",
+ "lang": "ruby",
+ "caption_node": {
+ "type": "CaptionNode",
+ "location": {
+ "filename": "debug_chapter.re",
+ "lineno": 3
+ },
+ "children": [
+ {
+ "type": "TextNode",
+ "location": {
+ "filename": "debug_chapter.re",
+ "lineno": 3
+ },
+ "content": "Test Code"
+ }
+ ]
+ },
+ "line_numbers": false,
+ "code_type": "list",
+ "original_text": "puts @<b>{bold code}\\n# Comment with @<fn>{code-fn}",
+ "children": [
+ {
+ "type": "CodeLineNode",
+ "location": {
+ "filename": "debug_chapter.re",
+ "lineno": 3
+ },
+ "children": [
+ {
+ "type": "TextNode",
+ "location": {
+ "filename": "debug_chapter.re",
+ "lineno": 3
+ },
+ "content": "puts "
+ },
+ {
+ "type": "InlineNode",
+ "location": {
+ "filename": "debug_chapter.re",
+ "lineno": 3
+ },
+ "children": [
+ {
+ "type": "TextNode",
+ "location": {
+ "filename": "debug_chapter.re",
+ "lineno": 3
+ },
+ "content": "bold code"
+ }
+ ],
+ "inline_type": "b",
+ "args": [
+ "bold code"
+ ]
+ }
+ ],
+ "original_text": "puts @<b>{bold code}"
+ },
+ {
+ "type": "CodeLineNode",
+ "location": {
+ "filename": "debug_chapter.re",
+ "lineno": 3
+ },
+ "children": [
+ {
+ "type": "TextNode",
+ "location": {
+ "filename": "debug_chapter.re",
+ "lineno": 3
+ },
+ "content": "# Comment with "
+ },
+ {
+ "type": "InlineNode",
+ "location": {
+ "filename": "debug_chapter.re",
+ "lineno": 3
+ },
+ "children": [
+ {
+ "type": "ReferenceNode",
+ "location": {
+ "filename": "debug_chapter.re",
+ "lineno": 3
+ },
+ "content": "code-fn",
+ "ref_id": "code-fn"
+ }
+ ],
+ "inline_type": "fn",
+ "args": [
+ "code-fn"
+ ],
+ "target_item_id": "code-fn"
+ }
+ ],
+ "original_text": "# Comment with @<fn>{code-fn}"
+ }
+ ]
+ }
+ ]
+ }
+ EXPECTED
+ assert_equal expected0, result
+
+ # Find code block node
+ code_block = ast['children'].find { |node| node['type'] == 'CodeBlockNode' }
+ assert_not_nil(code_block)
+
+ # === Code Block Children ===
+ result = JSON.pretty_generate(code_block['children'])
+ expected = <<~EXPECTED.chomp
+ [
+ {
+ "type": "CodeLineNode",
+ "location": {
+ "filename": "debug_chapter.re",
+ "lineno": 3
+ },
+ "children": [
+ {
+ "type": "TextNode",
+ "location": {
+ "filename": "debug_chapter.re",
+ "lineno": 3
+ },
+ "content": "puts "
+ },
+ {
+ "type": "InlineNode",
+ "location": {
+ "filename": "debug_chapter.re",
+ "lineno": 3
+ },
+ "children": [
+ {
+ "type": "TextNode",
+ "location": {
+ "filename": "debug_chapter.re",
+ "lineno": 3
+ },
+ "content": "bold code"
+ }
+ ],
+ "inline_type": "b",
+ "args": [
+ "bold code"
+ ]
+ }
+ ],
+ "original_text": "puts @<b>{bold code}"
+ },
+ {
+ "type": "CodeLineNode",
+ "location": {
+ "filename": "debug_chapter.re",
+ "lineno": 3
+ },
+ "children": [
+ {
+ "type": "TextNode",
+ "location": {
+ "filename": "debug_chapter.re",
+ "lineno": 3
+ },
+ "content": "# Comment with "
+ },
+ {
+ "type": "InlineNode",
+ "location": {
+ "filename": "debug_chapter.re",
+ "lineno": 3
+ },
+ "children": [
+ {
+ "type": "ReferenceNode",
+ "location": {
+ "filename": "debug_chapter.re",
+ "lineno": 3
+ },
+ "content": "code-fn",
+ "ref_id": "code-fn"
+ }
+ ],
+ "inline_type": "fn",
+ "args": [
+ "code-fn"
+ ],
+ "target_item_id": "code-fn"
+ }
+ ],
+ "original_text": "# Comment with @<fn>{code-fn}"
+ }
+ ]
+ EXPECTED
+ assert_equal expected, result
+ end
+end
diff --git a/test/ast/test_code_block_original_text.rb b/test/ast/test_code_block_original_text.rb
new file mode 100644
index 000000000..58935b876
--- /dev/null
+++ b/test/ast/test_code_block_original_text.rb
@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast/compiler'
+require 'review/book'
+require 'review/book/chapter'
+
+class TestCodeBlockOriginalText < Test::Unit::TestCase
+ def setup
+ @config = ReVIEW::Configure.values
+ @config['secnolevel'] = 2
+ @config['language'] = 'ja'
+ @book = ReVIEW::Book::Base.new(config: @config)
+
+ @log_io = StringIO.new
+ ReVIEW.logger = ReVIEW::Logger.new(@log_io)
+
+ @chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test_chapter', 'test_chapter.re', StringIO.new)
+ ReVIEW::I18n.setup(@config['language'])
+ end
+
+ def test_code_block_original_text_preservation
+ source = <<~EOS
+ = Chapter Title
+
+ //list[test-code][Test Code][ruby]{
+ puts @<b>{bold code}
+ # Comment with @<fn>{code-fn}
+ normal line
+ //}
+
+ //footnote[code-fn][Code block footnote]
+ EOS
+
+ @chapter.content = source
+
+ # Build AST without builder rendering
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(@chapter)
+
+ # Find code block node
+ code_block = ast_root.children.find { |node| node.class.name.include?('CodeBlockNode') }
+ assert_not_nil(code_block)
+
+ # Test original_text preservation
+ expected_original = "puts @<b>{bold code}\n# Comment with @<fn>{code-fn}\nnormal line"
+ assert_equal expected_original, code_block.original_text
+
+ # Test original_lines method
+ expected_lines = [
+ 'puts @<b>{bold code}',
+ '# Comment with @<fn>{code-fn}',
+ 'normal line'
+ ]
+ assert_equal expected_lines, code_block.original_lines
+
+ # Test processed_lines method (should reconstruct from AST)
+ processed = code_block.processed_lines
+ assert_equal 3, processed.size
+ assert_equal 'puts @<b>{bold code}', processed[0]
+ assert_equal '# Comment with @<fn>{code-fn}', processed[1]
+ assert_equal 'normal line', processed[2]
+ end
+end
diff --git a/test/ast/test_column_sections.rb b/test/ast/test_column_sections.rb
new file mode 100644
index 000000000..172cce995
--- /dev/null
+++ b/test/ast/test_column_sections.rb
@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast'
+require 'review/ast/compiler'
+require 'review/ast/review_generator'
+require 'review/book'
+require 'review/book/chapter'
+
+class TestColumnSections < Test::Unit::TestCase
+ def setup
+ @config = ReVIEW::Configure.values
+ @book = ReVIEW::Book::Base.new(config: @config)
+ @chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test_chapter', 'test_chapter.re', StringIO.new)
+ end
+
+ def test_column_section
+ source = <<~EOS
+ = Chapter Title
+
+ Regular paragraph content.
+
+ ==[column] Column Title
+
+ This is content inside a column.
+
+ Another paragraph in the column.
+
+ == Regular Section
+
+ Back to regular content.
+ EOS
+
+ @chapter.content = source
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(@chapter)
+
+ # Find column node
+ column_node = find_node_by_type(ast_root, ReVIEW::AST::ColumnNode)
+ assert_not_nil(column_node)
+ assert_equal(2, column_node.level)
+ assert_equal(:column, column_node.column_type)
+
+ # Check caption
+ assert_not_nil(column_node.caption_text)
+ assert_equal('Column Title', column_node.caption_text)
+
+ # Check that column has content as children
+ assert(column_node.children.any?, 'Column should have content as children')
+
+ # Test round-trip conversion
+ generator = ReVIEW::AST::ReVIEWGenerator.new
+ result = generator.generate(ast_root)
+ assert_include(result, '==[column] Column Title')
+ assert_include(result, 'This is content inside a column.')
+ assert_include(result, 'Another paragraph in the column.')
+ end
+
+ def test_column_with_label
+ source = <<~EOS
+ = Chapter Title
+
+ ==[column]{col1} Column with Label
+
+ Content of labeled column.
+ EOS
+
+ @chapter.content = source
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(@chapter)
+
+ # Find column node
+ column_node = find_node_by_type(ast_root, ReVIEW::AST::ColumnNode)
+ assert_not_nil(column_node)
+ assert_equal('col1', column_node.label)
+ assert_equal('Column with Label', column_node.caption_text)
+
+ # Test round-trip conversion
+ generator = ReVIEW::AST::ReVIEWGenerator.new
+ result = generator.generate(ast_root)
+ assert_include(result, '==[column]{col1} Column with Label')
+ end
+
+ def test_nested_column_levels
+ source = <<~EOS
+ = Chapter Title
+
+ ==[column] Level 2 Column
+
+ Content in level 2 column.
+
+ ===[column] Level 3 Column
+
+ Content in level 3 column.
+ EOS
+
+ @chapter.content = source
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(@chapter)
+
+ # Find column nodes
+ column_nodes = find_all_nodes_by_type(ast_root, ReVIEW::AST::ColumnNode)
+ assert_equal(2, column_nodes.length)
+
+ level2_column = column_nodes.find { |n| n.level == 2 }
+ level3_column = column_nodes.find { |n| n.level == 3 }
+
+ assert_not_nil(level2_column)
+ assert_equal('Level 2 Column', level2_column.caption_text)
+
+ assert_not_nil(level3_column)
+ assert_equal('Level 3 Column', level3_column.caption_text)
+ end
+
+ def test_column_vs_regular_headline
+ source = <<~EOS
+ = Chapter Title
+
+ == Regular Headline
+
+ Regular content.
+
+ ==[column] Column Headline
+
+ Column content.
+
+ == Another Regular Headline
+
+ More regular content.
+ EOS
+
+ @chapter.content = source
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(@chapter)
+
+ # Find different node types
+ headline_nodes = find_all_nodes_by_type(ast_root, ReVIEW::AST::HeadlineNode)
+ column_nodes = find_all_nodes_by_type(ast_root, ReVIEW::AST::ColumnNode)
+
+ # Should have 3 headlines (including the chapter title) and 1 column
+ assert_equal(3, headline_nodes.length)
+ assert_equal(1, column_nodes.length)
+
+ # Check that regular headlines are HeadlineNode
+ regular_headlines = headline_nodes.select { |n| n.level == 2 }
+ assert_equal(2, regular_headlines.length)
+
+ # Check that column is ColumnNode
+ column = column_nodes.first
+ assert_equal(2, column.level)
+ assert_equal('Column Headline', column.caption_text)
+ end
+
+ def test_column_with_inline_elements
+ source = <<~EOS
+ = Chapter Title
+
+ ==[column] Column with @<b>{Bold} Text
+
+ Content with @<i>{italic} and @<code>{code}.
+ EOS
+
+ @chapter.content = source
+ ast_compiler = ReVIEW::AST::Compiler.new
+ ast_root = ast_compiler.compile_to_ast(@chapter)
+
+ # Find column node
+ column_node = find_node_by_type(ast_root, ReVIEW::AST::ColumnNode)
+ assert_not_nil(column_node)
+
+ # Check that caption has inline elements processed
+ caption_text = column_node.caption_text
+ assert_include(caption_text, 'Bold')
+
+ # Check that content has inline elements in children
+ assert(column_node.children.any?, 'Column should have content as children')
+
+ # Test round-trip conversion
+ generator = ReVIEW::AST::ReVIEWGenerator.new
+ result = generator.generate(ast_root)
+ assert_include(result, '==[column]')
+ assert_include(result, '@<i>{italic}')
+ assert_include(result, '@<code>{code}')
+ end
+
+ private
+
+ def find_node_by_type(node, node_type)
+ return node if node.is_a?(node_type)
+
+ if node.children
+ node.children.each do |child|
+ result = find_node_by_type(child, node_type)
+ return result if result
+ end
+ end
+
+ nil
+ end
+
+ def find_all_nodes_by_type(node, node_type)
+ results = []
+
+ results << node if node.is_a?(node_type)
+
+ if node.children
+ node.children.each do |child|
+ results.concat(find_all_nodes_by_type(child, node_type))
+ end
+ end
+
+ results
+ end
+end
diff --git a/test/ast/test_compiler_error_messages.rb b/test/ast/test_compiler_error_messages.rb
new file mode 100644
index 000000000..791fa7d0c
--- /dev/null
+++ b/test/ast/test_compiler_error_messages.rb
@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast/compiler'
+require 'review/configure'
+require 'review/book'
+require 'review/i18n'
+
+class TestCompilerErrorMessages < Test::Unit::TestCase
+ def setup
+ @config = ReVIEW::Configure.values
+ @config['language'] = 'ja'
+ @book = ReVIEW::Book::Base.new
+ @book.config = @config
+ @log_io = StringIO.new
+ ReVIEW.logger = ReVIEW::Logger.new(@log_io)
+ ReVIEW::I18n.setup(@config['language'])
+ end
+
+ def test_max_headline_level_error_with_location
+ content = "= Chapter\n\n======= Too Deep Headline"
+
+ chapter = ReVIEW::Book::Chapter.new(
+ @book,
+ 1,
+ 'test',
+ 'deep_headline.re',
+ StringIO.new(content)
+ )
+
+ error = assert_raises(ReVIEW::CompileError) do
+ compiler = ReVIEW::AST::Compiler.for_chapter(chapter)
+ compiler.compile_to_ast(chapter)
+ end
+
+ # Verify error message contains expected information
+ assert_match(/Invalid header: max headline level is 6/, error.message)
+ assert_match(/at line 3/, error.message)
+ assert_match(/in deep_headline\.re/, error.message)
+ end
+
+ def test_unknown_block_command_with_location
+ content = "= Chapter\n\n//unknowncommand{\ncontent\n//}"
+
+ chapter = ReVIEW::Book::Chapter.new(
+ @book,
+ 1,
+ 'test',
+ 'unknown_command.re',
+ StringIO.new(content)
+ )
+
+ error = assert_raises(ReVIEW::CompileError) do
+ compiler = ReVIEW::AST::Compiler.for_chapter(chapter)
+ compiler.compile_to_ast(chapter)
+ end
+
+ # Verify error message contains expected information
+ assert_match(%r{Unknown block command: //unknowncommand}, error.message)
+ assert_match(/at line/, error.message)
+ assert_match(/in unknown_command\.re/, error.message)
+ end
+end
diff --git a/test/ast/test_context_stack.rb b/test/ast/test_context_stack.rb
new file mode 100644
index 000000000..382c98abb
--- /dev/null
+++ b/test/ast/test_context_stack.rb
@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast/markdown_adapter'
+
+class TestContextStack < Test::Unit::TestCase
+ # Mock node class for testing
+ class MockNode
+ attr_reader :children
+
+ def initialize(name)
+ @name = name
+ @children = []
+ end
+
+ def add_child(child)
+ @children << child
+ end
+
+ def to_s
+ @name
+ end
+ end
+
+ def setup
+ @root = MockNode.new('root')
+ @stack = ReVIEW::AST::MarkdownAdapter::ContextStack.new(@root)
+ end
+
+ def test_initialize
+ assert_equal @root, @stack.current
+ assert_true(@stack.empty?)
+ end
+
+ def test_push_and_pop
+ child = MockNode.new('child')
+
+ @stack.push(child)
+ assert_equal child, @stack.current
+ assert_false(@stack.empty?)
+ assert_equal 2, @stack.depth
+
+ @stack.pop
+ assert_equal @root, @stack.current
+ assert_true(@stack.empty?)
+ assert_equal 1, @stack.depth
+ end
+
+ def test_with_context
+ child = MockNode.new('child')
+ result = nil
+
+ @stack.with_context(child) do
+ result = @stack.current
+ end
+
+ # Context should be restored after block
+ assert_equal child, result
+ assert_equal @root, @stack.current
+ end
+
+ def test_with_context_exception_safety
+ child = MockNode.new('child')
+
+ begin
+ @stack.with_context(child) do
+ raise 'Test error'
+ end
+ rescue StandardError
+ # Exception caught
+ end
+
+ # Context should still be restored despite exception
+ assert_equal @root, @stack.current
+ assert_true(@stack.empty?)
+ end
+
+ def test_nested_contexts
+ child1 = MockNode.new('child1')
+ child2 = MockNode.new('child2')
+ child3 = MockNode.new('child3')
+
+ @stack.with_context(child1) do
+ assert_equal child1, @stack.current
+ assert_equal 2, @stack.depth
+
+ @stack.with_context(child2) do
+ assert_equal child2, @stack.current
+ assert_equal 3, @stack.depth
+
+ @stack.with_context(child3) do
+ assert_equal child3, @stack.current
+ assert_equal 4, @stack.depth
+ end
+
+ assert_equal child2, @stack.current
+ end
+
+ assert_equal child1, @stack.current
+ end
+
+ assert_equal @root, @stack.current
+ assert_true(@stack.empty?)
+ end
+
+ def test_pop_from_empty_raises_error
+ assert_raise(ReVIEW::CompileError) do
+ @stack.pop
+ end
+ end
+
+ def test_validate_success
+ assert_nothing_raised do
+ @stack.validate!
+ end
+ end
+
+ def test_validate_nil_in_stack
+ child = MockNode.new('child')
+ @stack.push(child)
+
+ # Manually corrupt the internal stack
+ internal_stack = @stack.instance_variable_get(:@stack)
+ internal_stack << nil
+
+ assert_raise_message(/Context corruption: nil found in stack/) do
+ @stack.validate!
+ end
+ end
+
+ def test_depth
+ assert_equal 1, @stack.depth
+
+ child1 = MockNode.new('child1')
+ @stack.push(child1)
+ assert_equal 2, @stack.depth
+
+ child2 = MockNode.new('child2')
+ @stack.push(child2)
+ assert_equal 3, @stack.depth
+
+ @stack.pop
+ assert_equal 2, @stack.depth
+
+ @stack.pop
+ assert_equal 1, @stack.depth
+ end
+
+ def test_empty
+ assert_true(@stack.empty?)
+
+ child = MockNode.new('child')
+ @stack.push(child)
+ assert_false(@stack.empty?)
+
+ @stack.pop
+ assert_true(@stack.empty?)
+ end
+end
diff --git a/test/ast/test_dumper.rb b/test/ast/test_dumper.rb
new file mode 100644
index 000000000..3452d15fa
--- /dev/null
+++ b/test/ast/test_dumper.rb
@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast/dumper'
+require 'tmpdir'
+require 'json'
+
+class TestDumper < Test::Unit::TestCase
+ def setup
+ @tmpdir = Dir.mktmpdir
+ @config = ReVIEW::Configure.values
+ end
+
+ def teardown
+ FileUtils.rm_rf(@tmpdir)
+ end
+
+ def create_review_file(content, filename = 'test.re')
+ path = File.join(@tmpdir, filename)
+ File.write(path, content)
+ path
+ end
+
+ def test_dump_ast
+ content = <<~REVIEW
+ = Test Chapter
+
+ This is a test paragraph.
+
+ //list[sample][Sample Code]{
+ puts 'Hello, World!'
+ //}
+ REVIEW
+
+ path = create_review_file(content)
+ dumper = ReVIEW::AST::Dumper.new
+ result = dumper.dump_file(path)
+
+ json = JSON.parse(result)
+ assert_equal 'DocumentNode', json['type']
+ assert_equal 3, json['children'].size
+
+ # Check headline
+ assert_equal 'HeadlineNode', json['children'][0]['type']
+ assert_equal 1, json['children'][0]['level']
+ expected_caption_node = {
+ 'type' => 'CaptionNode',
+ 'location' => { 'filename' => 'test.re', 'lineno' => 1 },
+ 'children' => [
+ {
+ 'type' => 'TextNode',
+ 'content' => 'Test Chapter',
+ 'location' => { 'filename' => 'test.re', 'lineno' => 1 }
+ }
+ ]
+ }
+ assert_equal expected_caption_node, json['children'][0]['caption_node']
+
+ # Check paragraph
+ assert_equal 'ParagraphNode', json['children'][1]['type']
+
+ # Check code block
+ assert_equal 'CodeBlockNode', json['children'][2]['type']
+ assert_equal 'sample', json['children'][2]['id']
+ expected_caption = {
+ 'type' => 'CaptionNode',
+ 'location' => { 'filename' => 'test.re', 'lineno' => 5 },
+ 'children' => [
+ {
+ 'type' => 'TextNode',
+ 'content' => 'Sample Code',
+ 'location' => { 'filename' => 'test.re', 'lineno' => 5 }
+ }
+ ]
+ }
+ assert_equal expected_caption, json['children'][2]['caption_node']
+ end
+
+ def test_dump_with_compact_options
+ content = "= Test\n\nParagraph"
+ path = create_review_file(content)
+
+ options = ReVIEW::AST::JSONSerializer::Options.new
+ options.pretty = false
+ options.include_location = false
+
+ dumper = ReVIEW::AST::Dumper.new(serializer_options: options)
+ result = dumper.dump_file(path)
+
+ # Should be compact JSON
+ assert_not_include(result, "\n")
+
+ json = JSON.parse(result)
+ # Should not have location
+ assert_nil(json['location'])
+ end
+
+ def test_dump_multiple_files
+ content1 = "= Chapter 1\n\nContent 1"
+ content2 = "= Chapter 2\n\nContent 2"
+
+ path1 = create_review_file(content1, 'ch01.re')
+ path2 = create_review_file(content2, 'ch02.re')
+
+ dumper = ReVIEW::AST::Dumper.new
+ results = dumper.dump_files([path1, path2])
+
+ assert_equal 2, results.size
+ assert_include(results, path1)
+ assert_include(results, path2)
+
+ json1 = JSON.parse(results[path1])
+ json2 = JSON.parse(results[path2])
+
+ # Check that both documents have headline children
+ assert_equal 'HeadlineNode', json1['children'][0]['type']
+ assert_equal 'HeadlineNode', json2['children'][0]['type']
+ end
+
+ def test_dump_nonexistent_file
+ dumper = ReVIEW::AST::Dumper.new
+ assert_raise(ReVIEW::FileNotFound) do
+ dumper.dump_file('/nonexistent/file.re')
+ end
+ end
+end
diff --git a/test/ast/test_format_auto_detection.rb b/test/ast/test_format_auto_detection.rb
new file mode 100644
index 000000000..05f875896
--- /dev/null
+++ b/test/ast/test_format_auto_detection.rb
@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast/compiler'
+require 'review/book'
+
+# Skip Markdown tests if Ruby < 3.1 (markly requires Ruby >= 3.1)
+# Note: Some tests use Markdown format detection and compilation
+if Gem::Version.new(RUBY_VERSION) < Gem::Version.new('3.1.0')
+ # Define empty test class to avoid load errors
+ class TestFormatAutoDetection < Test::Unit::TestCase
+ def test_skipped
+ omit('Markdown tests require Ruby >= 3.1')
+ end
+ end
+ return
+end
+
+class TestFormatAutoDetection < Test::Unit::TestCase
+ def setup
+ @config = ReVIEW::Configure.values
+ @book = ReVIEW::Book::Base.new('.', config: @config)
+ end
+
+ def test_markdown_file_detection
+ # Test .md extension
+ chapter_md = create_chapter('test.md', '# Markdown heading')
+ compiler = ReVIEW::AST::Compiler.for_chapter(chapter_md)
+
+ assert_instance_of(ReVIEW::AST::MarkdownCompiler, compiler)
+ end
+
+ def test_review_file_detection
+ # Test .re extension (Re:VIEW format)
+ chapter_re = create_chapter('test.re', '= Re:VIEW heading')
+ compiler = ReVIEW::AST::Compiler.for_chapter(chapter_re)
+
+ assert_instance_of(ReVIEW::AST::Compiler, compiler)
+ assert_not_instance_of(ReVIEW::AST::MarkdownCompiler, compiler)
+ end
+
+ def test_unknown_extension_defaults_to_review
+ # Test unknown extension defaults to Re:VIEW format
+ chapter_unknown = create_chapter('test.txt', '= Some heading')
+ compiler = ReVIEW::AST::Compiler.for_chapter(chapter_unknown)
+
+ assert_instance_of(ReVIEW::AST::Compiler, compiler)
+ assert_not_instance_of(ReVIEW::AST::MarkdownCompiler, compiler)
+ end
+
+ def test_no_extension_defaults_to_review
+ # Test no extension defaults to Re:VIEW format
+ chapter_no_ext = create_chapter('test', '= Some heading')
+ compiler = ReVIEW::AST::Compiler.for_chapter(chapter_no_ext)
+
+ assert_instance_of(ReVIEW::AST::Compiler, compiler)
+ assert_not_instance_of(ReVIEW::AST::MarkdownCompiler, compiler)
+ end
+
+ def test_markdown_compilation_with_auto_detection
+ # Test that Markdown file actually compiles to AST
+ content = <<~MD
+ # Main Title
+
+ This is a paragraph with **bold** text.
+
+ ## Subsection
+
+ - List item 1
+ - List item 2
+ MD
+
+ chapter = create_chapter('test.md', content)
+ compiler = ReVIEW::AST::Compiler.for_chapter(chapter)
+ ast = compiler.compile_to_ast(chapter)
+
+ assert_not_nil(ast)
+ assert_instance_of(ReVIEW::AST::DocumentNode, ast)
+ assert(ast.children.size > 0)
+
+ # Check that we get headline nodes
+ headlines = ast.children.select { |child| child.is_a?(ReVIEW::AST::HeadlineNode) }
+ assert_equal(2, headlines.size)
+ assert_equal(1, headlines[0].level)
+ assert_equal(2, headlines[1].level)
+ end
+
+ def test_review_compilation_with_auto_detection
+ # Test that Re:VIEW file actually compiles to AST
+ content = <<~RE
+ = Main Title
+
+ This is a paragraph with @<b>{bold} text.
+
+ == Subsection
+
+ * List item 1
+ * List item 2
+ RE
+
+ chapter = create_chapter('test.re', content)
+ compiler = ReVIEW::AST::Compiler.for_chapter(chapter)
+ ast = compiler.compile_to_ast(chapter)
+
+ assert_not_nil(ast)
+ assert_instance_of(ReVIEW::AST::DocumentNode, ast)
+ assert(ast.children.size > 0)
+
+ # Check that we get headline nodes
+ headlines = ast.children.select { |child| child.is_a?(ReVIEW::AST::HeadlineNode) }
+ assert_equal(2, headlines.size)
+ assert_equal(1, headlines[0].level)
+ assert_equal(2, headlines[1].level)
+ end
+
+ private
+
+ def create_chapter(filename, content)
+ require 'stringio'
+ ReVIEW::Book::Chapter.new(@book, 1, filename, filename, StringIO.new(content))
+ end
+end
diff --git a/test/ast/test_html_renderer.rb b/test/ast/test_html_renderer.rb
new file mode 100644
index 000000000..830c8c749
--- /dev/null
+++ b/test/ast/test_html_renderer.rb
@@ -0,0 +1,600 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast/compiler'
+require 'review/ast/node'
+require 'review/renderer/html_renderer'
+require 'review/book'
+require 'review/book/chapter'
+require 'review/configure'
+require 'review/i18n'
+
+class TestHtmlRenderer < Test::Unit::TestCase
+ def setup
+ @config = ReVIEW::Configure.values
+ @config['language'] = 'ja'
+ @book = ReVIEW::Book::Base.new(config: @config)
+
+ ReVIEW::I18n.setup('ja')
+
+ @compiler = ReVIEW::AST::Compiler.new
+ end
+
+ def test_headline_rendering
+ content = "= Test Chapter\n\nParagraph text.\n"
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render(ast_root)
+
+ assert_match(%r{<h1>.*Test Chapter</h1>}, html_output)
+ assert_match(%r{<p>Paragraph text\.</p>}, html_output)
+ end
+
+ def test_inline_elements
+ content = "= Chapter\n\nThis is @<b>{bold} and @<i>{italic} text.\n"
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render(ast_root)
+
+ assert_match(%r{<b>bold</b>}, html_output)
+ assert_match(%r{<i>italic</i>}, html_output)
+ end
+
+ def test_code_block
+ content = <<~REVIEW
+ = Chapter
+
+ //list[sample][Sample Code][ruby]{
+ puts "Hello World"
+ //}
+ REVIEW
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render(ast_root)
+
+ assert_match(/<div id="sample" class="caption-code">/, html_output)
+ assert_match(%r{<p class="caption">リスト1\.1: Sample Code</p>}, html_output)
+ assert_match(%r{<pre class="list.*">puts "Hello World"\n</pre>}, html_output)
+ end
+
+ def test_table_rendering
+ content = <<~REVIEW
+ = Chapter
+
+ //table[sample][Sample Table]{
+ Header1 Header2
+ --------------------
+ Cell1 Cell2
+ //}
+ REVIEW
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render(ast_root)
+
+ assert_match(/<div id="sample" class="table">/, html_output)
+ assert_match(%r{<p class="caption">表1\.1: Sample Table</p>}, html_output)
+ # No thead/tbody sections like HTMLBuilder
+ assert_no_match(/<thead>/, html_output)
+ assert_no_match(/<tbody>/, html_output)
+ # Since ---- is only 5 chars, it's not a separator, so it appears as body content
+ assert_match(%r{<th>Header1</th>}, html_output)
+ assert_match(%r{<td>Cell1</td>}, html_output)
+ end
+
+ def test_column_rendering
+ content = <<~REVIEW
+ = Chapter
+
+ ===[column] Column Title
+
+ Column content here.
+
+ ===[/column]
+ REVIEW
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render(ast_root)
+
+ assert_match(/<div class="column">/, html_output)
+ assert_match(/Column Title/, html_output)
+ assert_match(%r{<p>Column content here\.</p>}, html_output)
+ end
+
+ def test_note_block
+ content = <<~REVIEW
+ = Chapter
+
+ //note[Sample Note]{
+ This is a note.
+ //}
+ REVIEW
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render(ast_root)
+
+ assert_match(/<div class="note">/, html_output)
+ assert_match(%r{<p class="caption">Sample Note</p>}, html_output)
+ # Note content should be wrapped in paragraph tags like HTMLBuilder
+ assert_match(%r{<p>This is a note\.</p>}, html_output)
+ end
+
+ def test_text_escaping
+ content = "= Chapter\n\nText with <html> & \"quotes\".\n"
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render(ast_root)
+
+ assert_match(/<html> & "quotes"/, html_output)
+ end
+
+ def test_id_normalization
+ content = "={test-chapter} Test Chapter\n\nParagraph.\n"
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render(ast_root)
+
+ # HtmlRenderer now uses fixed anchor IDs like HTMLBuilder
+ assert_match(%r{<h1 id="test-chapter">.*</h1>}, html_output)
+ # Chapter title should be present
+ assert_match(/Test Chapter/, html_output)
+ end
+
+ def test_href_inline
+ content = "= Chapter\n\nVisit @<href>{https://example.com, Example Site}.\n"
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render(ast_root)
+
+ assert_match(%r{<a href="https://example\.com".*>Example Site</a>}, html_output)
+ end
+
+ def test_visit_embed_raw_basic
+ # Test basic //raw command without builder specification
+ embed = ReVIEW::AST::EmbedNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0),
+ embed_type: :raw,
+ arg: 'Raw HTML content with <br> tag',
+ target_builders: nil,
+ content: 'Raw HTML content with <br> tag')
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(''))
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ result = renderer.visit(embed)
+ expected = 'Raw HTML content with <br /> tag'
+
+ assert_equal expected, result
+ end
+
+ def test_visit_embed_raw_html_targeted
+ # Test //raw command targeted for HTML
+ embed = ReVIEW::AST::EmbedNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0),
+ embed_type: :raw,
+ arg: '|html|<div class="custom">HTML content</div>',
+ target_builders: ['html'],
+ content: '<div class="custom">HTML content</div>')
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(''))
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ result = renderer.visit(embed)
+ expected = '<div class="custom">HTML content</div>'
+
+ assert_equal expected, result
+ end
+
+ def test_visit_embed_raw_latex_targeted
+ # Test //raw command targeted for LaTeX (should output nothing)
+ embed = ReVIEW::AST::EmbedNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0),
+ embed_type: :raw,
+ arg: '|latex|\\textbf{LaTeX content}',
+ target_builders: ['latex'],
+ content: '\\textbf{LaTeX content}')
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(''))
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ result = renderer.visit(embed)
+ expected = ''
+
+ assert_equal expected, result
+ end
+
+ def test_visit_embed_raw_multiple_builders
+ # Test //raw command targeted for multiple builders including HTML
+ embed = ReVIEW::AST::EmbedNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0),
+ embed_type: :raw,
+ arg: '|html,latex|Content for both',
+ target_builders: ['html', 'latex'],
+ content: 'Content for both')
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(''))
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ result = renderer.visit(embed)
+ expected = 'Content for both'
+
+ assert_equal expected, result
+ end
+
+ def test_visit_embed_raw_inline
+ # Test inline @<raw> command
+ embed = ReVIEW::AST::EmbedNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0),
+ embed_type: :inline,
+ arg: '|html|<span class="inline">HTML</span>',
+ target_builders: ['html'],
+ content: '<span class="inline">HTML</span>')
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(''))
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ result = renderer.visit(embed)
+ expected = '<span class="inline">HTML</span>'
+
+ assert_equal expected, result
+ end
+
+ def test_visit_embed_raw_newline_conversion
+ # Test \\n to newline conversion
+ embed = ReVIEW::AST::EmbedNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0),
+ embed_type: :raw,
+ arg: 'Line 1\\nLine 2\\nLine 3',
+ target_builders: nil,
+ content: 'Line 1\\nLine 2\\nLine 3')
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(''))
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ result = renderer.visit(embed)
+ expected = "Line 1\nLine 2\nLine 3"
+
+ assert_equal expected, result
+ end
+
+ def test_visit_embed_raw_xhtml_compliance
+ # Test XHTML compliance for self-closing tags
+ embed = ReVIEW::AST::EmbedNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0),
+ embed_type: :raw,
+ arg: '<hr><br><img src="test.png"><input type="text">',
+ target_builders: nil,
+ content: '<hr><br><img src="test.png"><input type="text">')
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(''))
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ result = renderer.visit(embed)
+ expected = '<hr /><br /><img src="test.png" /><input type="text" />'
+
+ assert_equal expected, result
+ end
+
+ def test_visit_list_definition
+ # Test definition list
+ list = ReVIEW::AST::ListNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), list_type: :dl)
+
+ # First definition item
+ item1 = ReVIEW::AST::ListItemNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), level: 1)
+ item1.parent = list # Set parent for list type detection
+ # Term goes to term_children
+ term1 = ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'Alpha')
+ item1.term_children << term1
+ # Definition goes to children
+ def1 = ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'RISC CPU made by DEC.')
+ item1.add_child(def1)
+
+ # Second definition item
+ item2 = ReVIEW::AST::ListItemNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), level: 1)
+ item2.parent = list # Set parent for list type detection
+ # Term goes to term_children
+ term2 = ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'POWER')
+ item2.term_children << term2
+ # Definition goes to children
+ def2 = ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'RISC CPU made by IBM and Motorola.')
+ item2.add_child(def2)
+
+ list.add_child(item1)
+ list.add_child(item2)
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(''))
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ result = renderer.visit(list)
+
+ expected = "<dl>\n" +
+ '<dt>Alpha</dt><dd>RISC CPU made by DEC.</dd>' +
+ '<dt>POWER</dt><dd>RISC CPU made by IBM and Motorola.</dd>' +
+ "\n</dl>\n"
+
+ assert_equal expected, result
+ end
+
+ def test_visit_list_definition_single_child
+ # Test definition list with term only (no definition)
+ list = ReVIEW::AST::ListNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), list_type: :dl)
+
+ item = ReVIEW::AST::ListItemNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), level: 1)
+ item.parent = list # Set parent for list type detection
+ # Term goes to term_children
+ term = ReVIEW::AST::TextNode.new(location: ReVIEW::SnapshotLocation.new(nil, 0), content: 'Term Only')
+ item.term_children << term
+ # No definition (children is empty)
+
+ list.add_child(item)
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(''))
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ result = renderer.visit(list)
+
+ expected = "<dl>\n" +
+ '<dt>Term Only</dt><dd></dd>' +
+ "\n</dl>\n"
+
+ assert_equal expected, result
+ end
+
+ def test_tex_equation_without_id_mathjax
+ # Test TexEquationNode without ID using MathJax
+ @config['math_format'] = 'mathjax'
+ @book.config = @config
+
+ require 'review/ast/tex_equation_node'
+ equation = ReVIEW::AST::TexEquationNode.new(
+ location: nil,
+ id: nil,
+ content: 'E = mc^2'
+ )
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(''))
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ result = renderer.visit(equation)
+
+ # HTMLBuilder uses $$ for display mode
+ expected = "<div class=\"equation\">\n$$E = mc^2$$\n</div>\n"
+
+ assert_equal expected, result
+ end
+
+ def test_tex_equation_without_id_plain
+ # Test TexEquationNode without ID using plain text
+ @config['math_format'] = nil
+ @book.config = @config
+
+ require 'review/ast/tex_equation_node'
+ equation = ReVIEW::AST::TexEquationNode.new(
+ location: nil,
+ id: nil,
+ content: 'E = mc^2'
+ )
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(''))
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ result = renderer.visit(equation)
+
+ # Fallback format wraps in div.equation and pre tags
+ expected = "<div class=\"equation\">\n<pre>E = mc^2\n</pre>\n</div>\n"
+
+ assert_equal expected, result
+ end
+
+ def test_tex_equation_with_id_and_caption_mathjax
+ # Test TexEquationNode with ID and caption using MathJax
+ @config['math_format'] = 'mathjax'
+ @book.config = @config
+
+ content = <<~REVIEW
+ = Chapter
+
+ //texequation[eq1][Einstein's Mass-Energy Equivalence]{
+ E = mc^2
+ //}
+ REVIEW
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render(ast_root)
+
+ # Use caption-equation class like HTMLBuilder
+ assert_match(/<div id="eq1" class="caption-equation">/, html_output)
+ # Caption should use I18n.t('equation') and proper formatting
+ assert_match(%r{<p class="caption">式1\.1: Einstein's Mass-Energy Equivalence</p>}, html_output)
+ # MathJax uses $$ delimiters
+ assert_match(/\$\$E = mc\^2\$\$/, html_output)
+ end
+
+ def test_tex_equation_with_id_only_mathjax
+ # Test TexEquationNode with ID only (no caption) using MathJax
+ @config['math_format'] = 'mathjax'
+ @book.config = @config
+
+ content = <<~REVIEW
+ = Chapter
+
+ //texequation[eq1]{
+ \\int_{-\\infty}^{\\infty} e^{-x^2} dx = \\sqrt{\\pi}
+ //}
+ REVIEW
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render(ast_root)
+
+ # Use caption-equation class like HTMLBuilder
+ assert_match(/<div id="eq1" class="caption-equation">/, html_output)
+ # Caption should show equation number only (with colon from format_number_header)
+ assert_match(%r{<p class="caption">式1\.1:</p>}, html_output)
+ # Check that equation content is present
+ assert_match(/\\int_/, html_output)
+ end
+
+ def test_nest_ul
+ content = <<~EOS
+ = Chapter
+
+ * UL1
+
+ //beginchild
+
+ 1. UL1-OL1
+ 2. UL1-OL2
+
+ * UL1-UL1
+ * UL1-UL2
+
+ : UL1-DL1
+ \tUL1-DD1
+ : UL1-DL2
+ \tUL1-DD2
+
+ //endchild
+
+ * UL2
+
+ //beginchild
+
+ UL2-PARA
+
+ //endchild
+ EOS
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render(ast_root)
+
+ # Verify that nested structure is present
+ assert_match(/<li>UL1/, html_output)
+ assert_match(/<li>UL2/, html_output)
+ assert_match(/<li>UL1-OL1/, html_output)
+ assert_match(/<li>UL1-UL1/, html_output)
+ assert_match(/<dt>UL1-DL1/, html_output)
+ end
+
+ def test_nest_ol
+ content = <<~EOS
+ = Chapter
+
+ 1. OL1
+
+ //beginchild
+
+ 1. OL1-OL1
+ 2. OL1-OL2
+
+ * OL1-UL1
+ * OL1-UL2
+
+ : OL1-DL1
+ \tOL1-DD1
+ : OL1-DL2
+ \tOL1-DD2
+
+ //endchild
+
+ 2. OL2
+
+ //beginchild
+
+ OL2-PARA
+
+ //endchild
+ EOS
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render(ast_root)
+
+ # Verify that nested structure is present
+ assert_match(/<li>OL1/, html_output)
+ assert_match(/<li>OL2/, html_output)
+ assert_match(/<li>OL1-OL1/, html_output)
+ assert_match(/<li>OL1-UL1/, html_output)
+ assert_match(/<dt>OL1-DL1/, html_output)
+ end
+
+ def test_nest_dl
+ content = <<~EOS
+ = Chapter
+
+ : DL1
+
+ //beginchild
+
+ 1. DL1-OL1
+ 2. DL1-OL2
+
+ * DL1-UL1
+ * DL1-UL2
+
+ : DL1-DL1
+ \tDL1-DD1
+ : DL1-DL2
+ \tDL1-DD2
+
+ //endchild
+
+ : DL2
+ \tDD2
+
+ //beginchild
+
+ * DD2-UL1
+ * DD2-UL2
+
+ DD2-PARA
+
+ //endchild
+ EOS
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render(ast_root)
+
+ # Verify that nested structure is present
+ assert_match(/<dt>DL1/, html_output)
+ assert_match(/<dt>DL2/, html_output)
+ assert_match(/<li>DL1-OL1/, html_output)
+ assert_match(/<li>DL1-UL1/, html_output)
+ assert_match(/<li>DD2-UL1/, html_output)
+ end
+end
diff --git a/test/ast/test_html_renderer_builder_comparison.rb b/test/ast/test_html_renderer_builder_comparison.rb
new file mode 100644
index 000000000..43f3306b7
--- /dev/null
+++ b/test/ast/test_html_renderer_builder_comparison.rb
@@ -0,0 +1,426 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require_relative '../support/review/test/html_comparator'
+require 'review/ast/diff/html'
+
+class TestHtmlRendererBuilderComparison < Test::Unit::TestCase
+ def setup
+ @converter = ReVIEW::Test::HtmlComparator.new
+ @comparator = ReVIEW::AST::Diff::Html.new
+ end
+
+ def test_simple_paragraph_comparison
+ source = 'This is a simple paragraph.'
+
+ builder_html = @converter.convert_with_builder(source)
+ renderer_html = @converter.convert_with_renderer(source)
+
+ result = @comparator.compare(builder_html, renderer_html)
+
+ unless result.same_hash?
+ puts "Builder HTML: #{builder_html.inspect}"
+ puts "Renderer HTML: #{renderer_html.inspect}"
+ puts result.pretty_diff
+ end
+
+ assert result.same_hash?, 'Simple paragraph should produce equivalent HTML'
+ end
+
+ def test_headline_comparison
+ source = '= Chapter Title'
+
+ builder_html = @converter.convert_with_builder(source)
+ renderer_html = @converter.convert_with_renderer(source)
+
+ result = @comparator.compare(builder_html, renderer_html)
+
+ unless result.same_hash?
+ puts "Builder HTML: #{builder_html.inspect}"
+ puts "Renderer HTML: #{renderer_html.inspect}"
+ puts result.pretty_diff
+ end
+
+ assert result.same_hash?, 'Headline should produce equivalent HTML'
+ end
+
+ def test_inline_formatting_comparison
+ source = 'This has @<b>{bold} and @<i>{italic} and @<code>{code} text.'
+
+ builder_html = @converter.convert_with_builder(source)
+ renderer_html = @converter.convert_with_renderer(source)
+
+ result = @comparator.compare(builder_html, renderer_html)
+
+ unless result.same_hash?
+ puts "Builder HTML: #{builder_html.inspect}"
+ puts "Renderer HTML: #{renderer_html.inspect}"
+ puts result.pretty_diff
+ end
+
+ assert result.same_hash?, 'Inline formatting should produce equivalent HTML'
+ end
+
+ def test_code_block_comparison
+ source = <<~RE
+ //list[example][Code Example]{
+ def hello
+ puts "Hello World"
+ end
+ //}
+ RE
+
+ builder_html = @converter.convert_with_builder(source)
+ renderer_html = @converter.convert_with_renderer(source)
+
+ result = @comparator.compare(builder_html, renderer_html)
+
+ unless result.same_hash?
+ puts "Builder HTML: #{builder_html.inspect}"
+ puts "Renderer HTML: #{renderer_html.inspect}"
+ puts result.pretty_diff
+ end
+
+ assert result.same_hash?
+ end
+
+ def test_table_comparison
+ source = <<~RE
+ //table[sample][Sample Table]{
+ Header 1 Header 2
+ ---------------------
+ Data 1 Data 2
+ Data 3 Data 4
+ //}
+ RE
+
+ builder_html = @converter.convert_with_builder(source)
+ renderer_html = @converter.convert_with_renderer(source)
+
+ result = @comparator.compare(builder_html, renderer_html)
+
+ unless result.same_hash?
+ puts "Builder HTML: #{builder_html.inspect}"
+ puts "Renderer HTML: #{renderer_html.inspect}"
+ puts result.pretty_diff
+ end
+
+ assert result.same_hash?
+ end
+
+ def test_list_comparison
+ source = <<~RE
+ * First item
+ * Second item
+ * Third item
+ RE
+
+ builder_html = @converter.convert_with_builder(source)
+ renderer_html = @converter.convert_with_renderer(source)
+
+ result = @comparator.compare(builder_html, renderer_html)
+
+ unless result.same_hash?
+ puts "Builder HTML: #{builder_html.inspect}"
+ puts "Renderer HTML: #{renderer_html.inspect}"
+ puts result.pretty_diff
+ end
+
+ assert result.same_hash?
+ end
+
+ def test_note_block_comparison
+ source = <<~RE
+ //note[Note Title]{
+ This is a note block.
+ //}
+ RE
+
+ builder_html = @converter.convert_with_builder(source)
+ renderer_html = @converter.convert_with_renderer(source)
+
+ result = @comparator.compare(builder_html, renderer_html)
+
+ unless result.same_hash?
+ puts "Builder HTML: #{builder_html.inspect}"
+ puts "Renderer HTML: #{renderer_html.inspect}"
+ puts result.pretty_diff
+ end
+
+ assert result.same_hash?
+ end
+
+ def test_complex_document_comparison
+ source = <<~RE
+ = Chapter Title
+
+ This is a paragraph with @<b>{bold} text.
+
+ == Section Title
+
+ Here's a list:
+
+ * Item 1
+ * Item 2
+
+ And a code block:
+
+ //list[example][Example]{
+ puts "Hello"
+ //}
+
+ //table[data][Data Table]{
+ Name Value
+ ----------------------
+ A 1
+ B 2
+ //}
+ RE
+
+ builder_html = @converter.convert_with_builder(source)
+ renderer_html = @converter.convert_with_renderer(source)
+
+ result = @comparator.compare(builder_html, renderer_html)
+
+ unless result.same_hash?
+ puts 'Complex document differences found:'
+ puts "Builder HTML length: #{builder_html.length}"
+ puts "Renderer HTML length: #{renderer_html.length}"
+ puts "Builder HTML: #{builder_html.inspect}"
+ puts "Renderer HTML: #{renderer_html.inspect}"
+ puts result.pretty_diff
+ end
+
+ assert result.same_hash?
+ end
+
+ # Tests with actual Re:VIEW files from samples/syntax-book
+ def test_syntax_book_ch01
+ file_path = File.join(__dir__, '../../samples/syntax-book/ch01.re')
+ source = File.read(file_path)
+
+ builder_html = @converter.convert_with_builder(source)
+ renderer_html = @converter.convert_with_renderer(source)
+
+ result = @comparator.compare(builder_html, renderer_html)
+
+ unless result.same_hash?
+ puts 'ch01.re differences found:'
+ puts "Builder HTML length: #{builder_html.length}"
+ puts "Renderer HTML length: #{renderer_html.length}"
+ puts result.pretty_diff
+ end
+
+ assert result.same_hash?, 'ch01.re should produce equivalent HTML'
+ end
+
+ def test_syntax_book_ch02
+ book_dir = File.join(__dir__, '../../samples/syntax-book')
+ result = @converter.convert_chapter_with_book_context(book_dir, 'ch02')
+
+ builder_html = result[:builder]
+ renderer_html = result[:renderer]
+
+ result = @comparator.compare(builder_html, renderer_html)
+
+ unless result.same_hash?
+ puts 'ch02.re differences found:'
+ puts "Builder HTML length: #{builder_html.length}"
+ puts "Renderer HTML length: #{renderer_html.length}"
+ puts result.pretty_diff
+ end
+
+ assert result.same_hash?, 'ch02.re should produce equivalent HTML'
+ end
+
+ def test_syntax_book_ch03
+ file_path = File.join(__dir__, '../../samples/syntax-book/ch03.re')
+ source = File.read(file_path)
+
+ builder_html = @converter.convert_with_builder(source)
+ renderer_html = @converter.convert_with_renderer(source)
+
+ result = @comparator.compare(builder_html, renderer_html)
+
+ unless result.same_hash?
+ puts 'ch03.re differences found:'
+ puts "Builder HTML: #{builder_html}"
+ puts "Renderer HTML: #{renderer_html}"
+ puts result.pretty_diff
+ end
+
+ assert result.same_hash?, 'ch03.re should produce equivalent HTML'
+ end
+
+ def test_syntax_book_pre01
+ file_path = File.join(__dir__, '../../samples/syntax-book/pre01.re')
+ source = File.read(file_path)
+
+ builder_html = @converter.convert_with_builder(source)
+ renderer_html = @converter.convert_with_renderer(source)
+
+ result = @comparator.compare(builder_html, renderer_html)
+
+ unless result.same_hash?
+ puts 'pre01.re differences found:'
+ puts "Builder HTML length: #{builder_html.length}"
+ puts "Renderer HTML length: #{renderer_html.length}"
+ puts result.pretty_diff
+ end
+
+ assert result.same_hash?, 'pre01.re should produce equivalent HTML'
+ end
+
+ def test_syntax_book_appA
+ file_path = File.join(__dir__, '../../samples/syntax-book/appA.re')
+ source = File.read(file_path)
+
+ builder_html = @converter.convert_with_builder(source)
+ renderer_html = @converter.convert_with_renderer(source)
+
+ result = @comparator.compare(builder_html, renderer_html)
+
+ unless result.same_hash?
+ puts 'appA.re differences found:'
+ puts "Builder HTML length: #{builder_html.length}"
+ puts "Renderer HTML length: #{renderer_html.length}"
+ puts result.pretty_diff
+ end
+
+ assert result.same_hash?, 'appA.re should produce equivalent HTML'
+ end
+
+ def test_syntax_book_part2
+ file_path = File.join(__dir__, '../../samples/syntax-book/part2.re')
+ source = File.read(file_path)
+
+ builder_html = @converter.convert_with_builder(source)
+ renderer_html = @converter.convert_with_renderer(source)
+
+ result = @comparator.compare(builder_html, renderer_html)
+
+ unless result.same_hash?
+ puts 'part2.re differences found:'
+ puts "Builder HTML length: #{builder_html.length}"
+ puts "Renderer HTML length: #{renderer_html.length}"
+ puts result.pretty_diff
+ end
+
+ assert result.same_hash?, 'part2.re should produce equivalent HTML'
+ end
+
+ def test_syntax_book_bib
+ book_dir = File.join(__dir__, '../../samples/syntax-book')
+ result = @converter.convert_chapter_with_book_context(book_dir, 'bib')
+
+ builder_html = result[:builder]
+ renderer_html = result[:renderer]
+
+ result = @comparator.compare(builder_html, renderer_html)
+
+ unless result.same_hash?
+ puts 'bib.re differences found:'
+ puts "Builder HTML length: #{builder_html.length}"
+ puts "Renderer HTML length: #{renderer_html.length}"
+ puts result.pretty_diff
+ end
+
+ assert result.same_hash?, 'bib.re should produce equivalent HTML'
+ end
+
+ # Tests with actual Re:VIEW files from samples/debug-book
+ def test_debug_book_advanced_features
+ file_path = File.join(__dir__, '../../samples/debug-book/advanced_features.re')
+ source = File.read(file_path)
+
+ builder_html = @converter.convert_with_builder(source)
+ renderer_html = @converter.convert_with_renderer(source)
+
+ result = @comparator.compare(builder_html, renderer_html)
+
+ unless result.same_hash?
+ puts 'advanced_features.re differences found:'
+ puts "Builder HTML length: #{builder_html.length}"
+ puts "Renderer HTML length: #{renderer_html.length}"
+ puts result.pretty_diff
+ end
+
+ assert result.same_hash?, 'advanced_features.re should produce equivalent HTML'
+ end
+
+ def test_debug_book_comprehensive
+ file_path = File.join(__dir__, '../../samples/debug-book/comprehensive.re')
+ source = File.read(file_path)
+
+ builder_html = @converter.convert_with_builder(source)
+ renderer_html = @converter.convert_with_renderer(source)
+
+ result = @comparator.compare(builder_html, renderer_html)
+
+ unless result.same_hash?
+ puts 'comprehensive.re differences found:'
+ puts "Builder HTML length: #{builder_html.length}"
+ puts "Renderer HTML length: #{renderer_html.length}"
+ puts result.pretty_diff
+ end
+
+ assert result.same_hash?, 'comprehensive.re should produce equivalent HTML'
+ end
+
+ def test_debug_book_edge_cases_test
+ file_path = File.join(__dir__, '../../samples/debug-book/edge_cases_test.re')
+ source = File.read(file_path)
+
+ builder_html = @converter.convert_with_builder(source)
+ renderer_html = @converter.convert_with_renderer(source)
+
+ result = @comparator.compare(builder_html, renderer_html)
+
+ unless result.same_hash?
+ puts 'edge_cases_test.re differences found:'
+ puts "Builder HTML length: #{builder_html.length}"
+ puts "Renderer HTML length: #{renderer_html.length}"
+ puts result.pretty_diff
+ end
+
+ assert result.same_hash?, 'edge_cases_test.re should produce equivalent HTML'
+ end
+
+ def test_debug_book_extreme_features
+ file_path = File.join(__dir__, '../../samples/debug-book/extreme_features.re')
+ source = File.read(file_path)
+
+ builder_html = @converter.convert_with_builder(source)
+ renderer_html = @converter.convert_with_renderer(source)
+
+ result = @comparator.compare(builder_html, renderer_html)
+
+ unless result.same_hash?
+ puts 'extreme_features.re differences found:'
+ puts "Builder HTML length: #{builder_html.length}"
+ puts "Renderer HTML length: #{renderer_html.length}"
+ puts result.pretty_diff
+ end
+
+ assert result.same_hash?, 'extreme_features.re should produce equivalent HTML'
+ end
+
+ def test_debug_book_multicontent_test
+ file_path = File.join(__dir__, '../../samples/debug-book/multicontent_test.re')
+ source = File.read(file_path)
+
+ builder_html = @converter.convert_with_builder(source)
+ renderer_html = @converter.convert_with_renderer(source)
+
+ result = @comparator.compare(builder_html, renderer_html)
+
+ unless result.same_hash?
+ puts 'multicontent_test.re differences found:'
+ puts "Builder HTML length: #{builder_html.length}"
+ puts "Renderer HTML length: #{renderer_html.length}"
+ puts result.pretty_diff
+ end
+
+ assert result.same_hash?, 'multicontent_test.re should produce equivalent HTML'
+ end
+end
diff --git a/test/ast/test_html_renderer_inline_elements.rb b/test/ast/test_html_renderer_inline_elements.rb
new file mode 100644
index 000000000..b3c7b0ce0
--- /dev/null
+++ b/test/ast/test_html_renderer_inline_elements.rb
@@ -0,0 +1,602 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require_relative '../book_test_helper'
+require 'review/ast/compiler'
+require 'review/ast/node'
+require 'review/renderer/html_renderer'
+require 'review/book'
+require 'review/book/chapter'
+require 'review/configure'
+require 'review/i18n'
+
+class TestHtmlRendererInlineElements < Test::Unit::TestCase
+ include BookTestHelper
+
+ def setup
+ @config = ReVIEW::Configure.values
+ @config['language'] = 'ja'
+ @config['secnolevel'] = 2
+ @book = ReVIEW::Book::Base.new(config: @config)
+
+ ReVIEW::I18n.setup('ja')
+
+ @compiler = ReVIEW::AST::Compiler.new
+ end
+
+ def render_inline(content)
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ renderer.render(ast_root)
+ end
+
+ # Basic text formatting
+ def test_inline_b
+ content = "= Chapter\n\nThis is @<b>{bold} text.\n"
+ output = render_inline(content)
+ assert_match(%r{<b>bold</b>}, output)
+ end
+
+ def test_inline_strong
+ content = "= Chapter\n\nThis is @<strong>{strong} text.\n"
+ output = render_inline(content)
+ assert_match(%r{<strong>strong</strong>}, output)
+ end
+
+ def test_inline_i
+ content = "= Chapter\n\nThis is @<i>{italic} text.\n"
+ output = render_inline(content)
+ assert_match(%r{<i>italic</i>}, output)
+ end
+
+ def test_inline_em
+ content = "= Chapter\n\nThis is @<em>{emphasized} text.\n"
+ output = render_inline(content)
+ assert_match(%r{<em>emphasized</em>}, output)
+ end
+
+ def test_inline_u
+ content = "= Chapter\n\nThis is @<u>{underlined} text.\n"
+ output = render_inline(content)
+ assert_match(%r{<u>underlined</u>}, output)
+ end
+
+ def test_inline_del
+ content = "= Chapter\n\nThis is @<del>{deleted} text.\n"
+ output = render_inline(content)
+ assert_match(%r{<del>deleted</del>}, output)
+ end
+
+ def test_inline_ins
+ content = "= Chapter\n\nThis is @<ins>{inserted} text.\n"
+ output = render_inline(content)
+ assert_match(%r{<ins>inserted</ins>}, output)
+ end
+
+ # Code and monospace formatting
+ def test_inline_code
+ content = "= Chapter\n\nInline code: @<code>{var x = 10}\n"
+ output = render_inline(content)
+ assert_match(%r{<code class="inline-code tt">var x = 10</code>}, output)
+ end
+
+ def test_inline_tt
+ content = "= Chapter\n\nMonospace: @<tt>{monospace}\n"
+ output = render_inline(content)
+ assert_match(%r{<code class="tt">monospace</code>}, output)
+ end
+
+ def test_inline_ttb
+ content = "= Chapter\n\nBold monospace: @<ttb>{bold mono}\n"
+ output = render_inline(content)
+ assert_match(%r{<code class="tt"><b>bold mono</b></code>}, output)
+ end
+
+ def test_inline_tti
+ content = "= Chapter\n\nItalic monospace: @<tti>{italic mono}\n"
+ output = render_inline(content)
+ assert_match(%r{<code class="tt"><i>italic mono</i></code>}, output)
+ end
+
+ def test_inline_kbd
+ content = "= Chapter\n\nPress @<kbd>{Enter} key.\n"
+ output = render_inline(content)
+ assert_match(%r{<kbd>Enter</kbd>}, output)
+ end
+
+ def test_inline_samp
+ content = "= Chapter\n\nOutput: @<samp>{sample output}\n"
+ output = render_inline(content)
+ assert_match(%r{<samp>sample output</samp>}, output)
+ end
+
+ def test_inline_var
+ content = "= Chapter\n\nVariable: @<var>{variableName}\n"
+ output = render_inline(content)
+ assert_match(%r{<var>variableName</var>}, output)
+ end
+
+ # Superscript and subscript
+ def test_inline_sup
+ content = "= Chapter\n\nE = mc@<sup>{2}\n"
+ output = render_inline(content)
+ assert_match(%r{mc<sup>2</sup>}, output)
+ end
+
+ def test_inline_sub
+ content = "= Chapter\n\nH@<sub>{2}O\n"
+ output = render_inline(content)
+ assert_match(%r{H<sub>2</sub>O}, output)
+ end
+
+ # Ruby annotation
+ def test_inline_ruby
+ content = "= Chapter\n\n@<ruby>{漢字, かんじ}\n"
+ output = render_inline(content)
+ # InlineElementRenderer outputs simple ruby without rp tags
+ assert_match(%r{<ruby>漢字<rt>かんじ</rt></ruby>}, output)
+ end
+
+ def test_inline_ruby_without_annotation
+ content = "= Chapter\n\n@<ruby>{漢字}\n"
+ assert_nothing_raised do
+ output = render_inline(content)
+ assert_match(/漢字/, output)
+ assert_no_match(%r{<rt></rt>}, output)
+ end
+ end
+
+ # Special Japanese formatting
+ def test_inline_bou
+ content = "= Chapter\n\n@<bou>{傍点}\n"
+ output = render_inline(content)
+ assert_match(%r{<span class="bou">傍点</span>}, output)
+ end
+
+ def test_inline_ami
+ content = "= Chapter\n\n@<ami>{網掛け}\n"
+ output = render_inline(content)
+ assert_match(%r{<span class="ami">網掛け</span>}, output)
+ end
+
+ def test_inline_tcy
+ content = "= Chapter\n\n縦中横@<tcy>{10}文字\n"
+ output = render_inline(content)
+ assert_match(%r{<span class="tcy">10</span>}, output)
+ end
+
+ def test_inline_tcy_single_ascii
+ content = "= Chapter\n\n@<tcy>{A}文字\n"
+ output = render_inline(content)
+ assert_match(%r{<span class="upright">A</span>}, output)
+ end
+
+ # Keywords and index
+ def test_inline_kw
+ content = "= Chapter\n\n@<kw>{キーワード, keyword}\n"
+ output = render_inline(content)
+ # Uses half-width parentheses and includes IDX comment
+ assert_match(%r{<b class="kw">キーワード \(keyword\)</b><!-- IDX:キーワード -->}, output)
+ end
+
+ def test_inline_idx
+ content = "= Chapter\n\n@<idx>{索引項目}\n"
+ output = render_inline(content)
+ # idx displays the text and outputs an IDX comment (no anchor tag)
+ assert_match(/索引項目/, output)
+ assert_match(/<!-- IDX:索引項目 -->/, output)
+ end
+
+ def test_inline_idx_hierarchical
+ content = "= Chapter\n\n@<idx>{親項目<<>>子項目}\n"
+ output = render_inline(content)
+ # Display text includes the full hierarchical path with <<>>
+ assert_match(/親項目<<>>子項目/, output)
+ # IDX comment preserves the <<>> delimiter (not escaped in HTML comments)
+ assert_match(/<!-- IDX:親項目<<>>子項目 -->/, output)
+ end
+
+ def test_inline_hidx
+ content = "= Chapter\n\n@<hidx>{隠し索引}\n"
+ output = render_inline(content)
+ # hidx outputs only an IDX comment (no text, no anchor tag)
+ assert_match(/<!-- IDX:隠し索引 -->/, output)
+ # Text should not be displayed
+ refute_match(/>隠し索引</, output)
+ end
+
+ def test_inline_hidx_hierarchical
+ content = "= Chapter\n\n@<hidx>{索引<<>>項目}\n"
+ output = render_inline(content)
+ # hidx outputs only an IDX comment with <<>> delimiter (no text, no anchor tag)
+ # Note: <<>> is not escaped in HTML comments
+ assert_match(/<!-- IDX:索引<<>>項目 -->/, output)
+ # Text should not be displayed
+ refute_match(/>索引/, output)
+ refute_match(/項目</, output)
+ end
+
+ # Links
+ def test_inline_href
+ content = "= Chapter\n\n@<href>{https://example.com, Example}\n"
+ output = render_inline(content)
+ assert_match(%r{<a href="https://example\.com" class="link">Example</a>}, output)
+ end
+
+ def test_inline_href_url_only
+ content = "= Chapter\n\n@<href>{https://example.com}\n"
+ output = render_inline(content)
+ assert_match(%r{<a href="https://example\.com" class="link">https://example\.com</a>}, output)
+ end
+
+ def test_inline_href_internal_reference_with_label
+ content = "= Chapter\n\n@<href>{#anchor,Jump to anchor}\n"
+ output = render_inline(content)
+ assert_match(%r{<a href="#anchor" class="link">Jump to anchor</a>}, output)
+ end
+
+ def test_inline_href_internal_reference_without_label
+ content = "= Chapter\n\n@<href>{#anchor}\n"
+ output = render_inline(content)
+ assert_match(%r{<a href="#anchor" class="link">#anchor</a>}, output)
+ end
+
+ # Special characters
+ def test_inline_br
+ content = "= Chapter\n\nLine1@<br>{}Line2\n"
+ output = render_inline(content)
+ assert_match(%r{Line1<br />Line2}, output)
+ end
+
+ def test_inline_uchar
+ content = "= Chapter\n\n@<uchar>{2764} is a heart.\n"
+ output = render_inline(content)
+ assert_match(/❤/, output)
+ end
+
+ # HTML semantic elements
+ def test_inline_abbr
+ content = "= Chapter\n\n@<abbr>{HTML}\n"
+ output = render_inline(content)
+ assert_match(%r{<abbr>HTML</abbr>}, output)
+ end
+
+ def test_inline_acronym
+ content = "= Chapter\n\n@<acronym>{NATO}\n"
+ output = render_inline(content)
+ assert_match(%r{<acronym>NATO</acronym>}, output)
+ end
+
+ def test_inline_cite
+ content = "= Chapter\n\n@<cite>{Book Title}\n"
+ output = render_inline(content)
+ assert_match(%r{<cite>Book Title</cite>}, output)
+ end
+
+ def test_inline_dfn
+ content = "= Chapter\n\n@<dfn>{definition}\n"
+ output = render_inline(content)
+ assert_match(%r{<dfn>definition</dfn>}, output)
+ end
+
+ def test_inline_big
+ content = "= Chapter\n\n@<big>{large text}\n"
+ output = render_inline(content)
+ assert_match(%r{<big>large text</big>}, output)
+ end
+
+ def test_inline_small
+ content = "= Chapter\n\n@<small>{small text}\n"
+ output = render_inline(content)
+ assert_match(%r{<small>small text</small>}, output)
+ end
+
+ # Special formatting
+ def test_inline_recipe
+ content = "= Chapter\n\n@<recipe>{レシピ名}\n"
+ output = render_inline(content)
+ assert_match(%r{<span class="recipe">「レシピ名」</span>}, output)
+ end
+
+ def test_inline_balloon
+ content = "= Chapter\n\n@<balloon>{吹き出し}\n"
+ output = render_inline(content)
+ assert_match(%r{<span class="balloon">吹き出し</span>}, output)
+ end
+
+ def test_inline_dtp
+ content = "= Chapter\n\n@<dtp>{command}\n"
+ output = render_inline(content)
+ assert_match(/<\?dtp command \?>/, output)
+ end
+
+ # Math
+ def test_inline_m
+ content = "= Chapter\n\n@<m>{E = mc^2}\n"
+ output = render_inline(content)
+ # InlineElementRenderer uses class="equation" like HTMLBuilder
+ assert_match(%r{<span class="equation">E = mc\^2</span>}, output)
+ end
+
+ # Comments (draft mode)
+ def test_inline_comment_draft_mode
+ @config['draft'] = true
+ content = "= Chapter\n\nText @<comment>{draft comment} here.\n"
+ output = render_inline(content)
+ assert_match(%r{<span class="draft-comment">draft comment</span>}, output)
+ end
+
+ def test_inline_comment_non_draft_mode
+ @config['draft'] = false
+ content = "= Chapter\n\nText @<comment>{draft comment} here.\n"
+ output = render_inline(content)
+ assert_no_match(/draft-comment/, output)
+ assert_no_match(/draft comment/, output)
+ end
+
+ # Cross-references (basic tests)
+ def test_inline_list_reference
+ content = <<~REVIEW
+ = Chapter
+
+ //list[sample][Sample]{
+ code
+ //}
+
+ See @<list>{sample}.
+ REVIEW
+ output = render_inline(content)
+ assert_match(/リスト1\.1/, output)
+ # Reference text is rendered but not wrapped in span by InlineElementRenderer
+ assert_match(/リスト1\.1/, output)
+ end
+
+ def test_inline_table_reference
+ content = <<~REVIEW
+ = Chapter
+
+ //table[sample][Sample]{
+ A B
+ -----
+ 1 2
+ //}
+
+ See @<table>{sample}.
+ REVIEW
+ output = render_inline(content)
+ assert_match(/表1\.1/, output)
+ # Reference text is rendered but not wrapped in span by InlineElementRenderer
+ assert_match(/表1\.1/, output)
+ end
+
+ def test_inline_img_reference
+ content = <<~REVIEW
+ = Chapter
+
+ //image[sample][Sample Image]{
+ //}
+
+ See @<img>{sample}.
+ REVIEW
+ output = render_inline(content)
+ assert_match(/図1\.1/, output)
+ # Reference text is rendered but not wrapped in span by InlineElementRenderer
+ assert_match(/図1\.1/, output)
+ end
+
+ # Footnote reference
+ def test_inline_fn
+ content = <<~REVIEW
+ = Chapter
+
+ Text with footnote@<fn>{note1}.
+
+ //footnote[note1][Footnote text here.]
+ REVIEW
+ output = render_inline(content)
+ assert_match(/<a id="fnb-note1" href="#fn-note1"/, output)
+ assert_match(/class="noteref"/, output)
+ end
+
+ # Headline reference
+ def test_inline_hd
+ content = <<~REVIEW
+ = Chapter
+
+ == Section Title
+
+ See @<hd>{Section Title}.
+ REVIEW
+ output = render_inline(content)
+ # Should contain section reference
+ assert_match(/Section Title/, output)
+ end
+
+ # Section reference
+ def test_inline_sec
+ content = <<~REVIEW
+ = Chapter
+
+ == Section 1
+
+ See @<sec>{Section 1}.
+ REVIEW
+ output = render_inline(content)
+ assert_match(/1\.1/, output)
+ end
+
+ def test_inline_sec_respects_secnolevel
+ @config['secnolevel'] = 1
+ @config['chapterlink'] = true
+
+ content = <<~REVIEW
+ = Chapter
+
+ == Section 1
+
+ See @<sec>{Section 1}.
+ REVIEW
+
+ output = render_inline(content)
+ assert_match(/Section 1/, output)
+ assert_no_match(/1\.1/, output)
+ assert_no_match(%r{href="\./test\.html#h1-1"}, output)
+ end
+
+ # Column reference
+ def test_inline_column
+ content = <<~REVIEW
+ = Chapter
+
+ ===[column] Column Title
+
+ Column content.
+
+ ===[/column]
+
+ See @<column>{Column Title}.
+ REVIEW
+ output = render_inline(content)
+ assert_match(/Column Title/, output)
+ end
+
+ # Chapter reference
+ def test_inline_chap
+ # Use mktmpbookdir to create a proper book with chapters
+ mktmpbookdir('test.re' => "= Chapter Title\n\nSee @<chap>{test}.\n") do |_dir, book|
+ chapter = book.chapters[0]
+ chapter.generate_indexes
+ book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ output = renderer.render(ast_root)
+ # Should contain chapter number
+ assert_match(/第1章/, output)
+ end
+ end
+
+ def test_inline_title
+ # Use mktmpbookdir to create a proper book with chapters
+ mktmpbookdir('test.re' => "= Chapter Title\n\nSee @<title>{test}.\n") do |_dir, book|
+ chapter = book.chapters[0]
+ chapter.generate_indexes
+ book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ output = renderer.render(ast_root)
+ assert_match(/Chapter Title/, output)
+ end
+ end
+
+ # Page reference (unsupported in HTML)
+ def test_inline_pageref
+ content = "= Chapter\n\nSee @<pageref>{test}.\n"
+ output = render_inline(content)
+ # Should just output the content without error
+ assert_match(/test/, output)
+ end
+
+ # Icon images
+ def test_inline_icon
+ content = "= Chapter\n\n@<icon>{sample}\n"
+ output = render_inline(content)
+ # Should attempt to reference image or show missing image
+ assert_match(/sample/, output)
+ end
+
+ # Escaping special characters
+ def test_inline_escaping
+ content = "= Chapter\n\n@<b>{text with <html> & \"quotes\"}\n"
+ output = render_inline(content)
+ # Content is escaped once by visit_text, then rendered as-is
+ assert_match(%r{<b>text with <html> & "quotes"</b>}, output)
+ end
+
+ # Raw inline content
+ def test_inline_raw_html
+ content = "= Chapter\n\nText @<raw>{|html|<span class=\"custom\">HTML</span>} here.\n"
+ output = render_inline(content)
+ assert_match(%r{<span class="custom">HTML</span>}, output)
+ end
+
+ def test_inline_raw_other_format
+ content = "= Chapter\n\nText @<raw>{|latex|\\textbf{LaTeX}} here.\n"
+ output = render_inline(content)
+ # Should not output LaTeX content in HTML
+ assert_no_match(/textbf/, output)
+ end
+
+ # Complex inline combinations
+ def test_inline_nested_formatting
+ content = "= Chapter\n\n@<b>{bold @<i>{and italic\\}}\n"
+ output = render_inline(content)
+ assert_match(%r{<b>bold <i>and italic</i></b>}, output)
+ end
+
+ def test_inline_code_with_special_chars
+ content = "= Chapter\n\n@<code>{<tag> & \"value\"}\n"
+ output = render_inline(content)
+ # Content is escaped once by visit_text, then rendered as-is
+ assert_match(%r{<code class="inline-code tt"><tag> & "value"</code>}, output)
+ end
+
+ # Bibliography reference (requires bib file setup)
+ def test_inline_bib_basic
+ mktmpbookdir('bib.re' => '//bibpaper[ref1][Reference Title]{Author Name, Publisher, 2020}') do |_dir, book|
+ chapter = ReVIEW::Book::Chapter.new(book, 1, 'test', 'test.re', StringIO.new("= Chapter\n\nReference @<bib>{ref1}.\n"))
+ chapter.generate_indexes
+ book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ output = renderer.render(ast_root)
+ # Should contain reference markup with the bibliography reference
+ assert_match(/ref1/, output)
+ end
+ end
+
+ # Equation reference
+ def test_inline_eq_basic
+ content = <<~REVIEW
+ = Chapter
+
+ //texequation[eq1]{
+ E = mc^2
+ //}
+
+ See @<eq>{eq1}.
+ REVIEW
+ output = render_inline(content)
+ # Should contain equation reference
+ assert_match(/式1\.1/, output)
+ end
+
+ # Endnote reference
+ def test_inline_endnote_basic
+ content = <<~REVIEW
+ = Chapter
+
+ Text @<endnote>{note1}.
+
+ //endnote[note1][Endnote content]
+ REVIEW
+ output = render_inline(content)
+ # Should contain endnote reference markup
+ assert_match(/note1/, output)
+ end
+
+ # Section title reference
+ def test_inline_sectitle_basic
+ content = <<~REVIEW
+ = Chapter
+
+ == Section Title
+
+ See @<sectitle>{Section Title}.
+ REVIEW
+ output = render_inline(content)
+ assert_match(/Section Title/, output)
+ end
+end
diff --git a/test/ast/test_html_renderer_join_lines_by_lang.rb b/test/ast/test_html_renderer_join_lines_by_lang.rb
new file mode 100644
index 000000000..1ca31f70e
--- /dev/null
+++ b/test/ast/test_html_renderer_join_lines_by_lang.rb
@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require_relative '../support/review/test/html_comparator'
+require 'tmpdir'
+
+class TestHtmlRendererJoinLinesByLang < Test::Unit::TestCase
+ def test_join_lines_by_lang_disabled
+ Dir.mktmpdir do |dir|
+ setup_book(dir, join_lines_by_lang: false)
+
+ File.write(File.join(dir, 'test.re'), <<~RE)
+= Test
+
+Japanese text
+continues here
+
+English text
+continues here
+ RE
+
+ converter = ReVIEW::Test::HtmlComparator.new
+ result = converter.convert_chapter_with_book_context(dir, 'test')
+
+ assert_equal result[:builder], result[:renderer],
+ 'Builder and Renderer should produce same output when join_lines_by_lang is disabled'
+
+ # Without join_lines_by_lang, lines are joined without any separator
+ assert result[:builder].include?('Japanese textcontinues here'),
+ 'Lines should be joined without space when join_lines_by_lang is disabled'
+ end
+ end
+
+ def test_join_lines_by_lang_enabled_japanese
+ Dir.mktmpdir do |dir|
+ setup_book(dir, join_lines_by_lang: true)
+
+ File.write(File.join(dir, 'test.re'), <<~RE)
+= テスト
+
+これは日本語の文章です。
+複数行にわたっています。
+ RE
+
+ converter = ReVIEW::Test::HtmlComparator.new
+ result = converter.convert_chapter_with_book_context(dir, 'test')
+
+ assert_equal result[:builder], result[:renderer],
+ 'Builder and Renderer should produce same output for Japanese text'
+
+ # Japanese text should be joined without space
+ assert result[:builder].include?('これは日本語の文章です。複数行にわたっています。'),
+ 'Japanese lines should be joined without space'
+ end
+ end
+
+ def test_join_lines_by_lang_enabled_english
+ Dir.mktmpdir do |dir|
+ setup_book(dir, join_lines_by_lang: true)
+
+ File.write(File.join(dir, 'test.re'), <<~RE)
+= Test
+
+This is English text.
+It spans multiple lines.
+ RE
+
+ converter = ReVIEW::Test::HtmlComparator.new
+ result = converter.convert_chapter_with_book_context(dir, 'test')
+
+ assert_equal result[:builder], result[:renderer],
+ 'Builder and Renderer should produce same output for English text'
+
+ # English text should have space between lines
+ assert result[:builder].include?('This is English text. It spans multiple lines.'),
+ 'English lines should be joined with space'
+ end
+ end
+
+ def test_join_lines_by_lang_mixed_content
+ Dir.mktmpdir do |dir|
+ setup_book(dir, join_lines_by_lang: true)
+
+ File.write(File.join(dir, 'test.re'), <<~RE)
+= Test
+
+日本語とEnglish混在
+次の行です
+ RE
+
+ converter = ReVIEW::Test::HtmlComparator.new
+ result = converter.convert_chapter_with_book_context(dir, 'test')
+
+ assert_equal result[:builder], result[:renderer],
+ 'Builder and Renderer should produce same output for mixed content'
+ end
+ end
+
+ private
+
+ def setup_book(dir, join_lines_by_lang:)
+ config = {
+ 'bookname' => 'test',
+ 'language' => 'ja'
+ }
+ config['join_lines_by_lang'] = true if join_lines_by_lang
+
+ File.write(File.join(dir, 'config.yml'), config.to_yaml)
+ File.write(File.join(dir, 'catalog.yml'), <<~YAML)
+ CHAPS:
+ - test.re
+ YAML
+ end
+end
diff --git a/test/ast/test_html_renderer_math.rb b/test/ast/test_html_renderer_math.rb
new file mode 100644
index 000000000..0ac047607
--- /dev/null
+++ b/test/ast/test_html_renderer_math.rb
@@ -0,0 +1,388 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require 'review/ast/compiler'
+require 'review/ast/node'
+require 'review/renderer/html_renderer'
+require 'review/book'
+require 'review/book/chapter'
+require 'review/configure'
+require 'review/i18n'
+require 'tmpdir'
+
+class TestHtmlRendererMath < Test::Unit::TestCase
+ def setup
+ @config = ReVIEW::Configure.values
+ @config['language'] = 'ja'
+ @book = ReVIEW::Book::Base.new(config: @config)
+
+ ReVIEW::I18n.setup('ja')
+
+ @compiler = ReVIEW::AST::Compiler.new
+ end
+
+ # Test for texequation block with mathjax format
+ def test_texequation_mathjax
+ @config['math_format'] = 'mathjax'
+
+ content = <<~REVIEW
+ = Chapter
+
+ //texequation{
+ x = \\frac{-b \\pm \\sqrt{b^2 - 4ac}}{2a}
+ //}
+ REVIEW
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render_body(ast_root)
+
+ assert_match(/<div class="equation">/, html_output)
+ assert_match(/\$\$.*\\frac.*\$\$/, html_output)
+ assert_match(/x = \\frac\{-b \\pm \\sqrt\{b\^2 - 4ac\}\}\{2a\}/, html_output)
+ end
+
+ # Test for texequation block with ID and caption using mathjax
+ def test_texequation_with_id_caption_mathjax
+ @config['math_format'] = 'mathjax'
+
+ content = <<~REVIEW
+ = Chapter
+
+ //texequation[quadratic][二次方程式の解の公式]{
+ x = \\frac{-b \\pm \\sqrt{b^2 - 4ac}}{2a}
+ //}
+ REVIEW
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render_body(ast_root)
+
+ assert_match(/<div id="quadratic" class="caption-equation">/, html_output)
+ assert_match(%r{<p class="caption">式1\.1: 二次方程式の解の公式</p>}, html_output)
+ assert_match(/<div class="equation">/, html_output)
+ assert_match(/\$\$.*\\frac.*\$\$/, html_output)
+ end
+
+ # Test for mathjax escaping of special characters
+ def test_texequation_mathjax_escaping
+ @config['math_format'] = 'mathjax'
+
+ content = <<~REVIEW
+ = Chapter
+
+ //texequation{
+ a < b & c > d
+ //}
+ REVIEW
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render_body(ast_root)
+
+ # Check that <, >, & are properly escaped for mathjax
+ assert_match(/\\lt\{\}/, html_output)
+ assert_match(/\\gt\{\}/, html_output)
+ assert_match(/&/, html_output)
+ # Verify that the equation content itself has escaped characters
+ assert_match(/\$\$a \\lt\{\} b & c \\gt\{\} d\$\$/, html_output)
+ end
+
+ # Test for inline math with mathjax format
+ def test_inline_m_mathjax
+ @config['math_format'] = 'mathjax'
+
+ content = <<~REVIEW
+ = Chapter
+
+ Einstein's equation is @<m>{E = mc^2}.
+ REVIEW
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render_body(ast_root)
+
+ assert_match(%r{<span class="equation">\\\\?\( E = mc\^2 \\\\?\)</span>}, html_output)
+ end
+
+ # Test for inline math with mathjax escaping
+ def test_inline_m_mathjax_escaping
+ @config['math_format'] = 'mathjax'
+
+ content = <<~REVIEW
+ = Chapter
+
+ Test equation @<m>{a < b & c > d}.
+ REVIEW
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render_body(ast_root)
+
+ assert_match(/\\lt\{\}/, html_output)
+ assert_match(/\\gt\{\}/, html_output)
+ assert_match(/&/, html_output)
+ end
+
+ # Test for texequation with mathml format (requires math_ml gem)
+ def test_texequation_mathml
+ begin
+ require 'math_ml'
+ require 'math_ml/symbol/character_reference'
+ rescue LoadError
+ omit('math_ml gem not installed')
+ end
+
+ @config['math_format'] = 'mathml'
+
+ content = <<~REVIEW
+ = Chapter
+
+ //texequation{
+ E = mc^2
+ //}
+ REVIEW
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render_body(ast_root)
+
+ assert_match(/<div class="equation">/, html_output)
+ # MathML output contains <math> tags
+ assert_match(/<math/, html_output)
+ end
+
+ # Test for inline math with mathml format
+ def test_inline_m_mathml
+ begin
+ require 'math_ml'
+ require 'math_ml/symbol/character_reference'
+ rescue LoadError
+ omit('math_ml gem not installed')
+ end
+
+ @config['math_format'] = 'mathml'
+
+ content = <<~REVIEW
+ = Chapter
+
+ Einstein's equation is @<m>{E = mc^2}.
+ REVIEW
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render_body(ast_root)
+
+ assert_match(/<span class="equation">/, html_output)
+ assert_match(/<math/, html_output)
+ end
+
+ # Test for texequation with imgmath format (requires latex/dvipng)
+ def test_texequation_imgmath
+ # Check if latex and dvipng are available
+ unless system('which latex > /dev/null 2>&1') && system('which dvipng > /dev/null 2>&1')
+ omit('latex or dvipng not installed')
+ end
+
+ Dir.mktmpdir do |tmpdir|
+ @config['math_format'] = 'imgmath'
+ @config['imagedir'] = tmpdir
+ @config['imgmath_options'] = {
+ 'fontsize' => 12,
+ 'lineheight' => 14.4,
+ 'format' => 'png'
+ }
+
+ content = <<~REVIEW
+ = Chapter
+
+ //texequation{
+ E = mc^2
+ //}
+ REVIEW
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render_body(ast_root)
+
+ assert_match(/<div class="equation">/, html_output)
+ # Should contain img tag with math image
+ assert_match(%r{<img src=".*_review_math/_gen_.*\.png"}, html_output)
+ assert_match(/alt="E = mc\^2"/, html_output)
+ end
+ end
+
+ # Test for inline math with imgmath format
+ def test_inline_m_imgmath
+ unless system('which latex > /dev/null 2>&1') && system('which dvipng > /dev/null 2>&1')
+ omit('latex or dvipng not installed')
+ end
+
+ Dir.mktmpdir do |tmpdir|
+ @config['math_format'] = 'imgmath'
+ @config['imagedir'] = tmpdir
+ @config['imgmath_options'] = {
+ 'fontsize' => 12,
+ 'lineheight' => 14.4,
+ 'format' => 'png'
+ }
+
+ content = <<~REVIEW
+ = Chapter
+
+ Einstein's equation is @<m>{E = mc^2}.
+ REVIEW
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render_body(ast_root)
+
+ assert_match(/<span class="equation">/, html_output)
+ assert_match(%r{<img src=".*_review_math/_gen_.*\.png"}, html_output)
+ end
+ end
+
+ # Test for texequation with fallback (no math_format set)
+ def test_texequation_fallback
+ @config['math_format'] = nil
+
+ content = <<~REVIEW
+ = Chapter
+
+ //texequation{
+ E = mc^2
+ //}
+ REVIEW
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render_body(ast_root)
+
+ assert_match(/<div class="equation">/, html_output)
+ # Should fall back to <pre> tag
+ assert_match(/<pre>E = mc\^2/, html_output)
+ end
+
+ # Test for inline math with fallback
+ def test_inline_m_fallback
+ @config['math_format'] = nil
+
+ content = <<~REVIEW
+ = Chapter
+
+ Einstein's equation is @<m>{E = mc^2}.
+ REVIEW
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render_body(ast_root)
+
+ assert_match(%r{<span class="equation">E = mc\^2</span>}, html_output)
+ end
+
+ # Test for caption positioning (top/bottom)
+ def test_texequation_caption_top
+ @config['math_format'] = 'mathjax'
+ @config['caption_position'] = { 'equation' => 'top' }
+
+ content = <<~REVIEW
+ = Chapter
+
+ //texequation[einstein][アインシュタインの式]{
+ E = mc^2
+ //}
+ REVIEW
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render_body(ast_root)
+
+ # Caption should appear before equation div
+ assert_match(%r{<p class="caption">.*アインシュタインの式</p>\s*<div class="equation">}m, html_output)
+ end
+
+ # Test for caption positioning (bottom)
+ def test_texequation_caption_bottom
+ @config['math_format'] = 'mathjax'
+ @config['caption_position'] = { 'equation' => 'bottom' }
+
+ content = <<~REVIEW
+ = Chapter
+
+ //texequation[einstein][アインシュタインの式]{
+ E = mc^2
+ //}
+ REVIEW
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render_body(ast_root)
+
+ # Caption should appear after equation div
+ assert_match(%r{</div>\s*<p class="caption">.*アインシュタインの式</p>}m, html_output)
+ end
+
+ # Test for equation reference (@<eq>)
+ def test_equation_reference
+ @config['math_format'] = 'mathjax'
+
+ content = <<~REVIEW
+ = Chapter
+
+ //texequation[einstein][アインシュタインの式]{
+ E = mc^2
+ //}
+
+ See @<eq>{einstein} for details.
+ REVIEW
+
+ chapter = ReVIEW::Book::Chapter.new(@book, 1, 'test', 'test.re', StringIO.new(content))
+ chapter.generate_indexes
+ @book.generate_indexes
+ ast_root = @compiler.compile_to_ast(chapter)
+ renderer = ReVIEW::Renderer::HtmlRenderer.new(chapter)
+ html_output = renderer.render_body(ast_root)
+
+ # Check equation reference link (with chapterlink enabled, it includes file path)
+ assert_match(%r{<span class="eqref"><a href=".*#einstein">式1\.1</a></span>}, html_output)
+ end
+end
diff --git a/test/ast/test_idgxml_renderer.rb b/test/ast/test_idgxml_renderer.rb
new file mode 100644
index 000000000..ec959036b
--- /dev/null
+++ b/test/ast/test_idgxml_renderer.rb
@@ -0,0 +1,1549 @@
+# frozen_string_literal: true
+
+require_relative '../test_helper'
+require_relative '../book_test_helper'
+require 'review/ast/compiler'
+require 'review/ast/book_indexer'
+require 'review/renderer/idgxml_renderer'
+require 'review/book'
+require 'review/i18n'
+
+class IdgxmlRendererTest < Test::Unit::TestCase
+ include ReVIEW
+ include BookTestHelper
+
+ def setup
+ @config = ReVIEW::Configure.values
+ @config['secnolevel'] = 2
+ @config['tableopt'] = '10'
+ @config['builder'] = 'idgxml' # Set builder for tsize processing
+ @book = Book::Base.new(config: @config)
+ @log_io = StringIO.new
+ ReVIEW.logger = ReVIEW::Logger.new(@log_io)
+ @chapter = Book::Chapter.new(@book, 1, '-', nil, StringIO.new)
+ I18n.setup('ja')
+ end
+
+ def compile_block(src, reference_resolution: true)
+ @chapter.content = src
+ compiler = ReVIEW::AST::Compiler.for_chapter(@chapter)
+ ast = compiler.compile_to_ast(@chapter, reference_resolution: reference_resolution)
+ renderer = ReVIEW::Renderer::IdgxmlRenderer.new(@chapter)
+ result = renderer.render(ast)
+ # Strip XML declaration and root doc tags to match expected output format
+ # Remove leading/trailing newlines but preserve spaces (for //raw blocks)
+ result = result.sub(/\A<\?xml[^>]+\?><doc[^>]*>/, '').sub(%r{</doc>\s*\z}, '')
+ result.gsub(/\A\n+/, '').gsub(/\n+\z/, '')
+ end
+
+ def compile_inline(src, reference_resolution: true)
+ result = compile_block(src, reference_resolution: reference_resolution)
+ # For inline tests, also strip the paragraph tags if present
+ # Don't use .strip as it removes important whitespace like newlines from @<br>{}
+ result = result.sub(/\A<p>/, '').delete_suffix('</p>') if result.start_with?('<p>')
+ result
+ end
+
+ def test_headline_level1
+ actual = compile_block("={test} this is test.\n")
+ assert_equal %Q(<title id="test" aid:pstyle="h1">第1章 this is test. ), actual
+ end
+
+ def test_headline_level1_without_secno
+ @config['secnolevel'] = 0
+ actual = compile_block("={test} this is test.\n")
+ assert_equal %Q(this is test. ), actual
+ end
+
+ def test_headline_level2
+ actual = compile_block("=={test} this is test.\n")
+ assert_equal %Q(1.1 this is test. ), actual
+ end
+
+ def test_headline_level3
+ actual = compile_block("==={test} this is test.\n")
+ assert_equal %Q(this is test. ), actual
+ end
+
+ def test_headline_level3_with_secno
+ @config['secnolevel'] = 3
+ actual = compile_block("==={test} this is test.\n")
+ assert_equal %Q(1.0.1 this is test. ), actual
+ end
+
+ def test_headline_secttags
+ @config['structuredxml'] = true
+ actual = compile_block("= HEAD1\n== HEAD1-1\n\n=== HEAD1-1-1\n\n== HEAD1-2\n\n==== HEAD1-2-0-1\n\n===== HEAD1-2-0-1-1\n\n== HEAD1-3\n")
+ expected = '第1章 HEAD1 ' +
+ '1.1 HEAD1-1 ' +
+ 'HEAD1-1-1 1.2 HEAD1-2 ' +
+ 'HEAD1-2-0-1 ' +
+ 'HEAD1-2-0-1-1 1.3 HEAD1-3 [{外部参照<>&}', reference_resolution: false)
+ assert_equal %Q(][「●● 外部参照<>&」]), actual
+ end
+
+ def test_href
+ actual = compile_inline('@{http://github.com,GitHub}')
+ assert_equal %Q(GitHub ), actual
+ end
+
+ def test_href_without_label
+ actual = compile_inline('@{http://github.com}')
+ assert_equal %Q(http://github.com ), actual
+ end
+
+ def test_inline_href
+ actual = compile_inline('@{http://github.com, Git\\,Hub}')
+ assert_equal %Q(Git,Hub ), actual
+ end
+
+ def test_inline_raw
+ actual = compile_inline('@{@{inline\\}}')
+ assert_equal %Q(@{inline}), actual
+ end
+
+ def test_inline_in_table
+ actual = compile_block("//table{\n@{1}\t@{2}\n------------\n@{3}\t@{4}<>&\n//}\n")
+ assert_equal %Q(), actual
+ end
+
+ def test_inline_in_table_without_header
+ actual = compile_block("//table{\n@{1}\t@{2}\n@{3}\t@{4}<>&\n//}\n")
+ assert_equal %Q(), actual
+ end
+
+ def test_inline_in_table_without_cellwidth
+ @config['tableopt'] = nil
+ actual = compile_block("//table{\n@{1}\t@{2}\n------------\n@{3}\t@{4}<>&\n//}\n")
+ assert_equal %Q(), actual
+ end
+
+ def test_inline_in_table_without_header_and_cellwidth
+ @config['tableopt'] = nil
+ actual = compile_block("//table{\n@{1}\t@{2}\n@{3}\t@{4}<>&\n//}\n")
+ assert_equal %Q(), actual
+ end
+
+ def test_table
+ actual = compile_block("//table{\naaa\tbbb\n------------\nccc\tddd<>&\n//}\n")
+ expected = <<-EOS.chomp
+
+EOS
+ assert_equal expected, actual
+
+ actual = compile_block("//table[foo][FOO]{\naaa\tbbb\n------------\nccc\tddd<>&\n//}\n")
+ expected = <<-EOS.chomp
+
+EOS
+ assert_equal expected, actual
+
+ @config['caption_position']['table'] = 'bottom'
+ actual = compile_block("//table[foo][FOO]{\naaa\tbbb\n------------\nccc\tddd<>&\n//}\n")
+ expected = <<-EOS.chomp
+
+EOS
+ assert_equal expected, actual
+ end
+
+ def test_paragraph
+ actual = compile_block("foo\nbar\n")
+ assert_equal ' foobar
', actual
+
+ @book.config['join_lines_by_lang'] = true
+ actual = compile_block("foo\nbar\n")
+ assert_equal 'foo bar
', actual
+ end
+
+ def test_tabbed_paragraph
+ actual = compile_block("\tfoo\nbar\n")
+ assert_equal %Q(foobar
), actual
+
+ @book.config['join_lines_by_lang'] = true
+ actual = compile_block("\tfoo\nbar\n")
+ assert_equal %Q(foo bar
), actual
+ end
+
+ def test_inline_br
+ actual = compile_inline('@{2460} test2')
+ assert_equal 'test ① test2', actual
+ end
+
+ def test_inline_ruby
+ actual = compile_inline('@{coffin,bed}')
+ assert_equal %Q(coffin bed { coffin , bed }')
+ assert_equal %Q(coffin bed {ISO, International Organization for Standardization } @{Ruby<>}')
+ assert_equal %Q(ISO（International Organization for Standardization） Ruby<> {note1}
+
+ //endnote[note1][後注その1です。]
+ //printendnotes
+ REVIEW
+
+ actual = compile_block(src)
+ assert_includes(actual, "(1) ")
+ assert_includes(actual, "\n(1) \t後注その1です。 ")
+ end
+
+ def test_inline_maru
+ actual = compile_inline('@{1}@{20}@{A}@{z}')
+ assert_equal '①⑳Ⓐⓩ', actual
+ end
+
+ def test_inline_ttb
+ actual = compile_inline(%Q(@{test * <>"}))
+ assert_equal %Q(test * <>" ), actual
+ end
+
+ def test_inline_ttbold
+ actual = compile_inline(%Q(@{test * <>"}))
+ assert_equal %Q(test * <>" ), actual
+ end
+
+ def test_inline_balloon
+ actual = compile_inline('@{@maru[1]test}')
+ assert_equal '①test ', actual
+ end
+
+ def test_ul
+ src = <<-EOS
+ * AAA
+ * BBB
+EOS
+
+ expected = <<-EOS.chomp
+
+EOS
+ actual = compile_block(src)
+ assert_equal expected, actual
+ end
+
+ def test_ul_nest1
+ src = <<-EOS
+ * AAA
+ ** AA
+EOS
+
+ expected = <<-EOS.chomp
+
+EOS
+ actual = compile_block(src)
+ assert_equal expected, actual
+ end
+
+ def test_ol
+ src = <<-EOS
+ 3. AAA
+ 3. BBB
+EOS
+
+ expected = <<-EOS.chomp
+AAA BBB {test}<&>_]{\ntest1\ntest1.5\n\ntest@{2}\n//}\n")
+ assert_equal %Q(this is test <&>_ test1\ntest1.5\n\ntest2 \n
), actual
+
+ @config['caption_position']['list'] = 'bottom'
+ actual = compile_block("//emlist[this is @{test}<&>_]{\ntest1\ntest1.5\n\ntest@{2}\n//}\n")
+ assert_equal %Q(test1\ntest1.5\n\ntest2 \n this is test <&>_
), actual
+ end
+
+ def test_quote
+ actual = compile_block("//quote{\nfoo\nbar\n\nbuz\n//}\n")
+ assert_equal 'foobar
buz
', actual
+
+ @book.config['join_lines_by_lang'] = true
+ actual = compile_block("//quote{\nfoo\nbar\n\nbuz\n//}\n")
+ assert_equal 'foo bar
buz
', actual
+ end
+
+ def test_noindent
+ actual = compile_block("//noindent\nfoo\nbar\n\nfoo2\nbar2\n")
+ assert_equal %Q( foobar
foo2bar2
), actual
+
+ @book.config['join_lines_by_lang'] = true
+ actual = compile_block("//noindent\nfoo\nbar\n\nfoo2\nbar2\n")
+ assert_equal %Q(foo bar
foo2 bar2
), actual
+ end
+
+ def test_blankline
+ actual = compile_block("//blankline\nfoo\n")
+ assert_equal %Q(
foo
), actual
+ end
+
+ def test_image
+ def @chapter.image(_id)
+ item = Book::Index::Item.new('sampleimg', 1)
+ item.instance_eval { @path = './images/chap1-sampleimg.png' }
+ item
+ end
+
+ actual = compile_block("//image[sampleimg][sample photo]{\n//}\n")
+ assert_equal %Q(図1.1 sample photo ), actual
+
+ @config['caption_position']['image'] = 'top'
+ actual = compile_block("//image[sampleimg][sample photo]{\n//}\n")
+ assert_equal %Q(図1.1 sample photo 図1.1 sample photo ), actual
+ end
+
+ def test_indepimage
+ def @chapter.image(_id)
+ item = Book::Index::Item.new('sampleimg', 1)
+ item.instance_eval { @path = './images/chap1-sampleimg.png' }
+ item
+ end
+
+ actual = compile_block("//indepimage[sampleimg][sample photo]\n")
+ assert_equal %Q(sample photo ), actual
+
+ @config['caption_position']['image'] = 'top'
+ actual = compile_block("//indepimage[sampleimg][sample photo]\n")
+ assert_equal %Q(sample photo {normal}')
+ end
+
+ def test_inline_raw1
+ assert_equal 'body', compile_inline('@{|idgxml|body}')
+ end
+
+ def test_inline_raw2
+ assert_equal 'body', compile_inline('@{|idgxml, latex|body}')
+ end
+
+ def test_inline_raw3
+ assert_equal '', compile_inline('@{|latex, html|body}')
+ end
+
+ def test_inline_raw4
+ assert_equal '|idgxml body', compile_inline('@{|idgxml body}')
+ end
+
+ def test_inline_raw5
+ assert_equal "nor\nmal", compile_inline('@{|idgxml|nor\\nmal}')
+ end
+
+ def test_comment
+ actual = compile_block('//comment[コメント]')
+ assert_equal '', actual
+ end
+
+ def test_comment_for_draft
+ @config['draft'] = true
+ actual = compile_block('//comment[コメント<]')
+ assert_equal 'コメント< ', actual
+ actual = compile_block("//comment{\nA<>\nB&\n//}")
+ assert_equal %Q(A<>\nB& ), actual
+ end
+
+ def test_inline_comment
+ actual = compile_inline('test @{コメント} test2')
+ assert_equal 'test test2', actual
+ end
+
+ def test_inline_comment_for_draft
+ @config['draft'] = true
+ actual = compile_inline('test @{コメント} test2')
+ assert_equal 'test コメント test2', actual
+ end
+
+ def test_block_raw0
+ actual = compile_block(%Q(//raw[<>!"\\n& ]\n))
+ expected = %Q(<>!"\n& )
+ assert_equal expected, actual
+ end
+
+ def test_block_raw1
+ actual = compile_block(%Q(//raw[|idgxml|<>!"\\n& ]\n))
+ expected = %Q(<>!"\n& )
+ assert_equal expected, actual
+ end
+
+ def test_block_raw2
+ actual = compile_block(%Q(//raw[|idgxml, latex|<>!"\\n& ]\n))
+ expected = %Q(<>!"\n& )
+ assert_equal expected, actual
+ end
+
+ def test_block_raw3
+ actual = compile_block(%Q(//raw[|latex, html|<>!"\\n& ]\n))
+ expected = ''
+ assert_equal expected, actual
+ end
+
+ def test_block_raw4
+ actual = compile_block(%Q(//raw[|idgxml <>!"\\n& ]\n))
+ expected = %Q(|idgxml <>!"\n& )
+ assert_equal expected.chomp, actual
+ end
+
+ def test_cmd
+ actual = compile_block("//cmd{\nlineA\nlineB\n//}\n")
+ expected = <<-EOS.chomp
+lineA
+lineB
+
+EOS
+ assert_equal expected, actual
+
+ actual = compile_block("//cmd[cap1]{\nlineA\nlineB\n//}\n")
+ expected = <<-EOS.chomp
+cap1 lineA
+lineB
+
+EOS
+ assert_equal expected, actual
+ end
+
+ def test_emlistnum
+ actual = compile_block("//emlistnum[this is @{test}<&>_]{\ntest1\ntest1.5\n\ntest@{2}\n//}\n")
+ assert_equal %Q(this is test <&>_ 1: test1\n 2: test1.5\n 3: \n 4: test2 \n
), actual
+
+ @config['caption_position']['list'] = 'bottom'
+ actual = compile_block("//emlistnum[this is @{test}<&>_]{\ntest1\ntest1.5\n\ntest@{2}\n//}\n")
+ assert_equal %Q( 1: test1\n 2: test1.5\n 3: \n 4: test2 \nthis is test <&>_
), actual
+ end
+
+ def test_list
+ def @chapter.list(_id)
+ Book::Index::Item.new('samplelist', 1)
+ end
+ actual = compile_block("//list[samplelist][this is @{test}<&>_]{\ntest1\ntest1.5\n\ntest@{2}\n//}\n")
+ expected = <<-EOS.chomp
+リスト1.1 this is test <&>_ test1
+test1.5
+
+test2
+ {test}<&>_]{\ntest1\ntest1.5\n\ntest@{2}\n//}\n")
+ expected = <<-EOS.chomp
+test1
+test1.5
+
+test2
+ リスト1.1 this is test <&>_ {test}<&>_]{\ntest1\ntest1.5\n\ntest@{2}\n//}\n")
+ expected = <<-EOS.chomp
+リスト1.1 this is test <&>_ 1: test1
+ 2: test1.5
+ 3:
+ 4: test2
+foo/bar/test.rb foo
+bar
+
+buz
+ foo
+bar
+
+buz
+ foo/bar/test.rb {test}<&>_]{\ntest1\ntest1.5\n\ntest@{2}\n//}\n")
+ expected = <<-EOS.chomp
+this is test <&>_ test1
+ test1.5
+
+ test2
+ {test}<&>_]{\ntest1\ntest1.5\n\ntest@{2}\n//}\n")
+ expected = <<-EOS.chomp
+test1
+ test1.5
+
+ test2
+ this is test <&>_ {test}<&>_]{\ntest1\ntest1.5\n\ntest@{2}\n//}\n")
+ expected = <<-EOS.chomp
+this is test <&>_ test1
+ test1.5
+
+ test2
+ {test}<&>_]{\ntest1\ntest1.5\n\ntest@{2}\n//}\n")
+ expected = <<-EOS.chomp
+test1
+ test1.5
+
+ test2
+ this is test <&>_ {test}<&>_]{\ntest1\ntest1.5\n\ntest@{2}\n//}\n")
+ assert_equal %Q(this is <b>test</b><&>_ test1test1.5
test2
{test}<&>_]{\ntest1\ntest1.5\n\ntest@{2}\n//}\n")
+ assert_equal %Q(this is <b>test</b><&>_ test1 test1.5
test2
{2}\n//}\n")
+ assert_equal 'test1test1.5
test2
{2}\n//}\n")
+ assert_equal 'test1 test1.5
test2
{test}<&>_]{\ntest1\ntest1.5\n\ntest@{2}\n//}\n")
+ expected = <<-EOS.chomp
+this is test <&>_ test1
+ test1.5
+
+ test2
+
+EOS
+ assert_equal expected, actual
+ end
+
+ def test_emlist_with_tab
+ actual = compile_block("//emlist[this is @{test}<&>_]{\n\ttest1\n\t\ttest1.5\n\n\ttest@{2}\n//}\n")
+ expected = <<-EOS.chomp
+this is test <&>_ test1
+ test1.5
+
+ test2
+
+EOS
+ assert_equal expected, actual
+ end
+
+ def test_emlist_with_4tab
+ @config['tabwidth'] = 4
+ actual = compile_block("//emlist[this is @{test}<&>_]{\n\ttest1\n\t\ttest1.5\n\n\ttest@{2}\n//}\n")
+ expected = <<-EOS.chomp
+