asciidoctor-rhrev 1.0.0

data/lib/asciidoctor/rhrev/catalog.rb

@@ -0,0 +1,92 @@
+module Asciidoctor
+  module Rhrev
+    class Catalog
+        attr_accessor :entries
+        attr_accessor :all_entries
+        attr_accessor :cover_entries
+        
+        def initialize
+          @entries = {}  # Hash of revision => [entries]
+          @all_entries = {}  # Hash of revision => text for 'all' entries
+          @cover_entries = {}  # Hash of revision => text for 'cover' entries
+          @sequence_counter = 0  # Counter to track document order
+        end
+        
+        def self.default_labels
+          {
+            'page' => 'Page',
+            'major_changes' => 'Major changes since'
+          }
+        end
+        
+        def self.default_columns
+          '30,70'  # location, change
+        end
+        
+        def add_entry revision, anchor, change_text, reftext: nil, title: nil, sectnum: nil, context: nil, is_chapter: false, sectname: nil, caption_number: nil, source_line: nil
+          @entries[revision] ||= []
+          
+          # Prevent duplicates (e.g. if collected multiple times)
+          return if @entries[revision].any? { |e| e[:anchor] == anchor }
+          
+          @sequence_counter += 1
+          # Use source_line if available, otherwise fall back to sequence counter
+          sequence = source_line || @sequence_counter
+          @entries[revision] << {
+            anchor: anchor,
+            change: change_text,
+            dest: nil,
+            sequence: sequence,
+            reftext: reftext,
+            title: title,
+            sectnum: sectnum,
+            context: context,
+            is_chapter: is_chapter,
+            sectname: sectname,
+            caption_number: caption_number
+          }
+        end
+        
+        def add_all_entry revision, change_text
+          @all_entries[revision] = change_text
+        end
+        
+        def add_cover_entry revision, change_text
+          @cover_entries[revision] = change_text
+        end
+        
+        def link_dest_to_page anchor, physical_page_number, start_page_number, y: nil
+          @entries.each do |revision, entry_list|
+            entry_list.each do |entry|
+              next unless entry[:anchor] == anchor
+              
+              virtual_page_number = physical_page_number - (start_page_number - 1)
+              entry[:dest] = {
+                anchor: anchor,
+                page: (virtual_page_number < 1 ? 
+                  (Asciidoctor::PDF::RomanNumeral.new physical_page_number, :lower) : 
+                  virtual_page_number).to_s,
+                page_sortable: physical_page_number,
+                y: y
+              }
+            end
+          end
+        end
+        
+        def sorted_revisions
+          # Collect all unique revisions from entries, all_entries, and cover_entries
+          all_revisions = (@entries.keys + @all_entries.keys + @cover_entries.keys).uniq
+          
+          # Sort revisions in descending order (newest first)
+          all_revisions.sort do |a, b|
+            parse_revision(b) <=> parse_revision(a)
+          end
+        end
+        
+        def parse_revision rev_string
+          # Parse "1-1", "1-2", "1-10-2" into comparable array [1, 1], [1, 2], [1, 10, 2]
+          rev_string.split('-').map(&:to_i)
+        end
+      end
+  end
+end

data/lib/asciidoctor/rhrev/converter.rb

@@ -0,0 +1,437 @@
+require 'asciidoctor/pdf' unless defined? Asciidoctor::PDF
+require 'fileutils'
+require_relative 'helpers'
+require_relative 'catalog'
+require_relative 'renderer'
+require_relative 'exporter'
+require_relative 'processors'
+
+module Asciidoctor
+  module PDF
+    module Rhrev
+      # Import shared classes from parent namespace
+      Catalog = ::Asciidoctor::Rhrev::Catalog
+      Helpers = ::Asciidoctor::Rhrev::Helpers
+      
+      class Converter < ::Asciidoctor::Converter.for('pdf')
+        register_for 'pdf'
+        
+        include Helpers
+        include Renderer
+        include Exporter
+        
+        def initialize *args
+          super
+          @revision_history_extent = nil
+          @revision_prefix = nil
+          @rhrev_deferred_pages = nil
+          @pagerhref_tables = []
+          @export_completed = false
+          @catalog = nil
+          @manual_mode = false
+        end
+        
+        def revision_history
+          @catalog ||= Catalog.new
+        end
+        
+        def convert_document node
+          @revision_prefix = node.attr 'revhistoryprefix', 'rhrev'
+          
+          # Check if we're in manual mode (pagerhref support needed)
+          @manual_mode = node.attr('rhrev') == 'manual'
+          
+          # Initialize catalog
+          @catalog = revision_history
+          
+          # Prescan document to populate catalog before rendering
+          # This is necessary for accurate space allocation
+          prescan_document node
+          
+          # Render document (this will visit all nodes and update entry metadata)
+          result = super
+          
+          # Ink revision history if allocated
+          if @revision_history_extent && @catalog
+            ink_revision_history node, @revision_history_extent
+          end
+          
+          # Re-render tables with pagerhrefs (only in manual mode)
+          ink_pagerhref_tables if @manual_mode && @pagerhref_tables && !@pagerhref_tables.empty?
+          
+          # Export to file AFTER rendering (metadata like sectnum, caption_number are now populated)
+          if node.attr?('rhrev-export-to-file') && @catalog
+            export_to_adoc_file node
+          end
+          
+          result
+        end
+        
+        def convert_section node
+          # Skip collect during render if prescan already did it
+          collect_revision_entries node unless @prescan_complete
+          update_revision_entry_metadata node
+          
+          if node.id
+            @anchor_catalog ||= {}
+            @anchor_catalog[node.id] ||= {
+              title: node.title,
+              reftext: node.reftext,
+              sectnum: node.sectnum,
+              context: node.context,
+              level: node.level
+            }
+            @anchor_catalog[node.id][:dest] = { page: page_number, y: cursor }
+            
+            # Link destination to page for revision history
+            revision_history.link_dest_to_page node.id, page_number, 1, y: cursor
+          end
+          
+          super
+        end
+        
+        def convert_table node
+          has_id = node.id && !node.id.empty? rescue false
+          has_rhrev = false
+          if node.respond_to?(:attributes) && node.attributes
+            has_rhrev = node.attributes.keys.any? { |k| k.to_s.start_with?(@revision_prefix || 'rhrev') } rescue false
+          end
+          
+          # Check for pagerhref macros in table (only in manual mode)
+          # This check is expensive so we skip it unless in manual mode
+          has_pagerhref = @manual_mode && !@rendering_deferred_table && table_contains_pagerhref?(node)
+          
+          if !has_id && !has_rhrev && !has_pagerhref
+            return super
+          end
+          
+          # Skip collect during render if prescan already did it
+          collect_revision_entries node unless @prescan_complete
+          update_revision_entry_metadata node
+          
+          if has_pagerhref
+            allocate_pagerhref_table_extent node
+          else
+            result = super
+            catalog_block_anchor node
+            result
+          end
+        end
+        
+        def convert_image node
+          # Skip collect during render if prescan already did it
+          collect_revision_entries node unless @prescan_complete
+          update_revision_entry_metadata node
+          result = super
+          catalog_block_anchor node
+          result
+        end
+        
+        def convert_example node
+          # Skip collect during render if prescan already did it
+          collect_revision_entries node unless @prescan_complete
+          update_revision_entry_metadata node
+          result = super
+          catalog_block_anchor node
+          result
+        end
+        
+        def convert_listing node
+          # Skip collect during render if prescan already did it
+          collect_revision_entries node unless @prescan_complete
+          update_revision_entry_metadata node
+          result = super
+          catalog_block_anchor node
+          result
+        end
+        
+        def convert_floating_title node
+          # Skip collect during render if prescan already did it
+          collect_revision_entries node unless @prescan_complete
+          update_revision_entry_metadata node
+          result = super
+          catalog_block_anchor node
+          result
+        end
+        
+        def convert_rhrev node
+          return unless node.document.attr? 'rhrev'
+          return if @revision_history_extent
+          
+          collect_document_level_entries node.document
+          @revision_history_extent = allocate_revision_history_extent node.document
+          nil
+        end
+        
+        def convert_inline_quoted node
+          if node.text&.match?(/^\[pagerhref:/)
+            if node.text =~ /^\[pagerhref:(.+)\]$/
+              anchor = $1
+              lookup_anchor = anchor.gsub('----', ':::')
+              
+              if @anchor_catalog && @anchor_catalog[lookup_anchor] && @anchor_catalog[lookup_anchor][:dest]
+                page_num = @anchor_catalog[lookup_anchor][:dest][:page]
+                %(<a anchor="#{lookup_anchor}"><span class="pagerhref">#{page_num}</span></a>)
+              else
+                if scratch?
+                  %(<a anchor="#{lookup_anchor}"><span class="pagerhref">99</span></a>)
+                else
+                  %(<a anchor="#{lookup_anchor}"><span class="pagerhref">??</span></a>)
+                end
+              end
+            else
+              super
+            end
+          else
+            super
+          end
+        end
+        
+        def start_new_chapter chapter
+          if !@revision_history_extent && chapter.document && (chapter.document.attr? 'rhrev')
+            rhrev_value = chapter.document.attr('rhrev')
+            export_to_file = chapter.document.attr? 'rhrev-export-to-file'
+            # Effectively only when rhrev is 'true', add the revision history section at the beginning of the document (after the title_page)
+            if rhrev_value != 'macro' && rhrev_value != 'manual' && !export_to_file
+              collect_document_level_entries chapter.document
+              @revision_history_extent = allocate_revision_history_extent chapter.document
+            end
+          end
+          super
+        end
+        
+        def collect_revision_entries node
+          return if @prescan_complete
+          return unless node.respond_to?(:attributes)
+          
+          is_document = node.class.to_s.include?('Document')
+          return if is_document
+          
+          # Access raw attributes safely
+          attr_entries = node.instance_variable_get(:@attributes) rescue {}
+          return if attr_entries.nil? || attr_entries.empty?
+          
+          # Check for rhrev attributes before checking ID to debug missing IDs
+          has_rhrev = attr_entries.keys.any? { |k| k.to_s.start_with?(@revision_prefix) }
+          return unless has_rhrev
+          
+          has_id = node.id && !node.id.empty? rescue false
+          unless has_id
+            debug_log "Node #{node.context} has rhrev attributes but NO ID. Skipping. Attributes: #{attr_entries.keys.select{|k| k.to_s.start_with?(@revision_prefix)}}", @document
+            return
+          end
+          
+          debug_log "Found entry candidate on #{node.context} id=#{node.id}", @document
+          
+          attr_entries.each do |key, value|
+            key_str = key.to_s
+            next unless key_str.start_with?(@revision_prefix)
+            next if key_str.include?('-all') || key_str.end_with?('-cover')
+            
+            revision = key_str.sub("#{@revision_prefix}", '')
+            
+            debug_log "Adding entry: Rev=#{revision}, Anchor=#{node.id}, Change=#{value}", @document
+            
+            revision_history.add_entry revision, node.id, value.to_s,
+              reftext: nil,
+              title: nil,
+              sectnum: nil,
+              context: node.context,
+              is_chapter: false,
+              sectname: nil,
+              caption_number: nil,
+              source_line: node.lineno
+          end
+        end
+        
+        def update_revision_entry_metadata node
+          return unless node.id
+          return unless node.respond_to?(:attributes)
+          
+          with_attribute_missing_suppressed node.document do
+            node.attributes.each do |key, value|
+              key_str = key.to_s
+              next unless key_str.start_with?(@revision_prefix)
+              next if key_str.include?('-all') || key_str.end_with?('-cover')
+              
+              revision = key_str.sub("#{@revision_prefix}", '')
+              
+              entries = revision_history.entries[revision]
+              next unless entries
+              
+              entry = entries.find { |e| e[:anchor] == node.id }
+              next unless entry
+              
+              if entry[:change].to_s.empty?
+                entry[:change] = value
+              end
+              
+              entry[:reftext] = node.reftext
+              entry[:title] = node.title
+              entry[:sectnum] = node.respond_to?(:sectnum) ? node.sectnum : nil
+              
+              if node.context == :section && node.document.doctype == 'book'
+                entry[:is_chapter] = (node.level == 0 || node.level == 1)
+              end
+              
+              if node.respond_to?(:caption) && node.caption
+                if node.caption =~ /(\d+)/
+                  entry[:caption_number] = $1
+                end
+              end
+              
+              entry[:sectname] = node.sectname if node.respond_to?(:sectname)
+            end
+          end
+        end
+        
+        def catalog_block_anchor node
+          @anchor_catalog ||= {}
+          if node.id
+            @anchor_catalog[node.id] ||= {
+              title: node.title,
+              context: node.context
+            }
+            page_num = page_number
+            @anchor_catalog[node.id][:dest] = { page: page_num, y: cursor }
+            
+            revision_history.link_dest_to_page node.id, page_num, 1, y: cursor
+          end
+        end
+        
+        def table_contains_pagerhref? node
+          return false unless node.context == :table
+          
+          # Check cell content WITHOUT triggering attribute substitution
+          # This prevents counter attributes like {counter:tablecounter} from incrementing
+          # We MUST NOT call cell.text or access cell.inner_document as those trigger parsing
+          node.rows[:body].each do |row|
+            row.each do |cell|
+              # Check the raw @text instance variable if already evaluated
+              if cell.instance_variable_defined?(:@text)
+                raw_text = cell.instance_variable_get(:@text).to_s
+                return true if raw_text.include?('pagerhref:')
+              end
+              # Check the inner document's source lines if available (before parsing)
+              if cell.instance_variable_defined?(:@inner_document)
+                inner_doc = cell.instance_variable_get(:@inner_document)
+                if inner_doc && inner_doc.instance_variable_defined?(:@lines)
+                  lines = inner_doc.instance_variable_get(:@lines) || []
+                  return true if lines.any? { |l| l.to_s.include?('pagerhref:') }
+                end
+              end
+              # Last resort: check cell's style attribute for AsciiDoc cells
+              # AsciiDoc cells (a|) will have inner content that might contain pagerhref
+              if cell.style == :asciidoc
+                # For asciidoc cells, we need to check the source
+                # Access the cell's source blocks if available
+                if cell.instance_variable_defined?(:@inner_document)
+                  inner = cell.instance_variable_get(:@inner_document)
+                  if inner && inner.respond_to?(:blocks)
+                    inner.blocks.each do |block|
+                      if block.instance_variable_defined?(:@lines)
+                        lines = block.instance_variable_get(:@lines) || []
+                        return true if lines.any? { |l| l.to_s.include?('pagerhref:') }
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+          false
+        end
+        
+        def allocate_pagerhref_table_extent node
+          @rendering_deferred_table = true
+          
+          extent = dry_run onto: self do
+            super_convert_table node
+          end
+          
+          @rendering_deferred_table = false
+          
+          # Move cursor to after the allocated space
+          extent.each_page { |first_page| start_new_page unless first_page }
+          move_cursor_to extent.to.cursor
+          
+          # Store for later re-rendering with actual page numbers
+          @pagerhref_tables << {
+            node: node,
+            extent: extent
+          }
+        end
+        
+        def super_convert_table node
+          # Call the parent class method directly to avoid recursion
+          self.class.superclass.instance_method(:convert_table).bind(self).call(node)
+        end
+        
+        def ink_pagerhref_tables
+          return if scratch?
+          
+          @anchor_catalog ||= {}
+          
+          @pagerhref_tables.each do |table_info|
+            extent = table_info[:extent]
+            node = table_info[:node]
+            
+            # Go back to the allocated space
+            go_to_page extent.from.page
+            move_cursor_to extent.from.cursor
+            
+            # Re-render the table with flag set to prevent recursion
+            @rendering_deferred_table = true
+            super_convert_table node
+            @rendering_deferred_table = false
+          end
+        end
+        
+        def collect_document_level_entries doc
+          return if @document_entries_collected
+          @document_entries_collected = true
+          
+          (0..9).each do |major|
+            (0..9).each do |minor|
+              revision = "#{major}-#{minor}"
+              prevrev_attr = "#{revision}-prevrev"
+              
+              if doc.attr(prevrev_attr)
+                all_attr_name = "#{@revision_prefix}#{revision}-all"
+                if (all_value = doc.attr(all_attr_name))
+                  revision_history.add_all_entry revision, all_value
+                end
+                
+                cover_attr_name = "#{@revision_prefix}#{revision}-cover"
+                if (cover_value = doc.attr(cover_attr_name))
+                  revision_history.add_cover_entry revision, cover_value
+                end
+              end
+            end
+          end
+        end
+
+        def prescan_document doc
+          debug_log "Starting prescan_document", doc
+          
+          # Suppress attribute missing warnings during prescan
+          # This prevents counter attributes like {counter:tablecounter} from incrementing
+          with_attribute_missing_suppressed doc do
+            collect_document_level_entries doc
+            
+            # Use find_by with context filter - more efficient than single traversal
+            # because find_by(context:) can skip non-matching subtrees
+            [:section, :floating_title, :example, :listing, :table, :image].each do |ctx|
+              doc.find_by(context: ctx).each do |node|
+                collect_revision_entries node
+              end
+            end
+            
+            @prescan_complete = true
+            debug_log "Prescan complete. Catalog has #{revision_history.entries.values.flatten.size} entries.", doc
+          end
+        end
+      end
+    end
+  end
+end