railbow 0.6.2 → 0.7.0

data/lib/railbow/migration_formatter.rb

@@ -10,30 +10,12 @@ module Railbow
     def announce(message)
       return super if Railbow.plain?
 
-      f = FORMATTER
-      migration_name = self.class.name&.demodulize || "Migration"
-
-      line = case message
-      when /migrating/i
-        f.cyan("#{f.emoji(:migrating)} #{migration_name}: migrating...")
-      when /migrated\s*\((\d+\.\d+)s\)/i
-        raw_seconds = Regexp.last_match(1).to_f
-        formatted = f.format_timing(raw_seconds)
-        f.green("#{f.emoji(:migrated)} #{migration_name}: migrated") + " (#{formatted} total)"
-      when /reverting/i
-        f.yellow("#{f.emoji(:reverting)} #{migration_name}: reverting...")
-      when /reverted\s*\((\d+\.\d+)s\)/i
-        raw_seconds = Regexp.last_match(1).to_f
-        formatted = f.format_timing(raw_seconds)
-        f.green("#{f.emoji(:reverted)} #{migration_name}: reverted") + " (#{formatted} total)"
-      else
-        "#{migration_name}: #{message}"
-      end
-
-      write ""
-      write line
+      Railbow.guard(-> { super }) { railbow_announce(message) }
     end
 
+    # The yield runs the migration itself, so it stays outside the guard: a
+    # failing migration must raise as usual, and a formatting error must not
+    # re-run it through super. The fallback prints what Rails would have.
     def say_with_time(message)
       return super { yield } if Railbow.plain?
 
@@ -41,9 +23,16 @@ module Railbow
       result = nil
       time = Benchmark.measure { result = yield }
 
-      timing = f.format_timing(time.real)
-      write "  #{f.green(f.emoji(:check))} #{message} → #{timing}"
-      say("#{result} rows", :subitem) if result.is_a?(Integer)
+      plain = lambda do
+        say(message)
+        say("%.4fs" % time.real, :subitem)
+        say("#{result} rows", :subitem) if result.is_a?(Integer)
+      end
+      Railbow.guard(plain) do
+        timing = f.format_timing(time.real)
+        write "  #{f.green(f.emoji(:check))} #{message} → #{timing}"
+        say("#{result} rows", :subitem) if result.is_a?(Integer)
+      end
 
       result
     end
@@ -60,5 +49,32 @@ module Railbow
 
       puts text
     end
+
+    private
+
+    def railbow_announce(message)
+      f = FORMATTER
+      migration_name = self.class.name&.demodulize || "Migration"
+
+      line = case message
+      when /migrating/i
+        f.cyan("#{f.emoji(:migrating)} #{migration_name}: migrating...")
+      when /migrated\s*\((\d+\.\d+)s\)/i
+        raw_seconds = Regexp.last_match(1).to_f
+        formatted = f.format_timing(raw_seconds)
+        f.green("#{f.emoji(:migrated)} #{migration_name}: migrated") + " (#{formatted} total)"
+      when /reverting/i
+        f.yellow("#{f.emoji(:reverting)} #{migration_name}: reverting...")
+      when /reverted\s*\((\d+\.\d+)s\)/i
+        raw_seconds = Regexp.last_match(1).to_f
+        formatted = f.format_timing(raw_seconds)
+        f.green("#{f.emoji(:reverted)} #{migration_name}: reverted") + " (#{formatted} total)"
+      else
+        "#{migration_name}: #{message}"
+      end
+
+      write ""
+      write line
+    end
   end
 end

data/lib/railbow/migration_parser.rb

@@ -4,7 +4,6 @@ require "active_support/inflector"
 
 module Railbow
   class MigrationParser
-    # Methods that take a single table name as the first argument
     SINGLE_TABLE_METHODS = %w[
       create_table drop_table change_table
       add_column remove_column rename_column change_column
@@ -15,7 +14,6 @@ module Railbow
       add_timestamps remove_timestamps
     ].freeze
 
-    # Methods that take two table names as arguments
     DUAL_TABLE_METHODS = %w[
       add_foreign_key remove_foreign_key
     ].freeze
@@ -25,7 +23,6 @@ module Railbow
     SINGLE_TABLE_PATTERN = /\b(?:#{(SINGLE_TABLE_METHODS + DUAL_TABLE_METHODS).join("|")})\s+[:"](\w+)/
     DUAL_TABLE_PATTERN = /\b(?:#{DUAL_TABLE_METHODS.join("|")})\s+[:"](\w+)["\s,]+[:"](\w+)/
 
-    # SQL keywords followed by a table name
     SQL_TABLE_PATTERNS = [
       /\bUPDATE\s+["']?(\w+)["']?/i,
       /\bINSERT\s+INTO\s+["']?(\w+)["']?/i,
@@ -36,21 +33,19 @@ module Railbow
       /\bCREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["']?(\w+)["']?/i
     ].freeze
 
-    # Helper/DSL calls that name their target table via a keyword argument, e.g.
-    # `convert_to_monthly_partitions(table: :apples)` or
-    # `remove_foreign_key :accounts, to_table: :owners`. Catches project-level
-    # migration helpers regardless of the method name. Bare `from:`/`to:` are
-    # deliberately not matched — `change_column_default :users, :status,
+    # A table named by keyword argument, which catches project-level helpers
+    # such as `convert_to_monthly_partitions(table: :apples)` whatever their
+    # name. Not bare `from:`/`to:`: `change_column_default :users, :status,
     # from: nil, to: "active"` would yield phantom tables.
     KEYWORD_TABLE_PATTERN = /\b(?:table|to_table|from_table):\s*[:"']?(\w+)/
 
     # Ruby `#` comments up to end of line, but not `#{}` interpolation.
     COMMENT_PATTERN = /#(?!\{).*/
 
-    # AR class-level query/mutation methods that strongly signal a constant is a model.
-    # Kept narrow on purpose — methods like `find`, `all`, `first`, `count`, `create`,
-    # `new`, `transaction`, `order`, `includes` collide with stdlib/non-model constants
-    # (e.g. Time.new, File.find, Array#first) and would produce false positives.
+    # AR class methods that strongly signal a constant is a model. Kept narrow:
+    # `find`, `all`, `first`, `count`, `create`, `new`, `transaction`, `order`,
+    # `includes` also exist on non-model constants (Time.new, File.find) and
+    # would produce false positives.
     MODEL_AR_METHODS = %w[
       find_each find_in_batches
       find_by find_by!
@@ -74,9 +69,8 @@ module Railbow
     def self.extract_tables_from_content(content)
       return [] if content.nil? || content.empty?
 
-      # Comments would otherwise produce phantom tables — an explanatory
-      # "# ALTER TABLE foo ..." or a commented-out create_table reads exactly
-      # like the real thing to the patterns below.
+      # An explanatory "# ALTER TABLE foo ..." or a commented-out create_table
+      # reads exactly like the real thing to the patterns below.
       content = content.gsub(COMMENT_PATTERN, "")
 
       tables = []
@@ -89,10 +83,9 @@ module Railbow
       content.scan(KEYWORD_TABLE_PATTERN) { |match| tables << match[0] }
       tables.uniq!
 
-      # Model-based detection is heuristic (a constant that happens to respond
-      # to one of these methods isn't necessarily an AR model). Only use it to
-      # supplement sparse DDL/SQL findings — skip once we already know of ≥2
-      # tables, and cap the final total at 2.
+      # Model references are a guess (a constant answering these methods need
+      # not be a model), so they only fill in when DDL and SQL found fewer
+      # than 2 tables, and never take the total past 2.
       if tables.size < 2
         content.scan(MODEL_REFERENCE_PATTERN) do |match|
           break if tables.size >= 2

data/lib/railbow/multi_db.rb

@@ -51,10 +51,24 @@ module Railbow
       def flush
         return if empty?
 
-        Railbow::Status::Printer.new(@sections, skipped: @skipped).print
+        if Railbow.plain?
+          print_fallback
+        else
+          Railbow.guard(-> { print_fallback }) do
+            Railbow::Status::Printer.new(@sections, skipped: @skipped).print
+          end
+        end
         @sections = []
         @skipped = []
       end
+
+      private
+
+      # The stock Rails tables captured per database while their pools were
+      # still open; see MigrateStatusFormatter#migrate_status.
+      def print_fallback
+        @sections.each { |section| $stdout.write(section.fallback_output.to_s) }
+      end
     end
 
     module_function

data/lib/railbow/name_collision_resolver.rb

@@ -3,13 +3,9 @@
 require_relative "name_formatter"
 
 module Railbow
-  # Detects and resolves collisions when multiple different names produce the
-  # same formatted output.  Works by progressively expanding pattern tokens
-  # (F → FF → FFF → FFFF, then L) until every distinct raw name maps to a
-  # unique formatted string.
-  #
-  # Names that share the same first+last name but differ only in middle name
-  # are treated as the same person and merged before collision detection.
+  # Makes distinct names format distinctly by widening pattern tokens (F to
+  # FFFF, then L) until no two collide. Names differing only in the middle
+  # name count as one person and share an output.
   #
   #   NameCollisionResolver.resolve(["John Doe", "Jane Doe"], "F L")
   #   # => {"John Doe" => "Jo D", "Jane Doe" => "Ja D"}
@@ -20,19 +16,16 @@ module Railbow
 
     # @param names [Array<String, nil>] raw author names (may contain duplicates/nils)
     # @param pattern [String] a NameFormatter pattern or preset name
-    # @return [Hash{String => String}] raw_name → disambiguated formatted name
+    # @return [Hash{String => String}] raw name to disambiguated formatted name
     def resolve(names, pattern)
       pattern = NameFormatter::PRESETS.fetch(pattern, pattern)
       uniq_names = names.compact.reject(&:empty?).uniq
 
-      # Merge names that are the same person (same first+last, differ only in middle)
       canonical, aliases = merge_same_person(uniq_names)
 
-      # Format every canonical name with the base pattern
       result = {}
       canonical.each { |n| result[n] = NameFormatter.format(n, pattern) }
 
-      # Find collision groups (different raw names → same formatted output)
       collisions = find_collisions(result)
       unless collisions.empty?
         tokens = parse_tokens(pattern)
@@ -41,16 +34,14 @@ module Railbow
         end
       end
 
-      # Expand aliases: all variant spellings get the same formatted output
       aliases.each { |variant, canon| result[variant] = result[canon] }
 
       result
     end
 
-    # --- private helpers ---
-
-    # Group names by (first, last) and pick the shortest as canonical.
-    # Returns [canonical_names, aliases_hash] where aliases maps variant → canonical.
+    # Groups names by first and last name; the shortest (no middle name) is
+    # canonical. Returns [canonical_names, aliases], aliases mapping each
+    # variant to its canonical name.
     def merge_same_person(names)
       groups = {}
       names.each do |name|
@@ -66,7 +57,6 @@ module Railbow
       canonical = []
       aliases = {}
       groups.each_value do |group|
-        # Pick shortest name as canonical (the one without middle name)
         canon = group.min_by(&:length)
         canonical << canon
         group.each { |name| aliases[name] = canon unless name == canon }
@@ -81,14 +71,12 @@ module Railbow
         .transform_values { |pairs| pairs.map(&:first) }
     end
 
-    # Resolve a single collision group by progressively expanding tokens.
-    # Only names that still collide continue to be expanded; once a name
-    # becomes unique it keeps its current (minimal) expansion.
+    # Widens tokens, all F tokens before L, only for names that still collide:
+    # a name that becomes unique keeps its shortest distinct form.
     def resolve_group(raw_names, base_pattern, base_tokens, result)
       remaining = raw_names.dup
       tokens = base_tokens.map(&:dup)
 
-      # Expansion order: exhaust all F tokens first, then L tokens
       expansion_order = tokens.each_index.sort_by { |i| (tokens[i][:type] == "F") ? 0 : 1 }
 
       expansion_order.each do |ti|
@@ -102,15 +90,14 @@ module Railbow
 
           remaining.each { |n| result[n] = NameFormatter.format(n, current_pattern) }
 
-          # Check collisions only within this group (not the full result),
-          # so expansion from one group can't chase collisions with other groups
+          # Within this group only, so one group's expansion never chases
+          # collisions with another's.
           still_colliding = find_collisions(result.slice(*raw_names))
           if still_colliding.empty?
             remaining = []
             break
           end
 
-          # Only keep expanding names that still collide within the group
           remaining = still_colliding.values.flatten
         end
 
@@ -119,7 +106,7 @@ module Railbow
 
       return if remaining.empty?
 
-      # Last resort: numeric suffixes
+      # Fully expanded and still equal: number them.
       find_collisions(result.slice(*remaining)).each_value do |group|
         group[1..].each_with_index do |name, i|
           suffix = SUPERSCRIPTS[i] || (i + 2).to_s
@@ -128,7 +115,7 @@ module Railbow
       end
     end
 
-    # Parse pattern into token descriptors: [{type:, length:, maxed:}, ...]
+    # [{type:, length:, maxed:}, ...] for each token in the pattern.
     def parse_tokens(pattern)
       tokens = []
       pattern.scan(NameFormatter::TOKEN_RE) do |match|
@@ -139,7 +126,7 @@ module Railbow
       tokens
     end
 
-    # Rebuild a pattern string from token descriptors, preserving literals.
+    # The original pattern with its tokens resized, literals kept.
     def rebuild_pattern(tokens, original_pattern)
       ti = 0
       original_pattern.gsub(NameFormatter::TOKEN_RE) do

data/lib/railbow/name_formatter.rb

@@ -1,22 +1,22 @@
 # frozen_string_literal: true
 
 module Railbow
-  # Formats person names using a pattern language inspired by date-format strings.
+  # Formats person names with a pattern language modeled on date formats.
   #
-  # Tokens (repeat the letter to control length; 4+ means full word):
-  #   F / FF / FFF / FFFF+  — first name (1 char, 2 chars, … , full)
-  #   L / LL / LLL / LLLL+  — last name
-  #   M / MM / MMM / MMMM+  — middle name(s)
+  # Tokens (the letter count is the length; 4 or more means the full word):
+  #   F / FF / FFF / FFFF+   first name (1 char, 2 chars, 3 chars, full)
+  #   L / LL / LLL / LLLL+   last name
+  #   M / MM / MMM / MMMM+   middle name(s)
   #
   # Any other characters (spaces, dots, commas) are literals and pass through.
   #
   # Named presets:
-  #   "initials"        → "F L"
-  #   "short"           → "FF L"
-  #   "first_name"      → "FFFF"
-  #   "last_name"       → "LLLL"
-  #   "full_name"       → "FFFF MMMM LLLL"
-  #   "full_name_short" → "FFFF L."
+  #   "initials"        => "F L"
+  #   "short"           => "FF L"
+  #   "first_name"      => "FFFF"
+  #   "last_name"       => "LLLL"
+  #   "full_name"       => "FFFF MMMM LLLL"
+  #   "full_name_short" => "FFFF L."
   module NameFormatter
     PRESETS = {
       "initials" => "F L",
@@ -34,8 +34,7 @@ module Railbow
 
     module_function
 
-    # Format a name according to a pattern or preset name.
-    # Returns "" for nil/empty input.
+    # Formats a name by a pattern or preset name. "" for a nil or empty name.
     def format(name, pattern)
       return "" if name.nil? || name.empty?
 
@@ -59,14 +58,14 @@ module Railbow
         expanded.empty? ? EMPTY : expanded
       end
 
-      # Remove sentinels and any adjacent non-letter literals (dots, commas, spaces)
+      # A missing part takes its adjacent literals with it, so "F L." on a
+      # one-word name gives no stray dot.
       result.gsub(/[^a-zA-Z\x00]*\x00[^a-zA-Z\x00]*/, " ")
         .gsub(/  +/, " ")
         .strip
     end
 
-    # Truncate a word to `len` chars (4+ means full), preserving original case
-    # for full words, capitalizing otherwise.
+    # A full word keeps its case; a cut one is capitalized.
     def truncate(word, len)
       return "" if word.nil? || word.empty?
 

data/lib/railbow/notes_formatter.rb

@@ -2,6 +2,7 @@
 
 require "zlib"
 require "date"
+require_relative "clock"
 require_relative "git_utils"
 require_relative "formatters/base"
 require_relative "logo"
@@ -30,9 +31,18 @@ module Railbow
 
     PALETTE = Formatters::Base::TABLE_PALETTE
 
+    # git blame's author-mail for lines not committed yet
+    UNCOMMITTED_EMAIL = "not.committed.yet"
+
     def display(results, options = {})
       return super if Railbow.plain?
 
+      Railbow.guard(-> { super }) { railbow_display(results, options) }
+    end
+
+    private
+
+    def railbow_display(results, options = {})
       if Railbow::Params.help?
         print_help
         return
@@ -45,7 +55,6 @@ module Railbow
       since_date = Railbow::Params.parse_since(since_val, context: "annotations")
       git_needed = %w[all me].include?(author_mode) || since_date || sort_mode == "date"
 
-      # Build blame cache for all files if git features are needed
       blame_cache = {}
       if git_needed
         results.each_key do |source_file|
@@ -53,7 +62,7 @@ module Railbow
         end
       end
 
-      # Flatten annotations into a list for filtering/sorting
+      # Flattened so filtering and sorting can cross file boundaries
       entries = []
       results.each do |source_file, annotations|
         annotations.each do |annotation|
@@ -66,7 +75,6 @@ module Railbow
         end
       end
 
-      # Filter by SINCE
       skipped = 0
       if since_date
         before = entries.size
@@ -76,7 +84,7 @@ module Railbow
         skipped = before - entries.size
       end
 
-      # Sort by date (newest first) when requested
+      # Newest first; entries with no blame date sink to the end
       if sort_mode == "date"
         entries.sort_by! do |entry|
           d = entry.dig(:blame, :date)
@@ -84,21 +92,23 @@ module Railbow
         end
       end
 
-      # Determine "me" identity
       git_email = nil
       if author_mode == "me"
         git_email = current_git_email
       end
 
-      # Determine max location width for alignment when showing metadata
+      # Locations pad to one width so the author and date line up
       show_date = git_needed
       max_loc_width = 0
       author_colors = nil
       author_display = {}
       if author_mode == "all"
-        author_names = entries.filter_map { |e| e.dig(:blame, :author) }.uniq
+        author_names = entries.reject { |e| uncommitted?(e[:blame]) }
+          .filter_map { |e| e.dig(:blame, :author) }.uniq
         author_colors = ColorAssigner.new(author_names)
         author_display = Railbow::Params.format_authors(author_names)
+        # Uncommitted notes have no author; dashes fill the author column instead
+        no_author = "-" * (author_display.values.map(&:length).max || 4)
       end
       if show_date || author_mode == "all"
         entries.each do |entry|
@@ -107,11 +117,10 @@ module Railbow
         end
       end
 
-      # Group entries back by file for bar coloring
+      # A file with several notes gets its own bar color; a lone note's bar is dim
       file_counts = Hash.new(0)
       entries.each { |e| file_counts[e[:file]] += 1 }
 
-      # Display
       entries.each do |entry|
         source_file = entry[:file]
         annotation = entry[:annotation]
@@ -127,7 +136,6 @@ module Railbow
           DIM
         end
         colored_bar = "#{bar_color}#{BAR}#{RESET}"
-        # When highlighting "me", use bright white bar
         colored_bar = "#{WHITE}#{BAR}#{RESET}" if is_mine
 
         tag = annotation.tag
@@ -136,7 +144,6 @@ module Railbow
         colored_tag = "#{tag_color}#{BOLD}#{tag}#{RESET}"
         note = annotation.text.to_s.encode("UTF-8", invalid: :replace, undef: :replace)
 
-        # Build the file:line row with optional author+date
         loc_line = " #{colored_bar} #{location}"
 
         if author_mode == "all" && blame_info
@@ -144,7 +151,11 @@ module Railbow
           author_name = author_display[raw_author] || Railbow::Params.format_author(raw_author)
           blame_date = blame_info[:date] ? blame_info[:date].strftime("%Y-%m-%d") : ""
           padding = " " * [(max_loc_width - location.length + 2), 2].max
-          colored_author = "#{author_colors.color_for(raw_author)}#{author_name}#{RESET}"
+          colored_author = if uncommitted?(blame_info)
+            "#{DIM}#{no_author}#{RESET}"
+          else
+            "#{author_colors.color_for(raw_author)}#{author_name}#{RESET}"
+          end
           meta = "#{colored_author}  #{DIM}#{blame_date}#{RESET}"
           loc_line = " #{colored_bar} #{location}#{padding}#{meta}"
         elsif author_mode == "me" && is_mine && blame_info
@@ -164,7 +175,6 @@ module Railbow
         indent_width = 1 + 1 + 1 + 3 + tag.length + 1 # " " + BAR + " " + "   " + TAG + " "
         continuation_prefix = " #{colored_bar}   #{" " * (tag.length + 1)}"
 
-        # Apply "me" highlighting to note text
         if is_mine
           tag_str = "#{WHITE}#{tag}#{RESET} "
         end
@@ -198,13 +208,14 @@ module Railbow
       puts
     end
 
-    private
-
     def blame_file(path)
       return {} unless File.exist?(path)
 
-      output, status = Railbow::GitUtils.capture2("blame", "--porcelain", path)
-      return {} unless status.success?
+      # stderr is captured so "no such path in HEAD" never reaches the terminal
+      output, _err, status = Railbow::GitUtils.capture3("blame", "--porcelain", path)
+      # Untracked or ignored files (e.g. app/assets/builds) count as uncommitted,
+      # the way git blame dates uncommitted lines, so RBW_SINCE keeps them
+      return Hash.new(uncommitted_blame) unless status.success?
 
       result = {}
       current_line = nil
@@ -227,8 +238,8 @@ module Railbow
         elsif line.start_with?("author-time ")
           current_time = line.sub("author-time ", "").to_i
         elsif line.start_with?("\t") && current_line
-          # End of this blame entry — store it
-          date = current_time ? Time.at(current_time).to_date : nil
+          # The tab-prefixed source line closes a porcelain blame entry
+          date = current_time ? Railbow::Clock.in_zone(Time.at(current_time)).to_date : nil
           result[current_line] = {
             author: current_author,
             email: current_email,
@@ -240,6 +251,18 @@ module Railbow
       result
     end
 
+    def uncommitted_blame
+      {
+        author: "Not Committed Yet",
+        email: UNCOMMITTED_EMAIL,
+        date: Railbow::Clock.in_zone(Time.now).to_date
+      }.freeze
+    end
+
+    def uncommitted?(blame_info)
+      blame_info&.dig(:email) == UNCOMMITTED_EMAIL
+    end
+
     def current_git_email
       output, _status = Railbow::GitUtils.capture2("config", "user.email")
       output.strip.downcase