railbow 0.5.0 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d599ddd7c1bd3a12893312ab22f40ff75def87f5d85d42dd2ee5a11da7183225
-  data.tar.gz: 4413568aafb22c8cf2b1025bbd6f90696f4da6f3bcead307c48ffeac3e96f04c
+  metadata.gz: 61c0c3ed9ad2e0c2218e9f2b5e69f6eecec3253a82722408649e91b2822873be
+  data.tar.gz: 2179f41a4dfd77f4630940ce0280130a612d75202faede974611c27b0729058d
 SHA512:
-  metadata.gz: a02d2dda50ba6fa9ae4b04d166ebc51148532dcfccd5ab1a7777179d14767d2bb87b2fc4a9a5d3aadbb0eeae114a68f5365cd3bfd0d27286958b192f5fa43967
-  data.tar.gz: 5ad80b381822e25a9078093f82c8b52deccae5940334ce45645883e2d4c06a81070e2710876f58fc8af949cc3b96009369e141eb9945c3a1941233561c31f486
+  metadata.gz: c777b8cf30ac567ba71c6cc16f16e7f6bbfdc604d8fa1b161cafc17879cea825b446e02f72e43fa9f383d03752c2506a6653c951928302b6d290b689f5a4fa39
+  data.tar.gz: 87b8b0d21c779637d0f6c9c20271bec519677feda8d790cadd9644a33413d352550b6a883a96da0774bb7009f9f2667b55d9e23a670800684bbf824b58607b78

data/CHANGELOG.md

@@ -5,6 +5,18 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.6.0] - 2026-08-03
+
+### Fixed
+
+- On a terminal too narrow for the full `db:migrate:status` row, the table no
+  longer wraps mid-cell. A width budget degrades it gracefully instead, one
+  sacrifice at a time until the rows fit: the Migration Name column narrows
+  first (down to 24 columns), then the Tables column is dropped, then the
+  formatted date (the raw Migration ID still carries the timestamp), and as a
+  last resort the Who column. Each table gives up only as much as its terminal
+  demands, and a wide terminal renders exactly as before.
+
 ## [0.5.0] - 2026-07-28
 
 ### Added

data/lib/railbow/demo/status_demo.rb

@@ -48,15 +48,17 @@ module Railbow
         table_columns = [
           Railbow::Table::Column.new(label: "Status", max_width: 6, sticky: true, accent: true),
           Railbow::Table::Column.new(label: "Migration ID", sticky: true),
-          Railbow::Table::Column.new(label: "Created At"),
+          Railbow::Table::Column.new(label: "Created At", droppable: 2),
           Railbow::Table::Column.new(label: "Migration Name",
             max_width: name_col_width,
-            truncate: needs_name_truncation)
+            truncate: needs_name_truncation,
+            shrinkable: true, shrink_floor: 24)
         ]
         # No Author column in default config (author:me only highlights)
 
         tables_truncate_fn = ->(cell_raw, max_w) { formatter.table_tags_fitted(cell_raw, max_w) }
-        table_columns << Railbow::Table::Column.new(label: "Tables", truncate: true, truncate_fn: tables_truncate_fn)
+        table_columns << Railbow::Table::Column.new(label: "Tables", droppable: 1,
+          truncate: true, truncate_fn: tables_truncate_fn)
 
         # Build rows
         highlight_rows = Set.new

data/lib/railbow/status/printer.rb

@@ -263,10 +263,22 @@ module Railbow
         head += "#{RULE * 4} #{shown_count(section)} of #{section.total_count} " if section.hidden_count > 0
 
         width = (rule_width > 0) ? rule_width : DEFAULT_RULE_WIDTH
+        if (term = terminal_width)
+          width = [width, term].min
+        end
         filler = [width - formatter.display_width(head), 4].max
         "#{PURPLE}#{head}#{RULE * filler}#{RESET}"
       end
 
+      # The rule frames the table, but on a narrow terminal the table itself
+      # gives up width, so the rule must never trust fixed_width alone.
+      def terminal_width
+        return $stdout.winsize[1] if $stdout.respond_to?(:winsize) && $stdout.tty?
+        nil
+      rescue
+        nil
+      end
+
       # A bare "10 of 50" reads as "10 fell inside the window". When the floor
       # overrode the window the selection is a tail rather than a window, so it
       # says "last 10 of 50" - the same words the single-database note uses.

data/lib/railbow/status/section.rb

@@ -30,6 +30,10 @@ module Railbow
       # with it for horizontal space (tags, authors, table names).
       NAME_COL_WIDTH = 60
 
+      # Floor the width budget may shrink the name column down to on a narrow
+      # terminal, before it starts dropping columns instead.
+      NAME_COL_MIN_WIDTH = 24
+
       NO_FILE = "NO FILE"
 
       # A version one database in a shard group has and another does not.
@@ -311,6 +315,11 @@ module Railbow
 
       # The name column only needs capping when something else competes for the
       # row: table tags, an author column, branch badges or landed badges.
+      #
+      # On a terminal too narrow for the full row the width budget degrades the
+      # table instead of letting it wrap: the name column shrinks first, then
+      # Tables is dropped, then the formatted date (the raw Migration ID keeps
+      # the timestamp), then Who.
       def build_columns
         @name_col_width = needs_name_truncation? ? NAME_COL_WIDTH : nil
 
@@ -318,15 +327,17 @@ module Railbow
           Table::Column.new(label: "Status", max_width: status_col_width,
             sticky: true, accent: true, aliased: !sharded?),
           Table::Column.new(label: "Migration ID", sticky: true),
-          Table::Column.new(label: (date_format == "full") ? "Created At" : "Date"),
+          Table::Column.new(label: (date_format == "full") ? "Created At" : "Date",
+            droppable: 2),
           Table::Column.new(label: "Migration Name",
             max_width: @name_col_width,
-            truncate: !@name_col_width.nil?)
+            truncate: !@name_col_width.nil?,
+            shrinkable: true, shrink_floor: NAME_COL_MIN_WIDTH)
         ]
-        cols << Table::Column.new(label: "Who") if author_mode == "all"
+        cols << Table::Column.new(label: "Who", droppable: 3) if author_mode == "all"
         if tables_enabled?
           truncate_fn = ->(cell_raw, max_w) { formatter.table_tags_fitted(cell_raw, max_w) }
-          cols << Table::Column.new(label: "Tables",
+          cols << Table::Column.new(label: "Tables", droppable: 1,
             truncate: Railbow::Params.compact_oneline?, truncate_fn: truncate_fn)
         end
         cols

data/lib/railbow/table/column.rb

@@ -4,14 +4,18 @@ module Railbow
   module Table
     class Column
       attr_reader :label, :width, :min_width, :max_width, :align, :truncate, :truncate_fn,
-        :sticky, :accent, :aliased
+        :sticky, :accent, :aliased, :shrinkable, :shrink_floor, :droppable
 
       # accent: the column carries its own meaning through color (a status
       # glyph, say), so it keeps that color when the row is dimmed.
       # aliased: value aliases from config may rewrite this column's cells.
       # Off for cells the caller already resolved, such as a cluster of status
       # glyphs, which no whole-cell alias could ever match.
-      def initialize(label:, width: :auto, min_width: nil, max_width: nil, align: :left, truncate: false, truncate_fn: nil, sticky: false, accent: false, aliased: true)
+      # shrinkable: the width budget may narrow this column, down to
+      # shrink_floor, before it starts dropping columns.
+      # droppable: rank in the order the width budget drops columns entirely
+      # when shrinking is not enough - lower ranks go first. Nil: never dropped.
+      def initialize(label:, width: :auto, min_width: nil, max_width: nil, align: :left, truncate: false, truncate_fn: nil, sticky: false, accent: false, aliased: true, shrinkable: false, shrink_floor: nil, droppable: nil)
         @label = label
         @width = width
         @min_width = min_width
@@ -22,6 +26,9 @@ module Railbow
         @sticky = sticky
         @accent = accent
         @aliased = aliased
+        @shrinkable = shrinkable
+        @shrink_floor = shrink_floor
+        @droppable = droppable
       end
 
       def fixed?

data/lib/railbow/table/renderer.rb

@@ -14,15 +14,25 @@ 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
 
       # 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)
+      #
+      # 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
@@ -50,7 +60,21 @@ module Railbow
         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]
@@ -209,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 &&
@@ -305,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)

data/lib/railbow/text_utils.rb

@@ -26,5 +26,35 @@ module Railbow
       end
       "#{truncated}..."
     end
+
+    # ANSI-aware counterpart to truncate_str: escape codes pass through
+    # unmeasured, and a color left open at the cut is closed before the
+    # ellipsis so it cannot leak into whatever follows the cell.
+    def truncate_ansi(str, max_width)
+      s = str.to_s
+      return s if display_width(strip_ansi(s)) <= max_width
+
+      result = +""
+      width = 0
+      open_color = false
+      i = 0
+      while i < s.length
+        if s[i] == "\e" && (close = s.index("m", i))
+          code = s[i..close]
+          result << code
+          open_color = (code != "\e[0m")
+          i = close + 1
+        else
+          ch = s[i]
+          ch_width = display_width(ch)
+          break if width + ch_width > max_width - 3
+          result << ch
+          width += ch_width
+          i += 1
+        end
+      end
+      result << "\e[0m" if open_color
+      "#{result}..."
+    end
   end
 end

data/lib/railbow/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Railbow
-  VERSION = "0.5.0"
+  VERSION = "0.6.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: railbow
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.6.0
 platform: ruby
 authors:
 - Eugene M