natty-ui 0.35.0 → 1.0.3

data/lib/natty-ui/renderer/horizontal_rule.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module NattyUI
+  # @private
+  class HorizontalRule
+    def self.render(parent, kind)
+      return if (width = parent.columns) < 1
+      parent.puts(
+        "[bright_blue]#{
+          if kind.nil?
+            Border[:default].top * width
+          elsif kind.is_a?(Symbol)
+            Border[kind].top * width
+          else
+            kind = StrConst[kind]
+            if kind.width == 0
+              Border[:default].top * width
+            elsif kind.width > width
+              kind.to_str[0, width]
+            elsif kind.width == width
+              kind
+            else
+              kind.to_str * (width / kind.width)
+            end
+          end
+        }"
+      )
+    end
+  end
+
+  private_constant :HorizontalRule
+end

data/lib/natty-ui/{ls_renderer.rb → renderer/ls.rb}

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
 module NattyUI
-  class LSRenderer
+  # @private
+  class LS
+    # @private
     class << self
-      def lines(items, glyph, max_width)
+      def lines(columns, items, glyph)
         items = as_items(items, glyph)
-        lines = []
         width = items.max_by(&:width).width + 3
-        return lines if (sl_size = max_width / width).zero?
-        items.each_slice(sl_size) do |slice|
-          lines << slice.map { _1.to_s(width) }.join
-        end
+        return if (sl_size = columns / width).zero?
+        lines = []
+        items.each_slice(sl_size) { lines << it.map { it.ljust(width) }.join }
         lines
       end
 
@@ -19,7 +19,7 @@ module NattyUI
       def as_items(items, glyph)
         items.flatten!
         glyph = as_glyph(glyph, items.size)
-        items.map! { Item.new(glyph[_1]) }
+        items.map! { StrConst[glyph[it]] }
       end
 
       def as_glyph(glyph, size)
@@ -44,31 +44,19 @@ module NattyUI
           ->(s) { "#{glyph} #{s}" }
         end
       end
-
-      class Item
-        attr_reader :width
-
-        def to_s(in_width) = "#{@str}#{' ' * (in_width - @width)}"
-
-        def initialize(str)
-          @str = str
-          @width = Text.width(str)
-        end
-      end
-
-      private_constant :Item
     end
   end
 
-  class CompactLSRenderer < LSRenderer
+  # @private
+  class CompactLS < LS
     class << self
-      def lines(items, glyph, max_width)
+      def lines(columns, items, glyph)
         items = as_items(items, glyph)
         return [] if items.empty?
-        found, widths = find_columns(items, max_width)
+        found, widths = find_columns(items, columns)
         fill(found[-1], found[0].size)
         found.transpose.map! do |row|
-          row.each_with_index.map { |item, col| item&.to_s(widths[col]) }.join
+          row.each_with_index.map { |item, col| item&.ljust(widths[col]) }.join
         end
       end
 
@@ -79,7 +67,7 @@ module NattyUI
         widths = [items.max_by(&:width).width]
         1.upto(items.size - 1) do |slice_size|
           candidate = items.each_slice(items.size / slice_size).to_a
-          cwidths = candidate.map { _1.max_by(&:width).width + 3 }
+          cwidths = candidate.map { it.max_by(&:width).width + 3 }
           cwidths[-1] -= 3
           break if cwidths.sum > max_width
           found = candidate
@@ -94,5 +82,5 @@ module NattyUI
     end
   end
 
-  private_constant :LSRenderer, :CompactLSRenderer
+  private_constant :LS, :CompactLS
 end

data/lib/natty-ui/renderer/mark.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module NattyUI
+  # @private
+  module Mark
+    def self.render(parent, mark, *, **options)
+      options[:cprefix] = Utils.as_mark(mark)
+      parent.puts(*, **options)
+    end
+  end
+
+  private_constant :Mark
+end

data/lib/natty-ui/renderer/quote.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module NattyUI
+  # @private
+  Quote = StrConst["#{Ansi[:bright_blue]}▍#{Ansi::RESET}"]
+  def Quote.render(parent, *)
+    space = parent.columns
+    width = space * 0.75
+    parent.puts(*, prefix: self, max_width: width < 20 ? space : width.round)
+  end
+
+  private_constant :Quote
+end

data/lib/natty-ui/renderer/select.rb

@@ -0,0 +1,63 @@
+module NattyUI
+  # @private
+  class Select
+    def select(abortable)
+      start_line = NattyUI.lines_written
+      draw(last = current = 0)
+      Terminal.on_key_event do |event|
+        case event.name
+        when 'Esc', 'Ctrl+c'
+          break [] if abortable
+        when 'Space'
+          *last, selected = @items[current]
+          @items[current] = last << !selected
+        when 'Enter'
+          break @items.filter_map { |ret, _str, selected| ret if selected }
+        when 'Home'
+          current = 0
+        when 'End'
+          current = @items.size - 1
+        when 'Up', 'Back', 'Shift+Tab', 'i', 'w'
+          current = @items.size - 1 if (current -= 1) < 0
+        when 'Down', 'Tab', 'k', 's'
+          current = 0 if (current += 1) == @items.size
+        end
+        next if last == current
+        start_line = NattyUI.back_to_line(start_line, erase: false)
+        draw(last = current)
+      end
+    end
+
+    private
+
+    def draw(current)
+      @items.each_with_index do |(_ret, str, selected), idx|
+        @parent.puts(
+          str,
+          cprefix: MARKS.dig(idx == current, selected),
+          prefix: MARK_NONE
+        )
+      end
+    end
+
+    def initialize(parent, items)
+      @parent = parent
+      @items = items
+    end
+
+    MARKS = {
+      true => {
+        true => StrConst['[b bright_green]→[/fg] [\X][/b] '],
+        false => StrConst['[b bright_green]→[/fg] [\ ][/b] ']
+      }.compare_by_identity,
+      false => {
+        true => StrConst['  [\X] '],
+        false => StrConst['  [\ ] ']
+      }.compare_by_identity
+    }.compare_by_identity.freeze
+    MARK_NONE = StrConst.spacer(MARKS.dig(true, true).width)
+    private_constant :MARKS, :MARK_NONE
+  end
+
+  private_constant :Select
+end

data/lib/natty-ui/renderer/shell.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module NattyUI
+  # @private
+  module Shell
+    def self.render(parent, *, **)
+      Terminal.sh(*, **) do |line, kind|
+        parent.puts(line, bbcode: false, prefix: Utils.mark[kind])
+      end
+      parent
+    end
+  end
+
+  private_constant :Shell
+end

data/lib/natty-ui/renderer/shell_runner.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module NattyUI
+  # @private
+  module ShellRunner
+    def self.render(parent, tail, *, **)
+      tail = tail.clamp(1, Terminal.rows)
+      out, err, show = [], [], []
+      start = NattyUI.lines_written
+      width = parent.columns - Utils.mark.default.width
+      ret =
+        Terminal.sh(*, **) do |line, kind|
+          (kind == :error ? err : out) << line
+          first, *lines = Text::Formatter.format(line, width:, bbcode: false)
+          next unless first
+          start = NattyUI.back_to_line(start)
+          show << "#{Utils.mark[kind]}#{first}"
+          show.concat(lines.map! { "#{MARK_NONE}#{it}" }) unless lines.empty?
+          show = show.last(tail) if show.size > tail
+          parent.puts(*show, bbcode: false)
+        end
+      [ret, out, err] if ret
+    end
+
+    MARK_NONE = Utils.mark[:none]
+  end
+
+  private_constant :ShellRunner
+end

data/lib/natty-ui/renderer/table_renderer.rb

@@ -0,0 +1,446 @@
+# frozen_string_literal: true
+
+require_relative '../utils/border'
+
+module NattyUI
+  # @private
+  class TableRenderer
+    def self.lines(columns, table, **) = new(columns, table, **).lines
+
+    def lines
+      return [] if @rows.empty?
+      fit_widths
+      compose(compute_heights)
+    end
+
+    private
+
+    def initialize(max_width, table, **options)
+      @border = TableBorder.new(**options)
+      max_width = find_width(max_width, options[:width])
+      @rows, @col_count = build_rows(table, max_width)
+      return if @rows.empty?
+      seps = @border.col_sep && @col_count > 1 ? @col_count - 1 : 0
+      @content_width = max_width - @border.frame_size - seps
+    end
+
+    def build_rows(table, max_width)
+      rows = table.rows.each_filled.to_a
+      return [], 0 if rows.empty?
+
+      col_atts =
+        Array.new(table.columns.max) do |idx|
+          col = table.columns.at(idx)
+          col ? col.attributes.to_hash : {}
+        end
+
+      items =
+        rows.map do |row|
+          row_att = row.attributes.to_hash
+          col_atts.each_with_index.map do |col_att, idx|
+            Item.new(row.at(idx), row_att, col_att, max_width)
+          end
+        end
+
+      cols = items.transpose.keep_if { it.any?(&:any?) }
+      return [], 0 if cols.empty?
+      return items, col_atts.size if col_atts.size == cols.size
+      [cols.transpose, cols.size]
+    end
+
+    def fit_widths
+      cols =
+        Array.new(@col_count) do |c|
+          cells = @rows.map { it[c] }
+          pad = cells.map(&:h_pad).max
+
+          has_min = cells.any?(&:has_min)
+          cmin = has_min ? cells.map(&:content_min).max : 1
+
+          value = [cells.map(&:natural_width).max, cmin].max
+
+          cmax = cells.filter_map(&:content_max).min
+          if cmax
+            value = [value, cmax].min
+            max = cmax + pad
+          end
+
+          ColWidth.new(value, pad, has_min, cmin, max)
+        end
+      adjust(cols, @content_width)
+      @rows.each do |row|
+        row.each_with_index do |cell, c|
+          cell.resolve(cols[c].value, cols[c].pad)
+        end
+      end
+      @column_widths = cols.map(&:value).freeze # TODO: remove?
+    end
+
+    def adjust(cols, target)
+      delta = (cols.sum(&:value) - target).nonzero? or return
+      # 1) wrap content by shrinking columns down to their content minimum.
+      # Columns without a min_width are shrunk first; a column with a min_width
+      # is only reduced once no unconstrained column can give up more room.
+      while delta > 0
+        cand = []
+        free = []
+        cols.each do |c|
+          next unless c.shrinkable?
+          cand << c
+          free << c unless c.has_min
+        end
+        break if cand.empty?
+        (free.empty? ? cand : free).max_by(&:value).shrink!
+        delta -= 1
+      end
+      # 2) still too wide: trim padding, widest-padded column first
+      while delta > 0
+        break if (cand = cols.select(&:pad_reducible?)).empty?
+        cand.max_by(&:pad).reduce_pad!
+        delta -= 1
+      end
+      # 3) room to spare: grow columns to fill the width, but only on request
+      # and never past a column's configured max_width
+      return unless @expand
+      while delta < 0
+        break if (cand = cols.select(&:expandable?)).empty?
+        cand.min_by(&:value).expand!
+        delta += 1
+      end
+    end
+
+    def compute_heights
+      @rows.map do |row|
+        row.each(&:reflow!)
+        cells = row.map(&:height)
+        h = [cells.map(&:value).max, cells.map(&:min).max].max
+        mx = cells.filter_map(&:max).min
+        mx ? [h, mx].min : h
+      end
+    end
+
+    def compose(row_heights)
+      blanks = @column_widths.map { ' ' * it }
+      top, mid, bottom, left, right, sep = @border.parts(@column_widths)
+      ret = top ? [top] : []
+      @rows.each_with_index do |row, ri|
+        ret << mid if mid && ri > 0
+        h = row_heights[ri]
+        cell_lines = row.map { it.lines(h) }
+        h.times do |idx|
+          parts =
+            cell_lines.each_with_index.map do |cl, ci|
+              ctx = cl[idx]
+              ctx.nil? || ctx.empty? ? blanks[ci] : ctx
+            end
+          ret << "#{left}#{parts.join(sep)}#{right}"
+        end
+      end
+      bottom ? ret << bottom : ret
+    end
+
+    def find_width(max_width, value)
+      case value
+      when :max
+        @expand = true
+        max_width
+      when 0
+        [3, max_width].max
+      when Integer
+        @expand = true
+        if value < 0
+          [3, max_width + value].max
+        else
+          [value, max_width].min
+        end
+      when (0...1)
+        @expand = true
+        max_width * value
+      else
+        max_width
+      end
+    end
+
+    # @private
+    class TableBorder
+      attr_reader :frame_size, :col_sep
+
+      def parts(column_widths)
+        if @frame
+          top = top_row(column_widths) if @pos.top
+          right = "#{@style}#{@frame.right}#{@elyts}" if @pos.right
+          bottom = bottom_row(column_widths) if @pos.bottom
+          left = "#{@style}#{@frame.left}#{@elyts}" if @pos.left
+        end
+        mid = mid_row(column_widths) if @horizontal
+        sep = "#{@style}#{@col_sep}#{@elyts}" if @col_sep
+        [top, mid, bottom, left, right, sep]
+      end
+
+      private
+
+      def initialize(**options)
+        @style, @elyts = Utils.affix(options[:border_style])
+
+        @default =
+          if options.key?(:border)
+            case (value = options[:border])
+            when nil, false, :none
+              nil
+            when true
+              Border[:default]
+            when Symbol
+              Border[value]
+            end
+          else
+            Border[:default]
+          end
+
+        @frame = as_border(options[:border_frame])
+        @frame_size = 0
+
+        @vertical = as_border(options[:border_vertical])
+        @col_sep = @vertical&.left
+
+        @horizontal = as_border(options[:border_horizontal])
+
+        return @pos = FramePos::NONE unless @frame
+
+        @pos = FramePos[options.fetch(:frame, :all)]
+        return @frame = nil unless @pos.any?
+
+        @default = @frame
+        @frame_size += 1 if @pos.right
+        @frame_size += 1 if @pos.left
+      end
+
+      def as_border(value)
+        case value
+        when nil, true
+          @default
+        when :none
+          nil
+        when Symbol
+          Border[value]
+        end
+      end
+
+      def top_row(column_widths)
+        bar = @frame.top
+        cross = @vertical.vert_for(@default)[1] if @vertical
+        "#{@style}#{@frame.top_left if @pos.left}#{
+          column_widths.map { bar * it }.join(cross)
+        }#{@frame.top_right if @pos.right}#{@elyts}"
+      end
+
+      def bottom_row(column_widths)
+        bar = @frame.bottom
+        cross = @vertical.vert_for(@default)[2] if @vertical
+        "#{@style}#{@frame.bottom_left if @pos.left}#{
+          column_widths.map { bar * it }.join(cross)
+        }#{@frame.bottom_right if @pos.right}#{@elyts}"
+      end
+
+      def mid_row(column_widths)
+        if @frame
+          bar, left, right = @frame.hor_for(@horizontal).chars
+        else
+          bar = @horizontal.top
+        end
+        cross = @vertical&.inter_for(@horizontal)
+        "#{@style}#{left if @pos.left}#{
+          column_widths.map { bar * it }.join(cross)
+        }#{right if @pos.right}#{@elyts}"
+      end
+
+      class FramePos
+        # @private
+        def self.[](value)
+          case value
+          when Symbol
+            @defined[value]
+          when Enumerable
+            new(
+              value.include?(:top),
+              value.include?(:right),
+              value.include?(:bottom),
+              value.include?(:left)
+            )
+          else
+            NONE
+          end
+        end
+
+        attr_reader :top, :right, :bottom, :left
+
+        def any? = @top || @right || @bottom || @left
+
+        private
+
+        def initialize(top, right, bottom, left)
+          @top = top
+          @right = right
+          @bottom = bottom
+          @left = left
+        end
+
+        @defined = {
+          all: new(true, true, true, true),
+          top: new(true, false, false, false),
+          right: new(false, true, false, false),
+          bottom: new(false, false, true, false),
+          left: new(false, false, false, true)
+        }.compare_by_identity
+
+        @defined.default = NONE = new(false, false, false, false)
+      end
+    end
+
+    # @private
+    class ColWidth
+      attr_reader :value, :pad, :has_min
+
+      def shrinkable? = @value > @min
+      def expandable? = @max.nil? || @value < @max
+      def pad_reducible? = @pad > 0
+      def shrink! = (@value -= 1)
+      def expand! = (@value += 1)
+
+      def reduce_pad!
+        @value -= 1
+        @pad -= 1
+      end
+
+      def initialize(value, pad, has_min, min, max)
+        @value = value
+        @pad = pad
+        @min = min + pad
+        @has_min = has_min
+        @max = max
+      end
+    end
+
+    # @private
+    class Size
+      attr_reader :min, :max
+      attr_accessor :value
+
+      def initialize(min, max, value)
+        @min = min
+        @max = max
+        @value = [value, min].max
+        @value = max if max && @value > max
+      end
+    end
+
+    # @private
+    class Item
+      attr_reader :content_min, :content_max, :h_pad, :height, :has_min, :width
+
+      def any? = @any
+      def natural_width = @content_natural + @h_pad
+
+      def resolve(width, pad_budget)
+        @width = width
+        right, left = reduce_padding(pad_budget)
+        @hpad = [0, right, 0, left]
+        @rpad_h = right + left
+      end
+
+      def reflow!
+        @formatted =
+          if @width - @rpad_h < 1
+            []
+          else
+            @fmt.format(align: @align, padding: @hpad, width: @width)
+          end
+        h = [@formatted.size + @v_pad, @height.min].max
+        @height.value = @height.max ? [h, @height.max].min : h
+      end
+
+      def lines(box_height) = fit_height(@formatted, box_height, @vertical)
+
+      private
+
+      # Horizontal padding [right, left] capped at `budget` columns: the cell's
+      # own padding when it fits, otherwise `budget` split as evenly as possible
+      # with an odd column going to the left.
+      def reduce_padding(budget)
+        return @pad_right, @pad_left if @h_pad <= budget
+        right = (budget / 2.0).round
+        [right, budget - right]
+      end
+
+      # Compose the cell's content lines into a `box_height`-tall block: keep
+      # the vertical padding (@pad_top/@pad_bottom) as fixed top/bottom margins
+      # and distribute the remaining slack per vertical alignment; clip the
+      # content when it plus its padding is taller than the row.
+      def fit_height(lines, box_height, valign)
+        blank = ' ' * @width
+        slack = box_height - lines.size - @v_pad
+        if slack < 0
+          room = box_height - @v_pad
+          return Array.new(box_height, blank) if room <= 0
+          lines = valign == :bottom ? lines.last(room) : lines.first(room)
+          slack = 0
+        end
+        top, bottom =
+          case valign
+          when :bottom
+            [slack, 0]
+          when :middle
+            b = (slack / 2.0).round
+            [slack - b, b]
+          else
+            [0, slack]
+          end
+        Array.new(@pad_top + top, blank).concat(
+          lines,
+          Array.new(@pad_bottom + bottom, blank)
+        )
+      end
+
+      def initialize(cell, row_att, col_att, max_width)
+        att = row_att.merge(col_att)
+        if cell
+          @any = !cell.empty?
+          txt = cell.text
+          att.merge!(cell.attributes.to_hash)
+        else
+          @any = false
+        end
+        att = Table::Cell::Attributes.new(**att)
+        @fmt =
+          Text::Formatter.new(
+            *txt,
+            ansi: Terminal.ansi?,
+            spaces: att.spaces,
+            eol: att.eol
+          )
+        @content_natural = @any ? @fmt.max_line_width : 0
+        @align = att.align || :left
+        @vertical = att.vertical || :top
+        @pad_top, @pad_right, @pad_bottom, @pad_left = att.padding
+        @h_pad = @pad_right + @pad_left
+        @v_pad = @pad_top + @pad_bottom
+        @has_min = !att.min_width.nil?
+        @content_min = dim(att.min_width, 1, max_width)
+        @content_max = dim(att.max_width, nil, max_width)
+        @height =
+          Size.new(
+            (att.min_height || 1) + @v_pad,
+            att.max_height ? att.max_height + @v_pad : nil,
+            0 # placeholder: the real height is computed in reflow! once the width is known
+          )
+        resolve(natural_width, @h_pad)
+      end
+
+      def dim(value, default, max)
+        return default unless value
+        value.is_a?(Float) ? (value * max).round : value
+      end
+    end
+  end
+
+  private_constant :TableRenderer
+end