natty-ui 0.12.0 → 0.25.0

data/lib/natty-ui/framed.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require_relative 'element'
+
+module NattyUI
+  # {Element} with a frame around the content used by {Features.framed}.
+  #
+  class Framed < Element
+    # @!visibility private
+    def closed? = @bottom ? false : true
+
+    # @!visibility private
+    def puts(*objects, **options)
+      return self if closed?
+      options[:align] = @align
+      options[:expand] = true
+      super
+    end
+
+    # @!visibility private
+    def done
+      return if closed?
+      @parent.puts(@bottom)
+      @bottom = nil
+    end
+
+    # @!visibility private
+    def inspect = "#{_to_s.chop} align=#{@align.inspect} closed?=#{closed?}>"
+
+    private
+
+    def initialize(parent, align, chars, style, msg)
+      super(parent)
+      @align = align
+      if style
+        style = Ansi[*style]
+        @prefix = "#{style}#{chars[9]}[/] "
+        @suffix = " #{style}#{chars[9]}[/]"
+      else
+        @prefix = "#{chars[9]} "
+        @suffix = " #{chars[9]}"
+      end
+      @prefix_width = 2
+      @suffix_width = 2
+      line = chars[10] * (parent.columns - 2)
+      parent.puts("#{style}#{chars[0]}#{line}#{chars[2]}")
+      @bottom = "#{style}#{chars[6]}#{line}#{chars[8]}"
+      puts(*msg) unless msg.empty?
+    end
+  end
+end

data/lib/natty-ui/ls_renderer.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module NattyUI
+  class LSRenderer
+    class << self
+      def lines(items, glyph, max_width)
+        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
+        lines
+      end
+
+      private
+
+      def as_items(items, glyph)
+        items.flatten!
+        glyph = as_glyph(glyph, items.size)
+        items.map! { |item| Item.new(item = glyph[item], Text.width(item)) }
+      end
+
+      def as_glyph(glyph, size)
+        case glyph
+        when nil, false
+          lambda(&:itself)
+        when :hex
+          pad = size.to_s(16).size
+          glyph = 0
+          ->(s) { "#{(glyph += 1).to_s(16).rjust(pad, '0')} #{s}" }
+        when Integer
+          pad = (glyph + size).to_s.size
+          glyph -= 1
+          ->(s) { "#{(glyph += 1).to_s.rjust(pad)} #{s}" }
+        when Symbol
+          lambda do |s|
+            "#{
+              t = glyph
+              glyph = glyph.succ
+              t
+            } #{s}[/]"
+          end
+        else
+          ->(s) { "#{glyph} #{s}" }
+        end
+      end
+
+      Item =
+        Struct.new(:str, :width) do
+          def to_s(in_width) = "#{str}#{' ' * (in_width - width)}"
+        end
+      private_constant :Item
+    end
+  end
+
+  class CompactLSRenderer < LSRenderer
+    class << self
+      def lines(items, glyph, max_width)
+        items = as_items(items, glyph)
+        return [] if items.empty?
+        found, widths = find_columns(items, max_width)
+        fill(found[-1], found[0].size)
+        found.transpose.map! do |row|
+          row.each_with_index.map { |item, col| item&.to_s(widths[col]) }.join
+        end
+      end
+
+      private
+
+      def find_columns(items, max_width)
+        found = [items]
+        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[-1] -= 3
+          break if cwidths.sum > max_width
+          found = candidate
+          widths = cwidths
+        end
+        [found, widths]
+      end
+
+      def fill(ary, size)
+        (diff = size - ary.size).positive? && ary.fill(nil, ary.size, diff)
+      end
+    end
+  end
+
+  private_constant :LSRenderer, :CompactLSRenderer
+end

data/lib/natty-ui/progress.rb

@@ -0,0 +1,187 @@
+# frozen_string_literal: true
+
+module NattyUI
+  # @todo This chapter needs more documentation.
+  #
+  # Progress indictaor helper used by {Features.progress}.
+  #
+  module ProgressHelper
+    # @return [String]
+    attr_reader :title
+
+    # @attribute [w] title
+    def title=(value)
+      @title = value
+      redraw
+    end
+
+    # @return [Float]
+    attr_reader :value
+
+    # @attribute [w] value
+    def value=(val)
+      @value = val.to_f
+      @value = 0.0 if @value < 0
+      @max = @value if @max&.<(@value)
+      redraw
+    end
+
+    # @return [Float]
+    attr_reader :max
+
+    # @attribute [w] max
+    def max=(val)
+      @max = val.to_f
+      if @max <= 0
+        @max = nil
+      elsif @max < @value
+        @max = @value
+      end
+      redraw
+    end
+
+    def active? = @status.nil?
+    def ok? = @status == :ok
+    def failed? = @status == :failed
+
+    def step(count: 1, title: nil)
+      @title = title if title
+      self.value += count
+      self
+    end
+
+    def done(title = nil) = finish(:ok, title)
+    alias ok done
+
+    def failed(title = nil) = finish(:failed, title)
+
+    alias _to_s to_s
+    private :_to_s
+
+    # @!visibility private
+    def to_s
+      return "#{title}: #{format('%5.2f', @value)}" unless @max
+      "#{@title}: #{
+        format(
+          '%5.2f of %5.2f - %5.2f%%',
+          @value,
+          @max,
+          100.0 * (@value / @max)
+        )
+      }"
+    end
+
+    # @!visibility private
+    def inspect = "#{_to_s.chop} #{self}>"
+  end
+
+  class Progress
+    include ProgressHelper
+
+    private
+
+    def finish(status, title)
+      return if @status
+      @status = status
+      NattyUI.back_to_line(@pin_line)
+      if status == :failed
+        @parent.failed(title || @title)
+      else
+        cm = Theme.current.mark(:checkmark)
+        @parent.puts(
+          title || @title,
+          pin: @pin,
+          first_line_prefix: cm,
+          first_line_prefix_width: cm.width
+        )
+      end
+      self
+    end
+
+    def initialize(parent, title, max, pin)
+      @parent = parent
+      @value = 0.0
+      @title = title
+      @pin = pin
+      @pin_line = NattyUI.lines_written
+      @style = Theme.current.task_style
+      max ? self.max = max : redraw
+    end
+
+    def redraw
+      return if @status
+      bar = @max ? bar(@value / @max) : moving_bar
+      curr = bar ? [@title, bar] : [@title]
+      return if @last == curr
+      @pin_line = NattyUI.back_to_line(@pin_line) if @last
+      @parent.puts(
+        *curr,
+        first_line_prefix: "#{@style}➔ ",
+        first_line_prefix_width: 2
+      )
+      @last = curr
+    end
+
+    def moving_bar
+      "#{@style}#{'·' * @value}" if @value >= 1
+    end
+
+    def bar(diff)
+      size = [@parent.columns, 72].min - 11
+      percent = format('%5.2f', 100.0 * diff)
+      return percent if size < 10
+      return if percent == '100.00'
+      fill = '█' * (size * diff)
+      "#{percent}% [bright_black]┃#{@style}#{fill}[bright_black]#{
+        '░' * (size - fill.size)
+      }┃[/]"
+    end
+  end
+
+  class DumbProgress
+    include ProgressHelper
+
+    private
+
+    def finish(status, title)
+      return if @status
+      @status = status
+      if status == :failed
+        @parent.failed(title || @title)
+      else
+        cm = Theme.current.mark(:checkmark)
+        @parent.puts(
+          title || @title,
+          first_line_prefix: cm,
+          first_line_prefix_width: cm.width
+        )
+      end
+      self
+    end
+
+    def initialize(parent, title, max)
+      @parent = parent
+      @value = @last_value = 0.0
+      @title = title
+      max ? self.max = max : redraw
+    end
+
+    def redraw
+      return if @status
+      if @last_title != @title
+        @parent.puts(
+          @last_title = @title,
+          first_line_prefix: '➔ ',
+          first_line_prefix_width: 2
+        )
+      end
+      return if @max.nil? || @value < 1
+      percent = format('%3.0f %%', 100.0 * (@value / @max))
+      return if @last_percent == percent
+      @parent.puts(percent, first_line_prefix: '  ', first_line_prefix_width: 2)
+      @last_percent = percent
+    end
+  end
+
+  private_constant :Progress, :DumbProgress
+end

data/lib/natty-ui/section.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require_relative 'element'
+
+module NattyUI
+  # {Element} implemting a display section used by
+  #
+  # - {Features.section}
+  # - {Features.message}
+  # - {Features.information}
+  # - {Features.warning}
+  # - {Features.error}
+  # - {Features.failed}
+  #
+  class Section < Element
+    include StateMixin
+
+    # @!visibility private
+    def puts(*objects, **options) = @state ? self : super
+
+    private
+
+    def finish_ok(text)
+      puts(*text) unless text.empty?
+      @state = :ok
+      @parent.puts(@border.bottom)
+      self
+    end
+
+    def finish_failed
+      @parent.puts(@border.bottom)
+      super
+    end
+
+    def show_title(title)
+      return @parent.puts(@border.top) unless title
+      prefix = @border.top_left
+      suffix = @border.top_right
+      @parent.puts(
+        title,
+        prefix: prefix,
+        prefix_width: prefix.width,
+        suffix: suffix,
+        suffix_width: suffix.width
+      )
+    end
+
+    def initialize(parent, title, msg, kind)
+      super(parent)
+      title, rest = split(title) if title && !title.empty?
+      @border = Theme.current.section_border(kind)
+      show_title(title)
+      @prefix = @border.prefix
+      @prefix_width = @prefix.size
+      puts(*rest) if rest && !rest.empty?
+      puts(*msg) unless msg.empty?
+    end
+
+    def split(title)
+      rest =
+        Text.each_line(
+          title,
+          limit: @parent.columns - 9,
+          ansi: Terminal.ansi?
+        ).to_a
+      [rest.shift, rest]
+    end
+  end
+end

data/lib/natty-ui/table.rb

@@ -0,0 +1,241 @@
+# frozen_string_literal: true
+
+require_relative 'attributes'
+require_relative 'table_renderer'
+
+module NattyUI
+  # @todo This chapter needs more documentation.
+  #
+  # Collection of rows and columns used by {Features.table}.
+  #
+  class Table
+    class Column < NattyUI::Attributes::Base
+      include NattyUI::Attributes::Width
+
+      # @return [Integer] column index
+      attr_reader :index
+
+      def width
+        @width ||= find_width
+      end
+
+      def to_s = "#{super.chop} @index:#{@index} @width:#{width.inspect}>"
+      alias inspect to_s
+
+      private
+
+      def find_width
+        min = max = nil
+        @parent.each_cell_of(@index) do |cell|
+          next unless cell
+          m = cell.attributes.min_width
+          min = m if m && (min.nil? || m < min)
+          m = cell.attributes.max_width
+          max = m if m && (max.nil? || max < m)
+        end
+        wh_from(min.to_i, max.to_i)
+      end
+
+      def respond_to_missing?(name, _)
+        return suoer unless name.end_with?('=')
+        Cell::Attributes.public_method_defined?(name) || super
+      end
+
+      def method_missing(name, *args, **kwargs)
+        return super unless name.end_with?('=')
+        return super unless Cell::Attributes.public_method_defined?(name)
+        @parent.each_cell_of(@index) { _1.attributes.__send__(name, *args) }
+        args[0]
+      end
+
+      def initialize(parent, index, **attributes)
+        super(**attributes)
+        @parent = parent
+        @index = index
+      end
+    end
+
+    class ColumnsCollection
+      include Enumerable
+
+      # @return [Integer] count of columns
+      def count = columns.size
+
+      def empty? = columns.empty?
+
+      # @return [Column, nil] column at given index
+      def [](index) = columns[index]
+
+      def each(&block) = columns.each(&block)
+
+      def to_s = "#{super.chop} @columns:#{columns.inspect}>"
+      alias inspect to_s
+
+      private
+
+      def columns
+        cc = @parent.column_count
+        case cc <=> @columns.size
+        when -1
+          @columns = @columns.take(cc)
+        when 1
+          bi = @columns.size
+          @columns +=
+            Array.new(cc - @columns.size) { Column.new(@parent, bi + _1) }
+        else
+          @columns
+        end
+      end
+
+      def initialize(parent)
+        @parent = parent
+        @columns = []
+      end
+
+      def initialize_copy(*_)
+        super
+        @columns = []
+      end
+    end
+
+    class Row
+      include Enumerable
+
+      def empty? = @cells.empty?
+
+      # @return [Integer] count of cells
+      def count = @cells.size
+
+      def each(&block) = @cells.each(&block)
+
+      # @return [Cell, nil] cell at given index
+      def [](index) = @cells[index]
+
+      # @return [Cell] created cell
+      def []=(index, *args)
+        @cells[index] = create_cell(args)
+        @cells.map! { _1 || Cell.new }
+      end
+
+      # Add a new cell to the row with given `text` and `attributes`.
+      # @return [Cell] created cell
+      def add(*text, **attributes)
+        nc = Cell.new(*text, **attributes)
+        @cells << nc
+        block_given? ? yield(nc) : nc
+      end
+
+      def delete(cell)
+        cell.is_a?(Cell) ? @cells.delete(cell) : @cells.delete_at(cell)
+        self
+      end
+
+      # Add a new cell to the row with given `text`.
+      # @return [Row] itself
+      def <<(text)
+        add(text)
+        self
+      end
+
+      private
+
+      def respond_to_missing?(name, _)
+        return super unless name.end_with?('=')
+        Cell::Attributes.public_method_defined?(name) || super
+      end
+
+      def method_missing(name, *args, **_)
+        return super unless name.end_with?('=')
+        return super unless Cell::Attributes.public_method_defined?(name)
+        @cells.each { _1.attributes.__send__(name, *args) }
+        args[0]
+      end
+
+      def initialize
+        @cells = []
+      end
+
+      def initialize_copy(*_)
+        super
+        @cells = @cells.map(&:dup)
+      end
+
+      def create_cell(args)
+        args.flatten!(1)
+        Cell.new(*args)
+      end
+    end
+
+    class Cell
+      include TextWithAttributes
+
+      class Attributes < NattyUI::Attributes::Base
+        prepend NattyUI::Attributes::Width
+        prepend NattyUI::Attributes::Padding
+        prepend NattyUI::Attributes::Align
+        prepend NattyUI::Attributes::Vertical
+        prepend NattyUI::Attributes::Style
+      end
+    end
+
+    class Attributes < NattyUI::Attributes::Base
+      prepend NattyUI::Attributes::Border
+      prepend NattyUI::Attributes::BorderStyle
+      prepend NattyUI::Attributes::BorderAround
+    end
+
+    include Enumerable
+    include WithAttributes
+
+    # @return [ColumnsCollection] table columns
+    attr_reader :columns
+
+    def empty? = @rows.empty?
+
+    # @return [Integer] count of rows
+    def count = @rows.size
+
+    # @return [Integer] count of columns
+    def column_count = @rows.empty? ? 0 : @rows.max_by(&:count).count
+
+    def each(&block) = @rows.each(&block)
+
+    def [](row_index, column_index = nil)
+      row = @rows[row_index] or return
+      column_index ? row[column_index] : row
+    end
+
+    # @return [Row] created row
+    def add(*text, **attributes)
+      nr = Row.new
+      @rows << nr
+      text.each { nr.add(_1, **attributes) }
+      block_given? ? yield(nr) : nr
+    end
+
+    def delete(row)
+      row.is_a?(Row) ? @rows.delete(row) : @rows.delete_at(row)
+    end
+
+    def each_cell_of(column_index)
+      return to_enum(__method__, column_index) unless block_given?
+      return if (column_index = column_index.to_i) >= column_count
+      @rows.each { yield(_1[column_index]) }
+      nil
+    end
+
+    private
+
+    def initialize(**attributes)
+      super
+      @rows = []
+      @columns = ColumnsCollection.new(self)
+    end
+
+    def initialize_copy(*_)
+      super
+      @columns = ColumnsCollection.new(self)
+      @rows = @rows.map(&:dup)
+    end
+  end
+end