table_tennis 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 03c38407a65288ded066cc1986f53453d8dafe6e51096ea597e843c8ad115afb
-  data.tar.gz: a76db1bbb2a0ef775a629f71f6f76c2ee5c67a42255ba9856c5ccb9f66bb89bf
+  metadata.gz: 1b4fb283f2a6461183187e0833f77aa8934f40c2611a88b4e65da5a7b0e0b51a
+  data.tar.gz: 22b0ed370736791f838fedc5a8b3044664250f4014608525807f81d28040b4b6
 SHA512:
-  metadata.gz: 51d515f45a6f62d6ede57e5b8d752ccd5a637dc107d170e526693600d91e9a91988cef1ee570104c413951759cf673e80d569076544a137398ac09bf1b2735e7
-  data.tar.gz: 3e269c16f3a95e4e948d55d8713d5349d2e5b5527b97c0fd5722d8cee88e17f182078d720b9bafb6d233dc9feb76f209a8b17780549ad03468817dcaaeb2aedb
+  metadata.gz: 24e7cff664a8edb52ecde9ef90b458480e535bc8895d6dc7a067c64ef344964a3fbc9474ad0ea97cdb3f4123aeb2212ebddac9de296628785b557d959dd803e2
+  data.tar.gz: 99b2fc156f0960472f8d969c89deb4067e9dbcc466826f0b55dd02d0beeacbf493f1ba0fe00843c1f3cc80eb9b927a167e268af6609726a7b4ba9eab363ece5e

data/README.md

@@ -71,6 +71,7 @@ options = {
 | `color_scales` | ─ | Color code a column of floats, similar to the "conditional formatting" feature in Google Sheets. See [docs below](#color-scales). |
 | `color` | `nil` | Are ANSI colors enabled? Specify `true` or `false`, or leave it as nil to autodetect. Autodetect will turn on color unless redirecting to a file. When using autodetect, you can force it on by setting `ENV["FORCE_COLOR"]`, or off with `ENV["NO_COLOR"]`. |
 | `columns` | `nil` | Manually set which columns to include. Leave unset to show all columns.
+| `delims` | true | Format ints & floats with comma delimiter, like 123,456. |
 | `digits` | `3` | Format floats to this number of digits. TableTennis will look for either `Float` cells or string floats. |
 | `layout` | `true` | This controls column widths. Leave unset or use `true` for autolayout. Autolayout will shrink the table to fit inside the terminal. `false` turns off layout and columns will be full width. Use an int to fix all columns to a certain width, or a hash to just set a few. |
 | `mark` | ─ | `mark` is a way to highlight specific columns with a nice color. For example, use `mark: ->(row) { row[:planet] == "tatooine" }` to highlight those rows. Your lambda can also return a specific color if you want.
@@ -81,6 +82,7 @@ options = {
 | `strftime` | see → | strftime string for formatting Date/Time objects. The default is `"%Y-%m-%d"`, which looks like `2025-04-21`  |
 | `theme` | nil | When unset, will be autodetected based on terminal background color. If autodetect fails the theme defaults to :dark. You can also manually specify `:dark`, `:light` or `:ansi`. If colors are turned off this setting has no effect.|
 | `title` | ─ | Add a title line to the table. |
+| `titleize` | ─ | Titleize column names, so `person_id` becomes `Person`. |
 | `zebra` | `false` | Turn on zebra stripes. |
 
 ### Color Scales

data/justfile

@@ -13,8 +13,6 @@ check: lint test
 
 ci: check
 
-demo-watch *ARGS:
-  @watchexec --stop-timeout=0 --clear clear table-tennis-demo {{ARGS}}
 
 format:
   @just banner format...
@@ -30,6 +28,9 @@ lint:
 pry:
   bundle exec pry -I lib -r table_tennis.rb
 
+tennis-watch *ARGS:
+  @watchexec --stop-timeout=0 --clear clear tennis {{ARGS}}
+
 test *ARGS:
   @just banner rake test {{ARGS}}
   @bundle exec rake test {{ARGS}}

data/lib/table_tennis/column.rb

@@ -1,33 +1,46 @@
 module TableTennis
-  #
   # A single column in a table. The data is actually stored in the rows, but it
-  # can be enumerated from here. Mostly used for layout calculations.
-  #
-
+  # can be enumerated from here.
   class Column
+    extend Forwardable
     include Enumerable
+    include Util::Inspectable
     prepend MemoWise
 
-    attr_reader :name
+    # c is the column index
+    attr_reader :name, :data, :c
     attr_accessor :header, :width
+    def_delegators :data, *%i[rows]
 
-    def initialize(name, data)
-      @name, @data = name, data
+    def initialize(data, name, c)
+      @name, @data, @c = name, data, c
       @header = name.to_s
+      if data&.config&.titleize?
+        @header = Util::Strings.titleize(@header)
+      end
     end
 
     def each(&block)
       return to_enum(__method__) unless block_given?
-      @data.rows.each { yield(_1[name]) }
+      rows.each { yield(_1[c]) }
       self
     end
 
-    def each_index(&block)
-      return to_enum(__method__) unless block_given?
-      @data.rows.each_index { yield(_1) }
+    def map!(&block) = rows.each { _1[c] = yield(_1[c]) }
+
+    # what type is this column? Sample 100 rows and guess. Will be nil if we aren't sure.
+    def type
+      samples = rows.sample(100).map { _1[c] }
+      Util::Identify.identify_column(samples)
     end
+    memo_wise :type
 
-    def map!(&block) = @data.rows.each { _1[name] = yield(_1[name]) }
+    def alignment
+      case type
+      when :float, :int then :right
+      else :left
+      end
+    end
 
     def truncate(stop)
       @header = Util::Strings.truncate(header, stop)

data/lib/table_tennis/config.rb

@@ -10,6 +10,7 @@ module TableTennis
       color: nil, # true/false/nil (detect)
       columns: nil, # array of symbols, or inferred from rows
       debug: false, # true for debug output
+      delims: true, # true for numeric delimeters
       digits: 3, # format floats
       layout: true, # true/false/int or hash of columns -> width. true to infer
       mark: nil, # lambda returning boolean or symbol to mark rows in output
@@ -20,6 +21,7 @@ module TableTennis
       strftime: nil, # string for formatting dates
       theme: nil,  # :dark, :light or :ansi. :dark is the default
       title: nil, # string for table title, if any
+      titleize: false, # if true, titleize column names
       zebra: false, # turn on zebra stripes
     }.freeze
 
@@ -27,7 +29,7 @@ module TableTennis
       options = [OPTIONS, TableTennis.defaults, options].reduce { _1.merge(_2 || {}) }
       options[:color] = Config.detect_color? if options[:color].nil?
       options[:theme] = Config.detect_theme if options[:theme].nil?
-      options[:debug] = true if ENV["TM_DEBUG"]
+      options[:debug] = true if ENV["TT_DEBUG"]
       options.each { self[_1] = _2 }
 
       yield self if block_given?
@@ -43,6 +45,7 @@ module TableTennis
     {
       color: :bool,
       debug: :bool,
+      delims: :bool,
       digits: :int,
       mark: :proc,
       placeholder: :str,
@@ -50,6 +53,7 @@ module TableTennis
       save: :str,
       strftime: :str,
       title: :str,
+      titleize: :bool,
       zebra: :bool,
     }.each do |option, type|
       define_method(:"#{option}=") do |value|
@@ -206,7 +210,12 @@ module TableTennis
     end
 
     def _str(option, value)
-      value = value.to_s if option == :title && value.is_a?(Symbol)
+      case option
+      when :placeholder
+        value = "" if value.nil?
+      when :title
+        value = value.to_s if value.is_a?(Symbol)
+      end
       validate(option, value) do
         "expected string" if !value.is_a?(String)
       end

data/lib/table_tennis/row.rb

@@ -1,9 +1,11 @@
 module TableTennis
-  # A single table row (a hash). Doesn't have much behavior.
-  class Row < Hash
-    def initialize(column_names, fat_row)
-      super()
-      column_names.each { self[_1] = fat_row[_1] }
+  # We use this to store each row of data in the table. Row is an array, but with `r` too.
+  class Row < Array
+    # r is the index of this row
+    attr_reader :r
+    def initialize(r, values)
+      super(values)
+      @r = r
     end
   end
 end

data/lib/table_tennis/stage/base.rb

@@ -3,17 +3,15 @@ module TableTennis
     # Base class for each stage of the rendering pipeline, mostly here just to
     # delegate to TableData.
     class Base
-      prepend MemoWise
       extend Forwardable
+      prepend MemoWise
       include Util::Inspectable
 
       attr_reader :data
       def_delegators :data, *%i[column_names columns config input_rows rows theme]
       def_delegators :data, *%i[debug debug_if_slow]
 
-      def initialize(data)
-        @data = data
-      end
+      def initialize(data) = @data = data
     end
   end
 end

data/lib/table_tennis/stage/format.rb

@@ -1,68 +1,99 @@
 module TableTennis
   module Stage
-    # This stage "formats" the table by injesting cells that contain various
-    # ruby objects and formatting each one as a string. `rows` are formatted in
-    # place.
-    #
-    # For performance reasons, formatting is implemented as a series of lambdas.
-    # Each fn must return a string. Minimize the number of times we examine each
-    # cell. Float detection/printing can be slow. Favor .match? over =~.
+    # This stage "formats" the table by injesting columns that contain various
+    # ruby objects and formatting each as a string. Cells are formatted in place
+    # by transforming rows.
     class Format < Base
-      attr_reader :fns
-
       def run
-        setup_fns
+        # Sample each column and infer column types. Determine which fn_xxx to
+        # use for each column.
+        fns = columns.map do
+          fn = case _1.type
+          when :float then :fn_float
+          when :int then :fn_int
+          when :time then :fn_time if config.strftime
+          end
+          fn || :fn_default
+        end
+
         rows.each do |row|
-          row.transform_values! do
-            fn = fns[fn_for(_1)] || fns[:other]
-            fn.call(_1)
+          row.each_index do
+            value = row[_1]
+            # Try to format using the column fn. This can return nil. For
+            # example, a float column and value is nil, not a float, etc.
+            formatted = send(fns[_1], value)
+            # If the column formatter failed, use the default formatter
+            row[_1] = formatted || fn_default(value) || config.placeholder
           end
         end
       end
 
-      def fn_for(value)
+      #
+      # fns for each column type
+      #
+
+      def fn_float(value)
+        # cap memo_wise
+        @_memo_wise[__method__].tap { _1.clear if _1.length > 5000 }
+
         case value
-        when String then float?(value) ? :floatstr : :str
-        when Float then :float
-        when Date, Time, DateTime then :time
-        else
-          if value.respond_to?(:acts_like_time)
-            # Rails TimeWithZone
-            return :time
-          end
-          :other
+        when String then fmt_number(to_f(value), digits: config.digits) if Util::Identify.number?(value)
+        when Numeric then fmt_number(value, digits: config.digits)
         end
       end
+      memo_wise :fn_float
 
-      def float?(str) = str.match?(/^-?\d+[.]\d+$/)
-
-      def setup_fns
-        placeholder = config.placeholder || ""
-        str = ->(s) do
-          # normalize whitespace
-          if s.match?(/\s/)
-            s = s.strip.gsub("\n", "\\n").gsub("\r", "\\r")
-          end
-          # replace empty values with placeholder
-          s = placeholder if s.empty?
-          s
+      def fn_int(value)
+        case value
+        when String then fmt_number(to_i(value)) if Util::Identify.int?(value)
+        when Integer then fmt_number(value)
         end
-        other = ->(x) { str.call(x.to_s) }
+      end
+
+      def fn_time(value)
+        value.strftime(config.strftime) if Util::Identify.time?(value)
+      end
+
+      #
+      # primitives
+      #
+
+      # default formatting. cleanup whitespace
+      def fn_default(value)
+        return if value.nil?
+        str = (value.is_a?(String) ? value : value.to_s)
+        str = str.strip.gsub("\n", "\\n").gsub("\r", "\\r") if str.match?(/\s/)
+        return if str.empty?
+        str
+      end
 
-        # default behavior
-        @fns = {other:, str:}
+      DELIMS = /(\d)(?=(\d\d\d)+(?!\d))/
 
-        # now mix in optional float/time formatters
-        if config.digits
-          fmt = "%.#{config.digits}f"
-          @to_f_cache = Hash.new { _1[_2] = fmt % _2.to_f }
-          fns[:float] = -> { fmt % _1 }
-          fns[:floatstr] = -> { @to_f_cache[_1] }
+      # this is a bit slow but easy to understand
+      def fmt_number(x, digits: nil)
+        delims = config.delims && (x >= 1000 || x <= -1000)
+
+        # convert to string (and honor digits)
+        x = if digits
+          "%0.#{digits}f" % x
+        else
+          # be careful not to leave a trailing .0
+          x = x.to_i if x.is_a?(Float) && (x % 1) == 0
+          x.to_s
         end
-        if config.strftime
-          fns[:time] = -> { _1.strftime(config.strftime) }
+
+        if delims
+          x, r = x.split(".")
+          x.gsub!(DELIMS) { "#{_1}," }
+          x = "#{x}.#{r}" if r
         end
+
+        x
       end
+
+      # str to_xxx that are resistant to commas
+      def to_f(str) = str.delete(",").to_f
+      def to_i(str) = str.delete(",").to_i
     end
   end
 end

data/lib/table_tennis/stage/painter.rb

@@ -19,7 +19,7 @@ module TableTennis
         paint_row_numbers if config.row_numbers
         paint_rows if config.mark || config.zebra
         paint_columns if config.color_scales
-        paint_placeholders if config.placeholder
+        paint_placeholders
       end
 
       protected
@@ -42,43 +42,96 @@ module TableTennis
           if config.zebra? && r.even?
             style = :zebra
           end
-          if (mark_style = config.mark&.call(input_rows[r]))
-            style = mark_style.is_a?(Symbol) ? mark_style : :mark
+          if (user_mark = config.mark&.call(input_rows[r]))
+            style = mark_style(user_mark)
           end
           set_style(r:, style:) if style
         end
       end
 
+      # This is the main entry point for color scales. Color scaling is pretty simple.
+      # Scale.interpolate uses a `t` param to interpolate between the gradient colors. We pick a "t"
+      # for each cell to get the right color. For numeric columns, this is easy: t = (cell_value -
+      # min) / (max - min). For non-numeric columns, we do roughly the same thing but we pick
+      # "cell_value" by creating a sorted list of all cells in the column, then using the position
+      # of each string as the cell value. So if the column contained A..Z, A would bend up being t=0
+      # and Z would be t=1.
       def paint_columns
         columns.each.with_index do |column, c|
-          scale = config.color_scales[column.name]
-          next if !scale
-
-          floats = column.map { _1.to_f if _1 =~ /^-?\d+(\.\d+)?$/ }
-          min, max = floats.compact.minmax
-          next if min == max # edge case
-
-          # color
-          column.each_index.zip(floats).each do |r, f|
-            next if !f
-            t = (f - min) / (max - min)
-            bg = Util::Scale.interpolate(scale, t)
-            fg = Util::Colors.contrast(bg)
-            set_style(r:, c:, style: [fg, bg])
+          if (scale = config.color_scales[column.name])
+            if column.type == :float || column.type == :int
+              scale_numeric(c, scale)
+            else
+              scale_non_numeric(c, scale)
+            end
           end
         end
       end
 
       def paint_placeholders
-        placeholder = config.placeholder
         rows.each.with_index do |row, r|
-          row.each_value.with_index do |value, c|
-            if value == placeholder
+          row.each.with_index do |value, c|
+            if value == config.placeholder
               set_style(r:, c:, style: :chrome)
             end
           end
         end
       end
+
+      #
+      # helpers
+      #
+
+      def scale_numeric(c, scale)
+        # focus on rows that contain values
+        focus = rows.select { Util::Identify.number?(_1[c]) }
+        return if focus.length < 2 # edge case
+        floats = focus.map { _1[c].delete(",").to_f }
+
+        # find a "t" for each row
+        min, max = floats.minmax
+        return if min == max # edge case
+        t = floats.map { (_1 - min) / (max - min) }
+
+        # now interpolate
+        scale(c, scale, focus, t)
+      end
+
+      def scale_non_numeric(c, scale)
+        # focus on rows that contain values
+        focus = rows.select { _1[c] != config.placeholder }
+
+        # find a "t" for each row. since this column is non-numeric, we create a sorted list of all
+        # values in the column and use the position of each cell value to calculate t. So if the
+        # column contained A..Z, A would end up being t=0 and Z would be t=1.
+        all_values = focus.map { _1[c] }.uniq.sort
+        return if all_values.length < 2 # edge case
+        all_values = all_values.map.with_index do |value, ii|
+          t = ii.to_f / (all_values.length - 1)
+          [value, t]
+        end.to_h
+        t = focus.map { all_values[_1[c]] }
+
+        # now interpolate
+        scale(c, scale, focus, t)
+      end
+
+      # interpolate column c to paint a color scale
+      def scale(c, scale, rows, t)
+        rows.map(&:r).zip(t).each do |r, t|
+          bg = Util::Scale.interpolate(scale, t)
+          fg = Util::Colors.contrast(bg)
+          set_style(r:, c:, style: [fg, bg])
+        end
+      end
+
+      def mark_style(user_mark)
+        case user_mark
+        when String, Symbol then [nil, user_mark] # assume bg color
+        when Array then user_mark # a Paint array
+        else; :mark # default
+        end
+      end
     end
   end
 end

data/lib/table_tennis/stage/render.rb

@@ -58,7 +58,7 @@ module TableTennis
         row_style = data.get_style(r:)
 
         # assemble line by rendering cells
-        enum = (r != :header) ? rows[r].each_value : columns.map(&:header)
+        enum = (r != :header) ? rows[r].each : columns.map(&:header)
         line = enum.map.with_index do |value, c|
           render_cell(value, r, c, row_style)
         end.join(" #{pipe} ")
@@ -83,7 +83,14 @@ module TableTennis
         value = value.gsub(search) { paint(_1, :search) } if search
 
         # pad and paint
-        value = "#{value}#{" " * whitespace}" if whitespace > 0
+        if whitespace > 0
+          spaces = " " * whitespace
+          value = if columns[c].alignment == :left
+            "#{value}#{spaces}"
+          else
+            "#{spaces}#{value}"
+          end
+        end
         paint(value, style)
       end
 

data/lib/table_tennis/table.rb

@@ -15,14 +15,14 @@ module TableTennis
     include Util::Inspectable
 
     attr_reader :data
-    def_delegators :data, *%i[column_names columns config input_rows rows]
+    def_delegators :data, *%i[column_names columns config rows]
     def_delegators :data, *%i[debug debug_if_slow]
 
     # Create a new table with options (see Config or README). This is typically
     # called using TableTennis.new.
-    def initialize(input_rows, options = {}, &block)
+    def initialize(rows, options = {}, &block)
       config = Config.new(options, &block)
-      @data = TableData.new(config:, input_rows:)
+      @data = TableData.new(config:, rows:)
       sanity!
       save(config.save) if config.save
     end
@@ -41,7 +41,7 @@ module TableTennis
     def save(path)
       headers = column_names
       CSV.open(path, "wb", headers:, write_headers: true) do |csv|
-        rows.each { csv << _1.values }
+        rows.each { csv << _1 }
       end
     end
 
@@ -59,7 +59,7 @@ module TableTennis
         next if rows.empty? # ignore on empty data
         invalid = config[key].keys - data.column_names
         if !invalid.empty?
-          raise ArgumentError, "#{key} columns `#{invalid.join(", ")}` not found in input data"
+          raise ArgumentError, "#{key} columns `#{invalid.join(", ")}` not in (#{column_names})"
         end
       end
     end

data/lib/table_tennis/table_data.rb

@@ -9,15 +9,22 @@ module TableTennis
   #    account.
   # 3) Use fat_rows to calculate rows & columns.
   #
-  # Rows are hash tables and column names are symbols.
+  #  Generally we try to use this language:
+  # - `row` is a a Row, an array of cells
+  # - `column` is a Column. It doesn't store any data directly but it
+  #    can be enumerated.
+  # - `name` is a column.name
+  # - `value` is the value of a cell
+  # - `r` and `c` are row and column indexes
+  #
   class TableData
     prepend MemoWise
     include Util::Inspectable
 
     attr_accessor :config, :input_rows, :styles
 
-    def initialize(input_rows:, config: nil)
-      @config, @input_rows = config, input_rows
+    def initialize(rows:, config: nil)
+      @config, @input_rows = config, rows
 
       if !config && !ENV["MINITEST"]
         raise ArgumentError, "must provide a config"
@@ -45,7 +52,7 @@ module TableTennis
           raise ArgumentError, "specified column `#{name}` not found in any row of input data"
         end
       end
-      names.map { Column.new(_1, self) }
+      names.map.with_index { Column.new(self, _1, _2) }
     end
     memo_wise :columns
 
@@ -58,7 +65,7 @@ module TableTennis
     # memoization to cache the result of fat_rows, and then we create final rows
     # with just the columns we want
     def rows
-      fat_rows.map { Row.new(column_names, _1) }
+      fat_rows.map.with_index { Row.new(_2, _1.values_at(*column_names)) }
     end
     memo_wise :rows
 
@@ -68,14 +75,10 @@ module TableTennis
 
     # Set the style for a cell, row or column. The "style" is a
     # theme symbol or hex color.
-    def set_style(style:, r: nil, c: nil)
-      styles[[r, c]] = style
-    end
+    def set_style(style:, r: nil, c: nil) = styles[[r, c]] = style
 
     # Get the style for a cell, row or column.
-    def get_style(r: nil, c: nil)
-      styles[[r, c]]
-    end
+    def get_style(r: nil, c: nil) = styles[[r, c]]
 
     # what is the width of the columns, not including chrome?
     def data_width = columns.sum(&:width)
@@ -93,9 +96,6 @@ module TableTennis
     #
     def chrome_width = columns.length * 3 + 1
 
-    # this is handy for tests
-    def first_cell = rows.first.values&.first
-
     # for debugging
     def debug(str)
       return if !config&.debug

data/lib/table_tennis/theme.rb

@@ -64,12 +64,16 @@ module TableTennis
     # - a color that works with Colors.get (#fff, or :bold, or "steelblue")
     # - an array of colors
     def paint(str, value)
+      # cap memo_wise
+      @_memo_wise[__method__].tap { _1.clear if _1.length > 5000 }
+
       if (codes = codes(value))
         str = str.gsub(RESET, "#{RESET}#{codes}")
         str = "#{codes}#{str}#{RESET}"
       end
       str
     end
+    memo_wise :paint
 
     # for debugging, mostly
     def self.info

data/lib/table_tennis/util/colors.rb

@@ -2,6 +2,8 @@ module TableTennis
   module Util
     # Named color names and misc color helpers.
     module Colors
+      prepend MemoWise
+
       module_function
 
       NAMED = {
@@ -444,6 +446,7 @@ module TableTennis
       def contrast(bg)
         dark?(bg) ? "white" : "black"
       end
+      memo_wise self: :contrast
 
       # [r,g,b] => "#rrggbb"
       def to_hex(rgb)
@@ -452,7 +455,7 @@ module TableTennis
 
       # "#?(rgb|rrggbb|rrrrggggbbbb)" => [r,g,b]
       def to_rgb(hex)
-        if !hex.match(/\A#?([0-9a-f]+)\z/i)
+        if !hex.match(/\A#?([0-9a-f]+)\Z/i)
           return
         end
         hex = $1

data/lib/table_tennis/util/identify.rb

@@ -0,0 +1,51 @@
+module TableTennis
+  #
+  # This module helps to classifying columns and values. Are they floats? Dates?
+  # Floats strings?
+  #
+
+  module Util
+    # Helpers for measuring and truncating strings.
+    module Identify
+      prepend MemoWise
+
+      module_function
+
+      def identify_column(values)
+        # grab 100, what do we have?
+        types = values.filter_map { identify(_1) }.uniq
+        case types.length
+        when 0 # all nils, too bad
+        when 1
+          types.first # one type, it wins
+        when 2
+          :float if types.sort == %i[float int]
+        end
+        # all mixed up, can't do much with it
+      end
+
+      # Try to identify a single cell value. Peer into strings.
+      def identify(value)
+        case value
+        when nil, "" then return nil
+        when String
+          return :float if float?(value)
+          return :int if int?(value)
+          return nil if na?(value)
+          return :string
+        when Float then return :float
+        when Numeric then return :int
+        end
+        return :time if time?(value)
+        :unknown
+      end
+
+      # tests
+      def na?(str) = str.match?(/\A(n\/a|na|none|\s+)\Z/i)
+      def number?(str) = str.match?(/\A-?[\d,]+(?:[.]?\d*)?\Z/)
+      def float?(str) = str.match?(/\A-?[\d,]+[.]\d*\Z/)
+      def int?(str) = str.match?(/\A-?[\d,]+\Z/)
+      def time?(value) = value.respond_to?(:strftime)
+    end
+  end
+end

data/lib/table_tennis/util/inspectable.rb

@@ -3,10 +3,9 @@ module TableTennis
     # A mixin to avoid putting all row data into xxx.inspect. This makes
     # development much easier.
     module Inspectable
-      def inspect = ENV["MINITEST"] ? super : inspect_without_rows
-
-      def inspect_without_rows
+      def inspect
         vars = instance_variables.filter_map do
+          next if _1 == :@data || _1 == :@_memo_wise
           value = instance_variable_get(_1)
           if value.is_a?(Array) && _1.to_s =~ /rows$/
             value = if value.length == 1

data/lib/table_tennis/util/strings.rb

@@ -9,6 +9,15 @@ module TableTennis
       # strip ansi codes
       def unpaint(str) = str.gsub(/\e\[[0-9;]*m/, "")
 
+      # similar to rails titleize
+      def titleize(str)
+        str = str.gsub(/_id$/, "") # remove _id
+        str = str.tr("_", " ") # remove underscores
+        str = str.gsub(/(\w)([A-Z])/, '\1 \2') # OneTwo => One Two
+        str = str.split.map(&:capitalize).join(" ") # capitalize
+        str
+      end
+
       def width(text)
         simple?(text) ? text.length : Unicode::DisplayWidth.of(text)
       end
@@ -38,9 +47,10 @@ module TableTennis
 
           # we've gone too far. do we need to pop for the ellipsis?
           text = list[0, _1]
-          text.pop if w == 1
+          text.pop if width - w == stop
           return "#{text.join}…"
         end
+
         text
       end
 

data/lib/table_tennis/util/termbg.rb

@@ -202,7 +202,7 @@ module TableTennis
       private_class_method :env_colorfgbg
 
       def debug(s)
-        puts "termbg: #{s}" if ENV["TM_DEBUG"]
+        puts "termbg: #{s}" if ENV["TT_DEBUG"]
       end
       private_class_method :debug
     end

data/lib/table_tennis/version.rb

@@ -1,3 +1,3 @@
 module TableTennis
-  VERSION = "0.0.1".freeze
+  VERSION = "0.0.2"
 end

data/lib/table_tennis.rb

@@ -24,6 +24,7 @@ require "table_tennis/stage/painter"
 require "table_tennis/stage/render"
 
 require "table_tennis/util/colors"
+require "table_tennis/util/identify"
 require "table_tennis/util/scale"
 require "table_tennis/util/strings"
 require "table_tennis/util/termbg"

data/table_tennis.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |s|
   }
 
   # what's in the gem?
-  s.files = `git ls-files`.split("\n").grep_v(%r{^(bin|samples|test)/})
+  s.files = `git ls-files`.split("\n").grep_v(%r{^(bin|demo|test)/})
   s.require_paths = ["lib"]
 
   # gem dependencies

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: table_tennis
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Adam Doppelt
 bindir: bin
 cert_chain: []
-date: 2025-04-11 00:00:00.000000000 Z
+date: 2025-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: csv
@@ -106,6 +106,7 @@ files:
 - lib/table_tennis/table_data.rb
 - lib/table_tennis/theme.rb
 - lib/table_tennis/util/colors.rb
+- lib/table_tennis/util/identify.rb
 - lib/table_tennis/util/inspectable.rb
 - lib/table_tennis/util/scale.rb
 - lib/table_tennis/util/strings.rb