asciidoctor-dot-leader 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cafcd588c3080dba97a8b811c9a230f83623fa27e1d1449f471d6f93428ef6f9
-  data.tar.gz: 2b784579fa0453fef3dc0fd1d1d735e31889f9dce3227294225da08064de3300
+  metadata.gz: 2382e42c9d8e11c7427f3758ea61f111d4fa390fe99a6daf4c0f4eab46860f64
+  data.tar.gz: 7c518c228291a4be4c236c9848f2e97a0e2d4ea94e617efc7bd79e4667ea14ba
 SHA512:
-  metadata.gz: 78bb767ee1ea9560346744da1285c95ba72f26f8787f6843b10e046d9ccc575ef607c29d556bc2c7f53ff4bc0b38ed965aa93ab6164d9a597cc811fe1e6de34f
-  data.tar.gz: c7c1e40de2398e37458e1da098fa669b2fb8881a2505ad821a0fbe75d65f0a1591661d9f0333d79ab0e877d09c3a18314a6a590d0e2c9ba3861bf546480c80cc
+  metadata.gz: 726405e93b9ed14555643a2ba7d6a490f0f6ab075c54b7dbf16da785c638807f104dd812a0ca94a378316adcae5b8b2ff6df80f770daaee6018916b856f74da7
+  data.tar.gz: 81cbc4675e9ebef09663bdf94460a94ad80b024c2f52e1f800bdde550c616fae9d23f551e2d925711e895d2796728cafee1ab07d56650ea8975c47aa69b70be8

data/CHANGELOG.adoc

@@ -5,6 +5,11 @@ All notable changes to this project will be documented in this file.
 The format is based on https://keepachangelog.com/en/1.0.0/[Keep a Changelog],
 and this project adheres to https://semver.org/spec/v2.0.0.html[Semantic Versioning].
 
+== [1.2.0] - 2025-10-31
+
+This release adds support for column_boxes in asciidoctor-pdf link:https://asciidoctor.zulipchat.com/#narrow/channel/288690-users.2Fasciidoctor-pdf/topic/Implicit.20page.20break.20after.20column_box/near/503833058[^].
+
+
 == [1.1.0] - 2025-10-31
 
 === Fixed

data/README.adoc

@@ -80,7 +80,7 @@ This project provides an inline macro, `pass:[dot:leader["left", "right"]]`, whi
 
 === Target Application
 
-This has only been tested with the  Microsoft Visual Studio Code's AsciiDoc extension's _Preview_ function which uses the `backen-webview-html5`.
+This has only been tested with the  Microsoft Visual Studio Code's AsciiDoc extension's _Preview_ function which uses the `backend-webview-html5`.
 
 === Usage
 

data/lib/asciidoctor/dot_leader/dot_leader_pdf.rb

@@ -44,6 +44,12 @@ class DotLeader < (Asciidoctor::Converter.for 'pdf')
 
     left_side = node.attr('l_text') || ''
     right_side = node.attr('r_text') || ''    
+    
+    # DEBUG: Initial context information
+    is_column_box = defined?(::Prawn::Document::ColumnBox) && bounds.is_a?(::Prawn::Document::ColumnBox)
+    current_column = is_column_box ? bounds.current_column : 'N/A'
+    # log :info, %(DOT_LEADER_DEBUG: Starting - left="#{left_side}", right="#{right_side}", page=#{page_number}, cursor=#{cursor}, is_column=#{is_column_box}, current_column=#{current_column})
+    
     if left_side.empty? # Allow items only on the right
       left_side = ' '
     end
@@ -76,6 +82,8 @@ class DotLeader < (Asciidoctor::Converter.for 'pdf')
       }
     end
 
+    # log :info, %(DOT_LEADER_DEBUG: Dot leader config - text="#{dot_leader[:text]}", width=#{dot_leader[:width]}, spacer_width=#{dot_leader[:spacer_width]})
+
     # 2025-07-17 BYB: Set toc_font_info
     toc_font_info = theme_font :toc do
       { font: font, size: @font_size }
@@ -103,14 +111,12 @@ class DotLeader < (Asciidoctor::Converter.for 'pdf')
     line_metrics = calc_line_metrics @base_line_height
 
     # 2025-07-17 BYB: This needs to be modified
-    right_side_placeholder_width = rendered_width_of_string right_side * @toc_max_pagenum_digits
-    # puts right_side_placeholder_width.inspect # Various widths
-    right_side_placeholder_width = 0 # BYB: Not a problem for now
-    
     right_side_placeholder_width = rendered_width_of_fragments right_side_fragments, scale, node.roles.to_a
 
     left_side_test_width = rendered_width_of_fragments left_side_fragments, scale, node.roles.to_a
     
+    # log :info, %(DOT_LEADER_DEBUG: Text widths - left=#{left_side_test_width}, right=#{right_side_placeholder_width})
+    
     # 2025-07-17 Set hanging_indent to toc; potentially this could be styled
     hanging_indent = @theme.toc_hanging_indent
     start_page_number = page_number
@@ -123,7 +129,7 @@ class DotLeader < (Asciidoctor::Converter.for 'pdf')
       end
 
       if right_side_placeholder_width > bounds.width
-        warn "WARN: dot-leader: The right side too wide to fit on a line; skipping: #{left_side} #{right_side}"
+        log :warn, %(DOT_LEADER_DEBUG: Right side too wide; skipping: #{left_side} - right_width=#{right_side_placeholder_width}, bounds_width=#{bounds.width})
         return nil
       end
 
@@ -135,6 +141,8 @@ class DotLeader < (Asciidoctor::Converter.for 'pdf')
       start_cursor = last_fragment_cursor if last_fragment_position.page_number > start_page_number || (start_cursor - last_fragment_cursor) > line_metrics.height
     end
     
+    # log :info, %(DOT_LEADER_DEBUG: After left text - start_dots=#{start_dots}, start_cursor=#{start_cursor})
+    
     # 2025-07-17 No loop
     # NOTE: this will leave behind a gap where this entry would have been
     # break unless start_dots
@@ -154,29 +162,115 @@ class DotLeader < (Asciidoctor::Converter.for 'pdf')
         set_font toc_font_info[:font], dot_leader[:font_size]
         font_style dot_leader[:font_style]
         # For true vertical alignment, dots must be at consistent absolute positions across all lines
-        # Calculate the absolute position from page margin for universal grid alignment
-        # This ensures dots align across tables, lists, and other indented contexts
+        # CONTEXT-AWARE GRID ALIGNMENT:
+        # Use appropriate grid origin for each context to ensure proper alignment
+        # while maintaining correct positioning within bounds
         
-        # Get the absolute position where dots will start
-        # start_dots is in local bounds coordinates, convert to absolute page coordinates
-        start_dots_absolute = start_dots + bounds.absolute_left
+        # Calculate the absolute position where dots will start
+        # Note: start_dots may already be absolute in some contexts (like right column)
+        # Check if start_dots is already in absolute coordinates
+        if start_dots > bounds.width
+          # start_dots appears to be already absolute (larger than column width)
+          start_dots_absolute = start_dots
+        else
+          # start_dots is relative to bounds, convert to absolute
+          start_dots_absolute = start_dots + bounds.absolute_left
+        end
+        
+        if defined?(::Prawn::Document::ColumnBox) && bounds.is_a?(::Prawn::Document::ColumnBox)
+          # In column context: use UNIVERSAL grid origin (page margin) for alignment across all columns
+          # This ensures dots align consistently across left and right columns
+          
+          # Get column information for debugging
+          current_col = bounds.current_column
+          parent_bounds = bounds.instance_variable_get(:@parent)
+          total_columns = bounds.instance_variable_get(:@columns) || 2
+          
+          # Calculate the actual column dimensions from the parent
+          parent_width = parent_bounds.width
+          column_width = parent_width / total_columns
+          total_spacer_width = parent_width - (column_width * total_columns)
+          spacer_width = total_columns > 1 ? total_spacer_width / (total_columns - 1) : 0
+          column_offset = current_col * (column_width + spacer_width)
+          
+          # UNIVERSAL GRID: Use page margin as grid origin for all columns
+          # This ensures dots align across the entire page
+          grid_origin = page.margins[:left]
+          
+          # log :info, %(DOT_LEADER_DEBUG: Column context - current_column=#{current_col}, total_columns=#{total_columns}, column_width=#{column_width}, spacer_width=#{spacer_width}, column_offset=#{column_offset}, bounds_left=#{bounds.absolute_left}, grid_origin=#{grid_origin})
+        else
+          # In normal context: use the page margin as grid origin to ignore indentation
+          # This ensures consistent alignment across all list levels
+          grid_origin = page.margins[:left]
+          # log :info, %(DOT_LEADER_DEBUG: Normal context - bounds_left=#{bounds.absolute_left}, page_margin=#{page.margins[:left]}, grid_origin=#{grid_origin})
+        end
         
-        # Use the page's left margin as the grid origin for universal alignment
-        # In a normal flow at the top level, bounds.absolute_left equals the page margin
-        # Use a reference from the document's margin settings
-        page_margin_left = page.margins[:left]
+        # Calculate the position relative to the grid origin for alignment
+        start_dots_from_grid_origin = start_dots_absolute - grid_origin
         
-        # Calculate the position relative to the page margin for grid alignment
-        start_dots_from_page_margin = start_dots_absolute - page_margin_left
+        # log :info, %(DOT_LEADER_DEBUG: Position calculations - start_dots_absolute=#{start_dots_absolute}, start_dots_from_grid_origin=#{start_dots_from_grid_origin})
         
         # Find the first grid position after the left text ends
-        # Grid positions are at multiples of dot_leader[:width] from the page margin
-        first_dot_grid_index = (start_dots_from_page_margin / dot_leader[:width]).ceil
-        first_dot_position_absolute = page_margin_left + (first_dot_grid_index * dot_leader[:width])
+        # Grid positions are at multiples of dot_leader[:width] from the grid origin
+        first_dot_grid_index = (start_dots_from_grid_origin / dot_leader[:width]).ceil
+        first_dot_position_absolute = grid_origin + (first_dot_grid_index * dot_leader[:width])
         
         # Convert back to the local bounds coordinate system for rendering
+        # Use universal grid but fix coordinate conversion for right column
         first_dot_position = first_dot_position_absolute - bounds.absolute_left
         
+        # Special handling for columns beyond the first (right column in 2-column layout)
+        # We need to recalculate using the universal grid to ensure proper alignment
+        if defined?(::Prawn::Document::ColumnBox) && bounds.is_a?(::Prawn::Document::ColumnBox)
+          current_col = bounds.current_column
+          if current_col > 0
+            # Right column case: recalculate using universal grid
+            # We need to find the first grid position within the column that comes AFTER the left text
+          
+          # Calculate the left text width to ensure dots start after it
+          left_text_width = rendered_width_of_fragments left_side_fragments, scale, node.roles.to_a
+          
+          # Find the equivalent universal grid position that aligns with other columns
+          # Calculate where text ends (without spacer first)
+          # Use the absolute left position of the current column plus the text width
+          text_end_no_spacer = bounds.absolute_left + left_text_width
+          # Add the spacer to get the absolute position where dots should start
+          text_end_absolute = text_end_no_spacer + dot_leader[:spacer_width]
+          
+          # Find the first universal grid position after the text ends
+          # This ensures alignment with single column and other contexts
+          text_end_from_grid_origin = text_end_absolute - grid_origin
+          universal_grid_index = (text_end_from_grid_origin / dot_leader[:width]).ceil
+          
+          # Check if the previous grid position would still fit (with minimal spacing)
+          # This allows us to fit one more dot if the previous grid position comes after the actual text
+          if universal_grid_index > 0
+            previous_grid_position = grid_origin + ((universal_grid_index - 1) * dot_leader[:width])
+            # Check spacing from actual text end (not including the full spacer)
+            spacing_from_text = previous_grid_position - text_end_no_spacer
+            # Use previous position if it's at least 1pt after the text (minimal spacing)
+            if spacing_from_text >= 1.0
+              universal_grid_index -= 1
+            end
+          end
+          
+          # Calculate the absolute position using the universal grid
+          adjusted_position_absolute = grid_origin + (universal_grid_index * dot_leader[:width])
+          first_dot_position = adjusted_position_absolute - bounds.absolute_left
+          first_dot_position_absolute = adjusted_position_absolute
+          # CRITICAL: Update the grid index to match the adjusted position
+          first_dot_grid_index = universal_grid_index
+          
+            # log :info, %(DOT_LEADER_DEBUG: Right column adjustment - left_text_width=#{left_text_width}, text_end_absolute=#{text_end_absolute}, text_end_from_grid_origin=#{text_end_from_grid_origin}, universal_grid_index=#{universal_grid_index}, adjusted_grid_index=#{first_dot_grid_index}, adjusted_position=#{first_dot_position})
+          else
+            # log :info, %(DOT_LEADER_DEBUG: Left column - no adjustment needed)
+          end
+        else
+          # log :info, %(DOT_LEADER_DEBUG: Standard conversion - first_dot_position_absolute=#{first_dot_position_absolute}, bounds.absolute_left=#{bounds.absolute_left}, first_dot_position=#{first_dot_position})
+        end
+        
+        # log :info, %(DOT_LEADER_DEBUG: First dot - grid_index=#{first_dot_grid_index}, position_absolute=#{first_dot_position_absolute}, position_local=#{first_dot_position})
+        
         # Check if the first dot is too close to the left text
         # Calculate the actual left text width for precise spacing check
         left_text_width = rendered_width_of_fragments left_side_fragments, scale, node.roles.to_a
@@ -187,26 +281,33 @@ class DotLeader < (Asciidoctor::Converter.for 'pdf')
         
         # Calculate where the right text will start (in absolute coordinates)
         right_text_start_local = bounds.width - right_side_width - dot_leader[:spacer_width]
+        
+        # Convert to absolute coordinates: bounds.absolute_left already accounts for column position
         right_text_start_absolute = right_text_start_local + bounds.absolute_left
         
-        # Find the last grid position before the right text starts (using global grid)
+        # Find the last grid position before the right text starts (using the same grid origin)
         # Ensure the COMPLETE dot (start + width) fits before right text
-        right_text_from_page_margin = right_text_start_absolute - page_margin_left
+        right_text_from_grid_origin = right_text_start_absolute - grid_origin
         
         # Calculate the last grid index where a complete dot would fit
         # A dot at position N has its right edge at N + dot_leader[:width]
-        # The target: (last_dot_grid_index * dot_leader[:width]) + dot_leader[:width] <= right_text_from_page_margin
-        # Simplified: last_dot_grid_index <= (right_text_from_page_margin / dot_leader[:width]) - 1
+        # The target: (last_dot_grid_index * dot_leader[:width]) + dot_leader[:width] <= right_text_from_grid_origin
+        # Simplified: last_dot_grid_index <= (right_text_from_grid_origin / dot_leader[:width]) - 1
         # Add some buffer space to ensure the dot does not touch the right text
-        last_possible_dot_end = right_text_from_page_margin - (1.0 * dot_stripped_width)
+        last_possible_dot_end = right_text_from_grid_origin - (1.0 * dot_stripped_width)
         last_dot_grid_index = (last_possible_dot_end / dot_leader[:width]).floor
         
+        # log :info, %(DOT_LEADER_DEBUG: Right text - start_local=#{right_text_start_local}, start_absolute=#{right_text_start_absolute}, from_grid_origin=#{right_text_from_grid_origin})
+        
         # Calculate the number of dots that fit on the grid between left and right text
         num_dots = [last_dot_grid_index - first_dot_grid_index + 1, 0].max
-        
+        # log :info, %(DOT_LEADER_DEBUG: Last dot - last_possible_end=#{last_possible_dot_end}, last_grid_index=#{last_dot_grid_index}, num_dots=#{num_dots})
+
         # Calculate the indent to position the first dot at the correct grid position
         dot_indent = first_dot_position
-        
+
+        # log :info, %(DOT_LEADER_DEBUG: Final render - dot_indent=#{dot_indent}, num_dots=#{num_dots}, dot_text="#{dot_leader[:text]}")
+
         fragment_positions = []
         right_side_fragments.each do |fragment|
           fragment_positions << (fragment_position = ::Asciidoctor::PDF::FormattedText::FragmentPositionRenderer.new)
@@ -214,10 +315,15 @@ class DotLeader < (Asciidoctor::Converter.for 'pdf')
         end
         
         # Render the dots with a proper indent to align to the grid
-        indent dot_indent, 0 do
-          typeset_formatted_text [
-            { text: dot_leader[:text] * num_dots, color: dot_leader[:font_color] }
-          ], line_metrics, align: :left
+        if num_dots > 0
+          indent dot_indent, 0 do
+            typeset_formatted_text [
+              { text: dot_leader[:text] * num_dots, color: dot_leader[:font_color] }
+            ], line_metrics, align: :left
+          end
+          # log :info, %(DOT_LEADER_DEBUG: Dots rendered successfully)
+        else
+          log :warn, %(DOT_LEADER_DEBUG: No dots to render - num_dots=#{num_dots})
         end
         
         # Move cursor back to render right text
@@ -237,12 +343,13 @@ class DotLeader < (Asciidoctor::Converter.for 'pdf')
       ], line_metrics, align: :right
       end
     else
+      # log :info, %(DOT_LEADER_DEBUG: Skipping dot rendering - width=#{dot_leader[:width]}, levels_check=#{dot_leader[:levels] ? (dot_leader[:levels].include? entry_level.pred) : true})
       typeset_formatted_text [{ text: right_side, color: @font_color, anchor: entry_anchor }], line_metrics, align: :right
     end
     move_cursor_to end_cursor
 
+    # log :info, %(DOT_LEADER_DEBUG: Completed - final_cursor=#{cursor})
     # Return nil to avoid numbers being printed out
     nil
-
   end
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: asciidoctor-dot-leader
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - 白一百 baiyibai