natty-ui 0.6.0 → 0.8.0

data/lib/natty-ui/wrapper/section.rb

@@ -7,24 +7,12 @@ module NattyUI
     # Creates a default section and prints given arguments as lines
     # into the section.
     #
-    # @param [Array<#to_s>] args objects to print
+    # @param [Array<#to_s>] args optional objects to print
     # @yieldparam [Wrapper::Section] section the created section
     # @return [Object] the result of the code block
     # @return [Wrapper::Section] itself, when no code block is given
-    def section(*args, &block)
-      _section(self, :Section, args, prefix: '  ', suffix: '  ', &block)
-    end
+    def section(*args, &block) = _section(:Section, args, prefix: '  ', &block)
     alias sec section
-
-    # Creates a quotation section and prints given arguments as lines
-    # into the section.
-    #
-    # @param (see #section)
-    # @yieldparam (see #section)
-    # @return (see #section)
-    def quote(*args, &block)
-      _section(self, :Section, args, prefix: '▍ ', prefix_attr: 39, &block)
-    end
   end
 
   class Wrapper
@@ -34,47 +22,53 @@ module NattyUI
     # A section can contain other elements and sections.
     #
     # @see Features#section
-    # @see Features#quote
     class Section < Element
-      # Close the section.
-      #
-      # @return [Section] itself
-      def close = _close(:closed)
+      # @return [Integer] available columns count within the section
+      def available_width
+        @available_width ||=
+          @parent.available_width - @prefix_width - @suffix_width
+      end
 
-      # Print given arguments as lines into the section.
-      # Optionally limit the line width to given `max_width`.
+      # Print given arguments line-wise into the section.
       #
-      # @overload puts(..., max_width: nil)
+      # @overload puts(...)
       #   @param [#to_s] ... objects to print
-      #   @param [Integer, nil] max_width maximum line width
-      #   @comment @param [#to_s, nil] prefix line prefix
-      #   @comment @param [#to_s, nil] suffix line suffix
       #   @return [Section] itself
-      def puts(*args, max_width: nil, prefix: nil, suffix: nil)
+      def puts(*args, **kwargs)
         return self if @status
         @parent.puts(
           *args,
-          max_width: max_width,
-          prefix: prefix ? "#{@prefix}#{prefix}" : @prefix,
-          suffix: suffix ? "#{suffix}#{@suffix}" : @suffix
+          prefix: "#{@prefix}#{kwargs[:prefix]}",
+          prefix_width: @prefix_width + kwargs[:prefix_width].to_i,
+          suffix: "#{kwargs[:suffix]}#{@suffix}",
+          suffix_width: @suffix_width + kwargs[:suffix_width].to_i
         )
         self
       end
-      alias add puts
 
-      # Add at least one empty line
+      # Print given arguments into the section.
       #
-      # @param [#to_i] lines count of lines
-      # @return [Section] itself
-      def space(lines = 1)
-        @parent.puts(
-          "\n" * [lines.to_i, 1].max,
-          prefix: @prefix,
-          suffix: @suffix
+      # @overload print(...)
+      #   @param [#to_s] ... objects to print
+      #   @return [Section] itself
+      def print(*args, **kwargs)
+        return self if @status
+        @parent.print(
+          *args,
+          prefix: "#{@prefix}#{kwargs[:prefix]}",
+          prefix_width: @prefix_width + kwargs[:prefix_width].to_i,
+          suffix: "#{kwargs[:suffix]}#{@suffix}",
+          suffix_width: @suffix_width + kwargs[:suffix_width].to_i
         )
         self
       end
 
+      # Add at least one empty line
+      #
+      # @param [#to_i] lines count of lines
+      # @return [Section] itself
+      def space(lines = 1) = puts("\n" * [1, lines.to_i].max)
+
       # @note The screen manipulation is only available in ANSI mode see {#ansi?}
       #
       # Resets the part of the screen written below the current output line when
@@ -90,12 +84,20 @@ module NattyUI
       # @return [Object] block result
       def temporary = block_given? ? yield(self) : self
 
+      # @!visibility private
+      def inspect = @status ? "#{_to_s[..-2]} status=#{@status}>" : _to_s
+
       protected
 
-      def initialize(parent, prefix: nil, suffix: nil, **_)
+      def initialize(
+        parent,
+        prefix:,
+        prefix_width: NattyUI.display_width(prefix)
+      )
         super(parent)
         @prefix = prefix
-        @suffix = suffix
+        @prefix_width = prefix_width
+        @suffix_width = 0
       end
     end
   end

data/lib/natty-ui/wrapper/table.rb

@@ -0,0 +1,298 @@
+# frozen_string_literal: true
+require_relative 'element'
+
+module NattyUI
+  module Features
+    #
+    # Table view of data.
+    #
+    # @note Tables do not support text attributes yet and are still under
+    #   construction. This means table features are not complete defined and
+    #   may change in near future.
+    #
+    # @overload table(type: simple)
+    #   Construct and display a table.
+    #
+    #   @param [Symbol] type frame type;
+    #     valid types are `:simple`, `:heavy`, `:semi`, `:double`
+    #   @yieldparam [Table] table construction helper
+    #   @return [Wrapper::Section, Wrapper] it's parent object
+    #
+    #   @example
+    #    ui.table do |table|
+    #      table.add('name', 'price', 'origin')
+    #      table.add('apple', '1$', 'California')
+    #      table.add('banana', '2$', 'Brasil')
+    #      table.add('kiwi', '1.5$', 'Newzeeland')
+    #    end
+    #
+    #    # output:
+    #    # name   │ price │ origin
+    #    # ───────┼───────┼───────────
+    #    # apple  │ 1$    │ California
+    #    # ───────┼───────┼───────────
+    #    # banana │ 2$    │ Brasil
+    #    # ───────┼───────┼───────────
+    #    # kiwi   │ 1.5$  │ Newzeeland
+    #
+    # @overload table(*args, type: simple)
+    #   Display the given arrays as rows of a table.
+    #
+    #   @param [Array<#to_s>] args one or more arrays representing rows of the table
+    #   @param [Symbol] type frame type;
+    #     valid types are `:simple`, `:heavy`, `:semi`, `:double`
+    #   @return [Wrapper::Section, Wrapper] it's parent object
+    #
+    #   @example
+    #     ui.table(
+    #       %w[name price origin],
+    #       %w[apple 1$ California],
+    #       %w[banana 2$ Brasil],
+    #       %w[kiwi 1.5$ Newzeeland]
+    #     )
+    def table(*table, type: :simple)
+      table = Table.new(*table)
+      yield(table) if block_given?
+      _element(:Table, table.rows, type)
+    end
+
+    #
+    # Table-like display of key/value pairs.
+    #
+    # @param [#to_s] seperator
+    # @param [Hash<#to_s,#to_s>] kwargs
+    # @return [Wrapper::Section, Wrapper] it's parent object
+    #
+    # @example
+    #   ui.pairs(apple: '1$', banana: '2$', kiwi: '1.5$')
+    #
+    #   # output:
+    #   #  apple: 1$
+    #   # banana: 2$
+    #   #   kiwi: 1.5$
+    #
+    def pairs(seperator = ': ', **kwargs)
+      _element(:Pairs, Table.new(**kwargs).rows, seperator)
+    end
+
+    class Table
+      attr_reader :rows
+
+      def add_row(*columns)
+        @rows << columns
+        self
+      end
+      alias add add_row
+
+      def add_col(*columns)
+        columns.each_with_index do |col, row_idx|
+          (@rows[row_idx] ||= []) << col
+        end
+        self
+      end
+
+      def initialize(*args, **kwargs)
+        @rows = []
+        args.each { add_row(*_1) }
+        kwargs.each_pair { add_row(*_1) }
+      end
+    end
+    private_constant :Table
+  end
+
+  class Wrapper
+    # An {Element} to print a table.
+    #
+    # @see Features#table
+    class Table < Element
+      protected
+
+      def call(rows, type)
+        TableGenerator.each_line(
+          rows,
+          @parent.available_width - 1,
+          ORNAMENTS[type] ||
+            raise(ArgumentError, "invalid table type - #{type.inspect}"),
+          Ansi[39],
+          Ansi::RESET
+        ) { |line| @parent.puts(line) }
+        @parent
+      end
+
+      def coloring = [nil, nil]
+
+      ORNAMENTS = {
+        rounded: '│─┼',
+        simple: '│─┼',
+        heavy: '┃━╋',
+        double: '║═╬',
+        semi: '║╴╫'
+      }.compare_by_identity.freeze
+    end
+
+    # An {Element} to print key/value pairs.
+    #
+    # @see Features#pairs
+    class Pairs < Element
+      protected
+
+      def call(rows, seperator)
+        TableGenerator.each_simple_line(
+          rows,
+          @parent.available_width - 1,
+          seperator,
+          NattyUI.plain(seperator, ansi: false)[-1] == ' '
+        ) { |line| @parent.puts(line) }
+        @parent
+      end
+    end
+
+    class TableGenerator
+      def self.each_line(rows, max_width, ornament, opref, osuff)
+        return if rows.empty?
+        gen = new(rows, max_width, 3)
+        return unless gen.ok?
+        last_row = 0
+        col_div = " #{opref}#{ornament[0]}#{osuff} "
+        row_div = "#{ornament[1]}#{ornament[2]}#{ornament[1]}"
+        row_div =
+          "#{opref}#{gen.widths.map { ornament[1] * _1 }.join(row_div)}#{osuff}"
+        gen.each do |line, number|
+          if last_row != number
+            last_row = number
+            yield(row_div)
+          end
+          yield(line.join(col_div))
+        end
+      end
+
+      def self.each_simple_line(rows, max_width, col_div, first_right)
+        return if rows.empty?
+        gen = new(rows, max_width, NattyUI.display_width(col_div))
+        return unless gen.ok?
+        gen.aligns[0] = :right if first_right
+        gen.each { yield(_1.join(col_div)) }
+      end
+
+      attr_reader :widths, :aligns
+
+      def initialize(rows, max_width, col_div_size)
+        @rows =
+          rows.map do |row|
+            row.map do |col|
+              col = NattyUI.embellish(col).each_line(chomp: true).to_a
+              col.empty? ? col << '' : col
+            end
+          end
+        @max_width = max_width
+        @col_div_size = col_div_size
+        @widths = create_widths.freeze
+        @aligns = Array.new(@widths.size, :left)
+      end
+
+      def ok? = (@widths != nil)
+
+      def each
+        return unless @widths
+        col_empty = @widths.map { ' ' * _1 }
+        @rows.each_with_index do |row, row_idx|
+          row
+            .max_by(&:size)
+            .size
+            .times do |line_nr|
+              col_idx = -1
+              yield(
+                @widths.map do |col_width|
+                  cell = row[col_idx += 1] or next col_empty[col_idx]
+                  next col_empty[col_idx] if (line = cell[line_nr]).nil?
+                  align(line.to_s, col_width, @aligns[col_idx])
+                end,
+                row_idx
+              )
+            end
+        end
+      end
+
+      private
+
+      def align(str, width, alignment)
+        return str unless (width -= NattyUI.display_width(str)).positive?
+        return str << (' ' * width) if alignment == :left
+        (' ' * width) << str
+      end
+
+      def create_widths
+        matrix = create_matrix
+        col_widths = find_col_widths(matrix)
+        adjusted = adjusted_widths(col_widths)
+        return if adjusted.empty? # nothing to draw
+        return adjusted if col_widths == adjusted # all fine
+        if (size = adjusted.size) != col_widths.size
+          @rows.map! { _1.take(size) }
+          matrix.map! { _1.take(size) }
+          col_widths = col_widths.take(size)
+        end
+        diff = diff(col_widths, adjusted)
+        @rows.each_with_index do |row, row_idx|
+          diff.each do |col_idx|
+            adjust_to = adjusted[col_idx]
+            next if matrix[row_idx][col_idx] <= adjust_to
+            ary = NattyUI.each_line(*row[col_idx], max_width: adjust_to).to_a
+            ary.pop if ary.last.empty?
+            row[col_idx] = ary
+          end
+        end
+        adjusted
+      end
+
+      def create_matrix
+        ret =
+          @rows.map do |row|
+            row.map { |col| col.map { NattyUI.display_width(_1) }.max }
+          end
+        cc = ret.max_by(&:size).size
+        ret.each { (add = cc - _1.size).nonzero? and _1.fill(0, _1.size, add) }
+      end
+
+      def find_col_widths(matrix)
+        ret = nil
+        matrix.each do |row|
+          next ret = row.dup unless ret
+          row.each_with_index do |size, idx|
+            hs = ret[idx]
+            ret[idx] = size if hs < size
+          end
+        end
+        ret
+      end
+
+      def adjusted_widths(col_widths)
+        ret = col_widths.dup
+        if ret.sum <=
+             (left = @max_width - (@col_div_size * (col_widths.size - 1)))
+          return ret
+        end
+        indexed = ret.each_with_index.to_a
+        # TODO: optimize this!
+        until ret.sum <= left
+          indexed.sort! { |b, a| (a[0] <=> b[0]).nonzero? || (a[1] <=> b[1]) }
+          pair = indexed[0]
+          next ret[pair[1]] = pair[0] if (pair[0] -= 1).nonzero?
+          indexed.shift
+          return [] if indexed.empty?
+          ret.pop
+        end
+        ret
+      end
+
+      def diff(col_widths, adjusted)
+        ret = []
+        col_widths.each_with_index do |val, idx|
+          ret << idx if val != adjusted[idx]
+        end
+        ret
+      end
+    end
+    private_constant :TableGenerator
+  end
+end

data/lib/natty-ui/wrapper/task.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'section'
-require_relative '../mixins'
+require_relative 'mixins'
 
 module NattyUI
   module Features
@@ -15,31 +15,28 @@ module NattyUI
     # @return [Object] the result of the code block
     # @return [Wrapper::Task] itself, when no code block is given
     def task(title, *args, &block)
-      _section(self, :Task, args, title: title, &block)
+      _section(:Task, args, title: title, &block)
     end
   end
 
   module TaskMethods
     protected
 
-    def initialize(parent, title:, **opts)
-      @parent = parent
-      @temp = wrapper.temporary
+    def initialize(parent, title:)
+      @temp = parent.wrapper.temporary
       @final_text = [title]
-      super(parent, title: title, symbol: :task, **opts)
+      super(parent, title: title, glyph: :task)
     end
 
     def finish
-      unless failed?
-        @status = :completed if @status == :closed
-        @temp.call
-      end
+      return @parent.failed(*@final_text) if failed?
+      @temp.call
       _section(
-        @parent,
         :Message,
         @final_text,
+        owner: @parent,
         title: @final_text.shift,
-        symbol: @status
+        glyph: @status = :completed
       )
     end
   end

data/lib/natty-ui/wrapper.rb

@@ -1,15 +1,19 @@
 # frozen_string_literal: true
 
 require 'io/console'
+require_relative 'ansi'
 require_relative 'wrapper/ask'
 require_relative 'wrapper/framed'
 require_relative 'wrapper/heading'
+require_relative 'wrapper/horizontal_rule'
 require_relative 'wrapper/list_in_columns'
 require_relative 'wrapper/message'
 require_relative 'wrapper/progress'
 require_relative 'wrapper/query'
+require_relative 'wrapper/quote'
 require_relative 'wrapper/request'
 require_relative 'wrapper/section'
+require_relative 'wrapper/table'
 require_relative 'wrapper/task'
 
 module NattyUI
@@ -28,61 +32,60 @@ module NattyUI
 
     # @attribute [r] screen_size
     # @return [[Integer, Integer]] screen size as rows and columns
-    def screen_size
-      return @stream.winsize if @ws
-      [ENV['LINES'].to_i.nonzero? || 24, ENV['COLUMNS'].to_i.nonzero? || 80]
-    end
+    def screen_size = (@screen_size ||= determine_screen_size)
 
     # @attribute [r] screen_rows
     # @return [Integer] number of screen rows
-    def screen_rows
-      @ws ? @stream.winsize[0] : (ENV['LINES'].to_i.nonzero? || 24)
-    end
+    def screen_rows = screen_size[0]
 
     # @attribute [r] screen_columns
     # @return [Integer] number of screen columns
-    def screen_columns
-      @ws ? @stream.winsize[-1] : (ENV['COLUMNS'].to_i.nonzero? || 80)
-    end
+    def screen_columns = screen_size[1]
 
     # @!group Tool functions
 
-    # Print given arguments as lines to the output stream.
-    # Optionally limit the line width to given `max_width`.
+    # Print given arguments line-wise to the output stream.
     #
-    # @overload puts(..., max_width: nil)
+    # @overload puts(...)
     #   @param [#to_s] ... objects to print
-    #   @param [Integer, nil] max_width maximum line width
-    #   @comment @param [#to_s, nil] prefix line prefix
-    #   @comment @param [#to_s, nil] suffix line suffix
     #   @return [Wrapper] itself
-    def puts(*args, max_width: nil, prefix: nil, suffix: nil)
-      if args.empty?
-        @stream.puts(embellish("#{prefix}#{suffix}"))
-        @lines_written += 1
-      else
-        NattyUI.each_line(*args, max_width: max_width) do |line|
-          @stream.puts(embellish("#{prefix}#{line}#{suffix}"))
-          @lines_written += 1
-        end
-      end
+    def puts(*args, **kwargs)
+      args = prepare_print(args, kwargs)
+      @lines_written += args.size
+      @stream.puts(args)
+      @stream.flush
+      self
+    end
+
+    # Print given arguments to the output stream.
+    #
+    # @overload print(...)
+    #   @param [#to_s] ... objects to print
+    #   @return [Wrapper] itself
+    def print(*args, **kwargs)
+      args = prepare_print(args, kwargs).to_a
+      @lines_written += args.size - 1
+      @stream.print(args.join("\n"))
       @stream.flush
       self
     end
-    alias add puts
 
     # Add at least one empty line
     #
     # @param [#to_i] lines count of lines
     # @return [Wrapper] itself
     def space(lines = 1)
-      lines = [lines.to_i, 1].max
-      @stream << ("\n" * lines)
+      lines = [1, lines.to_i].max
+      (@stream << ("\n" * lines)).flush
       @lines_written += lines
-      @stream.flush
       self
     end
 
+    # Clear Screen
+    #
+    # @return [Wrapper] itself
+    def cls = self
+
     # @note The screen manipulation is only available in ANSI mode see {#ansi?}
     #
     # Saves current screen, deletes all screen content and moves the cursor
@@ -137,11 +140,47 @@ module NattyUI
     # @!visibility private
     alias inspect to_s
 
+    # @attribute [r] wrapper
+    # @return [Wrapper] self
+    alias wrapper itself
+
+    # @!visibility private
+    alias available_width screen_columns
+
+    # @!visibility private
+    def prefix = ''
+
+    # @return [Array<Symbol>] available glyph names
+    def glyph_names = GLYPHS.keys
+
+    #
+    # Get a pre-defined glyph
+    #
+    # @param [Symbol] name glyph name
+    # @return [String] the named glyph
+    # @return [nil] when glyph is not defined
+    def glyph(name) = GLYPHS[name]
+
     protected
 
-    def embellish(obj)
-      obj = NattyUI.plain(obj)
-      obj.empty? ? nil : obj
+    def prepare_print(args, kwargs)
+      prefix = kwargs[:prefix] and prefix = NattyUI.plain(prefix, ansi: false)
+      suffix = kwargs[:suffix] and suffix = NattyUI.plain(suffix, ansi: false)
+      return ["#{prefix}#{suffix}"] if args.empty?
+      NattyUI
+        .each_line(
+          *args.map! { NattyUI.plain(_1, ansi: false) },
+          max_width: max_with(prefix, suffix, kwargs)
+        )
+        .map { "#{prefix}#{_1}#{suffix}" }
+    end
+
+    def max_with(prefix, suffix, kwargs)
+      mw = kwargs[:max_width] and return mw
+      mw = screen_columns
+      mw -= kwargs[:prefix_width] || NattyUI.display_width(prefix) if prefix
+      mw -= kwargs[:suffix_width] || NattyUI.display_width(suffix) if suffix
+      mw
     end
 
     def temp_func
@@ -154,21 +193,55 @@ module NattyUI
     def initialize(stream)
       @stream = stream
       @lines_written = 0
-      @ws = stream.respond_to?(:winsize) && stream.winsize&.all?(&:positive?)
-    rescue Errno::ENOTTY
-      @ws = false
     end
 
-    def wrapper = self
-    def prefix = nil
-    alias suffix prefix
+    private_class_method :new
 
-    def prefix_width = 0
-    alias suffix_width prefix_width
-    alias width prefix_width
+    private
 
-    alias available_width screen_columns
+    def determine_screen_size
+      return @stream.winsize if @ws
+      if @ws.nil?
+        ret = try_fetch_winsize
+        if ret
+          @ws = true
+          Signal.trap('WINCH') { @screen_size = nil }
+          return ret
+        end
+        @ws = false
+      end
+      [ENV['LINES'].to_i.nonzero? || 24, ENV['COLUMNS'].to_i.nonzero? || 80]
+    end
 
-    private_class_method :new
+    def try_fetch_winsize
+      return unless @stream.respond_to?(:winsize)
+      ret = @stream.winsize
+      ret&.all?(&:positive?) ? ret : nil
+    rescue SystemCallError
+      nil
+    end
+
+    GLYPHS = {
+      default: "#{Ansi[:bold, 255]}•#{Ansi::RESET}",
+      information: "#{Ansi[:bold, 119]}𝒊#{Ansi::RESET}",
+      warning: "#{Ansi[:bold, 221]}!#{Ansi::RESET}",
+      error: "#{Ansi[:bold, 208]}𝙓#{Ansi::RESET}",
+      completed: "#{Ansi[:bold, 82]}✓#{Ansi::RESET}",
+      failed: "#{Ansi[:bold, 196]}𝑭#{Ansi::RESET}",
+      task: "#{Ansi[:bold, 39]}➔#{Ansi::RESET}",
+      query: "#{Ansi[:bold, 39]}▸#{Ansi::RESET}"
+    }.compare_by_identity.freeze
+
+    # GLYPHS = {
+    #   default: '●',
+    #   information: '🅸 ',
+    #   warning: '🆆 ',
+    #   error: '🅴 ',
+    #   completed: '✓',
+    #   failed: '🅵 ',
+    #   task: '➔',
+    #   query: '🆀 '
+    # }.compare_by_identity.freeze
+    private_constant :GLYPHS
   end
 end