railbow 0.3.0 → 0.5.0

data/lib/railbow/table/renderer.rb

@@ -10,40 +10,46 @@ module Railbow
 
       RESET = "\e[0m"
       WHITE = "\e[97m"
-      GHOST_BG = "\e[48;5;52m"    # deep red/maroon background — stands out as abnormal
+      GHOST_BG = "\e[48;5;52m"    # deep red/maroon background - stands out as abnormal
       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
 
       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.
+      def initialize(columns:, theme:, compact: {}, aliases: {}, min_widths: nil)
         @compact = compact
         @aliases = aliases
+        @min_widths = min_widths
         @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, 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)
         resolved = resolve_widths(rows)
 
         # In oneline mode, truncate non-sticky non-last columns at resolved width
@@ -64,12 +70,11 @@ module Railbow
         rows.each_with_index do |row, i|
           tc = (tick_rows.include?(i) && tick_col) ? tick_col : nil
           if separators.key?(i) && theme.format_separator
-            sep_row = Array.new(columns.size, "")
-            sep_row[1] = theme.format_separator.call(separators[i]) if columns.size > 1
-            lines << render_row(sep_row, resolved, tick_col: tc, tick_cross: true)
+            lines << render_separator_row(separators[i], resolved, tick_col: tc)
             tc = nil # tick already shown on separator row
           end
-          formatted = render_row(row, resolved, tick_col: tc, highlight: highlight_rows.include?(i), ghost: ghost_rows.include?(i))
+          formatted = render_row(row, resolved, tick_col: tc, highlight: highlight_rows.include?(i),
+            ghost: ghost_rows.include?(i), dim: dim_rows.include?(i))
           lines << formatted
         end
         lines.join("\n")
@@ -77,6 +82,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 +119,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
@@ -112,44 +139,65 @@ module Railbow
         }.join(theme.header_col_separator)
       end
 
-      def render_row(row, widths, tick_col: nil, tick_cross: false, highlight: false, ghost: false)
+      # A separator row is furniture, not data: the walls are drawn empty and the
+      # label is laid over them starting at the second column. Writing over the
+      # blanks rather than filling a cell means a label wider than its column
+      # spills into the empty space to its right instead of shifting the row.
+      def render_separator_row(label, widths, tick_col: nil)
+        pad = effective_padding
+        cells = widths.map { |w| "#{pad}#{" " * w}#{pad}" }
+
+        skeleton = cells.first.to_s.dup
+        (1...cells.size).each do |i|
+          skeleton << "#{separator_at(i - 1, tick_col, cross: true)}#{cells[i]}"
+        end
+        return skeleton if cells.size < 2 || label.nil? || label.empty?
+
+        offset = display_width(cells[0]) + display_width(separator_at(0, tick_col, cross: true)) + display_width(pad)
+        tail = skeleton[(offset + display_width(label))..] || ""
+        "#{skeleton[0, offset]}#{theme.format_separator.call(label)}#{tail}"
+      end
+
+      # The separator character between column index and index + 1. Columns
+      # flanking the tick column get the tick variant so the week line reads
+      # as one continuous rule.
+      def separator_at(index, tick_col, cross: false)
+        flanks_tick = tick_col && (index == tick_col - 1 || index == tick_col)
+        return theme.col_separator unless flanks_tick
+
+        cross ? theme.tick_cross_separator : theme.tick_separator
+      end
+
+      def render_row(row, widths, tick_col: nil, highlight: false, ghost: false, dim: false)
         last = columns.size - 1
         pad = effective_padding
-        default_sep = theme.col_separator
-        tick_sep = tick_cross ? theme.tick_cross_separator : theme.tick_separator
 
         prefix_parts = row[0...last].each_with_index.map { |cell, i|
           s = cell.to_s
           cell_w = display_width(strip_ansi(s))
           padding = " " * [widths[i] - cell_w, 0].max
           content = (columns[i].align == :right) ? "#{padding}#{s}" : "#{s}#{padding}"
-          if ghost
-            content = "#{GHOST_BG}#{GHOST_FG}#{content}#{RESET}"
-          elsif highlight
-            content = "#{WHITE}#{content}#{RESET}"
-          end
+          content = style_cell(content, highlight: highlight, ghost: ghost, dim: dim, accent: columns[i].accent)
           "#{pad}#{content}#{RESET}#{pad}"
         }
 
-        # Join prefix parts with per-position separators
-        # Loop index i joins column i-1 and column i (separator_index = i-1)
-        # For tick_col, flanking separator indices are tick_col-1 and tick_col
-        prefix = prefix_parts.first.to_s
+        # Join prefix parts with per-position separators.
+        # Loop index i joins column i-1 and column i (separator index = i-1).
+        # dup: appending to prefix_parts.first itself would corrupt the parts
+        # that render_last_cell measures for the wrapped-line indent.
+        prefix = prefix_parts.first.to_s.dup
         (1...prefix_parts.size).each do |i|
-          sep_idx = i - 1
-          sep = (tick_col && (sep_idx == tick_col - 1 || sep_idx == tick_col)) ? tick_sep : default_sep
-          prefix << "#{sep}#{prefix_parts[i]}"
+          prefix << "#{separator_at(i - 1, tick_col)}#{prefix_parts[i]}"
         end
 
         last_cell_raw = row[last].to_s
 
         # Separator before the last column has index (last - 1)
-        last_sep_idx = last - 1
-        last_sep = (tick_col && (last_sep_idx == tick_col - 1 || last_sep_idx == tick_col)) ? tick_sep : default_sep
-        render_last_cell(prefix, prefix_parts, last_cell_raw, widths, last, col_sep: last_sep, highlight: highlight, ghost: ghost)
+        last_sep = separator_at(last - 1, tick_col)
+        render_last_cell(prefix, prefix_parts, last_cell_raw, widths, last, col_sep: last_sep, highlight: highlight, ghost: ghost, dim: dim)
       end
 
-      def render_last_cell(prefix, prefix_parts, last_cell_raw, widths, last, col_sep: nil, highlight: false, ghost: false)
+      def render_last_cell(prefix, prefix_parts, last_cell_raw, widths, last, col_sep: nil, highlight: false, ghost: false, dim: false)
         pad = effective_padding
         sep = col_sep || theme.col_separator
 
@@ -167,7 +215,7 @@ module Railbow
         if columns[last].truncate_fn && last_col_max &&
             display_width(last_cell_plain) > last_col_max
           last_cell_raw = columns[last].truncate_fn.call(last_cell_raw, last_col_max)
-          last_cell_raw = style_cell(last_cell_raw, highlight: highlight, ghost: ghost)
+          last_cell_raw = style_cell(last_cell_raw, highlight: highlight, ghost: ghost, dim: dim, accent: columns[last].accent)
           return "#{prefix}#{sep}#{pad}#{last_cell_raw}#{RESET}#{pad}"
         end
 
@@ -175,18 +223,18 @@ module Railbow
         if columns[last].truncate && !columns[last].max_width && last_col_max &&
             display_width(last_cell_plain) > last_col_max
           last_cell_raw = truncate_by_words(last_cell_raw, last_col_max)
-          last_cell_raw = style_cell(last_cell_raw, highlight: highlight, ghost: ghost)
+          last_cell_raw = style_cell(last_cell_raw, highlight: highlight, ghost: ghost, dim: dim, accent: columns[last].accent)
           return "#{prefix}#{sep}#{pad}#{last_cell_raw}#{RESET}#{pad}"
         end
 
         # In oneline mode, truncate instead of wrapping
         if @compact[:oneline] && last_col_max && display_width(last_cell_plain) > last_col_max
           last_cell_raw = truncate_by_words(last_cell_raw, last_col_max)
-          last_cell_raw = style_cell(last_cell_raw, highlight: highlight, ghost: ghost)
+          last_cell_raw = style_cell(last_cell_raw, highlight: highlight, ghost: ghost, dim: dim, accent: columns[last].accent)
           return "#{prefix}#{sep}#{pad}#{last_cell_raw}#{RESET}#{pad}"
         end
 
-        last_cell_raw = style_cell(last_cell_raw, highlight: highlight, ghost: ghost)
+        last_cell_raw = style_cell(last_cell_raw, highlight: highlight, ghost: ghost, dim: dim, accent: columns[last].accent)
 
         if last_col_max && display_width(strip_ansi(last_cell_raw)) > last_col_max
           blank_prefix = prefix_parts.map { |part|
@@ -201,9 +249,17 @@ module Railbow
         end
       end
 
-      def style_cell(content, highlight: false, ghost: false)
+      def style_cell(content, highlight: false, ghost: false, dim: false, accent: false)
         if ghost
           "#{GHOST_BG}#{GHOST_FG}#{content}#{RESET}"
+        elsif dim
+          # An accent column keeps its color - on a dimmed row it is the one
+          # cell still carrying meaning. Everything else drops its own colors:
+          # one flat grey is what reads as "not in effect", and the resets that
+          # end each inner color would break the grey run anyway.
+          return content if accent
+
+          "#{DIMMED_FG}#{strip_ansi(content)}#{RESET}"
         elsif highlight
           "#{WHITE}#{content}#{RESET}"
         else
@@ -315,7 +371,7 @@ module Railbow
             current << token
             current_width += token_width
           elsif current_width.zero?
-            # Single token wider than max — try to break on underscores
+            # Single token wider than max - try to break on underscores
             broken = break_long_token(token, max_width)
             lines.concat(broken[0...-1])
             current = +broken.last
@@ -400,6 +456,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

data/lib/railbow/table/theme.rb

@@ -8,7 +8,8 @@ module Railbow
         :format_header_cell, :format_separator
 
       def initialize(col_separator:, header_col_separator:, cell_padding:,
-        format_header_cell:, format_separator: nil, tick_separator: nil, tick_cross_separator: nil)
+        format_header_cell:, format_separator: nil,
+        tick_separator: nil, tick_cross_separator: nil)
         @col_separator = col_separator
         @tick_separator = tick_separator || col_separator
         @tick_cross_separator = tick_cross_separator || @tick_separator
@@ -23,7 +24,7 @@ module Railbow
       RESET = "\e[0m"
       BOLD = "\e[1m"
       WHITE = "\e[97m"
-      PURPLE = "\e[38;5;141m"
+      PURPLE = "\e[38;5;97m" # separator rows: present, but never louder than the data
       BG_PURPLE = "\e[48;5;99m"
       DIM = "\e[2m"