natty-ui 0.34.0 → 1.0.2

data/lib/natty-ui/table_renderer.rb

@@ -1,165 +0,0 @@
-# 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?
-      att = table.attributes
-      case att.max_width
-      when Float
-        max_width *= att.max_width
-      when Integer
-        max_width = [max_width, att.max_width].min
-      end
-      unless att.border_chars.nil?
-        max_width -= (columns.size - 1)
-        max_width -= 2 if att.border_around
-      end
-      return [] if max_width < columns.size
-      new(columns, table.each.to_a, att, max_width).lines
-    end
-
-    attr_reader :lines
-
-    private
-
-    def initialize(columns, rows, att, max_width)
-      @max_width, @columns = WidthFinder.find(columns, max_width)
-      init_borders(att)
-      @columns = @columns.each.with_index
-
-      @lines = render(rows.shift)
-      @lines.unshift(@b_top) if @b_top
-
-      if @b_between
-        rows.each do |row|
-          @lines << @b_between
-          @lines += render(row)
-        end
-      else
-        rows.each { |row| @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(att)
-      chars = att.border_chars or return
-      style = border_style(att)
-      @b_inner = style[chars[9]]
-      return if chars[10] == ' '
-      return init_borders_around(chars, style) if att.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(att)
-      style = att.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, att.eol == false)
-      end
-
-      private
-
-      def width_corrected(text, width, ignore_newline)
-        @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,
-            ignore_newline: ignore_newline,
-            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
-
-    private_constant :Cell
-  end
-
-  private_constant :TableRenderer
-end

data/lib/natty-ui/theme.rb

@@ -1,403 +0,0 @@
-# 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 [Theme]
-      attr_reader :current
-
-      # Name of currently used theme
-      #
-      # @return [Symbol]
-      attr_reader :current_name
-
-      # Names of all registered themes
-      #
-      # @attribute [r] names
-      # @return [Array<Symbol>]
-      def names = @ll.keys.sort!
-
-      # Use a theme
-      #
-      # @param name [Symbol]
-      # @return [Symbol] name of used theme
-      def use(name)
-        sel = find(name).last
-        if sel.is_a?(Proc)
-          sel[builder = Builder.new]
-          sel = @ll[name][-1] = builder.build.freeze
-        end
-        @current = sel
-        @current_name = name
-      end
-
-      # Get the descrition of a theme.
-      #
-      # @param name [Symbol]
-      # @return [String] description of the theme
-      def description(name) = find(name).first
-
-      # Register a theme
-      #
-      # @param name [Symbol] theme name
-      # @param description [#to_s] theme description
-      # @yieldparam builder [Builder] theme build helper
-      # @return [Theme] itself
-      def register(name, description = nil, &block)
-        raise(ArgumentError, 'block missing') unless block
-        @ll[name.to_sym] = [description&.to_s || name.to_s.capitalize, block]
-        self
-      end
-
-      private
-
-      def find(name)
-        @ll.fetch(name) { raise(ArgumentError, "no such theme - #{name}") }
-      end
-    end
-
-    # @todo This chapter needs more documentation.
-    #
-    # Helper class to define a {Theme}.
-    #
-    class Builder
-      attr_accessor :section_border
-      attr_reader :mark,
-                  :border,
-                  :heading,
-                  :heading_sytle,
-                  :section_styles,
-                  :task_style,
-                  :choice_current_style,
-                  :choice_style,
-                  :sh_out_style,
-                  :sh_err_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 sh_out_style=(value)
-        @sh_out_style = Utils.style(value)
-      end
-
-      def sh_err_style=(value)
-        @sh_err_style = Utils.style(value)
-      end
-
-      # @return [Theme] new theme
-      def build = Theme.new(self)
-
-      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
-
-      private
-
-      def initialize
-        define_heading(%w[╸╸╺╸╺━━━ ╴╶╴╶─═══ ╴╶╴╶─── ════ ━━━━ ────])
-        @mark = {
-          default: '•',
-          bullet: '•',
-          checkmark: '✓',
-          quote: '▍',
-          information: '𝒊',
-          warning: '!',
-          error: '𝙓',
-          failed: '𝑭',
-          current: '➔',
-          choice: '◦',
-          current_choice: '◉',
-          option: '[ ]',
-          option_selected: '[X]',
-          sh_out: ':',
-          sh_err: '𝙓'
-        }
-        @border = {
-          ######### 0123456789012
-          default: '┌┬┐├┼┤└┴┘│─╶╴',
-          defaulth: '───────── ─╶╴',
-          defaultv: '││││││││││ ',
-          double: '╔╦╗╠╬╣╚╩╝║═',
-          doubleh: '═════════ ═',
-          doublev: '║║║║║║║║║║ ',
-          heavy: '┏┳┓┣╋┫┗┻┛┃━╺╸',
-          heavyh: '━━━━━━━━━ ━╺╸',
-          heavyv: '┃┃┃┃┃┃┃┃┃┃ ',
-          rounded: '╭┬╮├┼┤╰┴╯│─╶╴'
-        }
-        @section_border = :rounded
-        @section_styles = {}
-      end
-    end
-
-    attr_reader :task_style,
-                :choice_current_style,
-                :choice_style,
-                :sh_out_style,
-                :sh_err_style,
-                :option_states
-
-    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)
-      @sh_out_style = as_style(theme.sh_out_style)
-      @sh_err_style = as_style(theme.sh_err_style)
-      @sections =
-        create_sections(
-          SectionBorder.create(border(theme.section_border)),
-          theme.section_styles.dup.compare_by_identity
-        )
-      @option_states = create_option_states
-    end
-
-    private
-
-    def as_style(value) = (Ansi[*value].freeze if value)
-
-    def create_option_states
-      # [current?][selected?]
-      c = @mark[:current_choice]
-      n = @mark[:none]
-      uns = @mark[:option]
-      sel = @mark[:option_selected]
-      {
-        false => { false => n + uns, true => n + sel }.compare_by_identity,
-        true => { false => c + uns, true => c + sel }.compare_by_identity
-      }.compare_by_identity.freeze
-    end
-
-    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?
-      mark = mark.to_h { |n, e| [n.to_sym, Str.new("#{e} ")] }
-      mark[:none] ||= Str.new('  ', 2)
-      with_default(mark)
-    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.width)]
-      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.width)
-        ]
-      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)
-          if style
-            style = Ansi[*style]
-            reset = Ansi::RESET
-          end
-          [
-            Str.new("#{style}#{top}#{reset}", 6),
-            Str.new("#{style}#{top_left}#{reset} ", 4),
-            Str.new(" #{style}#{top_right}#{reset}", 6),
-            Str.new("#{style}#{bottom}#{reset}", 6),
-            Str.new("#{style}#{prefix}#{reset} ", 2)
-          ]
-        end
-      end
-
-    private_constant :SectionBorder
-
-    @ll = {}
-
-    register(:mono, 'Monochrome – Non-ANSI fallback', &:itself)
-
-    register(:default, 'Default – uses default colors') do |theme|
-      theme.heading_sytle = :bright_blue
-      theme.task_style = %i[bright_green b]
-      # theme.choice_style =
-      theme.sh_out_style = :default
-      theme.sh_err_style = :bright_yellow
-      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]',
-        current: '[bright_green]➔[/fg]',
-        choice: '[bright_white]◦[/fg]',
-        current_choice: '[bright_green]➔[/fg]',
-        option: '[dim][ ][/dim]',
-        option_selected: '[dim][[/dim][green]X[/fg][dim]][/dim]',
-        sh_out: '[bright_white]:[/fg]',
-        sh_err: '[red]𝙓[/fg]'
-      )
-      theme.define_section(
-        default: :bright_blue,
-        message: :bright_blue,
-        information: :bright_blue,
-        warning: :bright_yellow,
-        error: :red,
-        failed: :bright_red
-      )
-    end
-
-    register(:emoji, 'Emoji – emoticons and default colors') do |theme|
-      theme.heading_sytle = :bright_blue
-      theme.task_style = %i[bright_green b]
-      # theme.choice_style =
-      theme.sh_out_style = :default
-      theme.sh_err_style = :bright_red
-      theme.choice_current_style = %i[bright_white on_blue b]
-      theme.define_marker(
-        bullet: '▫️',
-        checkmark: '✅',
-        quote: '[bright_blue]▍[/fg]',
-        information: '📌',
-        warning: '⚠️',
-        error: '❗️',
-        failed: '‼️',
-        current: '➡️',
-        choice: '[bright_white]•[/fg]',
-        current_choice: '[bright_green]●[/fg]',
-        option: '[dim][ ][/dim] ',
-        option_selected: '[dim][[/dim][green]X[/fg][dim]][/dim]',
-        sh_out: '[white b]:[/]',
-        sh_err: '❗️'
-      )
-      theme.define_section(
-        default: :bright_blue,
-        message: :bright_blue,
-        information: :bright_blue,
-        warning: :bright_yellow,
-        error: :red,
-        failed: :bright_red
-      )
-    end
-
-    use(Terminal.colors == 2 ? :mono : :default)
-  end
-end

data/lib/natty-ui/utils.rb

@@ -1,111 +0,0 @@
-# frozen_string_literal: true
-
-module NattyUI
-  module Utils
-    class << self
-      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
-
-      def align(value)
-        POS_ALI.include?(value) ? value : :left
-      end
-
-      def position(value)
-        value if POS_ALI.include?(value)
-      end
-
-      def vertical(value)
-        VERT.include?(value) ? value : :top
-      end
-
-      def split_table_attr(values)
-        [values.slice(*TAB_ATTR), values.except(*TAB_ATTR)]
-      end
-
-      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
-          Array.new(4, value[0])
-        when 2
-          value * 2
-        when 3
-          value << value[1]
-        else
-          value
-        end
-      end
-      alias margin padding
-
-      def as_size(range, value)
-        return range.begin if value == :min
-        return range.end if value.nil? || value.is_a?(Symbol)
-        (
-          if value.is_a?(Numeric)
-            (value > 0 && value < 1 ? (range.end * value) : value).round
-          else
-            value.to_i
-          end
-        ).clamp(range)
-      end
-    end
-
-    POS_ALI = %i[right centered].freeze
-    VERT = %i[bottom middle].freeze
-    TAB_ATTR = %i[border_around border border_style position].freeze
-  end
-
-  class Str
-    attr_reader :to_s
-    alias to_str to_s
-    def empty? = width == 0
-    def inspect = @to_s.inspect
-
-    def width
-      return @width if @width
-      @width = Text.width(@to_s)
-      freeze
-      @width
-    end
-
-    def +(other)
-      other = Str.new(other) unless other.is_a?(Str)
-      Str.new(@to_s + other.to_s, width + other.width)
-    end
-
-    if Terminal.ansi?
-      def initialize(str, width = nil)
-        @to_s = Ansi.bbcode(str).freeze
-        return unless width
-        @width = @width.is_a?(Integer) ? width : Text.width(@to_s)
-        freeze
-      end
-    else
-      def initialize(str, width = nil)
-        @to_s = Ansi.plain(str).freeze
-        return unless width
-        @width = @width.is_a?(Integer) ? width : Text.width(@to_s)
-        freeze
-      end
-    end
-  end
-
-  private_constant :Utils, :Str
-end