asciidoctor-rhrev 1.0.0

data/lib/asciidoctor/rhrev/renderer.rb

@@ -0,0 +1,697 @@
+require 'fileutils'
+
+module Asciidoctor
+  module PDF
+    module Rhrev
+      module Renderer
+        include Helpers
+
+        def allocate_revision_history_extent doc
+          # Use accessor method, not instance variable
+          return unless revision_history
+          
+          start_page_number = page_number
+          
+          extent = dry_run onto: self do
+            ink_revision_history_content doc
+          end
+          
+          extent.each_page { |first_page| start_new_page unless first_page }
+          move_cursor_to extent.to.cursor
+          
+          end_page_number = page_number
+          @rhrev_deferred_pages = (extent.from.page..end_page_number)
+          
+          unless doc.attr? 'rhrev-suppress-new-page-after'
+            start_new_page
+          end
+          
+          extent
+        end
+        
+        def ink_revision_history doc, extent
+          return if scratch?
+          
+          go_to_page extent.from.page
+          move_cursor_to extent.from.cursor
+          
+          ink_revision_history_content doc
+          
+          end_page = page_number
+          start_page = extent.from.page
+          
+          has_foreground = @theme.page_foreground_image || doc.attr('page-foreground-image')
+          
+          if has_foreground
+            fg_image = resolve_background_image doc, @theme, 'page-foreground-image'
+            if fg_image && fg_image[0]
+              (start_page..end_page).each do |pg|
+                go_to_page pg
+                next if page.imported_page?
+                stamp_name = %(foreground-image-#{page.layout})
+                stamp stamp_name if (stamp_dictionary_registry.key? stamp_name rescue false)
+              end
+            end
+          end
+          
+          @rhrev_deferred_pages = nil
+        end
+        
+        def stamp_foreground_image doc, has_front_cover
+          pages = state.pages
+          if (first_page = (has_front_cover ? (pages.drop 1) : pages).find {|it| !it.imported_page? }) &&
+              (first_page_num = (pages.index first_page) + 1) &&
+              (fg_image = resolve_background_image doc, @theme, 'page-foreground-image') && fg_image[0]
+            stamps = ::Set.new
+            rhrev_range = @rhrev_deferred_pages || (0..0)
+            (first_page_num..page_count).each do |num|
+              next if rhrev_range.include?(num)
+              go_to_page num
+              next if page.imported_page?
+              unless stamps.include? (stamp_name = %(foreground-image-#{page.layout}))
+                create_stamp stamp_name do
+                  canvas { image fg_image[0], ({ position: :center, vposition: :center }.merge fg_image[1]) }
+                end
+                stamps << stamp_name
+              end
+              stamp stamp_name
+            end
+          end
+        end
+
+        def table_contains_pagerhref? node
+          return false unless node.context == :table
+          node.rows[:body].each do |row|
+            row.each do |cell|
+              return true if cell.text.to_s.include?('pagerhref:')
+            end
+          end
+          false
+        end
+        
+        def allocate_pagerhref_table_extent node
+          extent = dry_run onto: self do
+            @rendering_deferred_table = true
+            super_convert_table node
+            @rendering_deferred_table = false
+          end
+          
+          @pagerhref_tables ||= []
+          @pagerhref_tables << {
+            node: node,
+            extent: extent,
+            page: page_number
+          }
+          
+          move_cursor_to extent.to.cursor
+        end
+        
+        def ink_pagerhref_tables
+          @anchor_catalog ||= {}
+          
+          @pagerhref_tables.each do |table_info|
+            extent = table_info[:extent]
+            node = table_info[:node]
+            
+            # Resolve pagerhrefs before rendering
+            resolve_pagerhrefs_in_table node
+            
+            go_to_page extent.from.page
+            move_cursor_to extent.from.cursor
+            
+            @rendering_deferred_table = true
+            super_convert_table node
+            @rendering_deferred_table = false
+          end
+        end
+        
+        def resolve_pagerhrefs_in_table table
+           # Recursively search for pagerhref markers in the table and replace them
+           debug_log "Resolving pagerhrefs. Anchor catalog has #{@anchor_catalog.keys.size} entries: #{@anchor_catalog.keys.take(10)}", @document
+           
+           table.rows[:body].each do |row|
+             row.each do |cell|
+               next unless cell.text && cell.text.to_s.include?('pagerhref:')
+               
+               # Replace [pagerhref:anchor] with page number
+               # We use a regex that matches the marker created by the inline macro
+               cell.text = cell.text.to_s.gsub(/\[pagerhref:(.*?)\]/) do |match|
+                 anchor = $1
+                 if (entry = @anchor_catalog[anchor]) && entry[:dest]
+                    # TODO: Convert physical page to logical page if needed
+                    entry[:dest][:page].to_s
+                 else
+                    debug_log "Pagerhref resolution failed for anchor '#{anchor}'. Catalog has entry? #{@anchor_catalog.key?(anchor)}", @document
+                    "??"
+                 end
+               end
+             end
+           end
+        end
+        
+        def super_convert_table node
+          self.class.superclass.instance_method(:convert_table).bind(self).call(node)
+        end
+        
+        def render_adoc_include doc, filepath
+          return unless filepath && File.exist?(filepath)
+          begin
+            content = File.read(filepath)
+            subdoc = ::Asciidoctor.load content, safe: :safe, backend: 'pdf'
+            subdoc.blocks.each { |block| traverse block }
+          rescue => e
+            warn "asciidoctor: WARNING: Failed to render include file #{filepath}: #{e.message}"
+          end
+        end
+        
+        def ink_revision_history_content doc
+          collect_document_level_entries doc
+          
+          if doc.attr? 'rhrev-export-to-file'
+            export_to_adoc_file doc
+            return
+          end
+          
+          return if doc.attr('rhrev') == 'manual'
+          
+          if is_initial_release?(doc)
+            initial_handling = doc.attr 'rhrev-initial-handling', 'initial-release'
+            case initial_handling
+            when 'skip'; return
+            when 'normal'; # Continue
+            else
+              render_initial_release_table doc
+              return
+            end
+          end
+          
+          block_type = doc.attr 'rhrev-block-type', 'section'
+          
+          if block_type == 'table' && !(doc.attr? 'rhrev-disable-caption')
+            unless doc.attr? 'table-caption'
+              doc.set_attr 'table-caption', (doc.attr 'table-caption', 'Table')
+            end
+          end
+          
+          if block_type == 'section'
+            version_label = doc.attr('version-label')
+            default_title = "#{version_label} History"
+            if (title = doc.attr 'rhrev-customization-title', default_title)
+              unless title.empty?
+                heading_opts = { align: :left, margin_bottom: (@theme.heading_margin_bottom || 12) }
+                theme_font :heading, level: 2 do
+                  ink_prose title, heading_opts
+                end
+              end
+            end
+          end
+          
+          create_revision_table_properly doc if revision_history
+        end
+        
+        def is_initial_release? doc
+          revnumber = doc.attr('revnumber')
+          return false unless revnumber
+          revnumber.to_s.strip == '1.0' || revnumber.to_s.strip == '1'
+        end
+        
+        def render_initial_release_table doc
+          block_type = doc.attr 'rhrev-block-type', 'section'
+          
+          if block_type == 'section'
+            version_label = doc.attr('version-label')
+            default_title = "#{version_label} History"
+            if (title = doc.attr 'rhrev-customization-title', default_title)
+              unless title.empty?
+                heading_opts = { align: :left, margin_bottom: (@theme.heading_margin_bottom || 12) }
+                theme_font :heading, level: 2 do
+                  ink_prose title, heading_opts
+                end
+              end
+            end
+          end
+          
+          column_widths = get_column_widths doc
+          table_data = []
+          
+          page_label = doc.attr 'rhrev-localization-page', 'Page'
+          major_changes_text = doc.attr 'rhrev-localization-major-changes', 'Major changes since'
+          
+          revision_label = doc.attr('version-label', 'Revision')
+          revnumber = doc.attr('revnumber')
+          
+          header_text = "*#{major_changes_text} #{revision_label} #{revnumber}*"
+          table_data << ["*#{page_label}*", header_text]
+          
+          initial_text = doc.attr 'rhrev-customization-initial-release-text', 'Initial Release'
+          table_data << ["", initial_text]
+          
+          formatted_widths = column_widths.map { |w| w.to_i.to_s }.join(',')
+          markup_lines = []
+          markup_lines << "[cols='#{formatted_widths}']"
+          markup_lines << "|==="
+          table_data.each do |row|
+             markup_lines << "|#{row[0]} |#{row[1]}"
+          end
+          markup_lines << "|==="
+          
+          parsed_doc = ::Asciidoctor.load(markup_lines.join("\n"), safe: :safe, backend: 'pdf')
+          table = parsed_doc.blocks[0]
+          
+          table.set_attr 'frame', (doc.attr 'rhrev-table-frame', 'all')
+          table.set_attr 'grid', (doc.attr 'rhrev-table-grid', 'all')
+          if (stripes = doc.attr 'rhrev-table-stripes')
+            table.set_attr 'stripes', stripes
+          end
+          
+          convert_table table
+        end
+        
+        def ink_prose text, opts = {}
+          layout_prose text, opts
+        end
+        
+        def format_location_for_display location_text, entry, doc
+          %(<span class="rhrevpage">#{location_text}</span>)
+        end
+        
+        def format_with_role text, role
+          %(<span class="#{role}">#{text}</span>)
+        end
+        
+        def build_consolidated_list doc, items
+          return "" if items.empty?
+          items.map { |item| "* #{item}" }.join("\n")
+        end
+        
+        def build_description_xrefs anchor, doc, entry
+          # Build description xref text directly using <a anchor="..."> markup
+          # This is necessary because xref: syntax won't resolve in a parsed subdocument
+          xrefstyle_config = doc.attr 'rhrev-description-xrefstyle', ''
+          styles = xrefstyle_config.split(/\s+/).reject(&:empty?)
+          
+          has_reftext = entry && entry[:reftext]
+          
+          if styles.empty?
+            # Default: use basic style
+            display_text = build_xref_text(anchor, 'basic', entry, doc)
+            formatted_text = format_with_role(display_text, 'rhrevdescription')
+            "<a anchor=\"#{anchor}\">#{formatted_text}</a>"
+          elsif styles.length == 1
+            display_text = build_xref_text(anchor, styles[0], entry, doc)
+            formatted_text = format_with_role(display_text, 'rhrevdescription')
+            "<a anchor=\"#{anchor}\">#{formatted_text}</a>"
+          elsif styles.join(' ') == 'short basic'
+            # Special case: add both short and basic xrefs
+            # For sections: check if numbered (respects :!sectnum:)
+            is_numbered = entry ? check_if_numbered(entry, anchor, doc) : false
+            
+            if has_reftext || !is_numbered
+              # If reftext is defined OR section is unnumbered, just use basic to avoid duplication
+              display_text = build_xref_text(anchor, 'basic', entry, doc)
+              formatted_text = format_with_role(display_text, 'rhrevdescription')
+              "<a anchor=\"#{anchor}\">#{formatted_text}</a>"
+            else
+              # No reftext and numbered section, safe to add both
+              display_short = build_xref_text(anchor, 'short', entry, doc)
+              display_basic = build_xref_text(anchor, 'basic', entry, doc)
+              formatted_short = format_with_role(display_short, 'rhrevdescription')
+              formatted_basic = format_with_role(display_basic, 'rhrevdescription')
+              "<a anchor=\"#{anchor}\">#{formatted_short}</a> <a anchor=\"#{anchor}\">#{formatted_basic}</a>"
+            end
+          else
+            # Multiple styles - output each
+            xrefs = styles.map do |style|
+              display_text = build_xref_text(anchor, style, entry, doc)
+              formatted_text = format_with_role(display_text, 'rhrevdescription')
+              "<a anchor=\"#{anchor}\">#{formatted_text}</a>"
+            end
+            xrefs.join(" ")
+          end
+        end
+        
+        def create_revision_table_properly doc
+          asciidoc_table = build_table_via_parsing doc
+          
+          disable_caption = doc.attr? 'rhrev-disable-caption'
+          if disable_caption
+            saved_caption = doc.attr 'table-caption'
+            doc.set_attr 'table-caption', ''
+          end
+          
+          convert_table asciidoc_table
+          
+          if disable_caption
+            if saved_caption
+              doc.set_attr 'table-caption', saved_caption
+            else
+              doc.delete_attr 'table-caption'
+            end
+          end
+        end
+        
+        def add_custom_first_row_to_markup markup_lines, doc
+          if (first_row_merged = doc.attr 'rhrev-customization-first-row')
+            processed = preprocess_attribute_content(first_row_merged)
+            cell_prefix = needs_asciidoc_cell?(processed) ? "2+a|" : "2+|"
+            markup_lines << ""
+            markup_lines << "#{cell_prefix}#{processed}"
+          else
+            first_row_left = doc.attr 'rhrev-customization-first-row-left'
+            first_row_right = doc.attr 'rhrev-customization-first-row-right'
+            
+            if first_row_left || first_row_right
+              left_processed = first_row_left ? preprocess_attribute_content(first_row_left) : ''
+              right_processed = first_row_right ? preprocess_attribute_content(first_row_right) : ''
+              left_prefix = needs_asciidoc_cell?(left_processed) ? "a|" : "|"
+              right_prefix = needs_asciidoc_cell?(right_processed) ? "a|" : "|"
+              markup_lines << ""
+              markup_lines << "#{left_prefix}#{left_processed}"
+              markup_lines << "#{right_prefix}#{right_processed}"
+            end
+          end
+        end
+        
+        def build_table_via_parsing doc
+          column_widths = get_column_widths doc
+          markup_lines = []
+          formatted_widths = column_widths.map { |w| w.to_i.to_s }.join(',')
+          markup_lines << "[cols='#{formatted_widths}']"
+          markup_lines << "|==="
+          
+          add_custom_first_row_to_markup markup_lines, doc
+          
+          markup_lines << "|Placeholder"
+          markup_lines << "a|* Placeholder list"
+          markup_lines << "|==="
+          
+          markup_str = markup_lines.join("\n")
+          parsed_doc = ::Asciidoctor.load(markup_str, safe: :safe, backend: 'pdf')
+          table = parsed_doc.blocks[0]
+          
+          table.set_attr 'frame', (doc.attr 'rhrev-table-frame', 'all')
+          table.set_attr 'grid', (doc.attr 'rhrev-table-grid', 'all')
+          if (stripes = doc.attr 'rhrev-table-stripes')
+            table.set_attr 'stripes', stripes
+          end
+          if (caption = doc.attr 'rhrev-table-caption')
+            table.title = caption
+          end
+          
+          has_custom_first_row = (doc.attr? 'rhrev-customization-first-row') || 
+                                (doc.attr? 'rhrev-customization-first-row-left') || 
+                                (doc.attr? 'rhrev-customization-first-row-right')
+          
+          custom_first_row = has_custom_first_row ? table.rows.body[0] : nil
+          
+          placeholder_row = has_custom_first_row ? table.rows.body[1] : table.rows.body[0]
+          template_location_cell = placeholder_row[0]
+          template_asciidoc_cell = placeholder_row[1]
+          
+          table.rows.body.clear
+          table.rows.body << custom_first_row if custom_first_row
+          
+          page_label = doc.attr 'rhrev-localization-page', 'Page'
+          major_changes_text = doc.attr 'rhrev-localization-major-changes', 'Major changes since'
+          all_text = doc.attr 'rhrev-localization-all', 'All'
+          cover_text = doc.attr 'rhrev-localization-cover', 'Cover'
+          
+          revision_history.sorted_revisions.each do |revision|
+            prevrev_attr = "#{revision}-prevrev"
+            prevrevdate_attr = "#{revision}-prevrevdate"
+            revision_label = doc.attr('version-label', 'Revision')
+            prev_title = doc.attr(prevrev_attr) || "#{revision.tr('-', '.')}"
+            prev_date = doc.attr(prevrevdate_attr) || ""
+            prev_rev_text = format_prev_rev(prev_title, prev_date, doc)
+            
+            if prev_title.strip.downcase.start_with?(revision_label.downcase)
+              header_text = "*#{major_changes_text} #{prev_rev_text}*"
+            else
+              header_text = "*#{major_changes_text} #{revision_label} #{prev_rev_text}*"
+            end
+            
+            page_cell = build_text_cell table, 0, "*#{page_label}*"
+            header_cell = build_text_cell table, 1, header_text
+            table.rows.body << [page_cell, header_cell]
+            
+            if (all_change = revision_history.instance_variable_get(:@all_entries)[revision])
+              row = build_list_row table, all_text, all_change, nil, nil, template_location_cell, template_asciidoc_cell, doc, is_all_or_cover: true
+              table.rows.body << row
+            end
+            
+            if (cover_change = revision_history.instance_variable_get(:@cover_entries)[revision])
+              unless doc.backend.to_s == 'html5'
+                row = build_list_row table, cover_text, cover_change, nil, nil, template_location_cell, template_asciidoc_cell, doc, is_all_or_cover: true
+                table.rows.body << row
+              end
+            end
+            
+            entries = revision_history.entries[revision] || []
+            entries = entries.sort_by do |e|
+              page_num = e[:dest] ? e[:dest][:page_sortable] : Float::INFINITY
+              y_pos = e[:dest] && e[:dest][:y] ? e[:dest][:y] : 0
+              # Sort by page (ASC) then y_pos (DESC - top to bottom) then sequence (ASC)
+              [page_num, -y_pos, e[:sequence] || 0]
+            end
+            
+            entries.each do |entry|
+              location = build_location_text entry, doc
+              row = build_list_row table, location, entry[:change], entry[:anchor], entry, template_location_cell, template_asciidoc_cell, doc
+              table.rows.body << row
+            end
+          end
+          
+          if doc.attr? 'rhrev-table-extra-blank-row'
+            blank_row = build_text_row table, ["\u00A0", "\u00A0"]
+            table.rows.body << blank_row
+          end
+          
+          table
+        end
+        
+        def build_text_row table, cells_data
+          cells_data.map.with_index do |text, col_idx|
+            build_cell table, col_idx, text
+          end
+        end
+        
+        def format_as_list text
+          text_str = text.to_s
+          # Don't skip if it doesn't have * - we might want to force list
+          
+          tokens = text_str.split(/\s(?=\*+\s)/)
+          return text_str if tokens.empty?
+          
+          lines = []
+          first = tokens.shift
+          
+          # Check if first item already starts with *
+          if first.strip.start_with?('*')
+             lines << first.strip
+          else
+             lines << "* #{first.strip}"
+          end
+          
+          tokens.each do |token|
+            lines << token.strip
+          end
+          
+          lines.join("\n")
+        end
+        
+        def build_list_row table, location_text, change_text, anchor, entry, template_location_cell, template_asciidoc_cell, doc, is_all_or_cover: false
+          if anchor && location_text != '???'
+            location_cell = ::Asciidoctor::Table::Cell.new(template_location_cell.column, "", template_asciidoc_cell.attributes.dup)
+            location_cell.inner_document.blocks.clear
+            para_block = ::Asciidoctor::Block.new(location_cell.inner_document, :paragraph)
+            formatted_location = format_with_role(location_text, 'rhrevpage')
+            para_block.lines = ["<a anchor=\"#{anchor}\">#{formatted_location}</a>"]
+            location_cell.inner_document.blocks << para_block
+          else
+            location_cell = ::Asciidoctor::Table::Cell.new(template_location_cell.column, location_text, template_location_cell.attributes.dup)
+          end
+          
+          change_cell = ::Asciidoctor::Table::Cell.new(template_asciidoc_cell.column, "", template_asciidoc_cell.attributes.dup)
+          change_cell.inner_document.blocks.clear
+          
+          cell_doc = change_cell.inner_document
+          
+          if is_all_or_cover
+            # For all/cover entries, just add the change text
+            processed = preprocess_attribute_content(change_text)
+            if processed.include?('* ')
+              processed = format_as_list(processed)
+            end
+            if needs_asciidoc_cell?(processed)
+              parsed = ::Asciidoctor.load(processed, safe: :safe, backend: 'pdf')
+              parsed.blocks.each do |block|
+                block.parent = cell_doc
+                cell_doc.blocks << block
+              end
+            else
+              para = ::Asciidoctor::Block.new(cell_doc, :paragraph, source: processed)
+              cell_doc.blocks << para
+            end
+          else
+            description_config = doc.attr 'rhrev-customization-description-format', 'xref,desc'
+            show_desc = description_config.include?('desc')
+            show_xref = description_config.include?('xref')
+            
+            # Add xref as a direct paragraph block (not parsed) - <a anchor="..."> is PDF converter syntax
+            if show_xref && anchor
+              xref_markup = build_description_xrefs(anchor, doc, entry)
+              xref_block = ::Asciidoctor::Block.new(cell_doc, :paragraph)
+              xref_block.lines = [xref_markup]
+              cell_doc.blocks << xref_block
+            end
+            
+            # Add change description text
+            if show_desc && !change_text.to_s.empty?
+              processed = preprocess_attribute_content(change_text)
+              processed = format_as_list(processed)
+              
+              if needs_asciidoc_cell?(processed)
+                parsed = ::Asciidoctor.load(processed, safe: :safe, backend: 'pdf')
+                parsed.blocks.each do |block|
+                  block.parent = cell_doc
+                  cell_doc.blocks << block
+                end
+              else
+                para = ::Asciidoctor::Block.new(cell_doc, :paragraph, source: processed)
+                cell_doc.blocks << para
+              end
+            end
+          end
+          
+          [location_cell, change_cell]
+        end
+        
+        def build_cell table, col_idx, text
+          column = table.columns[col_idx]
+          ::Asciidoctor::Table::Cell.new column, text
+        end
+        
+        def build_text_cell table, col_idx, text
+          build_cell table, col_idx, text
+        end
+        
+        def build_location_text entry, doc
+          if entry[:dest]
+             entry[:dest][:page]
+          else
+             "???"
+          end
+        end
+        
+        def check_if_numbered(entry, anchor, doc)
+          context = entry[:context]
+          if context == :section
+            return true unless entry[:sectnum]
+            if doc.respond_to?(:catalog) && doc.catalog && doc.catalog[:refs]
+               section = doc.catalog[:refs][anchor]
+               if section && section.respond_to?(:numbered)
+                  return section.numbered
+               elsif section && section.respond_to?(:numbered?)
+                  return section.numbered?
+               end
+            end
+            return true
+          end
+          if entry[:caption_number]
+            return true
+          end
+          false
+        end
+        
+        def build_xref_text(anchor, style, entry, doc)
+           # If reftext is defined, it overrides everything
+           return entry[:reftext] if entry && entry[:reftext]
+           
+           title = entry && entry[:title] ? entry[:title] : nil
+           sectnum = entry && entry[:sectnum] ? entry[:sectnum] : nil
+           context = entry && entry[:context] ? entry[:context] : nil
+           is_chapter = entry && entry[:is_chapter]
+           caption_number = entry && entry[:caption_number]
+           
+           # Fallback if no title - convert anchor to title case
+           unless title
+             # Handle Antora ::: separator - extract fragment for display
+             display_anchor = anchor.include?(':::') ? anchor.split(':::').last : anchor
+             clean_anchor = display_anchor.sub(/^_/, '')
+             return clean_anchor.tr('-', ' ').split.map(&:capitalize).join(' ')
+           end
+           
+           # For sections with numbers, construct appropriate xreftext
+           if sectnum && context == :section
+             numbered = check_if_numbered(entry, anchor, doc)
+             
+             if numbered
+               if doc.attr? 'rhrev-customization-xrefstyleshort-remove-trailling-period'
+                 clean_sectnum = sectnum.to_s.sub(/\.$/, '')
+               else
+                 clean_sectnum = sectnum.to_s
+                 clean_sectnum += '.' unless clean_sectnum.end_with?('.')
+               end
+               signifier = is_chapter ? 'Chapter' : 'Section'
+               
+               case style
+               when 'full'
+                 "#{signifier} #{clean_sectnum}, \"#{title}\""
+               when 'short'
+                 "#{signifier} #{clean_sectnum}"
+               when 'basic'
+                 title
+               else
+                 title
+               end
+             else
+               # Section numbering is disabled, just return the title
+               title
+             end
+           elsif caption_number && [:example, :table, :listing, :image].include?(context)
+            # For numbered blocks (examples, tables, listings, images), the period must be added to match AsciiDoctor-PDF's default built-in theming/presentation behavior.
+             if doc.attr? 'rhrev-customization-xrefstyleshort-remove-trailling-period'
+               clean_caption_number = caption_number.to_s.sub(/\.$/, '')
+             else
+               clean_caption_number = caption_number.to_s
+               clean_caption_number += '.' unless clean_caption_number.end_with?('.')
+             end
+
+             signifier = case context
+             when :example
+               doc.attr('example-caption', 'Example').sub(/\.?\s*$/, '')
+             when :table
+               doc.attr('table-caption', 'Table').sub(/\.?\s*$/, '')
+             when :listing
+               doc.attr('listing-caption', 'Listing').sub(/\.?\s*$/, '')
+             when :image
+               doc.attr('figure-caption', 'Figure').sub(/\.?\s*$/, '')
+             else
+               context.to_s.capitalize
+             end
+             
+             case style
+             when 'full'
+               "#{signifier} #{clean_caption_number}, \"#{title}\""
+             when 'short'
+               "#{signifier} #{clean_caption_number}"
+             when 'basic'
+               title
+             else
+               title
+             end
+           else
+             # No section number or caption number, just return title for all styles
+             title
+           end
+        end
+        
+        def get_column_widths doc
+           widths_str = doc.attr 'rhrev-table-column-width', Asciidoctor::PDF::Rhrev::Catalog.default_columns
+           widths_str.split(',').map(&:strip)
+        end
+        
+      end
+    end
+  end
+end