natty-ui 0.12.0 → 0.25.0

data/lib/natty-ui/ansi.rb

@@ -1,521 +0,0 @@
-# frozen_string_literal: true
-
-module NattyUI
-  #
-  # Helper module for ANSI escape codes.
-  #
-  module Ansi
-    class << self
-      # Supported attribute names.
-      # @see []
-      #
-      # @attribute [r] attribute_names
-      # @return [Array<Symbol>] supported attribute names
-      def attribute_names = SATTR.keys.sort!
-
-      # Supported color names.
-      # @see []
-      #
-      # @attribute [r] color_names
-      # @return [Array<Symbol>] supported color names
-      def color_names = SCLR.keys
-
-      # @!group Control functions
-
-      # Move cursor given lines up.
-      #
-      # @param lines [Integer] number of lines to move
-      # @return [String] ANSI control code
-      def cursor_up(lines = 1) = "\e[#{lines}A"
-
-      # Move cursor given lines down.
-      #
-      # @param (see cursor_up)
-      # @return (see cursor_up)
-      def cursor_down(lines = 1) = "\e[#{lines}B"
-
-      # Move cursor given colums forward.
-      #
-      # @param columns [Integer] number of columns to move
-      # @return (see cursor_up)
-      def cursor_forward(columns = 1) = "\e[#{columns}C"
-
-      # Move cursor given colums back.
-      #
-      # @param (see cursor_forward)
-      # @return (see cursor_up)
-      def cursor_back(columns = 1) = "\e[#{columns}D"
-
-      # Move cursor of beginning of the given next line.
-      #
-      # @param (see cursor_up)
-      # @return (see cursor_up)
-      def cursor_next_line(lines = 1) = "\e[#{lines}E"
-
-      # Move cursor of beginning of the given previous line.
-      #
-      # @param (see cursor_up)
-      # @return (see cursor_up)
-      def cursor_previous_line(lines = 1) = "\e[#{lines}F"
-      alias cursor_prev_line cursor_previous_line
-
-      # Move cursor to given column in the current row.
-      #
-      # @param column [Integer] column index
-      # @return (see cursor_up)
-      def cursor_column(column = 1) = "\e[#{column}G"
-
-      # Move cursor to given row and column counting from the top left corner.
-      #
-      # @param row [Integer] row index
-      # @param column [Integer] column index
-      # @return (see cursor_up)
-      def cursor_pos(row, column = nil)
-        return column ? "\e[#{row};#{column}H" : "\e[#{row}H" if row
-        column ? "\e[;#{column}H" : "\e[H"
-      end
-
-      # @comment ??? def cursor_tab(count = 1) = "\e[#{column}I"
-
-      # Erase screen.
-      #
-      # @param part [:below, :above, :scrollback, :entire] part to erase
-      # @return (see cursor_up)
-      def screen_erase(part = :entire)
-        return "\e[0J" if part == :below
-        return "\e[1J" if part == :above
-        return "\e[3J" if part == :scrollback
-        "\e[2J"
-      end
-
-      # Clear part of current line.
-      #
-      # @param part [:to_end, :to_start, :entire] part to delete
-      # @return (see cursor_up)
-      def line_erase(part = :entire)
-        return "\e[0K" if part == :to_end
-        return "\e[1K" if part == :to_start
-        "\e[2K"
-      end
-
-      # @comment ??? def line_insert(lines = 1) = "\e[#{lines}L"
-      # @comment ??? def line_delete(lines = 1) = "\e[#{lines}M"
-      # @comment ??? def chars_delete(count = 1) = "\e[#{count}P"
-
-      # Scroll window given lines up.
-      #
-      # @param lines [Integer] number of lines to scroll
-      # @return (see cursor_up)
-      def scroll_up(lines = 1) = "\e[;#{lines}S"
-
-      # Scroll window given lines down.
-      #
-      # @param (see scroll_up)
-      # @return (see cursor_up)
-      def scroll_down(lines = 1) = "\e[;#{lines}T"
-
-      # @comment ??? def chars_erase(count = 1) = "\e[#{count}X"
-      # @comment ??? def cursor_reverse_tab(count = 1) = "\e[#{count}Z"
-
-      # set absolute col
-      # @comment ??? doubled! def cursor_column(column = 1) = "\e[#{column}`"
-      # set relative column
-      # @comment ??? def cursor_column_rel(column = 1) = "\e[#{column}a"
-      # set absolute row
-      # @comment ??? def cursor_row(row = 1) = "\e[#{row}d"
-      # set relative row
-      # @comment ??? def cursor_row_rel(row = 1) = "\e[#{row}e"
-
-      # Change window title.
-      # This is not widely supported but by XTerm and iTerm.
-      #
-      # @param [String] title text
-      # @return (see cursor_up)
-      def window_title(title) = "\e]2;#{title}\e\\"
-
-      # Change tab title.
-      # This is not widely supported but by iTerm.
-      #
-      # @param [String] title text
-      # @return (see cursor_up)
-      def tab_title(title) = "\e]0;#{title}\a"
-
-      # @!endgroup
-
-      # @!group Tool functions
-
-      # Combine given ANSI {.attribute_names}, {.color_names} and color codes.
-      #
-      # Colors can specified by their name for ANSI 3-bit and 4-bit colors.
-      # For 8-bit ANSI colors use 2-digit hexadecimal values `00`...`ff`.
-      #
-      # To use RGB ANSI colors (24-bit colors) specify 3-digit or 6-digit
-      # hexadecimal values `000`...`fff` or `000000`...`ffffff`.
-      # This represent the `RRGGBB` values (or `RGB` for short version) like you
-      # may known from CSS color notation.
-      #
-      # To use a color as background color prefix the color attribute with `bg_`
-      # or `on_`.
-      # To use a color as underline color prefix the color attribute with `ul_`.
-      # To clarify that a color attribute have to be used as foreground
-      # color use the prefix `fg_`.
-      #
-      # @example Valid Foreground Color Attributes
-      #   Ansi[:yellow]
-      #   Ansi['#fab']
-      #   Ansi['#00aa00']
-      #   Ansi[:fg_fab]
-      #   Ansi[:fg_00aa00]
-      #   Ansi[:af]
-      #   Ansi[:fg_af]
-      #
-      # @example Valid Background Color Attributes
-      #   Ansi[:bg_yellow]
-      #   Ansi[:bg_fab]
-      #   Ansi[:bg_00aa00]
-      #   Ansi['bg#00aa00']
-      #   Ansi[:bg_af]
-      #
-      #   Ansi[:on_yellow]
-      #   Ansi[:on_fab]
-      #   Ansi[:on_00aa00]
-      #   Ansi['on#00aa00']
-      #   Ansi[:on_af]
-      #
-      # @example Valid Underline Color Attributes
-      #   Ansi[:underline, :ul_yellow]
-      #   Ansi[:underline, :ul_fab]
-      #   Ansi[:underline, :ul_00aa00]
-      #   Ansi[:underline, 'ul#00aa00']
-      #   Ansi[:underline, :ul_fa]
-      #   Ansi[:underline, :ul_bright_yellow]
-      #
-      # @example Combined attributes:
-      #   Ansi[:bold, :italic, :bright_white, :on_0000cc]
-      #
-      # @param attributes [Array<Symbol, String>] attribute names to be used
-      # @return [String] combined ANSI attributes
-      def [](*attributes)
-        return '' if attributes.empty?
-        "\e[#{
-          attributes
-            .map do |arg|
-              case arg
-              when Symbol
-                SATTR[arg] || SCLR[arg] || color(arg.to_s) ||
-                  invalid_argument(arg)
-              when String
-                ATTR[arg] || CLR[arg] || color(arg) || invalid_argument(arg)
-              when (0..255)
-                "38;5;#{arg}"
-              when (256..511)
-                "48;5;#{arg - 256}"
-              when (512..767)
-                "58;5;#{arg - 512}"
-              else
-                invalid_argument(arg)
-              end
-            end
-            .join(';')
-        }m"
-      end
-
-      # Decorate given `str` with ANSI attributes and colors.
-      #
-      # @see []
-      #
-      # @param str [#to_s] object to be decorated
-      # @param attributes [Symbol, String] attribute names to be used
-      # @param reset [Boolean] whether to include reset code for ANSI attributes
-      # @return [String] `str` converted and decorated with the ANSI `attributes`
-      def embellish(str, *attributes, reset: true)
-        attributes = self[*attributes]
-        attributes.empty? ? str.to_s : "#{attributes}#{str}#{"\e[0m" if reset}"
-      end
-
-      # Remove ANSI functions, attributes and colors from given string.
-      #
-      # @see embellish
-      #
-      # @param str [#to_s] string to be modified
-      # @return [String] string without ANSI attributes
-      def blemish(str) = str.to_s.gsub(ESC, '')
-
-      # Try to combine given ANSI attributes and colors.
-      # The attributes and colors have to be seperated by space char (" ").
-      #
-      # @example Valid Attribute String
-      #   Ansi.try_convert('bold italic blink red on#00ff00')
-      #   # => ANSI attribute string for bold, italic text which blinks red on
-      #   #    green background
-      #
-      # @example Invalid Attribute String
-      #   Ansi.try_convert('cool bold on green')
-      #   # => nil
-      #
-      # @param attributes [#to_s] attributes separated by space char (" ")
-      # @return [String] combined ANSI attributes
-      # @return [nil] when string does not contain valid attributes
-      def try_convert(attributes)
-        return if !attributes || (attributes = attributes.to_s.split).empty?
-        "\e[#{
-          attributes
-            .map! { ATTR[_1] || CLR[_1] || color(_1) || return }
-            .join(';')
-        }m"
-      end
-
-      # @param str [#to_s] plain text string to enrich with color
-      # @param type [:foreground, :background, :underline] type of coloring
-      # @param frequence [Float] color change frequency
-      # @param spread [Float] number of chars with same color
-      # @param seed [Float] start index on sinus curve
-      # @return [String] fancy text
-      def rainbow(
-        str,
-        type: :foreground,
-        frequence: 0.3,
-        spread: 0.8,
-        seed: 1.1
-      )
-        type = color_type(type)
-        pos = -1
-        str
-          .to_s
-          .chars
-          .map! do |char|
-            i = (seed + ((pos += 1) / spread)) * frequence
-            "\e[#{type};2;#{(Math.sin(i) * 255).abs.to_i};" \
-              "#{(Math.sin(i + PI2_THIRD) * 255).abs.to_i};" \
-              "#{(Math.sin(i + PI4_THIRD) * 255).abs.to_i}m#{char}"
-          end
-          .join
-      end
-
-      # @!endgroup
-
-      private
-
-      def invalid_argument(name)
-        raise(
-          ArgumentError,
-          "unknown Ansi attribute name - '#{name}'",
-          caller(1)
-        )
-      end
-
-      def color_type(type)
-        case type
-        when :background, :bg, 'background', 'bg'
-          48
-        when :underline, :ul, 'underline', 'ul'
-          58
-        else
-          38
-        end
-      end
-
-      def color(val)
-        base = CLR_PREFIX[val[0, 2]]
-        idx = base ? 2 : 0
-        base ||= '38'
-        idx += 1 if val[idx] == '_' || val[idx] == ':'
-        idx += 1 if val[idx] == '#'
-        val = val[idx..]
-        return "#{base};5;#{val.hex}" if /\A[[:xdigit:]]{1,2}\z/.match?(val)
-        if /\A[[:xdigit:]]{6}\z/.match?(val)
-          return "#{base};2;#{val[0, 2].hex};#{val[2, 2].hex};#{val[4, 2].hex}"
-        end
-        return unless /\A[[:xdigit:]]{3}\z/.match?(val)
-        "#{base};2;#{(val[0] * 2).hex};#{(val[1] * 2).hex};#{(val[2] * 2).hex}"
-      end
-    end
-
-    # @!visibility private
-    CSI = /\e\[[\d;:]*[ABCDEFGHJKSTfminsuhl]/
-
-    # @!visibility private
-    OSC = /\e\]\d+(?:;[^;\a\e]+)*(?:\a|\e\\)/
-
-    ESC = /(#{CSI})|(#{OSC})/
-
-    CLR_PREFIX = {
-      'fg' => '38',
-      'bg' => '48',
-      'ul' => '58',
-      'on' => '48'
-    }.freeze
-
-    PI2_THIRD = 2 * Math::PI / 3
-    PI4_THIRD = 4 * Math::PI / 3
-
-    ATTR =
-      Module
-        .new do
-          def self.to_hash
-            map = {
-              # alternative names
-              'reset' => '',
-              'slow_blink' => 5,
-              'conceal' => 8,
-              'default_font' => 10,
-              'doubly' => 21,
-              'faint_off' => 22,
-              'fraktur_off' => 23,
-              'spacing' => 26,
-              'conceal_off' => 28,
-              'spacing_off' => 50,
-              'encircled_off' => 54,
-              'subscript_off' => 75,
-              # special
-              'curly_underline_off' => '4:0',
-              'dotted_underline_off' => '4:0',
-              'dashed_underline_off' => '4:0',
-              'curly_underline' => '4:3',
-              'dotted_underline' => '4:4',
-              'dashed_underline' => '4:5',
-              # aliases
-              'b' => 1, # bold
-              '/b' => 22, # bold_off
-              'i' => 3, # italic
-              '/i' => 23, # italic_off
-              'u' => 4, # underline
-              '/u' => 24, # underline_off
-              'h' => 8, # hide
-              '/h' => 28 # reveal
-            }
-            add = ->(s, n) { n.each_with_index { |a, idx| map[a] = s + idx } }
-            add[
-              1,
-              %w[
-                bold
-                faint
-                italic
-                underline
-                blink
-                rapid_blink
-                invert
-                hide
-                strike
-                primary_font
-                font1
-                font2
-                font3
-                font4
-                font5
-                font6
-                font7
-                font8
-                font9
-                fraktur
-                double_underline
-                bold_off
-                italic_off
-                underline_off
-                blink_off
-                proportional
-                invert_off
-                reveal
-                strike_off
-              ]
-            ]
-            add[
-              50,
-              %w[
-                proportional_off
-                framed
-                encircled
-                overlined
-                framed_off
-                overlined_off
-              ]
-            ]
-            add[73, %w[superscript subscript superscript_off]]
-
-            map.merge!(
-              map
-                .filter_map do |name, att|
-                  if name.end_with?('_off')
-                    ["/#{name.delete_suffix('_off')}", att]
-                  end
-                end
-                .to_h
-            )
-          end
-        end
-        .to_hash
-        .freeze
-
-    CLR =
-      Module
-        .new do
-          def self.to_hash
-            clr = {
-              0 => 'black',
-              1 => 'red',
-              2 => 'green',
-              3 => 'yellow',
-              4 => 'blue',
-              5 => 'magenta',
-              6 => 'cyan',
-              7 => 'white'
-            }
-            map = {}
-            add = ->(s, p) { clr.each_pair { |i, n| map["#{p}#{n}"] = s + i } }
-            ul = ->(r, g, b) { "58;2;#{r};#{g};#{b}" }
-            add[30, nil]
-            map['default'] = 39
-            add[90, 'bright_']
-            add[30, 'fg_']
-            map['fg_default'] = 39
-            map['/fg'] = 39
-            add[90, 'fg_bright_']
-            add[40, 'bg_']
-            map['bg_default'] = 49
-            map['/bg'] = 49
-            add[100, 'bg_bright_']
-            add[40, 'on_']
-            map['on_default'] = 49
-            add[100, 'on_bright_']
-            map.merge!(
-              'ul_black' => ul[0, 0, 0],
-              'ul_red' => ul[128, 0, 0],
-              'ul_green' => ul[0, 128, 0],
-              'ul_yellow' => ul[128, 128, 0],
-              'ul_blue' => ul[0, 0, 128],
-              'ul_magenta' => ul[128, 0, 128],
-              'ul_cyan' => ul[0, 128, 128],
-              'ul_white' => ul[128, 128, 128],
-              'ul_default' => '59',
-              '/ul' => '59',
-              'ul_bright_black' => ul[64, 64, 64],
-              'ul_bright_red' => ul[255, 0, 0],
-              'ul_bright_green' => ul[0, 255, 0],
-              'ul_bright_yellow' => ul[255, 255, 0],
-              'ul_bright_blue' => ul[0, 0, 255],
-              'ul_bright_magenta' => ul[255, 0, 255],
-              'ul_bright_cyan' => ul[0, 255, 255],
-              'ul_bright_white' => ul[255, 255, 255]
-            )
-          end
-        end
-        .to_hash
-        .freeze
-
-    SATTR = ATTR.transform_keys(&:to_sym).compare_by_identity.freeze
-    SCLR = CLR.transform_keys(&:to_sym).compare_by_identity.freeze
-
-    private_constant(
-      :ESC,
-      :CLR_PREFIX,
-      :PI2_THIRD,
-      :PI4_THIRD,
-      :SATTR,
-      :CLR,
-      :ATTR,
-      :SCLR
-    )
-  end
-end
-
-require_relative 'ansi/constants'

data/lib/natty-ui/ansi_wrapper.rb

@@ -1,199 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'wrapper'
-
-module NattyUI
-  class AnsiWrapper < Wrapper
-    def ansi? = true
-
-    def puts(*args, **kwargs)
-      return super if args.empty? || (animation = kwargs[:animation]).nil?
-      animation = Animation[animation].new(wrapper, args, kwargs)
-      @stream << Ansi::CURSOR_HIDE
-      animation.perform(@stream)
-      @lines_written += animation.lines_written
-      (@stream << Ansi::CURSOR_SHOW).flush
-      self
-    end
-
-    def page
-      unless block_given?
-        @stream.flush
-        return self
-      end
-      (@stream << Ansi::SCREEN_BLANK).flush
-      begin
-        yield(self)
-      ensure
-        (@stream << Ansi::SCREEN_UNBLANK).flush
-      end
-    end
-
-    def cls
-      (@stream << Ansi::CLS).flush
-      self
-    end
-
-    protected
-
-    def pprint(strs, opts)
-      prefix = opts[:prefix] and prefix = Text.embellish(prefix)
-      suffix = opts[:suffix] and suffix = Text.embellish(suffix)
-      return yield("#{prefix}#{suffix}") if strs.empty?
-      max_width =
-        opts.fetch(:max_width) do
-          screen_columns - (opts[:prefix_width] || Text.width(prefix)) -
-            (opts[:suffix_width] || Text.width(suffix))
-        end
-      case opts[:align]
-      when :right
-        Text.each_line(strs, max_width) do |line, width|
-          width = max_width - width
-          yield("#{prefix}#{' ' * width}#{line}#{suffix}")
-        end
-      when :center
-        Text.each_line(strs, max_width) do |line, width|
-          width = max_width - width
-          right = width / 2
-          yield(
-            "#{prefix}#{' ' * (width - right)}#{line}#{' ' * right}#{suffix}"
-          )
-        end
-      else
-        Text.each_line(strs, max_width) { yield("#{prefix}#{_1}#{suffix}") }
-      end
-    end
-
-    def temp_func
-      count = @lines_written
-      lambda do
-        if (c = @lines_written - count).nonzero?
-          @stream << Ansi.cursor_prev_line(c) << Ansi.screen_erase(:below) <<
-            Ansi::CURSOR_FIRST_COLUMN
-          @lines_written -= c
-        end
-        @stream.flush
-        self
-      end
-    end
-
-    class Progress < Progress
-      def draw(title, spinner)
-        @msg =
-          "#{@parent.prefix}#{Ansi[:bold, 39]}➔#{Ansi[:reset, 39]} " \
-            "#{title}#{Ansi::RESET} "
-        (wrapper.stream << @msg << Ansi::CURSOR_HIDE).flush
-        @msg = "#{Ansi::CLL}#{@msg}"
-        return @msg << BAR_COLOR if @max_value
-        @spinner = NattyUI::Spinner[spinner]
-      end
-
-      def redraw
-        (wrapper.stream << @msg << (@max_value ? fullbar : @spinner.next)).flush
-      end
-
-      def end_draw = (wrapper.stream << Ansi::CLL << Ansi::CURSOR_SHOW).flush
-
-      def fullbar
-        percent = @value / @max_value
-        count = (30 * percent).to_i
-        mv = max_value.to_i.to_s
-        "#{'█' * count}#{BAR_BACK}#{'▁' * (30 - count)}" \
-          "#{BAR_INK} #{value.to_i.to_s.rjust(mv.size)}/#{mv} " \
-          "(#{(percent * 100).round(2).to_s.rjust(6)})"
-      end
-
-      BAR_COLOR = Ansi[39, 295].freeze
-      BAR_BACK = Ansi[236, 492].freeze
-      BAR_INK = Ansi[:bold, 255, :on_default].freeze
-    end
-
-    module Temporary
-      def temporary
-        unless block_given?
-          wrapper.stream.flush
-          return self
-        end
-        count = wrapper.lines_written
-        begin
-          yield(self)
-        ensure
-          count = wrapper.lines_written - count
-          if count.nonzero?
-            wrapper.stream << Ansi.cursor_prev_line(count) <<
-              Ansi.display(:erase_below)
-          end
-          wrapper.stream.flush
-        end
-      end
-    end
-
-    class Section < Section
-      include Temporary
-    end
-
-    class Quote < Quote
-      include Temporary
-
-      def initialize(...)
-        super
-        @prefix = "#{Ansi[39]}#{@prefix}#{Ansi::RESET}"
-      end
-    end
-
-    class Framed < Framed
-      def color(str) = "#{Ansi[39]}#{str}#{Ansi::RESET}"
-
-      def init(type)
-        @prefix = "#{color(type[4])} "
-        @suffix = "#{Ansi.cursor_column(parent.rcol)}#{color(type[4])}"
-        aw = @parent.available_width - 2
-        parent.puts(color("#{type[0]}#{type[5] * aw}#{type[1]}"))
-        @finish = color("#{type[2]}#{type[5] * aw}#{type[3]}")
-      end
-    end
-
-    class Message < Section
-      protected
-
-      def initialize(parent, title:, glyph:, **opts)
-        color = COLORS[glyph] || COLORS[:default]
-        glyph = NattyUI::Glyph[glyph]
-        prefix_width = Text.width(glyph) + 1
-        parent.puts(
-          title,
-          prefix: "#{glyph} #{color}",
-          prefix_width: prefix_width,
-          suffix: Ansi::RESET,
-          suffix_width: 0
-        )
-        super(
-          parent,
-          prefix: ' ' * prefix_width,
-          prefix_width: prefix_width,
-          **opts
-        )
-      end
-
-      white = Ansi[255]
-      COLORS = {
-        default: white,
-        point: white,
-        information: white,
-        warning: Ansi[221],
-        error: Ansi[208],
-        completed: Ansi[82],
-        failed: Ansi[196],
-        task: Ansi[39],
-        query: white
-      }.compare_by_identity.freeze
-    end
-
-    class Task < Message
-      include ProgressAttributes
-      include TaskMethods
-    end
-  end
-
-  private_constant :AnsiWrapper
-end