railbow 0.3.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c42f0f6d8162662344a6ef8fb12388e8dd6a2a579384cab3829a85d806cb1571
-  data.tar.gz: 064fb908f8cd7567e9d8be53800e6972aa48faf65348aff7338c6088aa7427dd
+  metadata.gz: d599ddd7c1bd3a12893312ab22f40ff75def87f5d85d42dd2ee5a11da7183225
+  data.tar.gz: 4413568aafb22c8cf2b1025bbd6f90696f4da6f3bcead307c48ffeac3e96f04c
 SHA512:
-  metadata.gz: f7af392359a26db27919f6bac5d31ce22d6736615bbbe8d514c794e5114a2a71ff61081160340a3177fd4b172207b8c07ae2948fcfdaeaccbc0498b28370fb1c
-  data.tar.gz: e5a9364c62c93fa530cbde3222c2249b3f251043514fda4d4cf51a33cfaf27ad54bffed5d5abae43befe065634faee0d96ec60581adc22004cd45790e7f87534
+  metadata.gz: a02d2dda50ba6fa9ae4b04d166ebc51148532dcfccd5ab1a7777179d14767d2bb87b2fc4a9a5d3aadbb0eeae114a68f5365cd3bfd0d27286958b192f5fa43967
+  data.tar.gz: 5ad80b381822e25a9078093f82c8b52deccae5940334ce45645883e2d4c06a81070e2710876f58fc8af949cc3b96009369e141eb9945c3a1941233561c31f486

data/CHANGELOG.md

@@ -5,6 +5,101 @@ 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.5.0] - 2026-07-28
+
+### Added
+
+- Multi-database support for `db:migrate:status`. Rails runs the task once per
+  database; railbow now wraps that loop and renders the databases together, as
+  one section each in `database.yml` order with column widths shared so the
+  tables line up. The section header names the database by its `database.yml`
+  name, which is what you configure and filter by, rather than the database
+  name Rails reports.
+- A database with nothing in the time window and nothing pending collapses to a
+  one-line summary instead of an empty table, so the `cache`, `queue` and
+  `cable` databases of a stock Rails 8 app stop drowning out your own. Anything
+  it hides (pending migrations, ghosts) is counted in the line, along with the
+  flag that reveals them.
+- Databases sharing a `migrations_paths` (horizontal sharding) merge into a
+  single table carrying a status glyph per database, making drift between
+  shards visible at a glance. A dim `·` marks a version one shard has never
+  seen.
+- `RBW_DB` (config key `db`) selects and shapes a multi-database run:
+  `only:<name>` and `skip:<name>` (both repeatable) pick databases, `full`
+  draws the quiet ones in full, and `inline` merges everything into one table
+  ordered by version with a `Db` column, so the calendar spans the whole
+  application instead of restarting per database. Filtered-out databases are
+  named in a footer rather than silently dropped.
+
+- `RBW_SINCE_MIN` (config key `since_min`, default 10) makes the time window a
+  soft limit: whatever `since` leaves, the floor tops it back up to this many
+  migrations. A database with five migrations now shows all five rather than
+  hiding the two that happen to be old and reporting an empty period. The
+  hidden-count line says `showing the last 10` when the floor overrode the
+  window, and a multi-database section header reads `last 10 of 50` rather than
+  `10 of 50`, so a table holding rows older than the window it names still
+  reads honestly in both views. `RBW_SINCE_MIN=0` restores the old hard cutoff.
+- `RBW_DB=focus`, **the default**, expands only the first database and
+  summarizes the rest in a line each, so a multi-database app is one table to
+  read rather than several. A database holding pending migrations is expanded
+  anyway: the summary exists to hide what needs no action, and pending work is
+  the opposite of that. An empty `RBW_DB` (or `db: ""`) expands every database
+  that has recent activity, `full` expands everything including quiet ones, and
+  `focus` never applies to an `inline` run, which exists to hold every database
+  at once.
+
+### Changed
+
+- Git lookups are now shared across a run: authors, landed dates and branch
+  origins are resolved once per migrations directory instead of once per
+  database. `RBW_HELP=1` prints the help once for the whole run rather than
+  once per database.
+- `db:migrate:status` internals moved out of the rake file into
+  `Railbow::Status` (`Section`, `Printer`, `GitData`, `Ghosts`, `Help`). No
+  output changed: a single-database app renders byte for byte what it did
+  before, which a golden fixture now enforces.
+
+## [0.4.0] - 2026-07-28
+
+### Added
+
+- `RBW_CALENDAR=wdividers` gives every ISO week its own separator row, the
+  fuller counterpart to `wticks`. A week that opens a new month is left to the
+  month row rather than being announced twice. The default stays `wticks`, so
+  existing output is unchanged until you opt in.
+- `RBW_CALENDAR=counts` appends `· N migrations` to every separator row: how
+  many migrations that section holds, counted up to the next separator.
+- `RBW_CALENDAR=wlabel:<fmt>` sets the strftime pattern for week rows,
+  alongside the existing `label:` for month rows. It defaults to the month
+  pattern, so the week number sits at the same offset on every separator row
+  rather than shifting left when no new month is announced.
+- `railbow demo status` now honors `RBW_CALENDAR`, so the calendar modes can be
+  tried without a Rails project.
+- An empty `RBW_CALENDAR` (month separators, no week markers) is now documented
+  in the help output, the `railbow init` template, and the README. It always
+  worked; nobody could have guessed it.
+
+### Changed
+
+- Calendar separator rows are drawn in a muted purple (256-color 97) instead of
+  the brighter 141, so they frame the migrations without competing with them.
+- Migrations that are not applied (`down`) now render as a greyed-out row in
+  `db:migrate:status`, instead of signalling their state through the status
+  column alone. The row keeps its layout and its status glyph keeps its color;
+  everything else drops its own colors, so pending migrations read as inactive
+  next to the applied ones.
+
+### Fixed
+
+- Rows whose last column wrapped were indented with too wide a blank prefix:
+  building the row mutated the very cell that the wrapped-line indent is
+  measured from. Reachable from `routes`, `about`, and `stats`.
+- A separator label wider than its column no longer pushes the rest of the row
+  sideways. Separator rows are drawn as empty walls with the label laid over
+  them, so a long label spills into the blank space to its right.
+- `RBW_HELP` output for `db:migrate:status` uses plain hyphens instead of
+  em-dashes, matching the rest of the user-facing text.
+
 ## [0.3.0] - 2026-07-23
 
 ### Added

data/README.md

@@ -21,7 +21,8 @@
 - **Notes** - `rails notes` with git blame, author colors, date filtering, and sorting
 - **About** - polished `rails about` output
 - **Git Integration** - authors, diffs, branch origin, landing dates, uncommitted file indicators
-- **Calendar View** - month separators and week tick markers for migration timelines
+- **Calendar View** - month separators plus week ticks or full week rows, with optional per-section counts
+- **Multiple Databases** - read one table by default, the rest summarized in a line each (and expanded when they have migrations pending); sharded databases merged with a status per shard
 - **Ghost Recovery** - uses the [mighost](https://github.com/amberpixels/mighost) gem (optional) to recover names, authors, and branch badges for `NO FILE` migrations
 - **Smart Defaults** - auto-disables in CI, piped output, `NO_COLOR`, and LLM agents
 
@@ -103,8 +104,121 @@ Out of the box you get:
 - **Landing dates** - `⤻ Mar 04` badge when a migration was merged to main after its creation
 - **Branch badges** - `⎇ PS-142` showing the source branch/ticket
 - **Affected tables** - color-coded table names extracted from migration files
-- **Time filtering** - only the last 70 days shown by default (`since: 70d`)
+- **Time filtering** - only the last 70 days shown by default (`since: 70d`), as a soft limit: never fewer than 10 migrations, however old (`since_min: 10`)
 - **Your migrations highlighted** - rows authored by you are visually distinct
+- **Pending migrations greyed out** - a `down` row keeps its status glyph but loses its colors
+
+#### Weekly view
+
+By default each new ISO week is marked with a tick on the date column
+(`calendar: wticks`). For a fuller weekly breakdown, `wdividers` gives every
+week its own separator row, and `counts` appends how many migrations sit under
+each separator, week or month:
+
+```bash
+RBW_CALENDAR=wdividers,counts rake db:migrate:status
+```
+
+```
+         Feb 2026   W06 · 2 migrations
+ ↑↑    │ 20260202145343 │ 2026-02-02 14:53:43 │ Add weight field to animals          ● animals
+ ↑↑    │ 20260203134528 │ 2026-02-03 13:45:28 │ Create vaccination records           ● vaccination_records
+         Feb 2026   W07 · 1 migration
+ ↑↑    │ 20260210183902 │ 2026-02-10 18:39:02 │ Create pet tags                      ● pet_tags
+         Mar 2026   W10 · 1 migration
+ ↑↑    │ 20260303120000 │ 2026-03-03 12:00:00 │ Add breed restrictions to…           ● adoption_policies
+         Mar 2026   W11 · 1 migration
+ ↑↑    │ 20260313132325 │ 2026-03-13 13:23:25 │ Create veterinary appointm…  ⎇ PS-142  ● veterinary_appointments
+```
+
+Every separator carries the month, so the week number always sits at the same
+offset instead of shifting left on rows that open no new month, and every
+separator is drawn in the same muted purple. Both labels are `strftime`
+patterns: `label:` for months, `wlabel:` for weeks (defaulting to the same
+pattern).
+
+`RBW_CALENDAR` is the list of *week* markers, so an empty value leaves you with
+month separators and nothing else:
+
+```yaml
+view: "calendar,tables"
+calendar: ""            # month separators only
+```
+
+Dropping `calendar` from `view` instead removes the month separators too.
+
+#### Multiple databases
+
+Rails runs `db:migrate:status` once per database, so a multi-database app used
+to get one blind table per database: widths that did not line up, the help
+printed once per database, and every git lookup repeated. Railbow now renders
+the whole run together.
+
+By default you read one table: the first database in `database.yml` is rendered
+in full and every other one is summarized in a line each (`db: focus`).
+
+```
+📊 2 databases · primary, raw
+
+──── primary · myapp_development ──── 122 of 1500 ──────────────────────
+ ↑↑  │ 20260721130000 │ 2026-07-21 13:00:00 │ Partition sms notifications  ● sms_notifications
+ ↓↓  │ 20260727170000 │ 2026-07-27 17:00:00 │ Add cr push columns to lines ● lines
+
+⋯ raw · 5 migrations, all applied · latest Jul 22 2026
+```
+
+**A database with migrations pending is always expanded**, however focused the
+run is. The summary exists to hide what needs no action, and pending work is
+the opposite of that.
+
+Setting `db` to an empty value expands every database that has recent activity,
+each as its own section with column widths shared so the tables line up:
+
+```yaml
+db: ""            # or RBW_DB= on the command line
+```
+
+```
+──── primary · myapp_development ──── 122 of 1500 ──────────────────────
+ ↑↑  │ 20260721130000 │ 2026-07-21 13:00:00 │ Partition sms notifications  ● sms_notifications
+
+──── raw · raw_development ─────────────────────────────────────────────
+ ↑↑  │ 20260722120000 │ 2026-07-22 12:00:00 │ Drop archived activity logs  ● archived_activity_logs
+```
+
+A section header counts what it is showing: `122 of 1500` means 122 fell inside
+the time window. When the window found too few and the `since_min` floor topped
+the section back up, it reads `last 10 of 50` instead, because the rows are
+then the newest ten rather than a window's worth.
+
+Even then, a database with nothing in the time window collapses to one line
+rather than an empty table, which is what keeps the `cache`, `queue` and
+`cable` databases of a stock Rails 8 app from drowning out your own:
+
+```
+⋯ cache · 5 migrations, all applied · latest Feb 12 2024
+⋯ queue · 12 migrations, 3 pending outside the 70d window - RBW_SINCE=all
+```
+
+Databases that share a `migrations_paths` (horizontal sharding) run the same
+files, so they merge into one table carrying a status per database. Drift
+between shards is then visible at a glance, and `·` marks a version a shard has
+never seen:
+
+```
+──── primary + primary_shard_one · db/migrate ──────────────────────────
+ ↑↑ ↑↑ │ 20260601151200 │ 2026-06-01 15:12:00 │ Add owner id to pets
+ ↑↑ ↓↓ │ 20260726143000 │ 2026-07-26 14:30:00 │ Add policy number to bills
+```
+
+`RBW_DB` controls the rest: `only:<name>` and `skip:<name>` (both repeatable)
+pick databases, `full` draws every section in full and overrides `focus`, and
+`inline` merges everything into a single table ordered by version with a `Db`
+column, so the calendar spans the whole application rather than restarting per
+database. `focus` never applies to an inline run - a merged table exists to
+hold every database at once.
+
+A single-database app sees none of this: its output is unchanged.
 
 If the [mighost](https://github.com/amberpixels/mighost) gem is installed (`gem "mighost", group: [:development, :test]`), migrations whose files were deleted (e.g. after switching branches) show up with a 👻 status and their recovered name instead of a bare `********** NO FILE **********` row - Railbow talks to it through the stable `Mighost::API`. Each ghost row carries the most informative badge mighost can provide: `≡ <version>` when the migration was re-timestamped and lives on under another version (shown with a calmer 🪦 status), `⌥ <branch>` when a branch still holds the file, or `✂ deleted in:<sha>` pointing at the commit that removed it. Ghosts dismissed via `mighost:dismiss` (or hidden by `hide_superseded`) render as plain `NO FILE`.
 
@@ -153,10 +267,12 @@ rake railbow:init
 
 ```yaml
 since: 70d
+since_min: 10
 date: rel
 git: "author:me,diff,mask:auto"
 view: "calendar,tables"
 calendar: wticks
+db: focus
 
 compact: "maxw:120"
 
@@ -178,10 +294,12 @@ Every option can also be set via `RBW_*` environment variables, which override c
 | `RBW_PLAIN` | `1` | Disable all formatting |
 | `RBW_FORCE` | `1` | Force formatting even when piped, in CI, or run by an LLM agent (`RBW_PLAIN=1` still wins) |
 | `RBW_SINCE` | `2mo`, `70d`, `1y`, `all` | Filter migrations by time period |
+| `RBW_SINCE_MIN` | `10`, `0` | Never show fewer than this many migrations, however old (default 10; `0` disables) |
 | `RBW_DATE` | `full`, `rel`, `short`, `custom(%b %d)` | Date display format |
 | `RBW_GIT` | `author:me,diff,mask:auto` | Git integration options |
 | `RBW_VIEW` | `calendar,tables` | Enable calendar view and table detection |
-| `RBW_CALENDAR` | `wticks` | Show week tick markers |
+| `RBW_CALENDAR` | `wticks`, `wdividers,counts`, `` (empty) | Week markers: tick marks, full week separator rows, per-section counts. Empty means month separators only |
+| `RBW_DB` | `focus` (default), `` (empty), `only:primary`, `skip:cache`, `full`, `inline` | Multi-database runs: focus one database, expand them all, pick some, or merge them into one table |
 | `RBW_COMPACT` | `oneline,dense,noheader,maxw:80` | Compact display options |
 | `RBW_VERB` | `GET,POST` | Filter routes by HTTP method |
 | `RBW_SORT` | `file`, `date` | Sort order for notes |

data/lib/railbow/calendar.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require "date"
+
+module Railbow
+  # Turns an ordered list of migration versions into the calendar furniture that
+  # gives the status table its shape: a separator row when the month changes,
+  # optionally one when the ISO week changes, and optionally a tick mark on the
+  # date column at each week boundary.
+  #
+  # A separator introduces the rows beneath it and runs until the next separator,
+  # so the optional count always answers "how many migrations in this section".
+  module Calendar
+    DEFAULT_MONTH_LABEL = "%b %Y   W%V"
+    # Week rows carry the month too, so the week number sits at the same offset
+    # on every separator row rather than jumping left when the month is absent.
+    DEFAULT_WEEK_LABEL = DEFAULT_MONTH_LABEL
+
+    # What the renderer needs to draw the calendar: a label per separator row,
+    # and which rows open a week (for tick marks). Both keyed by row index.
+    class Furniture
+      attr_reader :separators, :tick_rows
+
+      def initialize
+        @separators = {}
+        @tick_rows = Set.new
+      end
+    end
+
+    module_function
+
+    def none
+      Furniture.new
+    end
+
+    def build(versions, weeks: false, ticks: false, counts: false,
+      month_label: DEFAULT_MONTH_LABEL, week_label: DEFAULT_WEEK_LABEL)
+      dates = versions.map { |v| parse_date(v) }
+      furniture = none
+
+      dates.each_with_index do |date, i|
+        prev = (i > 0) ? dates[i - 1] : nil
+        next unless date && prev
+
+        opens_week = week_key(prev) != week_key(date)
+
+        if month_key(prev) != month_key(date)
+          furniture.separators[i] = date.strftime(month_label)
+        elsif weeks && opens_week
+          furniture.separators[i] = date.strftime(week_label)
+        end
+
+        furniture.tick_rows << i if ticks && opens_week
+      end
+
+      append_counts(furniture.separators, dates.size) if counts
+      furniture
+    end
+
+    def parse_date(version)
+      v = version.to_s
+      Date.new(v[0..3].to_i, v[4..5].to_i, v[6..7].to_i)
+    rescue Date::Error
+      nil
+    end
+
+    def month_key(date)
+      [date.year, date.month]
+    end
+
+    # cwyear, not year: the ISO week of Jan 1 can belong to the year before.
+    def week_key(date)
+      [date.cwyear, date.cweek]
+    end
+
+    def append_counts(separators, total)
+      indices = separators.keys.sort
+      indices.each_with_index do |index, nth|
+        section_end = indices[nth + 1] || total
+        separators[index] = "#{separators[index]} · #{migration_count(section_end - index)}"
+      end
+    end
+
+    # Spelled out: a bare number next to a week label reads as part of the date.
+    def migration_count(count)
+      "#{count} #{(count == 1) ? "migration" : "migrations"}"
+    end
+  end
+end

data/lib/railbow/config.rb

@@ -14,10 +14,12 @@ module Railbow
         }
       },
       "since" => "70d",
+      "since_min" => 10,
       "git" => "author:all,diff,mask:auto",
       "author_format" => "short",
       "view" => "calendar,tables",
-      "calendar" => "wticks"
+      "calendar" => "wticks",
+      "db" => "focus"
     }.freeze
 
     @root = nil

data/lib/railbow/demo/status_demo.rb

@@ -3,7 +3,9 @@
 require "date"
 require_relative "../formatters/base"
 require_relative "../table"
+require_relative "../calendar"
 require_relative "../config"
+require_relative "../params"
 require_relative "fixtures"
 
 module Railbow
@@ -20,7 +22,8 @@ module Railbow
         puts "\n#{formatter.emoji(:status)} Database: #{formatter.cyan("db/development.sqlite3")}"
         puts
 
-        # Use default config: author:me, diff, calendar, tables, wticks, full date
+        # Fixed for the showcase: author:me, diff, tables, full date. The calendar
+        # options below come from the real params, so RBW_CALENDAR still applies.
         date_format = "full"
         tables_enabled = true
         diff_enabled = true
@@ -28,7 +31,7 @@ module Railbow
         git_email = Fixtures::DEMO_USER_EMAIL
         git_name = Fixtures::DEMO_USER_NAME
 
-        # Latest migration date — for "fresh" landed badge detection
+        # Latest migration date - for "fresh" landed badge detection
         latest_version = migrations.last[:version]
         latest_mig_date = parse_version_date(latest_version)
 
@@ -43,7 +46,7 @@ module Railbow
         name_col_width = needs_name_truncation ? 60 : nil
 
         table_columns = [
-          Railbow::Table::Column.new(label: "Status", max_width: 6, sticky: true),
+          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: "Migration Name",
@@ -57,7 +60,9 @@ module Railbow
 
         # Build rows
         highlight_rows = Set.new
+        down_rows = Set.new
         rows = migrations.each_with_index.map do |m, idx|
+          down_rows << idx if m[:status] == "down"
           colored_status = case m[:status]
           when "up" then formatter.green_bold("up")
           when "down" then formatter.yellow_bold("down")
@@ -106,40 +111,16 @@ module Railbow
           [colored_status, m[:version], created_at, display_name, table_tags]
         end
 
-        # Calendar separators
-        separators = {}
-        versions = migrations.map { |m| m[:version] }
-        month_keys = versions.map { |v| v[0..5] }
-        calendar_label_fmt = "%b %Y   W%V"
-
-        if month_keys.uniq.size > 1
-          month_keys.each_with_index do |mk, i|
-            next if i == 0
-            if mk != month_keys[i - 1]
-              v = versions[i]
-              date = Date.new(v[0..3].to_i, v[4..5].to_i, v[6..7].to_i)
-              separators[i] = date.strftime(calendar_label_fmt)
-            end
-          end
-        end
-
-        # Week ticks
-        tick_rows = Set.new
-        prev_week = nil
-        versions.each_with_index do |v, i|
-          y = v[0..3].to_i
-          m = v[4..5].to_i
-          d = v[6..7].to_i
-          next if y == 0 || m == 0 || d == 0
-
-          week = Date.new(y, m, d).cweek
-
-          if i > 0 && prev_week && week != prev_week
-            tick_rows << i
-          end
-
-          prev_week = week
-        end
+        # Calendar furniture. Driven by the real params, so RBW_CALENDAR can be
+        # tried out here without a Rails project.
+        calendar = Railbow::Calendar.build(
+          migrations.map { |m| m[:version] },
+          weeks: Railbow::Params.calendar_wdividers?,
+          ticks: Railbow::Params.calendar_wticks?,
+          counts: Railbow::Params.calendar_counts?,
+          month_label: Railbow::Params.calendar_label,
+          week_label: Railbow::Params.calendar_week_label
+        )
 
         aliases = Railbow::Config.table_aliases
         renderer = Railbow::Table::Renderer.new(
@@ -148,7 +129,10 @@ module Railbow
           compact: {oneline: false, dense: false, noheader: false, maxw: nil, hidden_columns: []},
           aliases: aliases
         )
-        puts renderer.render(rows, separators: separators, highlight_rows: highlight_rows, tick_rows: tick_rows, tick_col: 2)
+        puts renderer.render(rows,
+          separators: calendar.separators,
+          highlight_rows: highlight_rows, dim_rows: down_rows,
+          tick_rows: calendar.tick_rows, tick_col: 2)
       end
 
       private

data/lib/railbow/init.rb

@@ -22,6 +22,11 @@ module Railbow
       # Time window for migrations to display (e.g. 30d, 2mo, 1y, all)
       since: "70d"
 
+      # Never show fewer than this many migrations, however old they are.
+      # The window above is a soft limit: a database with five migrations shows
+      # all five rather than reporting an empty period. 0 disables the floor.
+      since_min: 10
+
       # Sort order: file (by filename/version) or date (by timestamp)
       # sort: "file"
 
@@ -43,12 +48,29 @@ module Railbow
       # View mode (comma-separated): calendar, tables
       view: "calendar,tables"
 
-      # Calendar options: wticks (show week tick separators)
+      # Calendar options (comma-separated), all require view: calendar.
+      # Leave empty ("") for month separators only, with no week markers.
+      #   wticks       - week tick marks on the date column
+      #   wdividers    - a separator row per ISO week
+      #   counts       - append "· N migrations" to separator rows (per section)
+      #   label:<fmt>  - strftime for month separators (default: %b %Y   W%V)
+      #   wlabel:<fmt> - strftime for week separators (default: same as label)
       calendar: "wticks"
 
       # Date format: full, rel, short, or custom(%b %d, %Y)
       # date: "full"
 
+      # Multi-database runs (comma-separated). Leave empty ("") to expand every
+      # database into its own section, in database.yml order; a database with
+      # nothing in the time window collapses to a one-line summary either way.
+      #   focus       - expand only the first database, summarizing the rest.
+      #                 A database with migrations pending is always expanded
+      #   only:<name> - render only this database (repeatable)
+      #   skip:<name> - drop this database (repeatable)
+      #   full        - draw every database in full, overriding focus
+      #   inline      - one merged table ordered by version, with a Db column
+      db: "focus"
+
       # Compact mode (comma-separated):
       #   oneline       - one line per migration
       #   dense         - reduce padding

data/lib/railbow/multi_db.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Railbow
+  # Rails runs db:migrate:status once per database, inside
+  # with_temporary_pool_for_each. Each call on its own cannot know whether more
+  # databases are coming, so railbow wraps that loop: sections collect into the
+  # open batch and the batch renders them together when the loop ends.
+  #
+  # A batch is inert unless something adds to it, so wrapping the other tasks
+  # that share the same Rails helper (db:migrate, db:prepare) costs one object.
+  module MultiDb
+    KEY = :railbow_multi_db_batch
+
+    class Batch
+      attr_reader :git_cache
+
+      def initialize
+        @sections = []
+        @skipped = []
+        @git_cache = {}
+        @help_shown = false
+      end
+
+      # A database excluded by RBW_DB. Recorded rather than dropped so the run
+      # can say what it left out.
+      def skip(name)
+        @skipped << name.to_s
+      end
+
+      # Databases sharing a migrations path see the same files, so they merge
+      # into one section that carries a status per database.
+      def add(section)
+        existing = @sections.find { |s| s.same_migrations?(section) }
+        if existing
+          existing.merge!(section)
+        else
+          @sections << section
+        end
+      end
+
+      def claim_help
+        return false if @help_shown
+
+        @help_shown = true
+      end
+
+      def empty?
+        @sections.empty? && @skipped.empty?
+      end
+
+      def flush
+        return if empty?
+
+        Railbow::Status::Printer.new(@sections, skipped: @skipped).print
+        @sections = []
+        @skipped = []
+      end
+    end
+
+    module_function
+
+    # Opens a batch for the duration of the block. The flush is in an ensure so
+    # that a database aborting mid-run (a missing schema_migrations table, say)
+    # still prints the sections collected before it.
+    def batch
+      previous = Thread.current[KEY]
+      batch = Batch.new
+      Thread.current[KEY] = batch
+      begin
+        yield
+      ensure
+        Thread.current[KEY] = previous
+        batch.flush
+      end
+    end
+
+    def current
+      Thread.current[KEY]
+    end
+
+    # True the first time it is asked within a run. Without a batch every call
+    # is its own run, so the answer is always true.
+    def claim_help
+      current ? current.claim_help : true
+    end
+  end
+end