natty-ui 0.10.0 → 0.11.1

data/lib/natty-ui/animation/rainbow.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module NattyUI
+  module Animation
+    class Rainbow < Base
+      protected
+
+      def write(stream)
+        plain = @lines.map { |line, _| Text.plain(line) }
+        11.upto(180) do |spread|
+          spread /= 100.0
+          plain.each do |line|
+            puts(
+              stream,
+              Ansi.rainbow(line, spread: spread, frequence: 0.1, seed: 0)
+            )
+          end
+          (stream << Ansi::RESET << @top).flush
+          sleep(0.01)
+        end
+        super
+      end
+    end
+
+    define rainbow: Rainbow
+    private_constant :Rainbow
+  end
+end

data/lib/natty-ui/animation/type_writer.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module NattyUI
+  module Animation
+    class TypeWriter < Base
+      protected
+
+      def write(stream)
+        num = 0
+        @style = attribute(:style, :default)
+        @cursor_style = attribute(:cursor_style, 0x2e)
+        @lines.each do |line, size|
+          if (num += 1).odd?
+            stream << @pos1
+            Text.plain(line).each_char { cursor(stream, _1).flush }
+          else
+            stream << Ansi.cursor_column(@prefix_width + size - 1)
+            Text
+              .plain(line)
+              .reverse
+              .each_char { (cursor(stream, _1) << CURSOR_2LEFT).flush }
+          end
+          stream << Ansi::RESET << @pos1 << line << Ansi::LINE_NEXT
+        end
+      end
+
+      def cursor(stream, char)
+        stream << @cursor_style
+        (SPACE.match?(char) ? '▁' : '▁▂▃▄▅▆▇█').each_char do |cursor|
+          (stream << cursor << CURSOR_1LEFT).flush
+          sleep(0.002)
+        end
+        stream << @style << char
+      end
+
+      CURSOR_1LEFT = Ansi.cursor_back(1).freeze
+      CURSOR_2LEFT = Ansi.cursor_back(2).freeze
+      SPACE = /[[:space:]]/
+    end
+
+    define type_writer: TypeWriter
+    private_constant :TypeWriter
+  end
+end

data/lib/natty-ui/animation.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module NattyUI
+  module Animation
+    def self.defined = @defined.keys
+    def self.defined?(name) = @defined.key?(name)
+    def self.define(**kwargs) = @defined.merge!(kwargs)
+
+    def self.[](name)
+      return if name.nil?
+      klass = @defined[name] || @defined[:default]
+      return klass unless klass.is_a?(String)
+      require(klass)
+      klass = @defined[name] and return klass
+      raise(LoadError, "unknown animation - #{name}")
+    end
+
+    class Base
+      attr_reader :lines_written
+
+      def initialize(wrapper, args, kwargs)
+        @prefix = Text.embellish(kwargs[:prefix])
+        @suffix = Text.embellish(kwargs[:suffix])
+        @prefix_width = kwargs[:prefix_width] || Text.width(@prefix)
+        @lines =
+          Text.as_lines(
+            args.map! { Ansi.blemish(_1) },
+            kwargs[:max_width] ||
+              wrapper.screen_columns - @prefix_width -
+                (kwargs[:suffix_width] || Text.width(@suffix))
+          )
+        diff = @lines.size - wrapper.screen_rows + 1
+        @lines = @lines[diff, wrapper.screen_rows] if diff.positive?
+        @options = kwargs
+        @prefix_width += 1
+        @top = Ansi.cursor_up(@lines_written = @lines.count)
+        @pos1 = Ansi.cursor_column(@prefix_width)
+      end
+
+      def perform(stream)
+        @lines.each { stream << "#{@prefix}#{' ' * _2}#{@suffix}\n" }
+        stream << @top
+        write(stream)
+      end
+
+      protected
+
+      def attribute(name, *default)
+        att = @options[name] or return Ansi[*default]
+        return Ansi[*att] if att.is_a?(Enumerable)
+        Ansi.try_convert(att.to_s) || Ansi[*default]
+      end
+
+      def write(stream) = @lines.each { |line, _| puts(stream, line) }
+      def puts(stream, line) = stream << @pos1 << line << Ansi::LINE_NEXT
+    end
+
+    private_constant :Base
+
+    dir = __dir__
+    @defined = {
+      binary: "#{dir}/animation/binary",
+      default: "#{dir}/animation/default",
+      matrix: "#{dir}/animation/matrix",
+      rainbow: "#{dir}/animation/rainbow",
+      type_writer: "#{dir}/animation/type_writer"
+    }.compare_by_identity
+  end
+end

data/lib/natty-ui/ansi/constants.rb

@@ -31,7 +31,7 @@ module NattyUI::Ansi
   RESET = self[:reset].freeze
 
   BOLD = self[:bold].freeze
-  BOLD_OFF = self[:bold_off].freeze
+  BOLD_OFF = self[:bold].freeze
 
   FAINT = self[:faint].freeze
   FAINT_OFF = self[:faint_off].freeze

data/lib/natty-ui/ansi.rb

@@ -257,7 +257,7 @@ module NattyUI
       # @return [String] combined ANSI attributes
       # @return [nil] when string does not contain valid attributes
       def try_convert(attributes)
-        return if (attributes = attributes.to_s.split).empty?
+        return if !attributes || (attributes = attributes.to_s.split).empty?
         "\e[#{
           attributes
             .map! { ATTR[_1] || CLR[_1] || color(_1) || return }
@@ -349,36 +349,45 @@ module NattyUI
     PI2_THIRD = 2 * Math::PI / 3
     PI4_THIRD = 4 * Math::PI / 3
 
-    SATTR =
+    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,
+              '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'
+              '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,
-              %i[
+              %w[
                 bold
                 faint
                 italic
@@ -412,7 +421,7 @@ module NattyUI
             ]
             add[
               50,
-              %i[
+              %w[
                 proportional_off
                 framed
                 encircled
@@ -421,12 +430,20 @@ module NattyUI
                 overlined_off
               ]
             ]
-            add[73, %i[superscript subscript superscript_off]]
-            map
+            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
-        .compare_by_identity
         .freeze
 
     CLR =
@@ -451,9 +468,11 @@ module NattyUI
             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
@@ -468,6 +487,7 @@ module NattyUI
               '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],
@@ -482,7 +502,7 @@ module NattyUI
         .to_hash
         .freeze
 
-    ATTR = SATTR.transform_keys(&:to_s).freeze
+    SATTR = ATTR.transform_keys(&:to_sym).compare_by_identity.freeze
     SCLR = CLR.transform_keys(&:to_sym).compare_by_identity.freeze
 
     private_constant(

data/lib/natty-ui/ansi_wrapper.rb

@@ -8,39 +8,10 @@ module NattyUI
 
     def puts(*args, **kwargs)
       return super if args.empty? || (animation = kwargs[:animation]).nil?
-
-      prefix = kwargs[:prefix]
-      if prefix && !prefix.empty?
-        prefix = Text.embellish(prefix)
-        prefix_width = kwargs[:prefix_width] || Text.width(prefix)
-      else
-        prefix = nil
-        prefix_width = 0
-      end
-      kwargs[:prefix] = prefix
-      kwargs[:prefix_width] = prefix_width
-
-      suffix = kwargs[:suffix]
-      suffix = suffix.empty? ? nil : Texct.embellish(suffix) if suffix
-
-      mw = kwargs[:max_width]
-      unless mw
-        mw = screen_columns - prefix_width
-        mw -= kwargs[:suffix_width] || Text.width(suffix) if suffix
-      end
-      kwargs[:max_width] = mw
-
-      (@stream << Ansi::CURSOR_HIDE).flush
-      animation = LineAnimation[animation].new(@stream, kwargs)
-      prefix = "#{Ansi::RESET}#{Ansi::CLL}#{prefix}"
-
-      Text.each_embellished_line(args.map! { Ansi.blemish(_1) }, mw) do |line|
-        @stream << prefix
-        animation.print(line)
-        (@stream << "#{prefix}#{line}#{suffix}\n").flush
-        @lines_written += 1
-      end
-
+      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
@@ -65,17 +36,32 @@ module NattyUI
 
     protected
 
-    def pprint(args, kwargs)
-      prefix = kwargs[:prefix] and prefix = Text.embellish(prefix)
-      suffix = kwargs[:suffix] and suffix = Text.embellish(suffix)
-      return yield("#{prefix}#{suffix}") if args.empty?
-      Text.each_embellished_line(
-        args,
-        kwargs.fetch(:max_width) do
-          screen_columns - kwargs.fetch(:prefix_width) { Text.width(prefix) } -
-            kwargs.fetch(:suffix_width) { Text.width(suffix) }
+    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
-      ) { yield("#{prefix}#{_1}#{suffix}") }
+      else
+        Text.each_line(strs, max_width) { yield("#{prefix}#{_1}#{suffix}") }
+      end
     end
 
     def temp_func
@@ -163,18 +149,18 @@ module NattyUI
       def color(str) = "#{Ansi[39]}#{str}#{Ansi::RESET}"
 
       def init(type)
-        @prefix = "#{color(type[0])} "
+        @prefix = "#{color(type[4])} "
         @suffix = "#{Ansi.cursor_column(parent.rcol)}#{color(type[4])}"
         aw = @parent.available_width - 2
-        parent.puts(color("#{type[1]}#{type[2] * aw}#{type[3]}"))
-        @finish = color("#{type[5]}#{type[6] * aw}#{type[7]}")
+        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:)
+      def initialize(parent, title:, glyph:, **opts)
         color = COLORS[glyph] || COLORS[:default]
         glyph = NattyUI.glyph(glyph) || glyph
         prefix_width = Text.width(glyph) + 1
@@ -185,18 +171,25 @@ module NattyUI
           suffix: Ansi::RESET,
           suffix_width: 0
         )
-        super(parent, prefix: ' ' * prefix_width, prefix_width: prefix_width)
+        super(
+          parent,
+          prefix: ' ' * prefix_width,
+          prefix_width: prefix_width,
+          **opts
+        )
       end
 
+      white = Ansi[255]
       COLORS = {
-        default: Ansi[255],
-        information: Ansi[255],
+        default: white,
+        point: white,
+        information: white,
         warning: Ansi[221],
         error: Ansi[208],
         completed: Ansi[82],
         failed: Ansi[196],
         task: Ansi[39],
-        query: Ansi[255]
+        query: white
       }.compare_by_identity.freeze
     end
 

data/lib/natty-ui/key_map.rb

@@ -4,21 +4,36 @@ module NattyUI
   KEY_MAP =
     Module # generator
       .new do
-        def self.add_mods(name, code)
-          @mods.each_pair do |mod, prefix|
-            @map["\e[1;#{mod}#{code}"] = "#{prefix}+#{name}"
+        def self.add_modifiers(**keys)
+          @mods.each_pair do |mod, pref|
+            @map.merge!(
+              keys.to_h do |name, code|
+                ["\e[1;#{mod}#{code}", "#{pref}+#{name}"]
+              end
+            )
           end
         end
 
-        def self.add_akey(name, code)
-          @map["\e[#{code}"] = name
-          add_mods(name, code)
+        def self.add_keys(**keys)
+          @map.merge!(keys.to_h { |name, code| ["\e[#{code}", name] })
+          add_modifiers(**keys)
         end
 
-        def self.add_fkey(name, code)
-          @map["\e[#{code}~"] = name
+        def self.add_fkeys(**keys)
+          @map.merge!(keys.to_h { |name, code| ["\e[#{code}~", name] })
           @mods.each_pair do |mod, prefix|
-            @map["\e[#{code};#{mod}~"] = "#{prefix}+#{name}"
+            @map.merge!(
+              keys.to_h do |name, code|
+                ["\e[#{code};#{mod}~", "#{prefix}+#{name}"]
+              end
+            )
+          end
+        end
+
+        def self.add_alt_keys(**keys)
+          keys.each_pair do |name, code|
+            @map[code] = name
+            @map["\e#{code}"] = "Alt+#{name}" # kitty
           end
         end
 
@@ -27,51 +42,59 @@ module NattyUI
           num = 0
           @map = ('A'..'Z').to_h { [(num += 1).chr, "Ctrl+#{_1}"] }
 
-          add_akey('Up', 'A')
-          add_akey('Down', 'B')
-          add_akey('Right', 'C')
-          add_akey('Left', 'D')
-          add_akey('End', 'F')
-          add_akey('Home', 'H')
+          add_modifiers('F1' => 'P', 'F2' => 'Q', 'F3' => 'R', 'F4' => 'S')
 
-          add_mods('F1', 'P')
-          add_mods('F2', 'Q')
-          add_mods('F3', 'R')
-          add_mods('F4', 'S')
+          add_keys(
+            'Up' => 'A',
+            'Down' => 'B',
+            'Right' => 'C',
+            'Left' => 'D',
+            'End' => 'F',
+            'Home' => 'H'
+          )
 
-          add_fkey('DEL', '3')
-          add_fkey('PgUp', '5')
-          add_fkey('PgDown', '6')
-          add_fkey('F1', 'F1')
-          add_fkey('F2', 'F2')
-          add_fkey('F3', 'F3')
-          add_fkey('F4', 'F4')
-          add_fkey('F5', '15')
-          add_fkey('F6', '17')
-          add_fkey('F7', '18')
-          add_fkey('F8', '19')
-          add_fkey('F9', '20')
-          add_fkey('F10', '21')
-          add_fkey('F11', '23')
-          add_fkey('F12', '24')
-          add_fkey('F13', '25')
-          add_fkey('F14', '26')
-          add_fkey('F15', '28')
-          add_fkey('F16', '29')
-          add_fkey('F17', '31')
-          add_fkey('F18', '32')
-          add_fkey('F19', '33')
-          add_fkey('F20', '34')
+          add_fkeys(
+            'DEL' => '3',
+            'PgUp' => '5',
+            'PgDown' => '6',
+            # -
+            'F1' => 'F1',
+            'F2' => 'F2',
+            'F3' => 'F3',
+            'F4' => 'F4',
+            # -
+            'F5' => '15',
+            'F6' => '17',
+            'F7' => '18',
+            'F8' => '19',
+            'F9' => '20',
+            'F10' => '21',
+            'F11' => '23',
+            'F12' => '24',
+            'F13' => '25',
+            'F14' => '26',
+            'F15' => '28',
+            'F16' => '29',
+            'F17' => '31',
+            'F18' => '32',
+            'F19' => '33',
+            'F20' => '34'
+          )
+
+          add_fkeys('F3' => '13') # kitty
+
+          add_alt_keys(
+            'ESC' => "\e",
+            'ENTER' => "\r",
+            'TAB' => "\t",
+            'BACK' => "\u007F",
+            'Ctrl+BACK' => "\b",
+            'Shift+TAB' => "\e[Z"
+          )
 
           # overrides and additionals
           @map.merge!(
-            "\e" => 'ESC',
-            "\4" => 'DEL', # = Ctrl+D
-            "\u007F" => 'BACK',
-            "\b" => 'Ctrl+BACK',
-            "\r" => 'ENTER', # = Ctrl+M
-            "\t" => 'TAB',
-            "\e[Z" => 'Shift+TAB',
+            "\4" => 'DEL',
             "\e[5" => 'PgUp',
             "\e[6" => 'PgDown',
             # SS3 control (VT 100 etc)

data/lib/natty-ui/preload.rb

@@ -3,7 +3,7 @@
 require_relative '../natty-ui'
 
 module NattyUI
-  LineAnimation.defined?(:matrix)
+  Animation.defined?(:matrix)
   Text::EastAsianWidth[0]
   KEY_MAP[0]
 end