railbow 0.4.0 → 0.6.0

data/lib/railbow/table/renderer.rb

@@ -14,38 +14,67 @@ module Railbow
       GHOST_FG = "\e[38;5;217m"   # warm pink foreground for contrast
       DIMMED_FG = "\e[38;5;242m"  # muted grey - a row that is not currently in effect
 
+      # The flexing last column never gets less than this from the terminal.
+      MIN_LAST_COL = 10
+      # Default floor for shrinkable columns that name no shrink_floor.
+      MIN_SHRINK_WIDTH = 16
+
       attr_reader :columns, :theme
 
-      def initialize(columns:, theme:, compact: {}, aliases: {})
+      # min_widths raises the resolved width of each column to at least the
+      # given value, which is how several tables rendered in one run line their
+      # columns up with each other. An explicit compact maxw still wins.
+      #
+      # term_width overrides the detected terminal width; render re-invokes
+      # itself through a reduced renderer when the budget drops a column, and
+      # the width it fits must be the same one this instance measured.
+      def initialize(columns:, theme:, compact: {}, aliases: {}, min_widths: nil, term_width: nil)
         @compact = compact
         @aliases = aliases
+        @min_widths = min_widths
+        @term_width = term_width
         @reverse_col_aliases = aliases[:columns]&.invert || {}
         @columns = apply_hidden_columns(columns)
         @theme = theme
       end
 
-      def render(rows, separators: {}, highlight_rows: Set.new, ghost_rows: Set.new, dim_rows: Set.new, tick_rows: Set.new, tick_col: nil)
-        return "" if columns.empty?
+      # The widths this table would resolve to on its own. Callers rendering
+      # several tables together take the per-column maximum and feed it back as
+      # min_widths.
+      def column_widths(rows)
+        return [] if columns.empty?
 
-        # Remap rows if columns were hidden
-        rows = remap_rows(rows) if @hidden_indices&.any?
+        resolve_widths(prepare_rows(rows))
+      end
 
-        # Apply value aliases
-        rows = apply_value_aliases(rows) if @aliases[:values]&.any?
+      # Width of everything left of the last column. The last column flexes to
+      # the terminal, so this is where furniture drawn around the table (a
+      # section rule, say) can stop without running past it.
+      def fixed_width(widths)
+        return 0 if columns.empty? || widths.nil? || widths.empty?
 
-        # Pre-truncate non-last columns that have truncate + max_width
-        rows = rows.map { |row|
-          row.each_with_index.map { |cell, i|
-            col = columns[i]
-            if col&.truncate && col.max_width && i < columns.size - 1
-              truncate_str(cell.to_s, col.max_width)
-            else
-              cell
-            end
-          }
-        }
+        compute_prefix_width(widths, columns.size - 1)
+      end
+
+      def render(rows, separators: {}, highlight_rows: Set.new, ghost_rows: Set.new, dim_rows: Set.new, tick_rows: Set.new, tick_col: nil)
+        return "" if columns.empty?
+
+        rows = prepare_rows(rows)
+
+        # Width budget: when even fully shrunk columns cannot bring the table
+        # under the terminal width, sacrifice the most expendable column and
+        # render without it. One column per pass - the reduced renderer asks
+        # again with what is left.
+        if (drop = drop_index_to_fit(rows))
+          return dropped_renderer(drop).render(
+            rows.map { |row| row.reject.with_index { |_, i| i == drop } },
+            separators: separators, highlight_rows: highlight_rows, ghost_rows: ghost_rows,
+            dim_rows: dim_rows, tick_rows: tick_rows, tick_col: shift_tick_col(tick_col, drop)
+          )
+        end
 
         resolved = resolve_widths(rows)
+        shrink_to_fit!(resolved, rows)
 
         # In oneline mode, truncate non-sticky non-last columns at resolved width
         if @compact[:oneline]
@@ -77,6 +106,25 @@ module Railbow
 
       private
 
+      # Everything that changes a cell's content, and therefore its width,
+      # before widths are resolved: hidden columns, value aliases, and the
+      # pre-truncation of non-last columns that cap themselves.
+      def prepare_rows(rows)
+        rows = remap_rows(rows) if @hidden_indices&.any?
+        rows = apply_value_aliases(rows) if @aliases[:values]&.any?
+
+        rows.map { |row|
+          row.each_with_index.map { |cell, i|
+            col = columns[i]
+            if col&.truncate && col.max_width && i < columns.size - 1
+              truncate_str(cell.to_s, col.max_width)
+            else
+              cell
+            end
+          }
+        }
+      end
+
       def resolve_widths(rows)
         all_rows = rows
         last = columns.size - 1
@@ -95,6 +143,9 @@ module Railbow
             w = [w, col.min_width].max if col.min_width
             w = [w, col.max_width].min if col.max_width
           end
+          # Alignment across tables raises the width; an explicit maxw caps it
+          # afterwards, so the user's cap stays authoritative.
+          w = [w, @min_widths[i].to_i].max if @min_widths && i != last && w > 0
           w = [w, global_maxw].min if global_maxw && i != last && w > 0
           w
         end
@@ -182,7 +233,7 @@ module Railbow
         last_cell_plain = strip_ansi(last_cell_raw)
         term_w = terminal_width
         prefix_width = compute_prefix_width(widths, last)
-        last_col_max = term_w ? [term_w - prefix_width - display_width(pad), 10].max : nil
+        last_col_max = term_w ? [term_w - prefix_width - display_width(pad), MIN_LAST_COL].max : nil
 
         # Use custom truncate_fn if available (e.g. table tags with +N)
         if columns[last].truncate_fn && last_col_max &&
@@ -278,12 +329,98 @@ module Railbow
       end
 
       def terminal_width
+        return @term_width if @term_width
         return $stdout.winsize[1] if $stdout.respond_to?(:winsize) && $stdout.tty?
         nil
       rescue
         nil
       end
 
+      # --- Width budget ---
+
+      # The index of the column to sacrifice, or nil while shrinking alone can
+      # still fit the table into the terminal.
+      def drop_index_to_fit(rows)
+        return nil unless terminal_width
+        return nil if rows.empty?
+
+        candidate = columns.each_index
+          .select { |i| columns[i].droppable }
+          .min_by { |i| columns[i].droppable }
+        return nil unless candidate
+        return nil if required_width(fully_shrunk_widths(rows), rows) <= terminal_width
+
+        candidate
+      end
+
+      def dropped_renderer(drop)
+        self.class.new(
+          columns: columns.reject.with_index { |_, i| i == drop },
+          theme: theme,
+          compact: @compact,
+          aliases: @aliases,
+          min_widths: @min_widths&.reject&.with_index { |_, i| i == drop },
+          term_width: terminal_width
+        )
+      end
+
+      def shift_tick_col(tick_col, drop)
+        return nil if tick_col.nil? || drop == tick_col
+
+        (drop < tick_col) ? tick_col - 1 : tick_col
+      end
+
+      # Narrows shrinkable columns just enough to close the overflow, and
+      # re-truncates their cells to the new width.
+      def shrink_to_fit!(widths, rows)
+        return if rows.empty? || !terminal_width
+
+        overflow = required_width(widths, rows) - terminal_width
+        return if overflow <= 0
+
+        last = columns.size - 1
+        columns.each_with_index do |col, i|
+          break if overflow <= 0
+          next if i == last || !col.shrinkable
+
+          cut = [widths[i] - shrink_floor(col), overflow].min
+          next if cut <= 0
+
+          widths[i] -= cut
+          overflow -= cut
+          rows.each { |row| row[i] = truncate_ansi(row[i].to_s, widths[i]) }
+        end
+      end
+
+      # Never below the header label: a column narrower than its own header
+      # would push the header row out of alignment.
+      def shrink_floor(col)
+        [col.shrink_floor || MIN_SHRINK_WIDTH, display_width(effective_label(col))].max
+      end
+
+      def fully_shrunk_widths(rows)
+        widths = resolve_widths(rows)
+        last = columns.size - 1
+        columns.each_with_index do |col, i|
+          next if i == last || !col.shrinkable
+
+          widths[i] = [widths[i], shrink_floor(col)].min
+        end
+        widths
+      end
+
+      # What the table needs from the terminal: every fixed column plus a
+      # reserve for the flexing last column, which truncates down to
+      # MIN_LAST_COL but never below it. The last column's header label counts
+      # too - it is drawn as-is, so a label wider than every cell would poke
+      # past the terminal edge otherwise.
+      def required_width(widths, rows)
+        last = columns.size - 1
+        last_w = rows.map { |row| display_width(strip_ansi(row[last].to_s)) }.max || 0
+        last_w = [last_w, display_width(effective_label(columns[last]))].max unless @compact[:noheader]
+        compute_prefix_width(widths, last) + [last_w, MIN_LAST_COL].min + display_width(effective_padding)
+      end
+
       def ansi_word_wrap(str, max_width)
         plain = strip_ansi(str)
         plain_lines = word_wrap(plain, max_width)
@@ -429,6 +566,8 @@ module Railbow
         # Build column index → value alias map
         col_map = {}
         columns.each_with_index do |col, i|
+          next unless col.aliased
+
           label = col.label
           col_map[i] = value_aliases[label] if value_aliases[label]
           # Also look up by original name if column was renamed by alias