railbow 0.5.0 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d599ddd7c1bd3a12893312ab22f40ff75def87f5d85d42dd2ee5a11da7183225
-  data.tar.gz: 4413568aafb22c8cf2b1025bbd6f90696f4da6f3bcead307c48ffeac3e96f04c
+  metadata.gz: de5537d849ecc612b80236db0a17543d6fad2ea18aeb0c3872dd48ced2dfdf5f
+  data.tar.gz: a6833af7828722eee5153a48bcf96f7008760948324337c46af90ecee3a86520
 SHA512:
-  metadata.gz: a02d2dda50ba6fa9ae4b04d166ebc51148532dcfccd5ab1a7777179d14767d2bb87b2fc4a9a5d3aadbb0eeae114a68f5365cd3bfd0d27286958b192f5fa43967
-  data.tar.gz: 5ad80b381822e25a9078093f82c8b52deccae5940334ce45645883e2d4c06a81070e2710876f58fc8af949cc3b96009369e141eb9945c3a1941233561c31f486
+  metadata.gz: e9d7ae02de3f895c3300dbcd547ad52ddb0309a53a999b2ad52694bc3d46430d90a0518451721df72868fed730f9b60e1c66ffa0e616d01207d2908b560950d0
+  data.tar.gz: 9fd9c71099808af2b42b186f13ff31112e9195e39af6b94f9650f649e6c7e1b7346d06133992229f9d354a24b955dd2c98ed9b4c77c85a1d727c31c7800bbdb6

data/CHANGELOG.md

@@ -5,6 +5,38 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.6.2] - 2026-09-21
+
+### Changed
+
+- Demo fixtures, README examples and spec data now use the PawShop sample
+  project throughout.
+
+## [0.6.1] - 2026-08-10
+
+### Fixed
+
+- On a narrow terminal, a migration's branch and landing badges no longer
+  vanish from the `db:migrate:status` name column, leaving a stray `...`
+  hanging in the padding where they used to sit. The badges are padded flush
+  against the right edge of the column, which is exactly where the width
+  budget was cutting; the name now gives up the space instead and the badges
+  stay put. When a badge is so wide that keeping it would leave under 12
+  columns for the name, it is dropped outright rather than squeezing the name
+  down to nothing.
+
+## [0.6.0] - 2026-08-03
+
+### Fixed
+
+- On a terminal too narrow for the full `db:migrate:status` row, the table no
+  longer wraps mid-cell. A width budget degrades it gracefully instead, one
+  sacrifice at a time until the rows fit: the Migration Name column narrows
+  first (down to 24 columns), then the Tables column is dropped, then the
+  formatted date (the raw Migration ID still carries the timestamp), and as a
+  last resort the Who column. Each table gives up only as much as its terminal
+  demands, and a wide terminal renders exactly as before.
+
 ## [0.5.0] - 2026-07-28
 
 ### Added

data/README.md

@@ -158,13 +158,13 @@ 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
+📊 2 databases · primary, log
 
-──── 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
+──── primary · myapp_development ──── 12 of 240 ────────────────────────
+ ↑↑  │ 20260721130000 │ 2026-07-21 13:00:00 │ Partition visit reminders    ● visit_reminders
+ ↓↓  │ 20260727170000 │ 2026-07-27 17:00:00 │ Add microchip ids to animals ● animals
 
-⋯ raw · 5 migrations, all applied · latest Jul 22 2026
+⋯ log · 5 migrations, all applied · latest Jul 22 2026
 ```
 
 **A database with migrations pending is always expanded**, however focused the
@@ -179,14 +179,14 @@ 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
+──── primary · myapp_development ──── 12 of 240 ────────────────────────
+ ↑↑  │ 20260721130000 │ 2026-07-21 13:00:00 │ Partition visit reminders    ● visit_reminders
 
-──── raw · raw_development ─────────────────────────────────────────────
- ↑↑  │ 20260722120000 │ 2026-07-22 12:00:00 │ Drop archived activity logs  ● archived_activity_logs
+──── log · log_development ─────────────────────────────────────────────
+ ↑↑  │ 20260722120000 │ 2026-07-22 12:00:00 │ Drop archived visit logs     ● archived_visit_logs
 ```
 
-A section header counts what it is showing: `122 of 1500` means 122 fell inside
+A section header counts what it is showing: `12 of 240` means 12 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.

data/lib/railbow/demo/fixtures.rb

@@ -5,15 +5,15 @@ require "date"
 module Railbow
   module Demo
     module Fixtures
-      # Fictional veterinary SaaS — "PawClinic"
+      # Fictional pet shop SaaS — "PawShop"
       # 4 authors: Alice Chen, Bob Wilson, Carol Davis, Me (current user)
       DEMO_USER_NAME = "Me"
       DEMO_USER_EMAIL = "me@example.com"
 
       AUTHORS = {
-        alice: {name: "Alice Chen", email: "alice@pawclinic.dev"},
-        bob: {name: "Bob Wilson", email: "bob@pawclinic.dev"},
-        carol: {name: "Carol Davis", email: "carol@pawclinic.dev"},
+        alice: {name: "Alice Chen", email: "alice@pawshop.dev"},
+        bob: {name: "Bob Wilson", email: "bob@pawshop.dev"},
+        carol: {name: "Carol Davis", email: "carol@pawshop.dev"},
         me: {name: DEMO_USER_NAME, email: DEMO_USER_EMAIL}
       }.freeze
 

data/lib/railbow/demo/status_demo.rb

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

data/lib/railbow/formatters/base.rb

@@ -34,6 +34,9 @@ module Railbow
 
       BRIGHT_WHITE = "\e[1;97m"
 
+      # Narrowest name a tagged cell will accept before the tags are dropped.
+      NAME_TAGS_FLOOR = 12
+
       def dim(str) = "#{DIM}#{str}#{RESET}"
       def green(str) = "#{GREEN}#{str}#{RESET}"
       def yellow(str) = "#{YELLOW}#{str}#{RESET}"
@@ -115,6 +118,32 @@ module Railbow
         "+#{total}"
       end
 
+      # Re-fits a Migration Name cell whose tags (branch, landed) were padded
+      # flush against the right edge of a wider column. Truncating such a cell
+      # from the right eats the tags whole and leaves a bare ellipsis floating
+      # after the padding, so the name gives up the space instead and the tags
+      # stay put. Below NAME_TAGS_FLOOR there is no room for both and the tags
+      # are dropped outright - the name is what the row is about.
+      def name_with_tags_fitted(cell, max_width)
+        str = cell.to_s
+        return truncate_ansi(str, max_width) if display_width(strip_ansi(str)) <= max_width
+
+        split = str.rindex(/\s{2,}\e\[/)
+        return truncate_ansi(str, max_width) unless split
+
+        # rindex stops at the last two spaces of the padding run, so the rest of
+        # it still hangs off the name and would be truncated in place of it.
+        name = str[0...split].rstrip
+        tags = str[split..].lstrip
+        tags_width = display_width(strip_ansi(tags))
+        name_room = max_width - tags_width - 2
+        return truncate_ansi(name, max_width) if name_room < NAME_TAGS_FLOOR
+
+        name = truncate_ansi(name, name_room)
+        padding = max_width - display_width(strip_ansi(name)) - tags_width
+        "#{name}#{" " * [padding, 2].max}#{tags}"
+      end
+
       def format_timing(seconds)
         milliseconds = (seconds * 1000).round(1)
 

data/lib/railbow/init.rb

@@ -37,7 +37,7 @@ module Railbow
       #   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-[^/]+)/
+      #   mask:<re>    - custom regex to extract branch label, e.g. mask:(PS-[^/]+)/
       git: "author:all,diff,mask:auto"
 
       # Author display format - preset or custom pattern (FF L, FFF LL, etc.):

data/lib/railbow/params.rb

@@ -189,7 +189,7 @@ module Railbow
     end
 
     # Built-in regex for extracting ticket/task identifiers from branch names.
-    # Matches patterns like: ws-123, 123, abc123, ab-123-456, feat/ws-1234, feat/123-some-feature
+    # Matches patterns like: ps-123, 123, abc123, ab-123-456, feat/ps-1234, feat/123-some-feature
     TICKET_RE = /(?:^|\/)([a-z]{1,5}-?\d+(?:-\d+)*|\d+(?:-\d+)*)/i
 
     # Extract a ticket identifier from a branch name.

data/lib/railbow/status/help.rb

@@ -86,7 +86,7 @@ module Railbow
                                      diff       - tag migrations by git origin
                                      base:<branch> - base branch for diff (default: auto-detected)
                                      mask:<re>  - regex to extract branch label
-                                                  e.g. mask:(WS-[^/]+)/
+                                                  e.g. mask:(PS-[^/]+)/
                                      mask:auto  - auto-extract ticket id from branch name
 
             RBW_PLAIN=1              Disable Railbow formatting (plain Rails output)
@@ -109,7 +109,7 @@ module Railbow
             RBW_DATE='custom(%b %d, %Y)' rake db:migrate:status
             RBW_GIT=diff rake db:migrate:status
             RBW_GIT=diff,base:develop rake db:migrate:status
-            RBW_GIT=diff,mask:(WS-[^/]+)/ rake db:migrate:status
+            RBW_GIT=diff,mask:(PS-[^/]+)/ rake db:migrate:status
             RBW_DB= rake db:migrate:status
             RBW_DB=only:primary rake db:migrate:status
             RBW_DB=inline rake db:migrate:status

data/lib/railbow/status/printer.rb

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

data/lib/railbow/status/section.rb

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

data/lib/railbow/table/column.rb

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

data/lib/railbow/table/renderer.rb

@@ -14,15 +14,25 @@ module Railbow
       GHOST_FG = "\e[38;5;217m"   # warm pink foreground for contrast
       DIMMED_FG = "\e[38;5;242m"  # muted grey - a row that is not currently in effect
 
+      # The flexing last column never gets less than this from the terminal.
+      MIN_LAST_COL = 10
+      # Default floor for shrinkable columns that name no shrink_floor.
+      MIN_SHRINK_WIDTH = 16
+
       attr_reader :columns, :theme
 
       # min_widths raises the resolved width of each column to at least the
       # given value, which is how several tables rendered in one run line their
       # columns up with each other. An explicit compact maxw still wins.
-      def initialize(columns:, theme:, compact: {}, aliases: {}, min_widths: nil)
+      #
+      # term_width overrides the detected terminal width; render re-invokes
+      # itself through a reduced renderer when the budget drops a column, and
+      # the width it fits must be the same one this instance measured.
+      def initialize(columns:, theme:, compact: {}, aliases: {}, min_widths: nil, term_width: nil)
         @compact = compact
         @aliases = aliases
         @min_widths = min_widths
+        @term_width = term_width
         @reverse_col_aliases = aliases[:columns]&.invert || {}
         @columns = apply_hidden_columns(columns)
         @theme = theme
@@ -50,7 +60,21 @@ module Railbow
         return "" if columns.empty?
 
         rows = prepare_rows(rows)
+
+        # Width budget: when even fully shrunk columns cannot bring the table
+        # under the terminal width, sacrifice the most expendable column and
+        # render without it. One column per pass - the reduced renderer asks
+        # again with what is left.
+        if (drop = drop_index_to_fit(rows))
+          return dropped_renderer(drop).render(
+            rows.map { |row| row.reject.with_index { |_, i| i == drop } },
+            separators: separators, highlight_rows: highlight_rows, ghost_rows: ghost_rows,
+            dim_rows: dim_rows, tick_rows: tick_rows, tick_col: shift_tick_col(tick_col, drop)
+          )
+        end
+
         resolved = resolve_widths(rows)
+        shrink_to_fit!(resolved, rows)
 
         # In oneline mode, truncate non-sticky non-last columns at resolved width
         if @compact[:oneline]
@@ -209,7 +233,7 @@ module Railbow
         last_cell_plain = strip_ansi(last_cell_raw)
         term_w = terminal_width
         prefix_width = compute_prefix_width(widths, last)
-        last_col_max = term_w ? [term_w - prefix_width - display_width(pad), 10].max : nil
+        last_col_max = term_w ? [term_w - prefix_width - display_width(pad), MIN_LAST_COL].max : nil
 
         # Use custom truncate_fn if available (e.g. table tags with +N)
         if columns[last].truncate_fn && last_col_max &&
@@ -305,12 +329,102 @@ module Railbow
       end
 
       def terminal_width
+        return @term_width if @term_width
         return $stdout.winsize[1] if $stdout.respond_to?(:winsize) && $stdout.tty?
         nil
       rescue
         nil
       end
 
+      # --- Width budget ---
+
+      # The index of the column to sacrifice, or nil while shrinking alone can
+      # still fit the table into the terminal.
+      def drop_index_to_fit(rows)
+        return nil unless terminal_width
+        return nil if rows.empty?
+
+        candidate = columns.each_index
+          .select { |i| columns[i].droppable }
+          .min_by { |i| columns[i].droppable }
+        return nil unless candidate
+        return nil if required_width(fully_shrunk_widths(rows), rows) <= terminal_width
+
+        candidate
+      end
+
+      def dropped_renderer(drop)
+        self.class.new(
+          columns: columns.reject.with_index { |_, i| i == drop },
+          theme: theme,
+          compact: @compact,
+          aliases: @aliases,
+          min_widths: @min_widths&.reject&.with_index { |_, i| i == drop },
+          term_width: terminal_width
+        )
+      end
+
+      def shift_tick_col(tick_col, drop)
+        return nil if tick_col.nil? || drop == tick_col
+
+        (drop < tick_col) ? tick_col - 1 : tick_col
+      end
+
+      # Narrows shrinkable columns just enough to close the overflow, and
+      # re-truncates their cells to the new width.
+      def shrink_to_fit!(widths, rows)
+        return if rows.empty? || !terminal_width
+
+        overflow = required_width(widths, rows) - terminal_width
+        return if overflow <= 0
+
+        last = columns.size - 1
+        columns.each_with_index do |col, i|
+          break if overflow <= 0
+          next if i == last || !col.shrinkable
+
+          cut = [widths[i] - shrink_floor(col), overflow].min
+          next if cut <= 0
+
+          widths[i] -= cut
+          overflow -= cut
+          # A column that knows how to re-fit its own cells does it here: a
+          # blind cut from the right would drop whatever the cell parked at its
+          # far edge (right-aligned tags) instead of shortening the content.
+          fit = col.truncate_fn || method(:truncate_ansi)
+          rows.each { |row| row[i] = fit.call(row[i].to_s, widths[i]) }
+        end
+      end
+
+      # Never below the header label: a column narrower than its own header
+      # would push the header row out of alignment.
+      def shrink_floor(col)
+        [col.shrink_floor || MIN_SHRINK_WIDTH, display_width(effective_label(col))].max
+      end
+
+      def fully_shrunk_widths(rows)
+        widths = resolve_widths(rows)
+        last = columns.size - 1
+        columns.each_with_index do |col, i|
+          next if i == last || !col.shrinkable
+
+          widths[i] = [widths[i], shrink_floor(col)].min
+        end
+        widths
+      end
+
+      # What the table needs from the terminal: every fixed column plus a
+      # reserve for the flexing last column, which truncates down to
+      # MIN_LAST_COL but never below it. The last column's header label counts
+      # too - it is drawn as-is, so a label wider than every cell would poke
+      # past the terminal edge otherwise.
+      def required_width(widths, rows)
+        last = columns.size - 1
+        last_w = rows.map { |row| display_width(strip_ansi(row[last].to_s)) }.max || 0
+        last_w = [last_w, display_width(effective_label(columns[last]))].max unless @compact[:noheader]
+        compute_prefix_width(widths, last) + [last_w, MIN_LAST_COL].min + display_width(effective_padding)
+      end
+
       def ansi_word_wrap(str, max_width)
         plain = strip_ansi(str)
         plain_lines = word_wrap(plain, max_width)

data/lib/railbow/text_utils.rb

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

data/lib/railbow/version.rb

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

metadata

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