railbow 0.6.2 → 0.7.0

data/lib/railbow/status/printer.rb

@@ -9,12 +9,9 @@ require_relative "../table"
 
 module Railbow
   module Status
-    # Turns collected sections into output. The only place db:migrate:status
-    # writes to stdout, which is what lets a multi-database run share column
-    # widths and print a single header.
-    #
-    # A run holding one database renders exactly as it did before multi-database
-    # support existed: no overview line, no section rule, nothing new.
+    # The only place db:migrate:status writes to stdout, which is what lets a
+    # multi-database run share column widths and print a single header. A
+    # single-database run gets no overview line and no section rule.
     class Printer
       RULE = "─"
       COLLAPSED = "⋯"
@@ -88,9 +85,8 @@ module Railbow
         puts render_table(section)
       end
 
-      # Says what the window hid, and admits when the floor overrode it: the
-      # table then holds rows older than the window it names, and a bare
-      # "hidden - SINCE=70d" would read as a contradiction next to them.
+      # Admits when the floor overrode the window: a bare "hidden - SINCE=90d"
+      # would contradict the older rows shown below it.
       def hidden_note(section)
         return nil unless section.hidden_count > 0
 
@@ -110,8 +106,7 @@ module Railbow
         puts
         puts section_header(section, renderer.fixed_width(widths))
 
-        # Reachable with RBW_DB=full, which asks for every section to be drawn
-        # in full, including the ones that would otherwise have collapsed.
+        # Reachable with RBW_DB=full, which draws even quiet sections in full.
         if section.state == :no_migrations
           puts formatter.yellow("  No migrations found")
           return
@@ -123,10 +118,9 @@ module Railbow
         puts render_table(section, renderer)
       end
 
-      # RBW_DB=inline: every database in one time-ordered table, each row
-      # carrying a Db badge. The calendar then spans the whole application
-      # rather than restarting per database, which is the point of asking for
-      # it. Quiet databases still collapse below the table.
+      # RBW_DB=inline: every database in one time-ordered table with a Db
+      # badge per row, so the calendar spans the whole application. Quiet
+      # databases still collapse below the table.
       def print_inline
         live = sections.reject { |s| collapse?(s) || s.rows.empty? }
         collapsed = sections - live
@@ -149,9 +143,8 @@ module Railbow
         collapsed.each { |section| puts collapsed_line(section) }
       end
 
-      # Sorted by version, so the databases interleave by when each migration
-      # was written. Ties fall back to config order, which keeps two databases
-      # that share a timestamp in database.yml order rather than an arbitrary one.
+      # Sorted by version; ties fall back to database.yml order rather than an
+      # arbitrary one.
       def inline_entries(live)
         assigner = Railbow::ColorAssigner.new(live.map { |s| inline_label(s) })
 
@@ -209,27 +202,21 @@ module Railbow
         puts formatter.dim("#{COLLAPSED} #{count_label(skipped.size, "database")} hidden: #{skipped.join(", ")}")
       end
 
-      # A quiet database says everything it has to say in one line. Nothing in
-      # the window means there is no table to draw either, so collapsing loses
-      # nothing - the counts below carry what the rows would have shown.
-      #
-      # RBW_DB=focus collapses the busy ones too, keeping the first database as
-      # the one you actually read. Pending migrations veto that: a database
-      # with work waiting is drawn in full however focused the run is.
+      # A quiet database has no table to draw, so one line says it all.
+      # RBW_DB=focus collapses all but the first database too, unless one has
+      # migrations pending.
       def collapse?(section)
         return false if Railbow::Params.db_full?
         return true if section.quiet?
-        # Focus shapes the sectioned view. Applying it to a merged table would
-        # drop every database but the first out of the very thing that exists
-        # to hold all of them.
+        # Focus would empty the inline table of every database but the first.
         return false if Railbow::Params.db_inline?
         return false unless Railbow::Params.db_focus?
 
         !focused?(section) && !section.pending_in_view?
       end
 
-      # The first database in database.yml, which is conventionally primary and
-      # is the one Rails migrates first.
+      # The first database in database.yml: conventionally primary, and the one
+      # Rails migrates first.
       def focused?(section)
         section.equal?(sections.first)
       end
@@ -279,9 +266,8 @@ module Railbow
         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.
+      # "last 10 of 50" when the floor overrode the window, since a bare
+      # "10 of 50" reads as "10 fell inside the window".
       def shown_count(section)
         shown = section.total_count - section.hidden_count
         section.floor_applied? ? "last #{shown}" : shown.to_s

data/lib/railbow/status/section.rb

@@ -12,16 +12,11 @@ require_relative "ghosts"
 
 module Railbow
   module Status
-    # One migrations directory's worth of db:migrate:status.
-    #
-    # Usually that is one database. Databases sharing a migrations_paths (the
-    # shape horizontal sharding takes) see the same files and differ only in
-    # what they have applied, so they merge into a single section carrying a
+    # One migrations directory's worth of db:migrate:status. Databases sharing
+    # a migrations_paths (horizontal sharding) merge into one section with a
     # status per database.
-    #
-    # Rows are built lazily, on first read, because merging has to finish
-    # before the status cells can be built. A section never prints: Printer
-    # owns output, which is what lets sections share column widths.
+    # Rows are built lazily because merging must finish first. Printer owns
+    # output, which is what lets sections share column widths.
     class Section
       # Index of the Date column, where calendar week ticks are drawn.
       TICK_COL = 2
@@ -42,8 +37,11 @@ module Railbow
       attr_reader :databases, :migrations_key, :state, :hidden_count, :total_count,
         :since_value, :entries, :ghosts
 
-      # True when the time window left too few rows and the floor topped the
-      # section back up, which is worth saying out loud: the table then shows
+      # What stock Rails prints for the databases in this section, shown if
+      # railbow fails to render it.
+      attr_accessor :fallback_output
+
+      # True when the floor topped the section back up, so the table shows
       # migrations from outside the window it advertises.
       def floor_applied?
         @floor_applied == true
@@ -64,8 +62,7 @@ module Railbow
         collect(pool)
       end
 
-      # The database this section is named after. Multi-database sections use
-      # #databases; this is the single-database convenience.
+      # Single-database convenience; multi-database sections use #databases.
       def database
         databases.first[:database]
       end
@@ -82,9 +79,8 @@ module Railbow
         migrations_key == other.migrations_key
       end
 
-      # Folds another database that runs the same migration files into this
-      # section: its statuses join the existing rows, its identity joins the
-      # header, and anything already built is discarded.
+      # Folds in another database running the same migration files. Anything
+      # already built is discarded.
       def merge!(other)
         other.entries.each do |version, entry|
           mine = (@entries[version] ||= {name: entry[:name], statuses: {}})
@@ -92,6 +88,7 @@ module Railbow
           mine[:statuses].merge!(entry[:statuses])
         end
         @databases.concat(other.databases)
+        @fallback_output = [fallback_output, other.fallback_output].compact.join
         @ghosts = other.ghosts.merge(@ghosts)
         @total_count = [@total_count, other.total_count].max
         @hidden_count = [@hidden_count, other.hidden_count].max
@@ -107,10 +104,8 @@ module Railbow
         databases.size > 1
       end
 
-      # Whether any row this section would render is still pending. Answered
-      # from the collected entries, so asking costs no git work - which is the
-      # point, since it is asked in order to decide whether to build the rows
-      # at all.
+      # Answered from collected entries, so it costs no git work: it is asked
+      # to decide whether to build the rows at all.
       def pending_in_view?
         entries.any? { |_, entry| entry[:statuses].value?("down") }
       end
@@ -223,11 +218,9 @@ module Railbow
         @latest_applied_version = applied.last&.dig(1)&.to_s
       end
 
-      # The time window is a soft limit. Whatever it leaves, the floor tops the
-      # result back up to RBW_SINCE_MIN rows, so a database with five
-      # migrations shows all five rather than hiding the two that happen to be
-      # old. The window is still what decides whether the section reads as
-      # recent - see #collect.
+      # The time window is a soft limit: the floor tops the result back up to
+      # RBW_SINCE_MIN rows. The window alone still decides whether the section
+      # reads as recent (see #collect).
       def apply_since_filter(db_list)
         since_cutoff = Railbow::Params.parse_since(since_value, context: "migrations")
         unless since_cutoff
@@ -235,7 +228,7 @@ module Railbow
           return db_list
         end
 
-        cutoff_version = since_cutoff.strftime("%Y%m%d%H%M%S").to_i
+        cutoff_version = Railbow::Clock.version_at(since_cutoff).to_i
         @window_count = db_list.count { |_, v, _| v.to_i >= cutoff_version }
 
         # Not Comparable#clamp: the floor can exceed the total, and clamp
@@ -313,13 +306,9 @@ module Railbow
         @calendar = build_calendar
       end
 
-      # 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.
+      # On a narrow terminal the table degrades instead of wrapping: the name
+      # column shrinks first, then Tables, the date (the Migration ID keeps the
+      # timestamp) and Who are dropped, in that order.
       def build_columns
         @name_col_width = needs_name_truncation? ? NAME_COL_WIDTH : nil
 
@@ -377,9 +366,8 @@ module Railbow
           name = entry[:name]
           statuses = entry[:statuses]
 
-          # A pending migration is not in effect yet: grey the whole row out so
-          # it reads as inactive next to the applied ones. In a shard group only
-          # a row pending everywhere reads as inactive.
+          # Pending rows are greyed out as not in effect; in a shard group only
+          # a row pending everywhere.
           @down_rows << idx if statuses.values.all? { |s| s == "down" }
 
           ghost = name.include?(NO_FILE) ? ghosts[version] : nil
@@ -426,8 +414,7 @@ module Railbow
         @status_aliases[status] || status
       end
 
-      # Builds the Migration Name cell and right-aligns whatever badges it
-      # carries. Yields a status indicator when the row earns one.
+      # Yields a status indicator when the row earns one.
       def name_cell(name:, version:, ghost:, latest_mig_date:)
         if ghost
           return with_tags(Ghosts.display_name(ghost), Ghosts.tag(ghost), strip: false)
@@ -468,8 +455,8 @@ module Railbow
         formatter.landed_tag(landed, fresh: latest_mig_date && landed >= latest_mig_date)
       end
 
-      # Pads the name so its tags sit flush against the right edge of the
-      # column. Falls back to a two-space gap when the column is uncapped.
+      # Tags sit flush right in a capped column, two spaces after the name
+      # otherwise.
       def with_tags(name, tags, strip: true)
         return name if tags.nil? || tags.empty?
         return "#{name}  #{tags}" unless @name_col_width
@@ -553,10 +540,7 @@ module Railbow
       end
 
       def version_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
+        Railbow::Clock.from_version(version)&.to_date
       end
     end
   end

data/lib/railbow/table/renderer.rb

@@ -61,10 +61,9 @@ module Railbow
 
         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.
+        # When even fully shrunk columns overflow the terminal, drop the most
+        # expendable column and render again. 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 } },
@@ -76,7 +75,6 @@ module Railbow
         resolved = resolve_widths(rows)
         shrink_to_fit!(resolved, rows)
 
-        # In oneline mode, truncate non-sticky non-last columns at resolved width
         if @compact[:oneline]
           rows = rows.map { |row|
             row.each_with_index.map { |cell, i|
@@ -134,7 +132,7 @@ module Railbow
           if col.fixed?
             w = col.width
           elsif i == last
-            # Last column: don't pad, will be wrapped if it overflows
+            # The last column flexes to the terminal, so it is never padded
             w = 0
           else
             header_w = display_width(effective_label(col))
@@ -205,8 +203,6 @@ module Railbow
           "#{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).
         # 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
@@ -216,7 +212,6 @@ module Railbow
 
         last_cell_raw = row[last].to_s
 
-        # Separator before the last column has index (last - 1)
         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
@@ -225,7 +220,6 @@ module Railbow
         pad = effective_padding
         sep = col_sep || theme.col_separator
 
-        # Truncate if configured via column settings
         if columns[last].truncate && columns[last].max_width
           last_cell_raw = truncate_str(last_cell_raw, columns[last].max_width)
         end
@@ -235,7 +229,7 @@ module Railbow
         prefix_width = compute_prefix_width(widths, last)
         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)
+        # A column's own truncate_fn knows its content (table tags fold into +N)
         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)
@@ -243,7 +237,6 @@ module Railbow
           return "#{prefix}#{sep}#{pad}#{last_cell_raw}#{RESET}#{pad}"
         end
 
-        # Truncate to terminal width (by whole words) instead of wrapping
         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)
@@ -251,7 +244,6 @@ module Railbow
           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, dim: dim, accent: columns[last].accent)
@@ -260,17 +252,21 @@ module Railbow
 
         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|
-            " " * display_width(strip_ansi(part))
-          }.join(sep)
-
-          wrapped = ansi_word_wrap(last_cell_raw, last_col_max)
-          "#{prefix}#{sep}#{pad}#{wrapped.first}#{RESET}#{pad}\n" +
-            wrapped[1..].map { |line| "#{blank_prefix}#{sep}#{pad}#{line}#{RESET}#{pad}" }.join("\n")
-        else
-          "#{prefix}#{sep}#{pad}#{last_cell_raw}#{RESET}#{pad}"
-        end
+        whole = "#{prefix}#{sep}#{pad}#{last_cell_raw}#{RESET}#{pad}"
+        return whole unless last_col_max && display_width(strip_ansi(last_cell_raw)) > last_col_max
+
+        # Wrap only when every line fits beside the fixed columns. Otherwise the
+        # terminal re-wraps each padded continuation line, leaving a blank line
+        # before every fragment, so the value stays on its row whole.
+        room = term_w - prefix_width - display_width(pad)
+        wrapped = ansi_word_wrap(last_cell_raw, last_col_max)
+        return whole unless wrapped.all? { |line| display_width(strip_ansi(line)) <= room }
+
+        blank_prefix = prefix_parts.map { |part|
+          " " * display_width(strip_ansi(part))
+        }.join(sep)
+        "#{prefix}#{sep}#{pad}#{wrapped.first}#{RESET}#{pad}\n" +
+          wrapped[1..].map { |line| "#{blank_prefix}#{sep}#{pad}#{line}#{RESET}#{pad}" }.join("\n")
       end
 
       def style_cell(content, highlight: false, ghost: false, dim: false, accent: false)
@@ -294,14 +290,13 @@ module Railbow
       def compute_prefix_width(widths, last)
         pad_w = display_width(effective_padding)
         sep_w = display_width(theme.col_separator)
-        # Each non-last column: pad + content + pad, joined by separator
+        # Padded fixed columns, the separator after each, and the last
+        # column's leading pad.
         total = 0
         (0...last).each do |i|
           total += pad_w + widths[i] + pad_w
         end
-        # Separators between columns + trailing separator before last column
         total += sep_w * last
-        # Plus pad on last column
         total += pad_w
         total
       end
@@ -413,11 +408,9 @@ module Railbow
         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.
+      # Every fixed column plus a reserve for the last column, which truncates
+      # down to MIN_LAST_COL but no further. Its header label counts too: it is
+      # drawn as-is, so a label wider than every cell would poke past the edge.
       def required_width(widths, rows)
         last = columns.size - 1
         last_w = rows.map { |row| display_width(strip_ansi(row[last].to_s)) }.max || 0
@@ -567,14 +560,13 @@ module Railbow
         value_aliases = @aliases[:values]
         return rows unless value_aliases&.any?
 
-        # 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
+          # Value aliases may name a renamed column by its original label
           original = @reverse_col_aliases[label]
           col_map[i] = value_aliases[original] if original && value_aliases[original]
         end
@@ -595,7 +587,7 @@ module Railbow
 
       def apply_cell_alias(cell, aliases_for_col)
         plain = strip_ansi(cell)
-        # Try exact match first, then prefix match for cells with appended indicators
+        # Exact match first, then a prefix match for cells with an indicator appended
         replacement = aliases_for_col[plain]
         if replacement
           cell.sub(plain) { replacement }

data/lib/railbow/tasks/migrate_status.rake

@@ -1,21 +1,19 @@
 # frozen_string_literal: true
 
+require "stringio"
 require_relative "../multi_db"
 require_relative "../status/help"
 require_relative "../status/printer"
 require_relative "../status/section"
 
-# Overrides the two DatabaseTasks methods db:migrate:status runs through.
-#
-# Rails calls migrate_status once per database, inside with_temporary_pool_for_each
-# - both for db:migrate:status and for db:migrate:status:<database_name>. Wrapping
-# the loop is what lets railbow render the databases together instead of one
-# blind table each.
+# Rails calls migrate_status once per database inside
+# with_temporary_pool_for_each, for db:migrate:status and
+# db:migrate:status:<database_name> alike. Wrapping that loop is what lets
+# railbow render the databases together instead of one blind table each.
 module Railbow
   module MigrateStatusFormatter
-    # Every supported Rails version (7.2 through 8.1) routes the per-database
-    # loop through here. Arguments are forwarded verbatim so Rails keeps
-    # applying its own defaults.
+    # Rails 7.2 through 8.1 all route through here. Arguments pass verbatim so
+    # Rails keeps applying its own defaults.
     def with_temporary_pool_for_each(*args, **kwargs, &block)
       Railbow::MultiDb.batch { super(*args, **kwargs, &block) }
     end
@@ -39,17 +37,35 @@ module Railbow
         Kernel.abort "Schema migrations table does not exist yet."
       end
 
-      section = Railbow::Status::Section.new(migration_connection_pool)
+      # Outside the guard: an error here is Rails' own (a database that is
+      # down) and must raise as it would without railbow. Captured while the
+      # pool is still open, it is also the fallback.
+      stock = railbow_capture_stdout { super }
 
-      # Without a batch (a direct call, or a Rails that no longer routes
-      # through with_temporary_pool_for_each) the section prints on its own,
-      # which is exactly the pre-multi-database behavior.
-      if batch
-        batch.add(section)
-      else
-        Railbow::Status::Printer.new([section]).print
+      Railbow.guard(-> { $stdout.write(stock) }) do
+        section = Railbow::Status::Section.new(migration_connection_pool)
+        section.fallback_output = stock
+
+        # No batch (a direct call, or a Rails that skips
+        # with_temporary_pool_for_each): the section prints on its own.
+        if batch
+          batch.add(section)
+        else
+          Railbow::Status::Printer.new([section]).print
+        end
       end
     end
+
+    private
+
+    def railbow_capture_stdout
+      original = $stdout
+      $stdout = StringIO.new
+      yield
+      $stdout.string
+    ensure
+      $stdout = original
+    end
   end
 end
 

data/lib/railbow/tasks/stats.rake

@@ -1,85 +1,21 @@
 # frozen_string_literal: true
 
-# Defer prepend until CodeStatistics is available.
-# CodeStatistics is autoloaded by Rails when the `stats` task runs,
-# but is not available at rake-file load time.
-#
-# Rails 8.1 namespaced the class to Rails::CodeStatistics, removed
-# the bare `require "code_statistics"` shim, and dropped the built-in
-# `stats` rake task. We handle both old and new layouts.
-Rails.application.config.after_initialize do
-  klass = nil
+require_relative "../stats_formatter"
 
-  begin
-    require "rails/code_statistics"
-    klass = Rails::CodeStatistics
-  rescue LoadError
-    # fall through
-  end
-
-  unless klass
-    begin
-      require "code_statistics"
-      klass = CodeStatistics
-    rescue LoadError
-      # code_statistics not available (e.g., production without railties dev deps)
-    end
-  end
+# Rails 7.2 runs `rails stats` as a rake task that never boots the app, so the
+# railtie initializer does not fire there: install from here as well.
+Railbow::StatsFormatter.install!
 
-  if klass
-    require_relative "../stats_formatter"
-    klass.prepend(Railbow::StatsFormatter)
-  end
-end
-
-# Rails 8.1 removed the built-in `stats` task.  Re-define it so that
-# `rails stats` / `rake stats` keeps working with Railbow formatting.
-unless Rake::Task.task_defined?(:stats)
+# Rails 8.1 dropped the `stats` rake task for the `rails stats` command; this
+# keeps `rake stats` working. Gated on the version, not task_defined?: railtie
+# tasks load before Rails' own, so on older Rails both would run.
+if Rails.gem_version >= Gem::Version.new("8.1")
   desc "Report code statistics (lines / LOC / classes / methods / M/C / LOC/M)"
   task stats: :environment do
-    klass = if defined?(Rails::CodeStatistics)
-      Rails::CodeStatistics
-    elsif defined?(CodeStatistics)
-      CodeStatistics
-    end
-
-    unless klass
-      abort "CodeStatistics is not available. Make sure railties is loaded."
-    end
-
-    stat_directories = [
-      ["Controllers", "app/controllers"],
-      ["Helpers", "app/helpers"],
-      ["Jobs", "app/jobs"],
-      ["Models", "app/models"],
-      ["Mailers", "app/mailers"],
-      ["Channels", "app/channels"],
-      ["JavaScripts", "app/javascript"],
-      ["Libraries", "lib"],
-      ["APIs", "app/apis"],
-      ["Controller tests", "test/controllers"],
-      ["Helper tests", "test/helpers"],
-      ["Job tests", "test/jobs"],
-      ["Model tests", "test/models"],
-      ["Mailer tests", "test/mailers"],
-      ["Channel tests", "test/channels"],
-      ["Integration tests", "test/integration"],
-      ["System tests", "test/system"],
-      ["Controller specs", "spec/controllers"],
-      ["Helper specs", "spec/helpers"],
-      ["Job specs", "spec/jobs"],
-      ["Model specs", "spec/models"],
-      ["Mailer specs", "spec/mailers"],
-      ["Channel specs", "spec/channels"],
-      ["Request specs", "spec/requests"],
-      ["System specs", "spec/system"]
-    ]
-
-    root = Rails.root.to_s
-    pairs = stat_directories
-      .map { |name, dir| [name, File.join(root, dir)] }
+    stat_directories = Rails::CodeStatistics.directories
+      .map { |name, dir| [name, Rails.root.join(dir)] }
       .select { |_, dir| File.directory?(dir) }
 
-    puts klass.new(*pairs)
+    Rails::CodeStatistics.new(*stat_directories).to_s
   end
 end

data/lib/railbow/version.rb

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