thundercli 0.2.0

data/lib/thunder/console/pretty.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+# WARN: AI MADE
+module Thunder
+  class Console
+    # Prints hashes and arrays as blocks: one item per line, a trailing comma, the closing bracket on its own line and
+    # a │ guide per level. Hashes always open a block; an array stays on one line while it holds only short values
+    # (except at the top, where two or more items open a block). Anything else prints as IRB does.
+    #   {
+    #   │ a: 1,
+    #   │ "b" => [2, 3],
+    #   │ c: {
+    #   │ │ d: 1,
+    #   │ │ e: 2,
+    #   │ }
+    #   }
+    class Pretty
+      include Theme
+
+      INLINE_WIDTH = 60
+      GUIDE = '│ '
+
+      def initialize(colorize:)
+        @colorize = colorize
+      end
+
+      def call(value) = render(value, top: true)
+
+      private
+
+      def render(value, top: false)
+        return block('{', '}', value.map { |key, item| pair(key, item) }) if value.is_a?(Hash) && value.any?
+        return block('[', ']', value.map { |item| render(item) }) if value.is_a?(Array) && block_array?(value, top)
+        return Views.reference(value) if value.is_a?(ActiveRecord::Base)
+
+        color_pp(value)
+      end
+
+      def block_array?(array, top)
+        return array.size > 1 || array.any? { |item| nested?(item) } if top
+
+        array.any? { |item| nested?(item) } || !inline?(color_pp(array))
+      end
+
+      def nested?(value) = (value.is_a?(Hash) || value.is_a?(Array)) && value.any?
+
+      def inline?(text) = !text.include?("\n") && text.gsub(/\e\[[\d;]*m/, '').size <= INLINE_WIDTH
+
+      def block(open, close, items)
+        guide = paint(GUIDE, :faint)
+        body = items.map do |item|
+          comma = item.end_with?('}', ']') && item.include?("\n") ? '' : ','
+          "#{item}#{comma}".gsub(/^/, guide)
+        end
+        [open, *body, close].join("\n")
+      end
+
+      # Ruby's own key format: a: for a symbol, "a" => for anything else.
+      def pair(key, value)
+        label = key.is_a?(Symbol) ? "#{key.inspect.delete_prefix(':')}:" : "#{color_pp(key)} =>"
+        label = paint(label, :accent) if key.is_a?(Symbol)
+        "#{label} #{render(value)}"
+      end
+
+      def color_pp(value) = IRB::ColorPrinter.pp(value, +'', colorize: @colorize).chomp
+
+      def paint(text, *roles) = @colorize ? Theme.paint(text, *roles) : text
+    end
+  end
+end

data/lib/thunder/console/prompt.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+# WARN: AI MADE
+module Thunder
+  class Console
+    # Powerline prompt: [⚡ chunk][env] ❯, the arrow red after a failed evaluation. With a Nerd Font the segments end
+    # in the  separator; without one (see Theme.nerd_font?) they are plain colored blocks.
+    class Prompt
+      include Theme
+
+      def initialize(console)
+        @console = console
+      end
+
+      # IRB switches to PROMPT_S inside an open string and to PROMPT_C in an unfinished expression, on the first line
+      # too, so all three are the full prompt.
+      def irb_prompts(failed: false)
+        prompt = main(failed:)
+        { PROMPT_I: prompt, PROMPT_S: prompt, PROMPT_C: prompt, RETURN: "#{paint('=>', :faint)} %s\n" }
+      end
+
+      # Repaints the prompts of a running IRB context.
+      def apply(context, failed:)
+        prompt = main(failed:)
+        context.prompt_i = prompt
+        context.prompt_s = prompt
+        context.prompt_c = prompt
+      end
+
+      def main(failed: false)
+        name = @console.chunk&.identifier || 'thunder'
+        env = @console.env
+        return "#{name}(#{env})#{' ✗' if failed} > " unless enabled?
+
+        "#{segments(name, env)} #{paint('❯', failed ? :fail : :ok)} "
+      end
+
+      private
+
+      # Reverse video: the segment is the theme color, the text the terminal background.
+      def segments(name, env)
+        production = env == 'production'
+        chunk_segment = "\e[0;7;3#{ACCENT_COLOR}m ⚡ #{name} "
+        env_segment = "\e[0;#{'1;' if production}7;3#{env_color(env)}m#{production ? ' PRODUCTION ' : " #{env} "}"
+        return "#{chunk_segment}#{env_segment}\e[0m" unless Theme.nerd_font?
+
+        "#{chunk_segment}\e[0;3#{ACCENT_COLOR};4#{env_color(env)}m#{SEPARATOR}#{env_segment}" \
+          "\e[0;3#{env_color(env)}m#{SEPARATOR}\e[0m"
+      end
+    end
+  end
+end

data/lib/thunder/console/theme.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+# WARN: AI MADE
+module Thunder
+  class Console
+    # The 16 ANSI colors (30-37, 90-97), so the terminal theme decides the actual colors. Off when stdout is not a
+    # terminal or NO_COLOR is set.
+    module Theme
+      # Indexes of the ANSI palette: foreground 30 + index, background 40 + index.
+      RED = 1
+      GREEN = 2
+      YELLOW = 3
+      BLUE = 4
+      MAGENTA = 5
+
+      ROLES = {
+        accent: "3#{BLUE}",
+        ok: "3#{GREEN}",
+        fail: "3#{RED}",
+        warn: "3#{YELLOW}",
+        muted: '39',
+        faint: '90',
+        bold: '1',
+        reverse: '7'
+      }.freeze
+
+      # Color of the env segment of the prompt.
+      ENV_COLORS = { 'development' => GREEN, 'test' => YELLOW, 'production' => RED }.freeze
+      OTHER_ENV_COLOR = MAGENTA
+      ACCENT_COLOR = BLUE
+      SEPARATOR = ''
+
+      # A terminal does not report its font. THUNDER_NERD_FONT=1/0 decides; without it, only terminals that ship the
+      # Nerd Font symbols themselves (WezTerm, Ghostty, kitty) get the powerline separator.
+      NERD_FONT_TERMINALS = %w[WezTerm ghostty].freeze
+
+      def self.nerd_font?
+        return @nerd_font if defined?(@nerd_font)
+
+        @nerd_font =
+          case ENV.fetch('THUNDER_NERD_FONT', nil)
+          when '1', 'true' then true
+          when '0', 'false' then false
+          else nerd_font_terminal?
+          end
+      end
+
+      def self.nerd_font_terminal?
+        NERD_FONT_TERMINALS.include?(ENV.fetch('TERM_PROGRAM', nil)) ||
+          ENV['TERM'] == 'xterm-kitty' || ENV.key?('KITTY_WINDOW_ID')
+      end
+      private_class_method :nerd_font_terminal?
+
+      module_function
+
+      def enabled? = $stdout.tty? && !ENV.key?('NO_COLOR')
+
+      def paint(text, *roles)
+        return text.to_s unless enabled? && roles.any?
+
+        "\e[#{roles.map { |role| ROLES.fetch(role) }.join(';')}m#{text}\e[0m"
+      end
+
+      def env_color(env) = ENV_COLORS.fetch(env, OTHER_ENV_COLOR)
+
+      # Label/value lines with the labels in one column; a multi-line value continues under its first line. guide (a
+      # role) draws a │ in that color before every line, tying the rows to a block.
+      #   chunk       library
+      #   operations  books.add
+      def rows(pairs, indent: 2, guide: nil)
+        pairs = pairs.compact
+        width = pairs.map { |label, _| label.size }.max.to_i
+        prefix = "#{' ' * indent}#{"#{paint('│', guide)} " if guide}"
+        margin = "#{prefix}#{' ' * (width + 2)}"
+        pairs.map do |label, value|
+          "#{prefix}#{paint(label.ljust(width), :faint)}  #{value.to_s.gsub("\n", "\n#{margin}")}"
+        end
+      end
+
+      def duration(seconds)
+        seconds < 1 ? "#{(seconds * 1000).round}ms" : format('%.1fs', seconds)
+      end
+    end
+  end
+end

data/lib/thunder/console/views/collection.rb

@@ -0,0 +1,172 @@
+# frozen_string_literal: true
+
+# WARN: AI MADE
+module Thunder
+  class Console
+    module Views
+      # A relation, or an array of records of one class, as a table: one record per line, the columns that fit the
+      # terminal and rows saying what was left out. Columns go in this order until the width ends: primary key, an
+      # identifying column (number, name, title...), the others in schema order, timestamps last. A column with one
+      # value in every record moves to the "same" row. Up to 3 records that do not fit are shown transposed, one
+      # record per column. Like ActiveRecord's own inspect, a relation loads at most 11 records.
+      #   =>  10 orders  relation · 40 columns, 9 shown
+      #      │ id         number           status   total_cents  created_at
+      #      │ 7c1e0b5a…  ORD-2026-000431  paid           15990  2026-10-21 14:19
+      #      │ same       currency BRL · coupon nil
+      #      │ hidden     subtotal_cents, notes, metadata, +19
+      class Collection
+        include Format
+
+        MAX_RECORDS = 10
+        MAX_ARRAY_RECORDS = 50
+        TRANSPOSE_UP_TO = 3
+        MAX_ROWS = 20
+        IDENTITY = %w[number code name title email slug key].freeze
+        GAP = 2
+
+        def self.records?(value)
+          value.is_a?(Array) && value.size > 1 && value.all?(ActiveRecord::Base) && value.map(&:class).uniq.size == 1
+        end
+
+        # A relation is read only up to MAX_RECORDS + 1 rows, so its total is unknown ("10+"); an array is already in
+        # memory, so its size is the total and up to MAX_ARRAY_RECORDS are shown.
+        def initialize(value)
+          if value.is_a?(ActiveRecord::Relation)
+            @klass = value.klass
+            @source = 'relation'
+            @limit = MAX_RECORDS
+            @records = read(value)
+            @total = @records.size > @limit ? nil : @records.size
+          else
+            @klass = value.first.class
+            @source = 'array'
+            @limit = MAX_ARRAY_RECORDS
+            @records = value
+            @total = value.size
+          end
+          @more = @records.size > @limit
+          @records = @records.first(@limit)
+        end
+
+        def call
+          return header([]) if @records.empty?
+          return Record.new(@records.first).call if @records.size == 1
+
+          names = @records.first.attribute_names
+          same = constant_columns(names)
+          shown, hidden = fit(order(names - same))
+          return transposed(names, same) if hidden.any? && @records.size <= TRANSPOSE_UP_TO
+
+          footer_rows = rows(footer(same, hidden), indent: 3, guide: :accent)
+          [header(names, shown + same), *table(shown), *footer_rows].join("\n")
+        end
+
+        private
+
+        def read(relation)
+          return relation.records.first(@limit + 1) if relation.loaded?
+
+          relation.take([relation.limit_value, @limit + 1].compact.min)
+        end
+
+        # Columns, other than the primary key, with one value in every record.
+        def constant_columns(names)
+          names.select do |name|
+            name != @klass.primary_key && @records.map { |record| record[name] }.uniq.size == 1
+          end
+        end
+
+        def header(names, shown = names)
+          count = @total || "#{@limit}+"
+          noun = key_for(@klass)
+          noun = noun.pluralize unless @total == 1
+          columns = "#{names.size} #{names.size == 1 ? 'column' : 'columns'}"
+          columns += ", #{shown.size} shown" unless names.size == shown.size
+          "#{badge("#{count} #{noun}")} #{paint([@source, (columns if names.any?)].compact.join(' · '), :faint)}"
+        end
+
+        def order(names)
+          primary = @klass.primary_key
+          identity = IDENTITY.find { |name| names.include?(name) }
+          first = [primary, identity].compact & names
+          stamps = names & TIMESTAMPS
+          first + (names - first - stamps) + stamps
+        end
+
+        def fit(names)
+          available = screen_width - MARGIN
+          used = 0
+          shown = names.take_while do |name|
+            used += width_of(name) + GAP
+            used - GAP <= available
+          end
+          shown = names.first(1) if shown.empty?
+          [shown, names - shown]
+        end
+
+        def width_of(name)
+          @widths ||= {}
+          @widths[name] ||= [name.size, *@records.map { |record| visible_size(cell(record[name])) }].max
+        end
+
+        def table(names)
+          guide = "   #{paint('│', :accent)} "
+          head = names.map { |name| ljust(paint(name, :faint), width_of(name)) }.join(' ' * GAP).rstrip
+          lines = @records.map do |record|
+            names.map do |name|
+              value = record[name]
+              value.is_a?(Numeric) ? rjust(cell(value), width_of(name)) : ljust(cell(value), width_of(name))
+            end.join(' ' * GAP).rstrip
+          end
+          [head, *lines].map { |line| "#{guide}#{line}" }
+        end
+
+        # label_width: the widest label of the rows these go with, so the values stay inside the screen.
+        def footer(same, hidden, label_width = 'hidden'.size)
+          width = screen_width - MARGIN - label_width - 2
+          [
+            (['same', same_text(same, width)] if same.any?),
+            (['hidden', "#{list(hidden, width - 22)}  #{paint('.select(...) to pick', :faint)}"] if hidden.any?),
+            (['more', paint(more_hint, :faint)] if @more)
+          ]
+        end
+
+        def more_hint
+          return "#{@limit} of #{@total} shown; .each or pp for all" if @total
+
+          "inspect reads #{@limit}; .to_a shows up to #{MAX_ARRAY_RECORDS}, .each goes through all"
+        end
+
+        def same_text(names, width)
+          entries = names.map do |name|
+            value = @records.first[name]
+            "#{name} #{value.nil? ? paint('nil', :faint) : cell(value)}"
+          end
+          text = entries.join(paint(' · ', :faint))
+          visible_size(text) <= width ? text : list(names, width)
+        end
+
+        # One record per column, one attribute per row.
+        def transposed(names, same)
+          columns = order(names - same)
+          primary = @klass.primary_key
+          @record_widths = @records.map { |record| [primary, *columns].map { |name| width_in(record, name) }.max }
+
+          ids = record_line(@records.map { |record| paint(cell(record[primary]), :bold) })
+          attributes = (columns - [primary]).map { |name| [name, record_line(@records.map { |r| cell(r[name]) })] }
+          label_width = [*columns, 'same'].map(&:size).max
+          table = [['', ids], *cap(attributes, MAX_ROWS), *footer(same, [], label_width)]
+
+          [header(names), *rows(table, indent: 3, guide: :accent)].join("\n")
+        end
+
+        def width_in(record, name) = visible_size(cell(record[name]))
+
+        # The cells of one attribute, one per record, each in its record's column.
+        def record_line(cells)
+          cells.each_with_index.map { |text, index| ljust(text, @record_widths[index]) }.join(' ' * GAP).rstrip
+        end
+      end
+    end
+  end
+end

data/lib/thunder/console/views/format.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'io/console'
+
+# WARN: AI MADE
+module Thunder
+  class Console
+    module Views
+      # What the views share: the terminal width, the registry or exporter key of a class, and cell and value formatting; Layout
+      # adds the sections and aligned columns they are printed in.
+      module Format
+        include Theme
+        include Layout
+
+        UUID = /\A\h{8}-\h{4}-\h{4}-\h{4}-\h{12}\z/i
+        ANSI = /\e\[[\d;]*m/
+        # Room taken by IRB's "=> " and the "│ " guide before a view's rows.
+        MARGIN = 5
+        CELL_WIDTH = 24
+        TIMESTAMPS = %w[created_at updated_at].freeze
+
+        # Columns taken before the view starts, when it is printed inside another table (a Response's payload).
+        attr_writer :inset
+
+        private
+
+        def screen_width
+          width = IO.console&.winsize&.last.to_i
+          width = width.positive? ? [width, 60].max : 120
+          [width - @inset.to_i, 40].max
+        rescue StandardError
+          120
+        end
+
+        # The key the class is registered or exported under in the console's chunk ('book', 'books.add',
+        # 'books.show'); its underscored name otherwise.
+        def key_for(klass)
+          chunk = Console.current&.chunk
+          items = [chunk&.registry, chunk&.exporter].compact.flat_map { |source| source.hash.values }
+          key = items.lazy.filter_map { |by_key| by_key.key(klass) }.first
+          key || klass.name.to_s.demodulize.underscore
+        end
+
+        def visible_size(text) = text.to_s.gsub(ANSI, '').size
+
+        def ljust(text, width) = "#{text}#{' ' * [width - visible_size(text), 0].max}"
+
+        def rjust(text, width) = "#{' ' * [width - visible_size(text), 0].max}#{text}"
+
+        def truncate(text, width)
+          text = text.to_s
+          text.size > width ? "#{text[0, [width - 1, 1].max]}…" : text
+        end
+
+        def uuid?(value) = value.is_a?(String) && value.match?(UUID)
+
+        def short_id(value) = uuid?(value) ? "#{value[0, 8]}…" : value.to_s
+
+        def time?(value) = value.is_a?(Time) || value.is_a?(DateTime) || value.is_a?(ActiveSupport::TimeWithZone)
+
+        # Times come from the database in UTC; they are shown in Time.zone when it is set, in the system's zone
+        # otherwise, so a time without its zone is the local one.
+        def local(value) = Time.zone ? value.in_time_zone : value.to_time.getlocal
+
+        # A value in a table cell: one line, at most CELL_WIDTH wide.
+        def cell(value)
+          return paint('·', :faint) if value.nil?
+          return paint(short_id(value), :faint) if uuid?(value)
+          return local(value).strftime('%Y-%m-%d %H:%M') if time?(value)
+
+          truncate(scalar(value) || value.inspect, CELL_WIDTH)
+        end
+
+        # The text of a date, decimal, string, number or boolean; nil for anything else.
+        def scalar(value)
+          case value
+          when Date then value.iso8601
+          when BigDecimal then value.to_s('F')
+          when String, Numeric, true, false then value.to_s
+          end
+        end
+
+        # A value in a row of its own, cut to width.
+        def value_text(value, width)
+          return paint('nil', :faint) if value.nil?
+          return value if uuid?(value)
+          return local(value).strftime('%Y-%m-%d %H:%M:%S') if time?(value)
+
+          case value
+          when Date, BigDecimal then scalar(value)
+          when String then long_string(value, width)
+          when Hash, Array then collection_text(value, width)
+          else truncate(value.inspect, width)
+          end
+        end
+
+        def long_string(value, width)
+          text = value.inspect
+          return text if text.size <= width
+
+          size = "  #{value.size >= 1000 ? format('%.1fk', value.size / 1000.0) : value.size} chars"
+          "#{truncate(text, width - size.size)}#{paint(size, :faint)}"
+        end
+
+        def collection_text(value, width)
+          text = value.inspect
+          return text if text.size <= width
+
+          value.is_a?(Hash) ? "{…} #{value.size} keys" : "[…] #{value.size} items"
+        end
+      end
+    end
+  end
+end

data/lib/thunder/console/views/layout.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+# WARN: AI MADE
+module Thunder
+  class Console
+    module Views
+      # How the views lay text out: lists cut to a width, badges, capped rows, titled sections and aligned columns.
+      # Measures text with visible_size and ljust, and fits it to screen_width, all from Format.
+      module Layout
+        include Theme
+
+        SECTION_INDENT = '   '
+        ITEM_INDENT = '     '
+
+        private
+
+        # Names joined with ", " up to width; the rest becomes "+N".
+        def list(names, width)
+          shown = []
+          names.each_with_index do |name, index|
+            rest = names.size - index - 1
+            candidate = [*shown, name].join(', ')
+            budget = rest.positive? ? width - ", +#{rest}".size : width
+            break if candidate.size > budget
+
+            shown << name
+          end
+          hidden = names.size - shown.size
+          return shown.join(', ') if hidden.zero?
+          return paint("+#{hidden}", :faint) if shown.empty?
+
+          "#{shown.join(', ')}#{paint(", +#{hidden}", :faint)}"
+        end
+
+        def badge(text, role = :accent) = paint(" #{text} ", role, :bold, :reverse)
+
+        # The first max - 1 rows and a row saying how many were left out, when there are more than max.
+        def cap(rows, max, hint = '')
+          return rows if rows.size <= max
+
+          [*rows.first(max - 1), ['', paint("… #{rows.size - (max - 1)} more#{hint}", :faint)]]
+        end
+
+        # A titled section: the title on a line of its own, then its lines indented under it.
+        #   params 2
+        #     title   String
+        #     copies  Integer  optional
+        def section(title, lines, count: nil)
+          head = paint(title, :accent, :bold)
+          head += " #{paint(count, :faint)}" if count
+          ["#{SECTION_INDENT}#{head}", *lines.map { |line| "#{ITEM_INDENT}#{line}" }]
+        end
+
+        # Rows of cells with every column aligned; the last cell of a row is not padded.
+        def aligned(table)
+          widths = []
+          table.each do |cells|
+            cells.each_with_index { |text, index| widths[index] = [widths[index].to_i, visible_size(text)].max }
+          end
+          table.map do |cells|
+            last = cells.size - 1
+            cells.each_with_index.map { |text, index| index == last ? text : ljust(text, widths[index]) }
+                 .join('  ').rstrip
+          end
+        end
+
+        # Width left for an item's text after the section indent.
+        def item_width = screen_width - 3 - ITEM_INDENT.size
+      end
+    end
+  end
+end

data/lib/thunder/console/views/model.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+# WARN: AI MADE
+module Thunder
+  class Console
+    module Views
+      # A model class as its schema, one section per part, one item per line: the columns with type and flags (pk,
+      # → the association of a foreign key, not null, default, array), primary and foreign keys first and timestamps
+      # last; then the associations by kind and the enums.
+      #   =>  MODEL  book  Library::Internal::Models::Book · books
+      #      columns 4
+      #        id          integer   pk
+      #        title       string    not null
+      #        created_at  datetime  not null
+      #      associations
+      #        has_many  loans
+      class Model
+        include Format
+
+        MAX_COLUMNS = 20
+        MACROS = %i[belongs_to has_one has_many has_and_belongs_to_many].freeze
+
+        def initialize(klass)
+          @klass = klass
+        end
+
+        def call
+          columns = @klass.columns
+          sections = [
+            section('columns', column_lines(columns), count: columns.size),
+            (section('associations', association_lines) if association_lines.any?),
+            (section('enums', enum_lines) if enum_lines.any?)
+          ]
+          [header, *sections.compact.flatten].join("\n")
+        rescue StandardError => e
+          [header, *section('schema', [paint("unavailable: #{e.message.lines.first.to_s.strip}", :faint)])].join("\n")
+        end
+
+        private
+
+        def header
+          details = paint("#{@klass.name} · #{@klass.table_name}", :faint)
+          "#{badge('MODEL')} #{paint(key_for(@klass), :bold)}  #{details}"
+        end
+
+        def column_lines(columns)
+          keys, rest = columns.partition { |column| key?(column.name) }
+          stamps, rest = rest.partition { |column| TIMESTAMPS.include?(column.name) }
+          ordered = keys + rest + stamps
+          lines = aligned(ordered.first(MAX_COLUMNS).map { |column| column_cells(column) })
+          return lines if ordered.size <= MAX_COLUMNS
+
+          [*lines, paint("… #{ordered.size - MAX_COLUMNS} more · #{@klass.name.demodulize}.columns for all", :faint)]
+        end
+
+        def column_cells(column) = [column.name, paint(type(column), :faint), *flags(column)]
+
+        def key?(name) = name == @klass.primary_key || foreign_keys.key?(name)
+
+        def type(column) = "#{column.type || column.sql_type}#{'[]' if column.respond_to?(:array?) && column.array?}"
+
+        def flags(column)
+          flags = []
+          flags << paint('pk', :accent) if column.name == @klass.primary_key
+          flags << paint("→ #{foreign_keys[column.name]}", :accent) if foreign_keys.key?(column.name)
+          flags << paint('not null', :faint) unless column.null || column.name == @klass.primary_key
+          flags << paint("default #{truncate(column.default, 20)}", :faint) unless column.default.nil?
+          flags.empty? ? [] : [flags.join(paint(' · ', :faint))]
+        end
+
+        def foreign_keys
+          @foreign_keys ||= @klass.reflect_on_all_associations(:belongs_to).to_h do |association|
+            [association.foreign_key.to_s, association.name.to_s]
+          end
+        end
+
+        def association_lines
+          @association_lines ||= aligned(MACROS.filter_map do |macro|
+            names = @klass.reflect_on_all_associations(macro).map { |association| association.name.to_s }
+            [paint(macro.to_s, :faint), list(names, item_width - macro.size - 2)] if names.any?
+          end)
+        end
+
+        def enum_lines
+          @enum_lines ||= aligned(enums.map { |name, values| [name, list(values.keys, item_width - name.size - 2)] })
+        end
+
+        def enums = @klass.respond_to?(:defined_enums) ? @klass.defined_enums : {}
+      end
+    end
+  end
+end