natty-ui 0.7.0 → 0.9.0

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

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
 module NattyUI
-  # @return [String] the version number of the gem
-  VERSION = '0.7.0'
+  # The version number of the gem.
+  VERSION = '0.9.0'
 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

@@ -13,13 +13,13 @@ module NattyUI
     # The default for `yes` includes `ENTER` and `RETURN` key
     #
     # @example
-    #   case sec.ask('Do you like the NattyUI gem?')
+    #   case ui.ask('Do you like the NattyUI gem?')
     #   when true
-    #     sec.info('Yeah!!')
+    #     ui.info('Yeah!!')
     #   when false
-    #     sec.write("That's pity!")
+    #     ui.write("That's pity!")
     #   else
-    #     sec.failed('You should have an opinion!')
+    #     ui.failed('You should have an opinion!')
     #   end
     #
     # @see NattyUI.in_stream
@@ -28,7 +28,7 @@ module NattyUI
     # @param yes [#to_s] chars which will be used to answer 'Yes'
     # @param no [#to_s] chars which will be used to answer 'No'
     # @return [Boolean] whether the answer is yes or no
-    # @return [nil] when input was aborted with `ESC`, `^C` or `^D`
+    # @return [nil] when input was aborted with `^C` or `^D`
     def ask(question, yes: "jotsyd\r\n", no: 'n')
       _element(:Ask, question, yes, no)
     end
@@ -42,27 +42,27 @@ module NattyUI
     class Ask < Element
       protected
 
-      def _call(question, yes, no)
+      def call(question, yes, no)
         yes, no = grab(yes, no)
-        query(question)
-        read(yes, no)
-      ensure
-        finish
-      end
-
-      def query(question)
-        (wrapper.stream << prefix << "▶︎ #{question} ").flush
-      end
-
-      def finish = (wrapper.stream << "\n").flush
-
-      def read(yes, no)
+        draw(question)
         while true
-          char = NattyUI.in_stream.getch
-          return if "\3\4\e".include?(char)
+          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
+      ensure
+        wrapper.ansi? ? (wrapper.stream << Ansi::CLL).flush : @parent.puts
+      end
+
+      def draw(question)
+        glyph = wrapper.glyph(:query)
+        @parent.print(
+          question,
+          prefix: "#{glyph} #{Ansi[255]}",
+          prefix_width: NattyUI.display_width(glyph) + 1,
+          suffix_width: 0
+        )
       end
 
       def grab(yes, no)

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

@@ -10,7 +10,7 @@ module NattyUI
     class Element
       include Features
 
-      # @return [Section] when embedded in a section
+      # @return [Element] when embedded in a section
       # @return [Wrapper] when not embedded in a section
       attr_reader :parent
 
@@ -22,6 +22,9 @@ module NattyUI
       # @return [Boolean] whether its closed or not
       def closed? = (@status != nil)
 
+      # @return [Integer] available columns count within the element
+      def available_width = @parent.available_width
+
       # Close the element.
       #
       # @return [Element] itself
@@ -29,28 +32,11 @@ module NattyUI
 
       alias _to_s to_s
       private :_to_s
-
       # @!visibility private
-      def inspect = "#{_to_s[..-2]} status=#{@status}}}>"
+      def inspect = _to_s
 
       protected
 
-      def prefix = "#{@parent.__send__(:prefix)}#{@prefix}"
-      def suffix = "#{@suffix}#{@parent.__send__(:suffix)}"
-      def prefix_width = _blemish_width(prefix)
-      def suffix_width = _blemish_width(suffix)
-      def available_width = wrapper.screen_columns - prefix_width - suffix_width
-      def finish = nil
-
-      def wrapper
-        return @wrapper if @wrapper
-        @wrapper = self
-        @wrapper = @wrapper.parent until @wrapper.is_a?(Wrapper)
-        @wrapper
-      end
-
-      def initialize(parent, **_) = (@parent = parent)
-
       def _close(state)
         return self if @status
         @status = state
@@ -58,18 +44,28 @@ module NattyUI
         @raise ? raise(BREAK) : self
       end
 
-      def _call
+      def call
+        NattyUI.instance_variable_set(:@element, self)
         @raise = true
         yield(self)
-        close unless closed?
+        closed? ? self : close
       rescue BREAK
         nil
+      ensure
+        NattyUI.instance_variable_set(:@element, @parent)
       end
 
-      BREAK = Class.new(StandardError)
-      private_constant :BREAK
+      def finish = nil
+      def prefix = "#{@parent.instance_variable_get(:@prefix)}#{@prefix}"
+
+      def initialize(parent)
+        @parent = parent
+      end
 
       private_class_method :new
+
+      BREAK = Class.new(StandardError)
+      private_constant :BREAK
     end
   end
 end

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

@@ -10,15 +10,13 @@ module NattyUI
     # When no block is given, the section must be closed, see
     # {Wrapper::Element#close}.
     #
-    # @param [#to_s] title object to print as section title
     # @param [Array<#to_s>] args more objects to print
-    # @param [Symbol] type frame type;
-    #   valid types are `:rounded`, `:simple`, `:heavy`, `:semi`, `:double`
+    # @param [:block, :double, :heavy, :rounded, :semi, :simple] type frame type
     # @yieldparam [Wrapper::Framed] framed the created section
     # @return [Object] the result of the code block
     # @return [Wrapper::Framed] itself, when no code block is given
-    def framed(title, *args, type: :rounded, &block)
-      _section(self, :Framed, args, title: title, type: type, &block)
+    def framed(*args, type: :rounded, &block)
+      _section(:Framed, args, type: type, &block)
     end
   end
 
@@ -30,25 +28,37 @@ module NattyUI
     class Framed < Section
       protected
 
-      def initialize(parent, title:, type:, **opts)
-        top_start, top_suffix, left, bottom = components(type)
-        parent.puts(" #{title} ", prefix: top_start, suffix: top_suffix)
-        @bottom = bottom
-        super(parent, prefix: "#{left} ", **opts)
+      def initialize(parent, type:)
+        deco = as_deco(type)
+        super(parent, prefix: "#{deco[0]} ", prefix_width: 2, suffix_width: 2)
+        init(deco)
       end
 
-      def finish = parent.puts(@bottom)
+      def as_deco(type)
+        if type.is_a?(Symbol)
+          ret = DECO[type] and return ret
+        elsif type.is_a?(String)
+          return type if type.size == 8
+          return type * 8 if type.size == 1
+        end
+        raise(ArgumentError, "invalid frame type - #{type.inspect}")
+      end
 
-      def components(type)
-        COMPONENTS[type] || raise(ArgumentError, "invalid frame type - #{type}")
+      def init(deco)
+        aw = @parent.available_width - 1
+        parent.puts("#{deco[1]}#{deco[2] * aw}")
+        @finish = "#{deco[5]}#{deco[6] * aw}"
       end
 
-      COMPONENTS = {
-        rounded: %w[╭── ───── │ ╰──────────],
-        simple: %w[┌── ───── │ └──────────],
-        heavy: %w[┏━━ ━━━━━ ┃ ┗━━━━━━━━━━],
-        semi: %w[┍━━ ━━━━━ │ ┕━━━━━━━━━━],
-        double: %w[╔══ ═════ ║ ╚══════════]
+      def finish = @parent.puts(@finish)
+
+      DECO = {
+        rounded: '│╭─╮│╰─╯',
+        simple: '│┌─┐│└─┘',
+        heavy: '┃┏━┓┃┗━┛',
+        double: '║╔═╗║╚═╝',
+        semi: '│╒═╕│╘═╛',
+        block: '▌▛▀▜▐▙▄▟'
       }.compare_by_identity.freeze
     end
   end

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

@@ -1,87 +1,60 @@
 # frozen_string_literal: true
 
-require_relative 'section'
+require_relative 'element'
 
 module NattyUI
   module Features
-    # Creates section with a H1 title.
+    # Prints a H1 title.
     #
-    # @param (see #information)
-    # @yieldparam [Wrapper::Heading] heading the created section
-    # @return [Object] the result of the code block
-    # @return [Wrapper::Heading] itself, when no code block is given
-    def h1(title, *args, &block)
-      _section(self, :Heading, args, title: title, weight: 1, &block)
-    end
+    # @param [#to_s] title text
+    # @return [Wrapper::Section, Wrapper] it's parent object
+    def h1(title) = _element(:Heading, title, '═══════')
 
-    # Creates section with a H2 title.
+    # Prints a H2 title.
     #
-    # @param (see #information)
-    # @yieldparam (see #h1)
+    # @param (see #h1)
     # @return (see #h1)
-    def h2(title, *args, &block)
-      _section(self, :Heading, args, title: title, weight: 2, &block)
-    end
+    def h2(title) = _element(:Heading, title, '━━━━━')
 
-    # Creates section with a H3 title.
+    # Prints a H3 title.
     #
-    # @param (see #information)
-    # @yieldparam (see #h1)
+    # @param (see #h1)
     # @return (see #h1)
-    def h3(title, *args, &block)
-      _section(self, :Heading, args, title: title, weight: 3, &block)
-    end
+    def h3(title) = _element(:Heading, title, '━━━')
 
-    # Creates section with a H4 title.
+    # Prints a H4 title.
     #
-    # @param (see #information)
-    # @yieldparam (see #h1)
+    # @param (see #h1)
     # @return (see #h1)
-    def h4(title, *args, &block)
-      _section(self, :Heading, args, title: title, weight: 4, &block)
-    end
+    def h4(title) = _element(:Heading, title, '───')
 
-    # Creates section with a H5 title.
+    # Prints a H5 title.
     #
-    # @param (see #information)
-    # @yieldparam (see #h1)
+    # @param (see #h1)
     # @return (see #h1)
-    def h5(title, *args, &block)
-      _section(self, :Heading, args, title: title, weight: 5, &block)
-    end
+    def h5(title) = _element(:Heading, title, '──')
   end
 
   class Wrapper
     #
-    # A {Section} with a highlighted title.
+    # A {Element} drawing a title.
     #
     # @see Features#h1
     # @see Features#h2
     # @see Features#h3
     # @see Features#h4
     # @see Features#h5
-    class Heading < Section
+    class Heading < Element
       protected
 
-      def initialize(parent, title:, weight:, **opts)
-        prefix, suffix = enclose(weight)
-        parent.puts(title, prefix: prefix, suffix: suffix)
-        super(parent, **opts)
-      end
-
-      def enclose(weight)
-        enclose = ENCLOSE[weight]
-        return "#{enclose} ", " #{enclose}" if enclose
-        raise(ArgumentError, "invalid heading weight - #{weight}")
+      def call(title, enclose)
+        @parent.puts(
+          title,
+          prefix: "#{Ansi[39]}#{enclose} #{Ansi[:bold, 255]}",
+          suffix: " #{Ansi[:bold_off, 39]}#{enclose}#{Ansi::RESET}",
+          max_width: available_width - 2 - (enclose.size * 2)
+        )
       end
-
-      ENCLOSE = {
-        1 => '═══════',
-        2 => '━━━━━',
-        3 => '━━━',
-        4 => '───',
-        5 => '──'
-      }.compare_by_identity.freeze
     end
   end
 end

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

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require_relative 'element'
+
+module NattyUI
+  module Features
+    # Print a horizontal rule
+    #
+    # @param [#to_s] symbol string to build the horizontal rule
+    # @return [Wrapper::Section, Wrapper] it's parent object
+    def hr(symbol = '─') = _element(:HorizontalRule, symbol)
+  end
+
+  class Wrapper
+    #
+    # A {Element} drawing a horizontal rule.
+    #
+    # @see Features#hr
+    class HorizontalRule < Element
+      protected
+
+      def call(symbol)
+        size = NattyUI.display_width(symbol = symbol.to_s)
+        return @parent.puts if size == 0
+        max_width = available_width
+        @parent.print(
+          symbol * ((max_width / size)),
+          max_width: max_width,
+          prefix: Ansi[39],
+          prefix_width: 0,
+          suffix: Ansi::RESET,
+          suffix_width: 0
+        )
+      end
+    end
+  end
+end