natty-ui 0.8.0 → 0.9.1

data/lib/natty-ui/ansi_constants.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module NattyUI
+  module Ansi
+    CURSOR_SHOW = "\e[?25h"
+    CURSOR_HIDE = "\e[?25l"
+    CURSOR_HOME = cursor_pos(nil, nil)
+    CURSOR_FIRST_ROW = cursor_pos(1).freeze
+    CURSOR_FIRST_COLUMN = cursor_column(1).freeze
+    CURSOR_SAFE_POS_SCO = "\e[s"
+    CURSOR_RESTORE_POS_SCO = "\e[u"
+    CURSOR_SAFE_POS_DEC = "\e7"
+    CURSOR_RESTORE_POS_DEC = "\e8"
+    CURSOR_SAFE_POS = CURSOR_SAFE_POS_DEC
+    CURSOR_RESTORE_POS = CURSOR_RESTORE_POS_DEC
+
+    CURSOR_ALIGN_RIGHT = "\e[9999G\e[1D\e[1C" # @!visibility private
+
+    SCREEN_ERASE = screen_erase(:entire)
+    SCREEN_SAVE = "\e[?47h"
+    SCREEN_RESTORE = "\e[?47l"
+    SCREEN_ALTERNATE = "\e[?1049h"
+    SCREEN_ALTERNATE_OFF = "\e[?1049l"
+    SCREEN_SAVE_ATTRIBUTES = '\e[#{'
+    SCREEN_RESTORE_ATTRIBUTES = '\e[#}'
+
+    SCREEN_BLANK = "\e[0m\e[s\e[?47h\e[H\e[2J" # @!visibility private
+    SCREEN_UNBLANK = "\e[?47l\e[u\e[0m" # @!visibility private
+
+    LINE_PREVIOUS = cursor_previous_line(1).freeze
+    LINE_NEXT = cursor_next_line(1).freeze
+    LINE_ERASE = line_erase(:entire)
+
+    # ANSI control code sequence to erase the screen and set cursor position on
+    # upper left corner.
+    CLS = (CURSOR_HOME + SCREEN_ERASE).freeze
+
+    # ANSI control code sequence to erase current line and position to first
+    # column.
+    CLL = (LINE_ERASE + CURSOR_FIRST_COLUMN).freeze
+
+    # ANSI control code to reset all attributes.
+    RESET = self[:reset].freeze
+
+    BOLD = self[:bold].freeze
+    BOLD_OFF = self[:bold_off].freeze
+
+    FAINT = self[:faint].freeze
+    FAINT_OFF = self[:faint_off].freeze
+
+    ITALIC = self[:italic].freeze
+    ITALIC_OFF = self[:italic_off].freeze
+
+    STRIKE = self[:strike].freeze
+    STRIKE_OFF = self[:strike_off].freeze
+
+    UNDERLINE = self[:underline].freeze
+    DOUBLE_UNDERLINE = self[:double_underline].freeze
+    UNDERLINE_OFF = self[:underline_off].freeze
+
+    CURLY_UNDERLINE = self[:curly_underline].freeze
+    CURLY_UNDERLINE_OFF = self[:curly_underline_off].freeze
+
+    BLINK = self[:blink].freeze
+    BLINK_OFF = self[:blink_off].freeze
+
+    INVERT = self[:invert].freeze
+    INVERT_OFF = self[:invert_off].freeze
+
+    HIDE = self[:hide].freeze
+    REVEAL = self[:reveal].freeze
+  end
+end

data/lib/natty-ui/ansi_wrapper.rb

@@ -2,41 +2,77 @@
 
 require_relative 'ansi'
 require_relative 'wrapper'
+require_relative 'line_animation'
 
 module NattyUI
   class AnsiWrapper < Wrapper
     def ansi? = true
 
+    def puts(*args, **kwargs)
+      return super if args.empty? || (animation = kwargs[:animation]).nil?
+
+      prefix = kwargs[:prefix]
+      if prefix && !prefix.empty?
+        prefix = NattyUI.embellish(prefix)
+        prefix_width = kwargs[:prefix_width] || NattyUI.display_width(prefix)
+      else
+        prefix = nil
+        prefix_width = 0
+      end
+      kwargs[:prefix] = prefix
+      kwargs[:prefix_width] = prefix_width
+
+      suffix = kwargs[:suffix]
+      suffix = suffix.empty? ? nil : NattyUI.embellish(suffix) if suffix
+
+      mw = kwargs[:max_width]
+      unless mw
+        mw = screen_columns - prefix_width
+        mw -= kwargs[:suffix_width] || NattyUI.display_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}"
+
+      NattyUI
+        .each_line(
+          *args.map! { NattyUI.embellish(Ansi.blemish(_1)) },
+          max_width: mw
+        )
+        .each do |line|
+          @stream << prefix
+          animation.print(line)
+          (@stream << "#{prefix}#{line}#{suffix}\n").flush
+          @lines_written += 1
+        end
+      (@stream << Ansi::CURSOR_SHOW).flush
+      self
+    end
+
     def page
       unless block_given?
         @stream.flush
         return self
       end
-      (@stream << Ansi::BLANK_SLATE).flush
+      (@stream << Ansi::SCREEN_BLANK).flush
       begin
         yield(self)
       ensure
-        (@stream << Ansi::UNBLANK_SLATE).flush
+        (@stream << Ansi::SCREEN_UNBLANK).flush
       end
     end
 
     def cls
-      (@stream << Ansi::CURSOR_HOME << Ansi::SCREEN_ERASE).flush
+      (@stream << Ansi::CLS).flush
       self
     end
 
     protected
 
     def prepare_print(args, kwargs)
-      prefix = kwargs[:prefix] and prefix = NattyUI.embellish(prefix)
-      suffix = kwargs[:suffix] and suffix = NattyUI.embellish(suffix)
-      return ["#{prefix}#{suffix}"] if args.empty?
-      NattyUI
-        .each_line(
-          *args.map! { NattyUI.embellish(_1) },
-          max_width: max_with(prefix, suffix, kwargs)
-        )
-        .map { "#{prefix}#{_1}#{suffix}" }
+      _prepare_print(args, kwargs) { NattyUI.embellish(_1) }
     end
 
     def temp_func
@@ -44,7 +80,7 @@ module NattyUI
       lambda do
         count = @lines_written - count
         if count.nonzero?
-          @stream << Ansi.cursor_line_up(count) << Ansi::SCREEN_ERASE_BELOW
+          @stream << Ansi.cursor_prev_line(count) << Ansi.display(:erase_below)
           @lines_written -= count
         end
         @stream.flush
@@ -53,27 +89,28 @@ module NattyUI
     end
 
     class Progress < Progress
-      def draw(title)
+      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::LINE_CLEAR}#{@msg}"
+        @msg = "#{Ansi::CLL}#{@msg}"
         return @msg << BAR_COLOR if @max_value
-        @msg << Ansi[:bold, 220]
-        @indicator = 0
+        spinner_color = Ansi[:bold, 220]
+        @spinner =
+          Enumerator.new do |y|
+            spinner.each_char { y << "#{spinner_color}#{_1}" } while true
+          end
       end
 
       def redraw
-        (wrapper.stream << @msg << (@max_value ? fullbar : indicator)).flush
+        (wrapper.stream << @msg << (@max_value ? fullbar : @spinner.next)).flush
       end
 
       def end_draw
-        (wrapper.stream << Ansi::LINE_CLEAR << Ansi::CURSOR_SHOW).flush
+        (wrapper.stream << Ansi::CLL << Ansi::CURSOR_SHOW).flush
       end
 
-      def indicator = '◐◓◑◒'[(@indicator += 1) % 4]
-
       def fullbar
         percent = @value / @max_value
         count = (30 * percent).to_i
@@ -101,8 +138,8 @@ module NattyUI
         ensure
           count = wrapper.lines_written - count
           if count.nonzero?
-            wrapper.stream << Ansi.cursor_line_up(count) <<
-              Ansi::SCREEN_ERASE_BELOW
+            wrapper.stream << Ansi.cursor_prev_line(count) <<
+              Ansi.display(:erase_below)
           end
           wrapper.stream.flush
         end
@@ -127,6 +164,14 @@ module NattyUI
 
     class Framed < Framed
       def color(str) = "#{Ansi[39]}#{str}#{Ansi::RESET}"
+
+      def init(deco)
+        @prefix = "#{color(deco[0])} "
+        @suffix = "#{Ansi.cursor_column(parent.rcol)}#{color(deco[4])}"
+        aw = @parent.available_width - 2
+        parent.puts(color("#{deco[1]}#{deco[2] * aw}#{deco[3]}"))
+        @finish = color("#{deco[5]}#{deco[6] * aw}#{deco[7]}")
+      end
     end
     private_constant :Framed
 

data/lib/natty-ui/key_map.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+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}"
+          end
+        end
+
+        def self.add_akey(name, code)
+          @map["\e[#{code}"] = name
+          add_mods(name, code)
+        end
+
+        def self.add_fkey(name, code)
+          @map["\e[#{code}~"] = name
+          @mods.each_pair do |mod, prefix|
+            @map["\e[#{code};#{mod}~"] = "#{prefix}+#{name}"
+          end
+        end
+
+        def self.to_hash
+          # control codes
+          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_mods('F1', 'P')
+          add_mods('F2', 'Q')
+          add_mods('F3', 'R')
+          add_mods('F4', 'S')
+
+          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')
+
+          # 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',
+            "\e[5" => 'PgUp',
+            "\e[6" => 'PgDown',
+            # SS3 control (VT 100 etc)
+            "\eOA" => 'Up',
+            "\eOB" => 'Down',
+            "\eOC" => 'Right',
+            "\eOD" => 'Left',
+            "\eOP" => 'F1',
+            "\eOQ" => 'F2',
+            "\eOR" => 'F3',
+            "\eOS" => 'F4',
+            "\eO2P" => 'Shift+F1',
+            "\eO2Q" => 'Shift+F2',
+            "\eO2R" => 'Shift+F3',
+            "\eO2S" => 'Shift+F4',
+            "\eOt" => 'F5',
+            "\eOu" => 'F6',
+            "\eOv" => 'F7',
+            "\eOw" => 'F8',
+            "\eOl" => 'F9',
+            "\eOx" => 'F10'
+          )
+        end
+
+        @mods = {
+          2 => 'Shift',
+          3 => 'Alt',
+          4 => 'Alt-Shift',
+          5 => 'Ctrl',
+          6 => 'Ctrl-Shift',
+          7 => 'Ctrl-Alt',
+          8 => 'Ctrl-Alt-Shift',
+          9 => 'Meta',
+          10 => 'Meta-Shift',
+          11 => 'Meta-Alt',
+          12 => 'Meta-Alt-Shift',
+          13 => 'Ctrl-Meta',
+          14 => 'Ctrl-Meta-Shift',
+          15 => 'Ctrl-Meta-Alt',
+          16 => 'Ctrl-Meta-Alt-Shift'
+        }.compare_by_identity
+      end
+      .to_hash
+      .freeze
+end

data/lib/natty-ui/line_animation/default.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module NattyUI
+  module LineAnimation
+    class Default < None
+      def initialize(*_)
+        super
+        @column = @options[:prefix_width] + 1
+        @color = color
+        @num = 0
+      end
+
+      def print(line)
+        line = plain(line)
+        time = 0.5 / line.size
+        @stream << @color
+        if (@num += 1).odd?
+          line.each_char do |char|
+            (@stream << char).flush
+            sleep(time)
+          end
+        else
+          pos = @column + line.size
+          line.reverse!
+          line.each_char do |char|
+            (@stream << Ansi.cursor_column(pos -= 1) << char).flush
+            sleep(time)
+          end
+        end
+      end
+    end
+
+    define default: Default
+  end
+end

data/lib/natty-ui/line_animation/matrix.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module NattyUI
+  module LineAnimation
+    class Matrix < None
+      def initialize(*_)
+        super
+        @prefix = "#{to_column}#{color}"
+      end
+
+      def print(line)
+        line = plain(line)
+        str = Array.new(line.size) { CHARS.sample }.join
+        pos = Array.new(line.size, &:itself).shuffle
+        until pos.size < 4
+          pos.shift(pos.size / 4).each { str[_1] = line[_1] }
+          pos.sample(pos.size / 2).each { str[_1] = CHARS.sample }
+          (@stream << "#{@prefix}#{str}").flush
+          sleep(0.08)
+        end
+      end
+
+      CHARS = '2598Z*):.\=+-¦|_ｦｱｳｴｵｶｷｹｺｻｼｽｾｿﾀﾂﾃﾅﾆﾇﾈﾊﾋﾎﾏﾐﾑﾒﾓﾔﾕﾗﾘﾜ'.chars
+    end
+
+    define matrix: Matrix
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module NattyUI
+  module LineAnimation
+    class Rainbow < None
+      def initialize(*_)
+        super
+        @prefix = to_column
+      end
+
+      def print(line)
+        line = plain(line)
+        11.upto(200) do |spread|
+          (
+            @stream << @prefix <<
+              Ansi.rainbow(
+                line,
+                frequence: 0.1,
+                spread: spread / 100.0,
+                seed: 0
+              )
+          ).flush
+          sleep(0.01)
+        end
+      end
+    end
+
+    define rainbow: Rainbow
+  end
+end

data/lib/natty-ui/line_animation/test.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module NattyUI
+  module LineAnimation
+    class Test < None
+      def initialize(*_)
+        super
+        @color = attribute(:color, :default)
+      end
+
+      def print(line, column)
+        prefix = "#{Ansi.cursor_column(column)}#{@color}"
+        line = plain(line)
+        str = Array.new(line.size) { CHARS.sample }.join
+        pos = Array.new(line.size, &:itself).shuffle
+        until pos.size < 4
+          pos.shift(pos.size / 4).each { str[_1] = line[_1] }
+          pos.sample(pos.size / 2).each { str[_1] = CHARS.sample }
+          (@stream << "#{prefix}#{str}").flush
+          sleep(0.08)
+        end
+      end
+
+      CHARS = '2598Z*):.\=+-¦|_ｦｱｳｴｵｶｷｹｺｻｼｽｾｿﾀﾂﾃﾅﾆﾇﾈﾊﾋﾎﾏﾐﾑﾒﾓﾔﾕﾗﾘﾜ'.chars
+    end
+
+    define test: Test
+  end
+end

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

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module NattyUI
+  module LineAnimation
+    class TypeWriter < None
+      def initialize(*_)
+        super
+        @color = color
+        @cursor_color = attribute(:cursor_color, 0x2e)
+        @column = @options[:prefix_width] + 1
+        @num = 0
+      end
+
+      def print(line)
+        line = plain(line)
+        if (@num += 1).odd?
+          line.each_char do |char|
+            cursor(char)
+            (@stream << char).flush
+          end
+        else
+          pos = @column + line.size
+          line.reverse!
+          line.each_char do |char|
+            @stream << Ansi.cursor_column(pos -= 1)
+            cursor(char)
+            (@stream << char).flush
+          end
+        end
+      end
+
+      def cursor(char)
+        return sleep(0.016) if SPACE.match?(char)
+        @stream << @cursor_color
+        '▁▂▃▄▅▆▇█'.each_char do |cursor|
+          (@stream << cursor).flush
+          sleep(0.002)
+          @stream << CURSOR_BACK
+        end
+        @stream << @color
+      end
+
+      def print_org(line)
+        plain(line).each_char do |char|
+          if SPACE.match?(char)
+            sleep(0.016)
+          else
+            @stream << @cursor_color
+            '▁▂▃▄▅▆▇█'.each_char do |cursor|
+              (@stream << cursor).flush
+              sleep(0.002)
+              @stream << CURSOR_BACK
+            end
+          end
+          (@stream << @color << char).flush
+        end
+      end
+
+      CURSOR_BACK = Ansi.cursor_back(1)
+    end
+
+    define type_writer: TypeWriter
+  end
+end

data/lib/natty-ui/line_animation.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require_relative 'ansi'
+
+module NattyUI
+  module LineAnimation
+    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 None
+      def initialize(stream, options)
+        @stream = stream
+        @options = options
+      end
+
+      def print(_line) = nil
+
+      protected
+
+      def to_column = Ansi.cursor_column(@options[:prefix_width] + 1)
+      def color = attribute(:color, :default)
+      def plain(str) = NattyUI.plain(str, ansi: false)
+
+      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
+
+      SPACE = /[[:space:]]/
+    end
+
+    dir = __dir__
+    @defined = {
+      default: "#{dir}/line_animation/default",
+      matrix: "#{dir}/line_animation/matrix",
+      rainbow: "#{dir}/line_animation/rainbow",
+      type_writer: "#{dir}/line_animation/type_writer",
+      test: "#{dir}/line_animation/test"
+    }.compare_by_identity
+  end
+
+  private_constant :LineAnimation
+end

data/lib/natty-ui/version.rb

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

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module NattyUI
+  module Features
+    # Print given arguments line-wise with animation.
+    #
+    # @overload animate(..., animation: :default)
+    #   @param [#to_s] ... objects to print
+    #   @param [:default, :matrix, :rainbow, :type_writer]
+    #     animation type of animation
+    #   @return [Wrapper::Section, Wrapper] it's parent object
+    def animate(*args, **kwargs)
+      kwargs[:animation] ||= :default
+      puts(*args, **kwargs)
+    end
+  end
+end

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

@@ -46,19 +46,13 @@ module NattyUI
         yes, no = grab(yes, no)
         draw(question)
         while true
-          char = NattyUI.in_stream.getch
+          char = NattyUI.read_key(mode: :raw)
           return if "\3\4".include?(char)
           return true if yes.include?(char)
           return false if no.include?(char)
         end
-      rescue Interrupt, SystemCallError
-        nil
       ensure
-        if @parent.ansi?
-          (wrapper.stream << Ansi::LINE_CLEAR).flush
-        else
-          @parent.puts
-        end
+        wrapper.ansi? ? (wrapper.stream << Ansi::CLL).flush : @parent.puts
       end
 
       def draw(question)