natty-ui 0.12.1 → 0.25.0

data/lib/natty-ui/table_renderer.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require 'terminal/text'
+require_relative 'width_finder'
+
+module NattyUI
+  class TableRenderer
+    def self.[](table, max_width)
+      columns = table.columns.map(&:width)
+      return [] if columns.empty?
+      attributes = table.attributes
+      unless attributes.border_chars.nil?
+        max_width -= (columns.size - 1)
+        max_width -= 2 if attributes.border_around
+      end
+      return [] if max_width < columns.size
+      new(columns, table.each.to_a, attributes, max_width).lines
+    end
+
+    attr_reader :lines
+
+    private
+
+    def initialize(columns, rows, attributes, max_width)
+      @max_width, @columns = WidthFinder.find(columns, max_width)
+      init_borders(attributes)
+      @columns = @columns.each.with_index
+      @lines = render(rows.shift)
+      @lines.unshift(@b_top) if @b_top
+      rows.each do |row|
+        @lines << @b_between if @b_between
+        @lines += render(row)
+      end
+      @lines << @b_bottom if @b_bottom
+    end
+
+    def render(row)
+      cells = @columns.map { |cw, i| Cell.new(row[i], cw) }
+      height = cells.max_by { _1.text.size }.text.size
+      cells.each { _1.correct_height(height) }
+      Array.new(height) do |line|
+        "#{@b_outer}#{cells.map { _1.text[line] }.join(@b_inner)}#{@b_outer}"
+      end
+    end
+
+    def init_borders(attributes)
+      chars = attributes.border_chars or return
+      style = border_style(attributes)
+      @b_inner = style[chars[9]]
+      return init_borders_around(chars, style) if attributes.border_around
+      @b_between = chars[10] * (@max_width + @columns.size - 1)
+      i = -1
+      @columns[0..-2].each { |w| @b_between[i += w + 1] = chars[4] }
+      @b_between = style[@b_between]
+    end
+
+    def init_borders_around(chars, style)
+      fw = chars[10] * (@max_width + @columns.size - 1)
+      @b_top = "#{chars[0]}#{fw}#{chars[2]}"
+      @b_bottom = "#{chars[6]}#{fw}#{chars[8]}"
+      @b_between = "#{chars[3]}#{fw}#{chars[5]}"
+      i = 0
+      @columns[0..-2].each do |w|
+        @b_top[i += w + 1] = chars[1]
+        @b_bottom[i] = chars[7]
+        @b_between[i] = chars[4]
+      end
+      @b_top = style[@b_top]
+      @b_bottom = style[@b_bottom]
+      @b_between = style[@b_between]
+      @b_outer = @b_inner
+    end
+
+    def border_style(attributes)
+      style = attributes.border_style_bbcode
+      style ? ->(line) { "#{style}#{line}[/]" } : lambda(&:itself)
+    end
+
+    class Cell
+      attr_reader :width, :text
+
+      def correct_height(height)
+        return self if (diff = height - @text.size) <= 0
+        @text =
+          case @vertical
+          when :bottom
+            [Array.new(diff, @empty), @text]
+          when :middle
+            tc = diff / 2
+            [Array.new(tc, @empty), @text, Array.new(diff - tc, @empty)]
+          else
+            [@text, Array.new(diff, @empty)]
+          end.flatten(1)
+        self
+      end
+
+      def initialize(cell, width)
+        return @text = [] unless cell
+        att = cell.attributes
+        @padding = att.padding.dup
+        @align = att.align
+        @vertical = att.vertical
+        @style = att.style_bbcode
+        @text = width_corrected(cell.text, width)
+      end
+
+      private
+
+      def width_corrected(text, width)
+        @width, @padding[3], @padding[1] =
+          WidthFinder.adjust(width, @padding[3], @padding[1])
+        @empty = @style ? "#{@style}#{' ' * width}[/]" : ' ' * width
+        [
+          Array.new(@padding[0], @empty),
+          Text.each_line_with_size(
+            *text,
+            limit: @width,
+            bbcode: true,
+            ansi: Terminal.ansi?
+          ).map(&txt_fmt),
+          Array.new(@padding[2], @empty)
+        ].flatten(1)
+      end
+
+      def txt_fmt
+        lpad, rpad = pads
+        case @align
+        when :right
+          ->(txt, w) { "#{lpad}#{' ' * (@width - w)}#{txt}#{rpad}" }
+        when :centered
+          lambda do |txt, w|
+            s = @width - w
+            "#{lpad}#{' ' * (lw = s / 2)}#{txt}#{' ' * (s - lw)}#{rpad}"
+          end
+        else
+          ->(txt, w) { "#{lpad}#{txt}#{' ' * (@width - w)}#{rpad}" }
+        end
+      end
+
+      def pads
+        return ' ' * @padding[3], "[/]#{' ' * @padding[1]}" unless @style
+        ["#{@style}#{' ' * @padding[3]}", "#{' ' * @padding[1]}[/]"]
+      end
+    end
+  end
+  private_constant :TableRenderer
+end

data/lib/natty-ui/task.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative 'element'
+
+module NattyUI
+  # {Element} implemting a task display section used by {Features.task}.
+  #
+  class Task < Temporary
+    include StateMixin
+
+    private
+
+    def finish_ok(text)
+      NattyUI.back_to_line(@start_line)
+      @start_line = nil
+      cm = Theme.current.mark(:checkmark)
+      text << @title if text.empty?
+      @parent.puts(
+        *text,
+        first_line_prefix: cm,
+        first_line_prefix_width: cm.width,
+        pin: @pin
+      )
+      super()
+    end
+
+    def initialize(parent, title, msg, pin)
+      super(parent)
+      @title = title
+      @prefix = '  '
+      @prefix_width = 2
+      @pin = pin
+      style = Theme.current.task_style
+      parent.puts(
+        title,
+        first_line_prefix: "#{style}➔ ",
+        first_line_prefix_width: 2,
+        prefix: "#{style}  ",
+        prefix_width: 2
+      )
+      puts(*msg) unless msg.empty?
+    end
+  end
+end

data/lib/natty-ui/temporary.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require_relative 'element'
+
+module NattyUI
+  # {Element} implemting a temprary display section used by
+  # {Features.temporary}.
+  #
+  class Temporary < Element
+    # @!visibility private
+    def puts(*objects, **options)
+      return self if @state
+      if options.delete(:pin)
+        @pins ||= []
+        @pins << [objects, options.except(:prefix_width, :suffix_width)]
+      end
+      super
+    end
+
+    # @!visibility private
+    def done
+      return self if @state
+      NattyUI.back_to_line(@start_line) if @start_line
+      @pins&.each { |objects, options| puts(*objects, **options) }
+      @state = :ok
+      self
+    end
+
+    private
+
+    alias finish_ok done
+
+    def initialize(parent)
+      @start_line = NattyUI.lines_written
+      super
+    end
+  end
+end

data/lib/natty-ui/theme.rb

@@ -0,0 +1,303 @@
+# frozen_string_literal: true
+
+require_relative 'utils'
+
+module NattyUI
+  # @todo This chapter needs more documentation.
+  #
+  # A theme defines the style of elements.
+  #
+  class Theme
+    class << self
+      # Currently used theme
+      #
+      # @return [Compiled]
+      attr_reader :current
+
+      # @attribute [w] current
+      def current=(value)
+        case value
+        when Theme::Compiled
+          @current = value
+        when Theme
+          @current = value.compiled
+        else
+          raise(TypeError, 'Theme expected')
+        end
+      end
+
+      # Create a theme.
+      #
+      # @return [Theme] new theme
+      def create
+        theme = new
+        yield(theme) if block_given?
+        theme
+      end
+
+      # Default theme.
+      #
+      # @attribute [r] default
+      # @return [Theme] default theme
+      def default
+        create do |theme|
+          theme.heading_sytle = :bright_blue
+          theme.task_style = %i[bright_green b]
+          # theme.choice_style =
+          theme.choice_current_style = %i[bright_white on_blue b]
+          theme.define_marker(
+            bullet: '[bright_white]•[/fg]',
+            checkmark: '[bright_green]✓[/fg]',
+            quote: '[bright_blue]▍[/fg]',
+            information: '[bright_yellow]𝒊[/fg]',
+            warning: '[bright_yellow]![/fg]',
+            error: '[red]𝙓[/fg]',
+            failed: '[bright_red]𝑭[/fg]',
+            choice: '[bright_white]◦[/fg]',
+            current_choice: '[bright_green]◉[/fg]'
+          )
+          theme.define_section(
+            default: :bright_blue,
+            message: :bright_blue,
+            information: :bright_blue,
+            warning: :bright_yellow,
+            error: :red,
+            failed: :bright_red
+          )
+        end
+      end
+    end
+
+    attr_accessor :section_border
+    attr_reader :mark,
+                :border,
+                :heading,
+                :heading_sytle,
+                :section_styles,
+                :task_style,
+                :choice_current_style,
+                :choice_style
+
+    def heading_sytle=(value)
+      @heading_sytle = Utils.style(value)
+    end
+
+    def task_style=(value)
+      @task_style = Utils.style(value)
+    end
+
+    def choice_current_style=(value)
+      @choice_current_style = Utils.style(value)
+    end
+
+    def choice_style=(value)
+      @choice_style = Utils.style(value)
+    end
+
+    def compiled = Compiled.new(self).freeze
+
+    def define_marker(**defs)
+      @mark.merge!(defs)
+      self
+    end
+
+    def define_border(**defs)
+      defs.each_pair do |name, str|
+        s = str.to_s
+        case Text.width(s, bbcode: false)
+        when 1
+          @border[name.to_sym] = "#{s * 11}  "
+        when 11
+          @border[name.to_sym] = "#{s}  "
+        when 13
+          @border[name.to_sym] = s
+        else
+          raise(
+            TypeError,
+            "invalid boder definition for #{name} - #{str.inspect}"
+          )
+        end
+      end
+      self
+    end
+
+    def define_heading(*defs)
+      @heading = defs.flatten.take(6)
+      @heading += Array.new(6 - @heading.size, @heading[-1])
+      self
+    end
+
+    def define_section(**defs)
+      defs.each_pair do |name, style|
+        style = Utils.style(style)
+        @section_styles[name.to_sym] = style if style
+      end
+      self
+    end
+
+    class Compiled
+      attr_reader :task_style, :choice_current_style, :choice_style
+
+      def defined_marks = @mark.keys.sort!
+      def defined_borders = @border.keys.sort!
+
+      def heading(index) = @heading[index.to_i.clamp(1, 6) - 1]
+
+      def mark(value)
+        return @mark[value] if value.is_a?(Symbol)
+        (element = Str.new(value, true)).empty? ? @mark[:default] : element
+      end
+
+      def border(value)
+        return @border[value] if value.is_a?(Symbol)
+        case Text.width(value = value.to_s, bbcode: false)
+        when 1
+          "#{value * 11}  "
+        when 11
+          "#{value}  "
+        when 13
+          value
+        else
+          @border[:default]
+        end
+      end
+
+      def section_border(kind)
+        kind.is_a?(Symbol) ? @sections[kind] : @sections[:default]
+      end
+
+      def initialize(theme)
+        @heading = create_heading(theme.heading, theme.heading_sytle).freeze
+        @border = create_border(theme.border).freeze
+        @mark = create_mark(theme.mark).freeze
+        @task_style = as_style(theme.task_style)
+        @choice_current_style = as_style(theme.choice_current_style)
+        @choice_style = as_style(theme.choice_style)
+        @sections =
+          create_sections(
+            SectionBorder.create(border(theme.section_border)),
+            theme.section_styles.dup.compare_by_identity
+          )
+      end
+
+      private
+
+      def as_style(value) = (Ansi[*value].freeze if value)
+
+      def create_sections(template, styles)
+        Hash
+          .new do |h, kind|
+            h[kind] = SectionBorder.new(*template.parts(styles[kind])).freeze
+          end
+          .compare_by_identity
+      end
+
+      def create_mark(mark)
+        return {} if mark.empty?
+        with_default(mark.to_h { |n, e| [n.to_sym, Str.new("#{e} ")] })
+      end
+
+      def create_border(border)
+        return {} if border.empty?
+        with_default(border.transform_values { _1.dup.freeze })
+      end
+
+      def create_heading(heading, style)
+        return create_styled_heading(heading, style) if style
+        heading.map do |left|
+          right = " #{left.reverse}"
+          [left = Str.new("#{left} ", true), Str.new(right, left.size)]
+        end
+      end
+
+      def create_styled_heading(heading, style)
+        heading.map do |left|
+          right = Ansi.decorate(left.reverse, *style)
+          [
+            left = Str.new("#{Ansi.decorate(left, *style)} ", true),
+            Str.new(" #{right}", left.size)
+          ]
+        end
+      end
+
+      def with_default(map)
+        map.default = (map[:default] ||= map[map.first.first])
+        map.compare_by_identity
+      end
+
+      SectionBorder =
+        Struct.new(:top, :top_left, :top_right, :bottom, :prefix) do
+          def self.create(border)
+            mid = border[10] * 2
+            mid2 = mid * 2
+            right = "#{border[11]}#{border[12] * 2}"
+            new(
+              border[0] + mid2 + right,
+              border[0] + mid,
+              mid + right,
+              border[6] + mid2 + right,
+              border[9]
+            )
+          end
+
+          def parts(style)
+            unless style
+              return [
+                Str.new(top, 6),
+                Str.new("#{top_left} ", 4),
+                Str.new(" #{top_right}", 6),
+                Str.new(bottom, 6),
+                Str.new("#{prefix} ", 2)
+              ]
+            end
+            style = Ansi[*style]
+            [
+              # TODO: use rather [/fg]
+              Str.new("#{style}#{top}#{Ansi::RESET}", 6),
+              Str.new("#{style}#{top_left}#{Ansi::RESET} ", 4),
+              Str.new(" #{style}#{top_right}#{Ansi::RESET}", 6),
+              Str.new("#{style}#{bottom}#{Ansi::RESET}", 6),
+              Str.new("#{style}#{prefix}#{Ansi::RESET} ", 2)
+            ]
+          end
+        end
+
+      private_constant :SectionBorder
+    end
+
+    private
+
+    def initialize
+      define_heading(%w[╸╸╺╸╺━━━ ╴╶╴╶─═══ ╴╶╴╶─── ════ ━━━━ ────])
+      @mark = {
+        default: '•',
+        bullet: '•',
+        checkmark: '✓',
+        quote: '▍',
+        information: '𝒊',
+        warning: '!',
+        error: '𝙓',
+        failed: '𝑭',
+        choice: '◦',
+        current_choice: '◉'
+      }
+      @border = {
+        ######### 0123456789012
+        default: '┌┬┐├┼┤└┴┘│─╶╴',
+        defaulth: '───────── ─╶╴',
+        defaultv: '││││││││││ ',
+        double: '╔╦╗╠╬╣╚╩╝║═',
+        doubleh: '═════════ ═',
+        doublev: '║║║║║║║║║║ ',
+        heavy: '┏┳┓┣╋┫┗┻┛┃━╺╸',
+        heavyh: '━━━━━━━━━ ━╺╸',
+        heavyv: '┃┃┃┃┃┃┃┃┃┃ ',
+        rounded: '╭┬╮├┼┤╰┴╯│─╶╴'
+      }
+      @section_border = :rounded
+      @section_styles = {}
+    end
+
+    self.current = Terminal.colors == 2 ? new : default
+  end
+end

data/lib/natty-ui/utils.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module NattyUI
+  module Utils
+    class << self
+      # @!visibility private
+      def style(value)
+        value =
+          case value
+          when Array
+            value.dup
+          when Enumerable
+            value.to_a
+          when Symbol, Integer
+            [value]
+          when nil
+            return
+          else
+            value.to_s.delete_prefix('[').delete_suffix(']').split
+          end
+        value.uniq!
+        value.keep_if { Ansi.valid?(_1) }.empty? ? nil : value
+      end
+
+      # @!visibility private
+      def align(value)
+        value == :right || value == :centered ? value : :left
+      end
+
+      # @!visibility private
+      def vertical(value)
+        value == :bottom || value == :middle ? value : :top
+      end
+
+      # @!visibility private
+      def padding(*value)
+        value = value.flatten.take(4).map! { [0, _1.to_i].max }
+        case value.size
+        when 0
+          [0, 0, 0, 0]
+        when 1
+          [value[0], 0, 0, 0]
+        when 2
+          value * 2
+        when 3
+          value << value[1]
+        else
+          value
+        end
+      end
+      alias margin padding
+    end
+  end
+
+  class Str
+    attr_reader :to_s
+
+    alias to_str to_s
+    def inspect = to_s.inspect
+    def empty? = size == 0
+
+    def size
+      return @size if @size
+      @size = Text.width(self)
+      freeze
+      @size
+    end
+    alias width size
+
+    def initialize(str, size = nil)
+      @to_s = Ansi.bbcode(str).freeze
+      return unless size
+      @size = @size.is_a?(Integer) ? size : Text.width(self)
+      freeze
+    end
+  end
+
+  private_constant :Utils, :Str
+end

data/lib/natty-ui/version.rb

@@ -2,5 +2,5 @@
 
 module NattyUI
   # The version number of the gem.
-  VERSION = '0.12.1'
+  VERSION = '0.25.0'
 end