railbow 0.1.0

data/lib/railbow/init.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require_relative "config"
+require "fileutils"
+
+module Railbow
+  module Init
+    module_function
+
+    TEMPLATE = <<~YAML
+      # Railbow configuration
+      # https://github.com/amberpixels/railbow
+      #
+      # Config layers (each overrides the previous):
+      #   1. Gem defaults (built-in)
+      #   2. Global:  ~/.config/railbow/config.yml
+      #   3. Project: .railbow.yml        (commit to git)
+      #   4. Local:   .railbow.local.yml  (gitignored, personal overrides)
+      #
+      # Every key can also be overridden via RBW_* environment variables.
+
+      # Time window for migrations to display (e.g. 30d, 2mo, 1y, all)
+      since: "70d"
+
+      # Sort order: file (by filename/version) or date (by timestamp)
+      # sort: "file"
+
+      # Git integration (comma-separated compound value):
+      #   author       — add Author column (same as author:all)
+      #   author:me    — highlight your own migrations
+      #   author:all   — show all authors
+      #   diff         — tag migrations by git origin branch
+      #   base:<branch> — base branch for diff (default: auto-detected)
+      #   mask:auto    — auto-extract ticket id from branch name
+      #   mask:<re>    — custom regex to extract branch label, e.g. mask:(WS-[^/]+)/
+      git: "author:all,diff,mask:auto"
+
+      # Author display format — preset or custom pattern (FF L, FFF LL, etc.):
+      #   initials (J D), short (Jo D), first_name (John), last_name (Doe),
+      #   full_name (John Doe), full_name_short (John D.)
+      author_format: "short"
+
+      # View mode (comma-separated): calendar, tables
+      view: "calendar,tables"
+
+      # Calendar options: wticks (show week tick separators)
+      calendar: "wticks"
+
+      # Date format: full, rel, short, or custom(%b %d, %Y)
+      # date: "full"
+
+      # Compact mode (comma-separated):
+      #   oneline       — one line per migration
+      #   dense         — reduce padding
+      #   noheader      — hide table headers
+      #   maxw:<N>      — max column width
+      #   hide:<col>    — hide a column (repeatable)
+      # compact: ""
+
+      # Rename column headers and cell values in table output
+      aliases:
+        columns:
+          Status: Live
+        values:
+          Status:
+            up: "↑↑"
+            down: "↓↓"
+          # Verb:
+          #   GET: G
+          #   POST: P
+    YAML
+
+    def global_path
+      File.join(Config.global_dir, "config.yml")
+    end
+
+    def project_path
+      File.join(Config.root, ".railbow.yml")
+    end
+
+    def run(input: $stdin, output: $stdout)
+      output.puts "  Where should the config be created?"
+      output.puts ""
+      output.puts "    1) Global:  #{global_path}"
+      output.puts "    2) Project: #{project_path}"
+      output.puts "    3) Cancel"
+      output.puts ""
+      output.print "  Choose [1/2/3]: "
+      output.flush
+
+      choice = input.gets&.strip
+      target = case choice
+      when "1" then global_path
+      when "2" then project_path
+      else
+        output.puts "  Cancelled."
+        return
+      end
+
+      if File.exist?(target)
+        output.puts "  Already exists: #{target}"
+        output.puts "  Remove it first if you want to regenerate."
+        return
+      end
+
+      FileUtils.mkdir_p(File.dirname(target))
+      File.write(target, TEMPLATE)
+      output.puts ""
+      output.puts "  Created: #{target}"
+    end
+  end
+end

data/lib/railbow/logo.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Railbow
+  LOGO_SEGMENTS = [
+    ["░█▀▀█", "░█▀▀█", "▀█▀", "░█───", "░█▀▀█", "░█▀▀▀█", "░█───░█"],
+    ["░█▄▄▀", "░█▄▄█", "░█─", "░█───", "░█▀▀▄", "░█──░█", "░█─█─░█"],
+    ["░█─░█", "░█─░█", "▄█▄", "░█▄▄█", "░█▄▄█", "░█▄▄▄█", "─░█░█─"]
+  ].freeze
+
+  LOGO_COLORS = [
+    "\e[38;5;196m", "\e[38;5;208m", "\e[38;5;220m",
+    "\e[38;5;40m", "\e[38;5;33m", "\e[38;5;93m", "\e[38;5;163m"
+  ].freeze
+
+  RESET = "\e[0m"
+
+  def self.print_logo
+    LOGO_SEGMENTS.each do |segments|
+      print " "
+      segments.each_with_index do |seg, i|
+        print "#{LOGO_COLORS[i]}#{seg}#{RESET}"
+        print " " unless i == segments.length - 1
+      end
+      puts
+    end
+  end
+end

data/lib/railbow/migration_formatter.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+require "benchmark"
+require_relative "formatters/base"
+
+module Railbow
+  module MigrationFormatter
+    FORMATTER = Formatters::Base.new.freeze
+
+    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
+    end
+
+    def say_with_time(message)
+      return super { yield } if Railbow.plain?
+
+      f = FORMATTER
+      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)
+
+      result
+    end
+
+    def say(message, subitem = false)
+      return super if Railbow.plain?
+
+      prefix = subitem ? "     " : "  "
+      write("#{prefix}#{message}")
+    end
+
+    def write(text = "")
+      return super if Railbow.plain?
+
+      puts text
+    end
+  end
+end

data/lib/railbow/migration_parser.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+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
+      add_index remove_index
+      add_reference remove_reference
+      add_belongs_to remove_belongs_to
+      add_timestamps remove_timestamps
+    ].freeze
+
+    # Methods that take two table names as arguments
+    DUAL_TABLE_METHODS = %w[
+      add_foreign_key remove_foreign_key
+    ].freeze
+
+    SINGLE_TABLE_PATTERN = /\b(?:#{SINGLE_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,
+      /\bDELETE\s+FROM\s+["']?(\w+)["']?/i,
+      /\bALTER\s+TABLE\s+["']?(\w+)["']?/i,
+      /\bTRUNCATE\s+(?:TABLE\s+)?["']?(\w+)["']?/i,
+      /\bDROP\s+TABLE\s+(?:IF\s+EXISTS\s+)?["']?(\w+)["']?/i,
+      /\bCREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?["']?(\w+)["']?/i
+    ].freeze
+
+    # 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.
+    MODEL_AR_METHODS = %w[
+      find_each find_in_batches
+      find_by find_by!
+      find_or_create_by find_or_create_by!
+      find_or_initialize_by
+      where update_all delete_all destroy_all
+      upsert_all insert_all
+      pluck pick
+      in_batches
+    ].freeze
+
+    MODEL_REFERENCE_PATTERN = /\b([A-Z][A-Za-z0-9]*(?:::[A-Z][A-Za-z0-9]*)*)\.(?:#{MODEL_AR_METHODS.join("|")})\b/
+
+    def self.extract_tables(filepath)
+      return [] if filepath.nil? || filepath.empty?
+      return [] unless File.exist?(filepath)
+
+      extract_tables_from_content(File.read(filepath))
+    end
+
+    def self.extract_tables_from_content(content)
+      return [] if content.nil? || content.empty?
+
+      tables = []
+
+      content.scan(SINGLE_TABLE_PATTERN) { |match| tables << match[0] }
+      content.scan(DUAL_TABLE_PATTERN) { |match| tables.concat(match) }
+      SQL_TABLE_PATTERNS.each do |pattern|
+        content.scan(pattern) { |match| tables << match[0] }
+      end
+      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.
+      if tables.size < 2
+        content.scan(MODEL_REFERENCE_PATTERN) do |match|
+          break if tables.size >= 2
+          table = ActiveSupport::Inflector.tableize(match[0].split("::").last)
+          tables << table unless tables.include?(table)
+        end
+      end
+
+      tables
+    end
+  end
+end

data/lib/railbow/name_collision_resolver.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+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.
+  #
+  #   NameCollisionResolver.resolve(["John Doe", "Jane Doe"], "F L")
+  #   # => {"John Doe" => "Jo D", "Jane Doe" => "Ja D"}
+  module NameCollisionResolver
+    SUPERSCRIPTS = %w[² ³ ⁴ ⁵ ⁶ ⁷ ⁸ ⁹].freeze
+
+    module_function
+
+    # @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
+    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)
+        collisions.each do |_formatted, raw_names|
+          resolve_group(raw_names, pattern, tokens, result)
+        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.
+    def merge_same_person(names)
+      groups = {}
+      names.each do |name|
+        parts = name.split(/[\s._-]+/)
+        key = if parts.size >= 2
+          [parts.first.downcase, parts.last.downcase]
+        else
+          [parts.first&.downcase, nil]
+        end
+        (groups[key] ||= []) << name
+      end
+
+      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 }
+      end
+
+      [canonical, aliases]
+    end
+
+    def find_collisions(mapping)
+      mapping.group_by { |_raw, fmt| fmt }
+        .select { |_fmt, pairs| pairs.size > 1 }
+        .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.
+    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|
+        tok = tokens[ti]
+        next if tok[:maxed]
+
+        until tok[:maxed]
+          tok[:length] += 1
+          tok[:maxed] = true if tok[:length] >= 4
+          current_pattern = rebuild_pattern(tokens, base_pattern)
+
+          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
+          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
+
+        break if remaining.empty?
+      end
+
+      return if remaining.empty?
+
+      # Last resort: numeric suffixes
+      find_collisions(result.slice(*remaining)).each_value do |group|
+        group[1..].each_with_index do |name, i|
+          suffix = SUPERSCRIPTS[i] || (i + 2).to_s
+          result[name] = "#{result[name]}#{suffix}"
+        end
+      end
+    end
+
+    # Parse pattern into token descriptors: [{type:, length:, maxed:}, ...]
+    def parse_tokens(pattern)
+      tokens = []
+      pattern.scan(NameFormatter::TOKEN_RE) do |match|
+        type = match[0]
+        len = Regexp.last_match(0).length
+        tokens << {type: type, length: len, maxed: len >= 4}
+      end
+      tokens
+    end
+
+    # Rebuild a pattern string from token descriptors, preserving literals.
+    def rebuild_pattern(tokens, original_pattern)
+      ti = 0
+      original_pattern.gsub(NameFormatter::TOKEN_RE) do
+        tok = tokens[ti]
+        ti += 1
+        tok[:type] * tok[:length]
+      end
+    end
+
+    private_class_method :merge_same_person, :find_collisions, :resolve_group,
+      :parse_tokens, :rebuild_pattern
+  end
+end

data/lib/railbow/name_formatter.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Railbow
+  # Formats person names using a pattern language inspired by date-format strings.
+  #
+  # 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)
+  #
+  # 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."
+  module NameFormatter
+    PRESETS = {
+      "initials" => "F L",
+      "short" => "FF L",
+      "first_name" => "FFFF",
+      "last_name" => "LLLL",
+      "full_name" => "FFFF MMMM LLLL",
+      "full_name_short" => "FFFF L."
+    }.freeze
+
+    TOKEN_RE = /([FLM])\1*/
+    # Sentinel inserted when a token expands to empty, so surrounding
+    # literals that only make sense next to a value can be cleaned up.
+    EMPTY = "\x00"
+
+    module_function
+
+    # Format a name according to a pattern or preset name.
+    # Returns "" for nil/empty input.
+    def format(name, pattern)
+      return "" if name.nil? || name.empty?
+
+      pattern = PRESETS.fetch(pattern, pattern)
+      parts = name.split(/[\s._-]+/)
+
+      first = parts.first || ""
+      last = (parts.size > 1) ? parts.last : ""
+      middle = (parts.size > 2) ? parts[1..-2] : []
+
+      result = pattern.gsub(TOKEN_RE) do |match|
+        letter = match[0]
+        len = match.length
+
+        expanded = case letter
+        when "F" then truncate(first, len)
+        when "L" then truncate(last, len)
+        when "M" then middle.map { |m| truncate(m, len) }.join(" ")
+        end
+
+        expanded.empty? ? EMPTY : expanded
+      end
+
+      # Remove sentinels and any adjacent non-letter literals (dots, commas, spaces)
+      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.
+    def truncate(word, len)
+      return "" if word.nil? || word.empty?
+
+      if len >= 4 || len >= word.length
+        word
+      else
+        word[0, len].capitalize
+      end
+    end
+
+    private_class_method :truncate
+  end
+end