arrolio 0.1.0 → 0.1.1

data/lib/arrolio/table/auto_layout.rb

@@ -15,12 +15,13 @@ module Arrolio
       MIN_COLUMN_WIDTH = 20.0 # points — prevents columns from collapsing
       CELL_PADDING = 8.0      # points — left + right padding per cell
 
-      attr_reader :table, :available_width, :measurer
+      attr_reader :table, :available_width, :measurer, :grid
 
-      def initialize(table, available_width:, measurer: nil)
+      def initialize(table, available_width:, measurer: nil, grid: nil)
         @table = table
         @available_width = available_width.to_f
         @measurer = measurer || default_measurer
+        @grid = grid || Grid.build(table)
       end
 
       # Returns an Array of Float widths (one per column), summing
@@ -35,18 +36,26 @@ module Arrolio
       private
 
       def column_count
-        @table.column_count
+        [@table.column_count, @grid.column_count].max
       end
 
-      # Natural width of each column = max cell natural width across rows.
+      # Natural width of each column = max cell natural width across
+      # rows. Placements come from the occupancy grid, so cells land
+      # in the columns they actually occupy (rowspan cells in later
+      # rows no longer shift into the wrong slot). Cells with colspan
+      # distribute their natural width equally across the spanned
+      # slots so a wide header doesn't accidentally collapse.
       def natural_widths
         widths = Array.new(column_count, MIN_COLUMN_WIDTH)
-        @table.rows.each do |row|
-          row.cells.each_with_index do |cell, ci|
-            next if ci >= widths.length
+        @grid.placements.each do |placement|
+          span = [placement.colspan, 1].max
+          span = [span, column_count - placement.column_index].min
+          share = cell_natural_width(placement.cell) / span.to_f
+          span.times do |offset|
+            idx = placement.column_index + offset
+            break if idx >= widths.length
 
-            w = cell_natural_width(cell)
-            widths[ci] = w if w > widths[ci]
+            widths[idx] = [widths[idx], share].max
           end
         end
         widths
@@ -84,7 +93,7 @@ module Arrolio
       end
 
       def default_measurer
-        GlyphMeasurer.new(font_name: 'Times New Roman')
+        GlyphMeasurer.new(font_name: 'Times-Roman')
       end
     end
   end

data/lib/arrolio/table/grid.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Arrolio
+  module Table
+    # Occupancy grid over a Content::Table, honoring colspan and
+    # rowspan. Answers the two questions every table consumer asks:
+    # which column does each cell actually occupy, and which rows are
+    # welded together by a vertical span (and therefore cannot be
+    # split apart across pages).
+    #
+    # Built once per layout pass and shared by AutoLayout (natural
+    # widths), TableFlowable (row heights, cell placement), and
+    # splitting (atomic row groups).
+    class Grid
+      # One cell's position in the grid. +row_index+ is the row the
+      # cell STARTS in — a rowspan cell is placed and drawn only
+      # there, with a height covering every spanned row.
+      Placement = Struct.new(:cell, :row_index, :column_index,
+                             :colspan, :rowspan, keyword_init: true) do
+        def spans_multiple_rows?
+          rowspan > 1
+        end
+
+        def spans_multiple_columns?
+          colspan > 1
+        end
+      end
+
+      attr_reader :placements, :row_count, :column_count
+
+      def self.build(table)
+        rows = table.rows
+        occupied = {}
+        placements = []
+        rows.each_with_index do |row, row_index|
+          column_index = 0
+          row.cells.each do |cell|
+            column_index += 1 while occupied[[row_index, column_index]]
+            colspan = cell.colspan.to_i
+            rowspan = cell.rowspan.to_i
+            placements << Placement.new(
+              cell: cell, row_index: row_index, column_index: column_index,
+              colspan: colspan, rowspan: rowspan
+            )
+            rowspan.times do |r|
+              colspan.times do |c|
+                occupied[[row_index + r, column_index + c]] = true
+              end
+            end
+            column_index += colspan
+          end
+        end
+        new(placements: placements, row_count: rows.length,
+            column_count: occupied.keys.map(&:last).max.to_i + 1)
+      end
+
+      def initialize(placements:, row_count:, column_count:)
+        @placements = placements.freeze
+        @row_count = row_count
+        @column_count = column_count
+        @by_row = Array.new(row_count) { [] }
+        @placements.each { |p| @by_row[p.row_index] << p }
+        @by_row.each(&:freeze)
+        freeze
+      end
+
+      def placements_starting_in(row_index)
+        @by_row[row_index] || []
+      end
+
+      # Rows welded together by rowspan cells, as arrays of row
+      # indexes in ascending order. Rows not covered by any span come
+      # back as single-element groups. Splitting the table across
+      # pages must happen between groups, never inside one.
+      def atomic_row_groups
+        groups = []
+        group = []
+        welded = welded_rows
+        (0...@row_count).each do |row_index|
+          group << row_index
+          next if welded.include?(row_index + 1)
+
+          groups << group.freeze
+          group = []
+        end
+        groups << group.freeze unless group.empty?
+        groups.freeze
+      end
+
+      private
+
+      # Row indexes > 0 whose content starts in the row above (i.e.
+      # a rowspan from above covers their first column slot).
+      def welded_rows
+        covered = {}
+        @placements.each do |p|
+          next unless p.spans_multiple_rows?
+
+          (1...p.rowspan).each { |r| covered[p.row_index + r] = true }
+        end
+        covered
+      end
+    end
+  end
+end

data/lib/arrolio/table.rb

@@ -5,5 +5,6 @@ module Arrolio
   # - AutoLayout — content-based column width computation.
   module Table
     autoload :AutoLayout, 'arrolio/table/auto_layout'
+    autoload :Grid, 'arrolio/table/grid'
   end
 end

data/lib/arrolio/text_layout/knuth_plass/breaker.rb

@@ -12,20 +12,38 @@ module Arrolio
       # converges in O(n) for typical text because most candidate
       # breaks are pruned early.
       #
+      # When no break sequence is feasible within TOLERANCE (every
+      # candidate line is too loose), a second pass runs with
+      # emergency stretch added to every line's stretchability —
+      # TeX's \emergencystretch. Without it, the only surviving path
+      # is the forced final break, which packs the whole paragraph
+      # into one overfull line and silently runs off the page.
+      #
       # Produces TextLayout::Line[] output — compatible with the
       # existing Greedy breaker so the engine can swap freely.
       class Breaker
         Infinity = Float::INFINITY
 
-        # Tolerance for adjustment ratio — lines with ratio above
-        # this are considered "underfull" and penalized.
-        TOLERANCE = 100.0
+        # Tolerance for adjustment ratio — lines with |ratio| above
+        # this are infeasible and rejected. Standard TeX default
+        # (\tolerance=200) maps to ratio ≈ 1.26 because badness is
+        # 100*|r|^3. We use a slightly looser limit (2.5) to allow
+        # reasonable stretch on tight paragraphs while rejecting
+        # the pathological overfills greedy avoids by construction.
+        TOLERANCE = 2.5
+
+        # Stretch added to every line during the emergency pass.
+        # Comparable to TeX's \emergencystretch = 2em at body size.
+        EMERGENCY_STRETCH = 20.0
 
         # Extra penalty for consecutive flagged breaks (hyphens).
         FLAGGED_PENALTY = 3000.0
 
-        # Extra penalty for the last line being underfull.
-        DEMERITS_LAST_LINE = 50.0
+        # Last-resort cost for a forced break landing an overfull
+        # line (ratio beyond the available shrink). Must exceed the
+        # worst badness demerits ((1+10000)^2 = 1e8) so ANY
+        # breakable alternative wins.
+        OVERFULL_FORCED_PENALTY = 1_000_000_000.0
 
         attr_reader :items, :line_widths, :runs, :measurer, :align
 
@@ -44,51 +62,85 @@ module Arrolio
         end
 
         def layout
-          nodes = active_nodes
-          return [] if nodes.empty?
-
-          # Only consider nodes that reached the end of the items
-          # (the FINISHED penalty at the last position).
-          final_nodes = nodes.select { |n| n.position == @items.length - 1 }
-          return [] if final_nodes.empty?
-
-          # Backtrack from the best final node.
-          breaks = reconstruct_breaks(best_final_node(final_nodes))
+          build_prefix_sums
+          node = solve
+          node = solve(emergency_stretch: EMERGENCY_STRETCH) unless feasible?(node)
+          return [] if node.nil?
 
-          # Build Line objects from the break points.
-          lines = []
-          prev_item = 0
-          breaks.each_with_index do |br, line_idx|
-            width = line_width_for(line_idx)
-            placed = build_placed_runs(prev_item, br, width)
-            used = compute_line_width(prev_item, br)
-            lines << Line.new(placed, width: used, max_width: width, align: @align)
-            prev_item = br
-          end
-          lines
+          build_lines(node)
         end
 
         # Internal: a node in the dynamic programming graph.
         Node = Struct.new(:position, :line, :fitness, :total_demerits,
                           :previous, keyword_init: true)
 
+        # Internal: a run of same-signature text being merged into a
+        # single PlacedRun (one canvas.text call at render time).
+        RunGroup = Struct.new(:signature, :text, :x_offset, keyword_init: true)
+
         private
 
         # Active-node dynamic programming. Each active node represents
         # a feasible break position. We iterate through items and
         # try breaking at each feasible position.
-        def active_nodes
-          @active = [Node.new(position: -1, line: 0, fitness: 1,
-                              total_demerits: 0, previous: nil)]
-          @items.each_with_index do |_item, i|
+        def solve(emergency_stretch: 0.0)
+          @emergency_stretch = emergency_stretch.to_f
+          # The emergency pass accepts any STRETCH ratio (TeX's
+          # \emergencystretch philosophy: a loose line beats an
+          # overfull one). A fixed stretch budget alone cannot
+          # bridge the dead zone between over-shrunk and too-loose
+          # breaks when candidates sit far short of the measure.
+          @stretch_limit = emergency_stretch.positive? ? Float::INFINITY : TOLERANCE
+          active = [Node.new(position: -1, line: 0, fitness: 1,
+                             total_demerits: 0, previous: nil)]
+          @items.each_with_index do |item, i|
             next unless feasible_break?(i)
 
-            @active = @active.reject { |a| prune?(a, i) }
-            candidates = @active.filter_map { |a| try_break(a, i) }
-            best = best_candidate(candidates)
-            @active << best if best
+            best = best_candidate(active.filter_map { |a| try_break(a, i) })
+            next unless best
+
+            if item.penalty? && item.forced_break?
+              # A forced break must be taken: no earlier active node
+              # may span across it (otherwise the DP happily skips
+              # forced breaks when the parfill glue makes the single
+              # line feasible).
+              active = [best]
+            else
+              active << best
+            end
+          end
+          best_final_node(active.select { |n| n.position == @items.length - 1 })
+        end
+
+        # True when the solution contains no line whose adjustment
+        # ratio escaped TOLERANCE via a forced break. When false, the
+        # paragraph needs the emergency pass.
+        def feasible?(final_node)
+          return false if final_node.nil?
+
+          prev_item = 0
+          reconstruct_breaks(final_node).each_with_index do |br, line_idx|
+            natural = compute_line_width(prev_item, br)
+            ratio = adjustment_ratio(natural, line_width_for(line_idx),
+                                     prev_item, br)
+            return false if ratio.abs > TOLERANCE
+
+            prev_item = br
+          end
+          true
+        end
+
+        def build_lines(final_node)
+          lines = []
+          prev_item = 0
+          reconstruct_breaks(final_node).each_with_index do |br, line_idx|
+            width = line_width_for(line_idx)
+            placed = build_placed_runs(prev_item, br)
+            lines << Line.new(placed, width: compute_line_width(prev_item, br),
+                                      max_width: width, align: @align)
+            prev_item = br
           end
-          @active
+          lines
         end
 
         def feasible_break?(i)
@@ -96,33 +148,37 @@ module Arrolio
           (item.penalty? && !item.no_break?) || (item.glue? && i.positive? && @items[i - 1].box?)
         end
 
-        def prune?(node, _current)
-          node.line >= @line_widths.length + 10
-        end
-
         def try_break(node, break_pos)
           item = @items[break_pos]
           width = line_width_for(node.line)
-          line_w = compute_line_width(node.position + 1, break_pos)
+          line_start = node.position + 1
+          line_w = compute_line_width(line_start, break_pos)
 
           is_forced = item.penalty? && item.forced_break?
-          ratio = adjustment_ratio(line_w, width, break_pos)
+          ratio = adjustment_ratio(line_w, width, line_start, break_pos)
 
           # Forced breaks are always accepted but still penalized
           # for bad ratios so the algorithm prefers shorter lines.
-          unless is_forced
-            return nil if ratio.abs > TOLERANCE
-          end
-
-          ratio = 0.0 if ratio == Infinity || ratio == -Infinity
+          # TeX semantics: shrink is a hard limit (ratio < -1 needs
+          # more compression than the glue has - an overfull box),
+          # stretch is soft up to TOLERANCE. Allowing ratio < -1
+          # made the DP prefer overfull compression over loose
+          # lines (clamped badness scores compression cheaper).
+          return nil if !is_forced && (ratio > @stretch_limit || ratio < -1.0)
+
+          ratio = 0.0 if ratio.infinite?
           demerits = demerits_for(ratio, break_pos)
+          # A forced break is always TAKEN (correctness) but an
+          # overfull line through it is a last resort: without this,
+          # free shrink made the DP pack whole paragraphs onto one
+          # line via the un-rejectable final penalty.
+          demerits += OVERFULL_FORCED_PENALTY if is_forced && ratio < -1.0
           total = node.total_demerits + demerits
-          fitness = fitness_class(ratio)
 
           Node.new(
             position: break_pos,
             line: node.line + 1,
-            fitness: fitness,
+            fitness: fitness_class(ratio),
             total_demerits: total,
             previous: node
           )
@@ -137,10 +193,11 @@ module Arrolio
         end
 
         # Adjustment ratio: how stretched (positive) or shrunk
-        # (negative) a line is. 0 = perfect fit.
-        def adjustment_ratio(natural_width, target_width, break_pos)
-          glue_stretch = total_stretch(break_pos)
-          glue_shrink = total_shrink(break_pos)
+        # (negative) a line is. 0 = perfect fit. Emergency stretch
+        # widens the feasibility window without changing shrink.
+        def adjustment_ratio(natural_width, target_width, line_start, line_end)
+          glue_stretch = line_stretch(line_start, line_end) + @emergency_stretch
+          glue_shrink = line_shrink(line_start, line_end)
 
           if natural_width < target_width
             glue_stretch.positive? ? (target_width - natural_width) / glue_stretch : Infinity
@@ -153,10 +210,14 @@ module Arrolio
 
         def demerits_for(ratio, break_pos)
           penalty = @items[break_pos].penalty? ? @items[break_pos].penalty : 0
+          # FOP justifies every line to the measure after breaking:
+          # shrink (ratio < 0) is free, unlike TeX's cubic badness.
+          # Penalizing it made the DP prefer an extra loose line
+          # where the reference compresses (5.6's 4-line vs our 5).
           badness = if ratio.negative?
-            (100 * ((-ratio) ** 3)).to_i
-          else
-            0
+                      0
+                    else
+                      (100 * (ratio ** 3)).clamp(0, 10_000).to_i
                     end
           # Standard Knuth-Plass demerits. Forced breaks (penalty =
           # -Infinity) use d = (1 + badness)^2 — the penalty term
@@ -181,21 +242,25 @@ module Arrolio
           end
         end
 
+        # Prefix sums so range width/stretch/shrink queries are O(1).
+        def build_prefix_sums
+          @prefix_width = [0.0]
+          @prefix_stretch = [0.0]
+          @prefix_shrink = [0.0]
+          @items.each do |item|
+            @prefix_width << (@prefix_width.last + item.width.to_f)
+            @prefix_stretch << (@prefix_stretch.last + (item.glue? ? item.stretch : 0.0))
+            @prefix_shrink << (@prefix_shrink.last + (item.glue? ? item.shrink : 0.0))
+          end
+        end
+
         # Sum of widths from item +start+ to item +stop+ (exclusive).
         # Discards trailing glue at the break point.
         def compute_line_width(start, stop)
           return 0.0 if start >= stop
 
-          sum = 0.0
-          (start...stop).each do |i|
-            item = @items[i]
-            next if item.nil?
-
-            # Trailing glue after last box is discarded at break.
-            last_box = last_box_index_in(start, stop)
-            sum += item.width if i <= last_box
-          end
-          sum
+          last_box = last_box_index_in(start, stop)
+          last_box < start ? 0.0 : @prefix_width[last_box + 1] - @prefix_width[start]
         end
 
         def last_box_index_in(start, stop)
@@ -206,16 +271,12 @@ module Arrolio
           idx
         end
 
-        def total_stretch(break_pos)
-          sum = 0.0
-          @items[0..break_pos].each { |item| sum += item.stretch if item.glue? }
-          sum
+        def line_stretch(line_start, line_end)
+          @prefix_stretch[line_end] - @prefix_stretch[line_start]
         end
 
-        def total_shrink(break_pos)
-          sum = 0.0
-          @items[0..break_pos].each { |item| sum += item.shrink if item.glue? }
-          sum
+        def line_shrink(line_start, line_end)
+          @prefix_shrink[line_end] - @prefix_shrink[line_start]
         end
 
         def line_width_for(line_idx)
@@ -232,32 +293,73 @@ module Arrolio
           breaks.reverse
         end
 
-        def build_placed_runs(start_item, stop_item, _width)
+        # Merges contiguous Box + Glue items into PlacedRuns — one
+        # canvas.text call per group — so pdftotext sees word
+        # separators instead of glued-together Tj fragments. A new
+        # group starts whenever the rendering signature (style,
+        # baseline shift, scale, href) changes, so bold/italic and
+        # sub/superscript runs keep their formatting. Glue past the
+        # line's last box (at the break) is dropped: it is discarded
+        # by width accounting and would otherwise inflate the
+        # renderer's justify word count.
+        def build_placed_runs(start_item, stop_item)
+          last_box = last_box_index_in(start_item, stop_item)
           placed = []
-          x_offset = 0.0
+          group = nil
+
           (start_item...stop_item).each do |i|
             item = @items[i]
-            next unless item&.box?
-
-            run = @runs[item.run_index]
-            next unless run
-
-            slice = run.text[item.char_offset, item.char_length]
-            next if slice.nil? || slice.empty?
-
-            sub = InlineRun.new(slice, style: run.style,
-                                       baseline_shift: run.baseline_shift,
-                                       font_size_scale: run.font_size_scale,
-                                       href: run.href)
-            placed << Line::PlacedRun.new(run: sub, x_offset: x_offset)
-            x_offset += item.width
+            next unless item
+            next if item.glue? && item.stretch.infinite?
+
+            if item.box?
+              run = @runs[item.run_index]
+              next unless run
+
+              slice = run.text[item.char_offset, item.char_length]
+              next if slice.nil? || slice.empty?
+
+              signature = [run.style, run.baseline_shift,
+                           run.font_size_scale, run.href]
+              if group.nil? || group.signature != signature
+                flush_placed_group(placed, group) if group
+                group = RunGroup.new(signature: signature, text: String.new,
+                                     x_offset: item_offset(first_box_in(start_item, stop_item), i))
+              end
+              group.text << slice
+            elsif item.glue? && group && i < last_box
+              group.text << ' '
+            end
           end
+          flush_placed_group(placed, group) if group
           placed
         end
 
-        def finalize_node(position, line, fitness, total_demerits, previous)
-          Node.new(position: position, line: line, fitness: fitness,
-                   total_demerits: total_demerits, previous: previous)
+        # Offsets are relative to the line's FIRST BOX, not the
+        # break-following item: the leading glue is discarded at a
+        # break, and pricing it shifted every continuation line
+        # right by one space width (a phantom indent that also
+        # shortened the measure and caused extra wraps).
+        def first_box_in(start_item, stop_item)
+          (start_item...stop_item).each do |i|
+            return i if @items[i]&.box?
+          end
+          start_item
+        end
+
+        def item_offset(start_item, item_idx)
+          @prefix_width[item_idx] - @prefix_width[start_item]
+        end
+
+        def flush_placed_group(placed, group)
+          return if group.text.empty?
+
+          style, baseline_shift, font_size_scale, href = group.signature
+          run = InlineRun.new(group.text, style: style,
+                                          baseline_shift: baseline_shift,
+                                          font_size_scale: font_size_scale,
+                                          href: href)
+          placed << Line::PlacedRun.new(run: run, x_offset: group.x_offset)
         end
       end
     end

data/lib/arrolio/text_layout/knuth_plass/item_builder.rb

@@ -22,6 +22,12 @@ module Arrolio
           @runs.each_with_index do |run, run_idx|
             build_items_for_run(run, run_idx, items)
           end
+          # Parfillskip: zero-width glue with infinite stretch before
+          # the FINISHED penalty (TeX's \parfillskip). Makes the last
+          # line of a paragraph never loose, so short final lines are
+          # always feasible. Paragraphs with no feasible intermediate
+          # break are rescued by Breaker's emergency-stretch pass.
+          items << Glue.new(width: 0, stretch: Float::INFINITY, shrink: 0)
           items << FINISHED
           items
         end
@@ -38,6 +44,26 @@ module Arrolio
             return
           end
 
+          build_word_items(run, run_idx, text, 0, items)
+        end
+
+        # A run with embedded newlines wraps WITHIN each segment
+        # (a segment can be a whole paragraph) and places a forced
+        # break between segments. Emitting each segment as a single
+        # box made long segments unbreakable overfull lines.
+        def build_newline_items(run, run_idx, text, items)
+          # -1 keeps trailing empty segments: a lone "\n" run
+          # must still emit its forced-break penalty.
+          segments = text.split("\n", -1)
+          base = 0
+          segments.each_with_index do |seg, i|
+            build_word_items(run, run_idx, seg, base, items) unless seg.empty?
+            base += seg.length + 1
+            items << Penalty.new(penalty: -Float::INFINITY, run_index: run_idx) if i < segments.length - 1
+          end
+        end
+
+        def build_word_items(run, run_idx, text, base_offset, items)
           words = text.split(/(\s+)/)
           offset = 0
           words.each do |word|
@@ -46,31 +72,18 @@ module Arrolio
               stretch = measure(' ', run) * 0.5
               shrink = measure(' ', run) * 0.33
               items << Glue.new(width: width, stretch: stretch, shrink: shrink,
-                                run_index: run_idx, char_offset: offset)
+                                run_index: run_idx, char_offset: base_offset + offset)
             elsif word.include?('-')
-              build_hyphenated_word(word, run, run_idx, offset, items)
+              build_hyphenated_word(word, run, run_idx, base_offset + offset, items)
             elsif !word.empty?
               width = measure(word, run)
               items << Box.new(width: width, run_index: run_idx,
-                               char_offset: offset, char_length: word.length)
+                               char_offset: base_offset + offset, char_length: word.length)
             end
             offset += word.length
           end
         end
 
-        def build_newline_items(run, run_idx, text, items)
-          segments = text.split("\n")
-          segments.each_with_index do |seg, i|
-            unless seg.empty?
-              width = measure(seg, run)
-              items << Box.new(width: width, run_index: run_idx,
-                               char_offset: text.index(seg) || 0,
-                               char_length: seg.length)
-            end
-            items << Penalty.new(penalty: -Float::INFINITY, run_index: run_idx) if i < segments.length - 1
-          end
-        end
-
         def build_hyphenated_word(word, run, run_idx, offset, items)
           parts = word.split(/(-)/)
           part_offset = offset
@@ -94,7 +107,8 @@ module Arrolio
             text,
             font_size: run.style.font_size * run.font_size_scale,
             character_spacing: run.style.character_spacing,
-            word_spacing: 0
+            word_spacing: 0,
+            font_name: run.style.font_name
           )
         end
       end

data/lib/arrolio/text_layout/knuth_plass.rb

@@ -5,6 +5,9 @@ module Arrolio
   module TextLayout
     module KnuthPlass
       autoload :Item, 'arrolio/text_layout/knuth_plass/item'
+      autoload :Box, 'arrolio/text_layout/knuth_plass/item'
+      autoload :Glue, 'arrolio/text_layout/knuth_plass/item'
+      autoload :Penalty, 'arrolio/text_layout/knuth_plass/item'
       autoload :Breaker, 'arrolio/text_layout/knuth_plass/breaker'
       autoload :ItemBuilder, 'arrolio/text_layout/knuth_plass/item_builder'
     end

data/lib/arrolio/text_layout/line.rb

@@ -38,9 +38,11 @@ module Arrolio
         @align == :justify
       end
 
+      # Negative when the line is overfull (TeX shrink): the
+      # renderer compresses inter-word gaps. Clamping at zero made
+      # compressed lines draw at natural width, past the measure.
       def justify_stretch
         return 0.0 unless justified?
-        return 0.0 if @width >= @max_width
 
         gaps = word_gap_count
         return 0.0 if gaps.zero?