asciidoctor-rhrev 1.0.0

data/lib/asciidoctor/rhrev/exporter.rb

@@ -0,0 +1,242 @@
+module Asciidoctor
+  module PDF
+    module Rhrev
+      module Exporter
+        def should_export_to_file? doc
+          doc.attr?('rhrev-export-to-file') || doc.attr?('rhrev-adoc-output')
+        end
+
+        def export_to_adoc_file doc
+          # Prevent double export
+          return if @export_completed
+          @export_completed = true
+          
+          export_attr = doc.attr('rhrev-export-to-file')
+          adoc_output = doc.attr('rhrev-adoc-output')
+          
+          # Determine output filename
+          # rhrev-export-to-file can be: true (use rhrev-adoc-output or default), or a filename
+          if export_attr == true || export_attr == 'true' || export_attr == ''
+            output_file = adoc_output || 'revhistory.adoc'
+          else
+            output_file = export_attr || adoc_output || 'revhistory.adoc'
+          end
+          
+          return unless output_file
+          
+          # Make path relative to document directory if not absolute
+          unless output_file.start_with?('/')
+            doc_dir = doc.attr('docdir') || Dir.pwd
+            output_file = File.join(doc_dir, output_file)
+          end
+          
+          # Create directory if it doesn't exist
+          output_dir = File.dirname(output_file)
+          FileUtils.mkdir_p(output_dir) unless output_dir == '.' || File.directory?(output_dir)
+          
+          debug_log "Exporting revision history to: #{output_file}", doc
+          
+          output = []
+          
+          # Get column configuration
+          column_widths = doc.attr 'rhrev-table-column-width', '30,70'
+          
+          output << "[cols='#{column_widths}']"
+          output << "|==="
+          
+          # Get localization strings
+          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'
+          
+          # Get export format (pagerhref or xref)
+          export_format = doc.attr 'rhrev-export-format', 'pagerhref'
+          
+          # Process each revision
+          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)
+            
+            # Build header text, avoiding "Revision Revision" repetition
+            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
+            
+            output << ""
+            output << "a|*#{page_label}*"
+            output << "a|#{header_text}"
+            
+            # All entry
+            if (all_change = revision_history.instance_variable_get(:@all_entries)[revision])
+              output << ""
+              output << "a|#{all_text}"
+              output << "a|"
+              export_change_text output, all_change, is_all_or_cover: true
+            end
+            
+            # Cover entry
+            if (cover_change = revision_history.instance_variable_get(:@cover_entries)[revision])
+              next if doc.backend.to_s == 'html5'
+              output << ""
+              output << "a|#{cover_text}"
+              output << "a|"
+              export_change_text output, cover_change, is_all_or_cover: true
+            end
+            
+            # Block entries - sort by sequence (source order in document)
+            entries = revision_history.entries[revision] || []
+            entries = entries.sort_by { |e| e[:sequence] || 0 }
+            
+            entries.each do |entry|
+              page_num = entry[:dest] ? entry[:dest][:page] : '???'
+              
+              # Convert anchor to portable xref format for Antora export
+              xref_anchor = convert_anchor_to_xref_for_export(entry[:anchor], doc)
+              
+              output << ""
+              if export_format == 'pagerhref'
+                # Use pagerhref macro for manual mode imports
+                output << "a|pagerhref:#{xref_anchor}[]"
+              else
+                # Use xref syntax with page number
+                output << "a|xref:#{xref_anchor}[#{page_num}]"
+              end
+              
+              # Build description cell with xrefs based on rhrev-description-xrefstyle
+              output << build_export_description_xrefs(xref_anchor, doc, entry)
+              output << ""  # Blank line before bullet list for AsciiDoc parsing
+              export_change_with_bullets output, entry[:change]
+            end
+          end
+          
+          output << "|==="
+          
+          File.write(output_file, output.join("\n"))
+          debug_log("Exported revision history to #{output_file}", doc)
+        end
+        
+        # Convert Antora-style anchor to xref format for export
+        # e.g., "chapter-1:::section-1-1" -> "chapter-1.adoc#section-1-1"
+        def convert_anchor_to_xref_for_export anchor, doc = nil
+          return anchor unless anchor
+          
+          # Skip transformation for standalone asciidoctor-pdf builds
+          return anchor if doc && !antora_build?(doc)
+          
+          # Auto-detect separator (---- for xml_ids, ::: for default)
+          separator = if anchor.include?('----')
+                        '----'
+                      elsif anchor.include?(':::')
+                        ':::'
+                      else
+                        nil
+                      end
+          
+          if separator
+            parts = anchor.split(separator, 2)
+            page_id = parts[0]
+            fragment = parts[1]
+            "#{page_id}.adoc##{fragment}"
+          else
+            # No separator - just a page reference
+            "#{anchor}.adoc"
+          end
+        end
+        
+        # Build description cell xrefs based on rhrev-description-xrefstyle
+        def build_export_description_xrefs xref_target, doc, entry = nil
+          xrefstyle_config = doc.attr 'rhrev-description-xrefstyle', ''
+          styles = xrefstyle_config.split(/\s+/).reject(&:empty?)
+          
+          # Check if entry has reftext defined
+          has_reftext = entry && entry[:reftext] && !entry[:reftext].to_s.empty?
+          
+          # Check if entry is numbered (sections with sectnum, or blocks with caption_number)
+          is_numbered = entry && (entry[:sectnum] || entry[:caption_number])
+          
+          if styles.empty?
+            # No xrefstyle specified - use default (empty brackets)
+            "a|xref:#{xref_target}[]"
+          elsif styles.length == 1
+            # Single xrefstyle
+            "a|xref:#{xref_target}[xrefstyle=#{styles[0]}]"
+          elsif styles.join(' ') == 'short basic'
+            # Special case: "short basic"
+            # - Numbered items (sections with sectnum, blocks with caption) → ALWAYS output both
+            #   e.g., "Section 1.1" + "Features", "Table 5" + "Pin Descriptions"
+            # - Unnumbered items with reftext (floating titles) → output only basic
+            #   to avoid duplication like "Register X Register X"
+            if is_numbered
+              # Numbered item - always use both styles
+              xrefs = styles.map { |style| "xref:#{xref_target}[xrefstyle=#{style}]" }
+              "a|#{xrefs.join(" \n")}"
+            elsif has_reftext
+              # Unnumbered with reftext - use basic only to avoid duplication
+              "a|xref:#{xref_target}[xrefstyle=basic]"
+            else
+              # Unnumbered without reftext - use both styles
+              xrefs = styles.map { |style| "xref:#{xref_target}[xrefstyle=#{style}]" }
+              "a|#{xrefs.join(" \n")}"
+            end
+          else
+            # Multiple xrefstyles - output each
+            xrefs = styles.map { |style| "xref:#{xref_target}[xrefstyle=#{style}]" }
+            "a|#{xrefs.join(" \n")}"
+          end
+        end
+        
+        # Export change text, matching embedded behavior for all/cover entries
+        def export_change_text output, change_text, is_all_or_cover: false
+          lines = change_text.to_s.split(/\r?\n/).map(&:strip).reject(&:empty?)
+          
+          # Single line without asterisks = plain text
+          if is_all_or_cover && lines.length == 1 && !lines[0].include?('*')
+            output << lines[0]
+          else
+            export_change_with_bullets output, change_text
+          end
+        end
+        
+        # Export change text with proper bullet formatting
+        def export_change_with_bullets output, change_text
+          return if change_text.to_s.empty?
+          
+          lines = change_text.to_s.split(/\r?\n/).map(&:strip).reject(&:empty?)
+          
+          lines.each do |line|
+            # Split on inline asterisks (e.g., "Text. * Bullet one ** Sub-bullet")
+            tokens = line.split(/\s(?=\*+\s)/)
+            first = tokens.shift
+            
+            # First token becomes a bullet
+            if first && !first.empty?
+              first = first.strip
+              if first.start_with?('*')
+                output << first
+              else
+                output << "* #{first}"
+              end
+            end
+            
+            # Remaining tokens are already asterisk-prefixed
+            tokens.each do |token|
+              token = token.strip
+              if token =~ /^(\*+)\s+(.*)/
+                stars = $1
+                content = $2.strip
+                output << "#{stars} #{content}"
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor/rhrev/helpers.rb

@@ -0,0 +1,117 @@
+module Asciidoctor
+  module Rhrev
+    module Helpers
+        # Check if we're running under Antora (vs standalone asciidoctor-pdf)
+        def antora_build? doc
+          # Antora sets these attributes automatically
+          doc.attr?('page-component-name') || doc.attr?('page-module') || doc.attr?('page-relative-src-path')
+        end
+        
+        # Convert Antora-style anchor ID to standard AsciiDoc xref format for export
+        def convert_anchor_to_xref anchor, doc = nil
+          return anchor unless anchor
+          
+          # For PDF generation (even in Antora), we want internal links if possible.
+          # Returning the anchor ID directly allows Asciidoctor PDF to resolve it internally.
+          # The previous logic converted to file.adoc#id which creates broken external links in PDF.
+          return anchor
+          
+          # Skip transformation for standalone asciidoctor-pdf builds
+          return anchor if doc && !antora_build?(doc)
+          
+          # Auto-detect separator from the anchor itself
+          # Check for xml_ids separator first (---- four dashes), then default (:::)
+          separator = if anchor.include?('----')
+                        '----'
+                      elsif anchor.include?(':::')
+                        ':::'
+                      else
+                        nil
+                      end
+          
+          if separator
+            # Split into page and fragment
+            parts = anchor.split(separator, 2)
+            page_id = parts[0]
+            fragment = parts[1]
+            "#{page_id}.adoc##{fragment}"
+          else
+            # No separator - just a page reference, add .adoc suffix
+            "#{anchor}.adoc"
+          end
+        end
+        
+        def preprocess_attribute_content content_string
+          # Preprocess attribute content to handle AsciiDoc line continuations
+          # Compatible with both .yml and .adoc import statements
+          return content_string unless content_string
+          
+          # Replace " +" with hard line break, but preserve escaped " \+"
+          # Also handle literal \n sequences if they come from YAML
+          content_string.gsub('\\n', "\n")
+                       .gsub(/(?<!\\) \+$/, " +")
+        end
+
+        def format_prev_rev prev_title, prev_date, doc
+          return "" if prev_title.to_s.empty?
+          
+          # Only include date if rhrev-customization-prevrev-include-date attribute is set
+          include_date = doc.attr? 'rhrev-customization-prevrev-include-date'
+          
+          if include_date && !prev_date.to_s.empty?
+            date_format = doc.attr 'rhrev-customization-date-format', '%Y-%m-%d'
+            begin
+              # Try to parse and format date if possible
+              parsed_date = Date.parse(prev_date)
+              formatted_date = parsed_date.strftime(date_format)
+              "#{prev_title} - #{formatted_date}"
+            rescue
+              # Fallback if date parsing fails
+              "#{prev_title} - #{prev_date}"
+            end
+          else
+            "#{prev_title}"
+          end
+        end
+
+        def needs_asciidoc_cell? content
+          return false unless content
+          # Check for AsciiDoc formatting markers
+          content.include?('*') || 
+          content.include?('_') || 
+          content.include?('`') || 
+          content.include?('http') || 
+          content.include?('xref:') ||
+          content.include?('<<') ||
+          content.include?('link:') ||
+          content.include?('+') # Line breaks
+        end
+
+        def debug_log(message, doc = nil)
+          return unless doc&.attr?('rhrev-debug')
+          if doc.respond_to?(:logger)
+            doc.logger.debug "[RHREV] #{message}"
+          else
+            warn "[RHREV] #{message}"
+          end
+        end
+
+        def with_attribute_missing_suppressed doc
+          # Suppress attribute-missing warnings
+          # Save current attribute-missing setting
+          saved_attribute_missing = doc.attr 'attribute-missing'
+          # Set to skip to suppress warnings
+          doc.set_attr 'attribute-missing', 'skip'
+          
+          yield
+        ensure
+          # Restore attribute-missing setting
+          if saved_attribute_missing
+            doc.set_attr 'attribute-missing', saved_attribute_missing
+          else
+            doc.delete_attr 'attribute-missing'
+          end
+        end
+    end
+  end
+end

data/lib/asciidoctor/rhrev/processors.rb

@@ -0,0 +1,48 @@
+module Asciidoctor
+  module Rhrev
+    # Preprocessor to sanitize xref syntax before parsing
+    # This fixes Antora Assembler's xref:page:::anchor[] syntax that triggers warnings
+    class XrefSanitizerPreprocessor < Asciidoctor::Extensions::Preprocessor
+        def process document, reader
+          # Convert xref:page:::anchor[] to <<page:::anchor>>
+          # This prevents "unknown name for block macro" warnings
+          lines = reader.read_lines
+          sanitized = lines.map do |line|
+            if line.match?(/xref:[\w-]+:::[^\[\]]+\[\]/)
+              line.gsub(/xref:([\w-]+:::[^\[\]]+)\[\]/, '<<\1>>')
+            elsif line.match?(/xref:[\w-]+----[^\[\]]+\[\]/)
+              line.gsub(/xref:([\w-]+----[^\[\]]+)\[\]/, '<<\1>>')
+            else
+              line
+            end
+          end
+          
+          reader.restore_lines sanitized
+          reader
+        end
+      end
+      
+      # Block macro processor for rhrev::[] macro placement
+      class RhrevBlockMacroProcessor < Asciidoctor::Extensions::BlockMacroProcessor
+        use_dsl
+        named :rhrev
+
+        def process parent, target, attrs
+          # Create a block with context :rhrev that the converter will recognize
+          create_block parent, :rhrev, nil, attrs
+        end
+      end
+
+      # Inline macro processor for pagerhref:anchor[] page number references
+      class PagerhrefInlineMacroProcessor < Asciidoctor::Extensions::InlineMacroProcessor
+        use_dsl
+        named :pagerhref
+
+        def process parent, target, attrs
+          # Create a marker that the converter will recognize and replace with page number
+          # Format: [pagerhref:anchor]
+          create_inline parent, :quoted, "[pagerhref:#{target}]", type: :unquoted
+        end
+      end
+  end
+end