natty-ui 0.12.0 → 0.25.0

data/lib/natty-ui/text.rb

@@ -1,203 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'ansi'
-
-module NattyUI
-  module Text
-    class << self
-      def plain_but_ansi(str)
-        (str = str.to_s).empty? and return str
-        str.gsub(BBCODE) do
-          match = Regexp.last_match[1]
-          if match[0] == '/'
-            next if match.size == 1
-            next "[#{match[1..]}]" if match[1] == '/'
-          end
-          Ansi.try_convert(match) ? nil : "[#{match}]"
-        end
-      end
-
-      def plain(str) = Ansi.blemish(plain_but_ansi(str))
-
-      def embellish(str)
-        (str = str.to_s).empty? and return str
-        reset = false
-        str =
-          str.gsub(BBCODE) do
-            match = Regexp.last_match[1]
-            if match[0] == '/'
-              if match.size == 1
-                reset = false
-                next Ansi::RESET
-              end
-              next "[#{match[1..]}]" if match[1] == '/'
-            end
-
-            ansi = Ansi.try_convert(match)
-            ansi ? reset = ansi : "[#{match}]"
-          end
-        reset ? "#{str}#{Ansi::RESET}" : str
-      end
-
-      # works for UTF-8 chars only!
-      def char_width(char)
-        ord = char.ord
-        return WIDTH_CONTROL_CHARS[ord] || 2 if ord < 0x20
-        return 1 if ord < 0xa1
-        size = EastAsianWidth[ord]
-        return @ambiguous_char_width if size == -1
-        if size == 1 && char.size >= 2
-          sco = char[1].ord
-          # Halfwidth Dakuten Handakuten
-          return sco == 0xff9e || sco == 0xff9f ? 2 : 1
-        end
-        size
-      end
-
-      def width(str)
-        return 0 if (str = plain_but_ansi(str)).empty?
-        str = str.encode(UTF_8) if str.encoding != UTF_8
-        width = 0
-        in_zero_width = false
-        str.scan(WIDTH_SCANNER) do |np_start, np_end, _csi, _osc, gc|
-          if in_zero_width
-            in_zero_width = false if np_end
-            next
-          end
-          next in_zero_width = true if np_start
-          width += char_width(gc) if gc
-        end
-        width
-      end
-
-      def each_line_plain(strs, max_width)
-        return if (max_width = max_width.to_i) < 1
-        strs.each do |str|
-          plain_but_ansi(str).each_line(chomp: true) do |line|
-            next yield(line, 0) if line.empty?
-            empty = String.new(encoding: line.encoding)
-            current = empty.dup
-            width = 0
-            in_zero_width = false
-            line = line.encode(UTF_8) if line.encoding != UTF_8
-            line.scan(WIDTH_SCANNER) do |np_start, np_end, csi, osc, gc|
-              next in_zero_width = (current << "\1") if np_start
-              next in_zero_width = !(current << "\2") if np_end
-              next if osc || csi
-              next current << gc if in_zero_width
-              cw = char_width(gc)
-              if (width += cw) > max_width
-                yield(current, width - cw)
-                width = cw
-                current = empty.dup
-              end
-              current << gc
-            end
-            yield(current, width)
-          end
-        end
-        nil
-      end
-
-      def as_lines_plain(strs, width, height = nil)
-        ret = []
-        each_line_plain(strs, width) do |*info|
-          ret << info
-          break if height == ret.size
-        end
-        ret
-      end
-
-      def each_line(strs, max_width)
-        return if (max_width = max_width.to_i) < 1
-        strs.each do |str|
-          str
-            .to_s
-            .each_line(chomp: true) do |line|
-              line = embellish(line)
-              next yield(line, 0) if line.empty?
-              current = String.new(encoding: line.encoding)
-              seq = current.dup
-              width = 0
-              in_zero_width = false
-              line = line.encode(UTF_8) if line.encoding != UTF_8
-              line.scan(WIDTH_SCANNER) do |np_start, np_end, csi, osc, gc|
-                next in_zero_width = (current << "\1") if np_start
-                next in_zero_width = !(current << "\2") if np_end
-                next (current << osc) && (seq << osc) if osc
-                if csi
-                  current << csi
-                  next seq.clear if csi == "\e[m" || csi == "\e[0m"
-                  next if in_zero_width
-                  next seq << csi
-                end
-                next current << gc if in_zero_width
-                cw = char_width(gc)
-                if (width += cw) > max_width
-                  yield(current, width - cw)
-                  width = cw
-                  current = seq.dup
-                end
-                current << gc
-              end
-              yield(current, width)
-            end
-        end
-      end
-
-      def as_lines(strs, width, height = nil)
-        ret = []
-        each_line(strs, width) do |*info|
-          ret << info
-          break if height == ret.size
-        end
-        ret
-      end
-    end
-
-    UTF_8 = Encoding::UTF_8
-    BBCODE = /(?:\[((?~[\[\]]))\])/
-    WIDTH_SCANNER = /\G(?:(\1)|(\2)|(#{Ansi::CSI})|(#{Ansi::OSC})|(\X))/
-    WIDTH_CONTROL_CHARS = {
-      0x00 => 0,
-      0x01 => 1,
-      0x02 => 1,
-      0x03 => 1,
-      0x04 => 1,
-      0x05 => 0,
-      0x06 => 1,
-      0x07 => 0,
-      0x08 => 0,
-      0x09 => 8,
-      0x0a => 0,
-      0x0b => 0,
-      0x0c => 0,
-      0x0d => 0,
-      0x0e => 0,
-      0x0f => 0,
-      0x10 => 1,
-      0x11 => 1,
-      0x12 => 1,
-      0x13 => 1,
-      0x14 => 1,
-      0x15 => 1,
-      0x16 => 1,
-      0x17 => 1,
-      0x18 => 1,
-      0x19 => 1,
-      0x1a => 1,
-      0x1b => 1,
-      0x1c => 1,
-      0x1d => 1,
-      0x1e => 1,
-      0x1f => 1
-    }.compare_by_identity.freeze
-
-    autoload(:EastAsianWidth, File.join(__dir__, 'text', 'east_asian_width'))
-    private_constant :EastAsianWidth
-
-    @ambiguous_char_width = 1
-  end
-
-  private_constant :Text
-end

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

@@ -1,17 +0,0 @@
-# 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 [:binary, :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

@@ -1,78 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'element'
-
-module NattyUI
-  module Features
-    # Ask a yes/no question from user.
-    #
-    # The defaults for `yes` and `no` will work for
-    # Afrikaans, Dutch, English, French, German, Italian, Polish, Portuguese,
-    # Romanian, Spanish and Swedish.
-    #
-    # The default for `yes` includes `ENTER` and `RETURN` key
-    #
-    # @example
-    #   case ui.ask('Do you like the NattyUI gem?')
-    #   when true
-    #     ui.info('Yeah!!')
-    #   when false
-    #     ui.write("That's pity!")
-    #   else
-    #     ui.failed('You should have an opinion!')
-    #   end
-    #
-    # @see NattyUI.in_stream
-    #
-    # @param question [#to_s] Question to display
-    # @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 `^C` or `^D`
-    def ask(question, yes: "jotsyd\r\n", no: 'n')
-      _element(:Ask, question, yes, no)
-    end
-  end
-
-  class Wrapper
-    #
-    # An {Element} to ask user input for yes/no queries.
-    #
-    # @see Features#ask
-    class Ask < Element
-      protected
-
-      def call(question, yes, no)
-        yes, no = grab(yes, no)
-        draw(question)
-        while true
-          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 = NattyUI::Glyph[:query]
-        @parent.print(
-          question,
-          prefix: "#{glyph} #{Ansi[255]}",
-          prefix_width: Text.width(glyph) + 1,
-          suffix_width: 0
-        )
-      end
-
-      def grab(yes, no)
-        yes = yes.to_s.chars.uniq
-        raise(ArgumentError, ':yes can not be empty') if yes.empty?
-        no = no.to_s.chars.uniq
-        raise(ArgumentError, ':no can not be empty') if no.empty?
-        return yes, no if (yes & no).empty?
-        raise(ArgumentError, 'chars in :yes and :no can not be intersect')
-      end
-    end
-  end
-end

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

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'features'
-
-module NattyUI
-  class Wrapper
-    #
-    # Basic visual element.
-    #
-    class Element
-      include Features
-
-      # @attribute [r] available_width
-      # @return [Integer] available columns count within the element
-      def available_width = @parent.available_width
-
-      # @attribute [r] closed?
-      # @return [Boolean] whether its closed or not
-      def closed? = (@status != nil)
-
-      # @return [Section, Wrapper] parent element
-      attr_reader :parent
-
-      # @return [Symbol, nil] status when closed
-      attr_reader :status
-
-      # @attribute [r] wrapper
-      # @return [Wrapper] assigned output stream wrapper
-      def wrapper
-        return @wrapper if @wrapper
-        @wrapper = @parent
-        @wrapper = @wrapper.parent until @wrapper.is_a?(Wrapper)
-        @wrapper
-      end
-
-      # Close the element.
-      #
-      # @return [Element] itself
-      def close = _close(:closed)
-
-      alias _to_s to_s
-      private :_to_s
-      # @!visibility private
-      def inspect = _to_s
-
-      protected
-
-      def _close(state)
-        return self if @status
-        @status = state
-        finish
-        @raise ? raise(BREAK) : self
-      end
-
-      def call
-        NattyUI.instance_variable_set(:@element, self)
-        @raise = true
-        yield(self)
-        closed? ? self : close
-      rescue BREAK
-        nil
-      ensure
-        NattyUI.instance_variable_set(:@element, @parent)
-      end
-
-      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/features.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-module NattyUI
-  #
-  # Features of {NattyUI} - methods to display natty elements.
-  #
-  module Features
-    protected
-
-    def _element(type, ...)
-      wrapper.class.const_get(type).__send__(:new, self).__send__(:call, ...)
-    end
-
-    def _section(type, args = nil, owner: nil, **opts, &block)
-      sec = wrapper.class.const_get(type).__send__(:new, owner || self, **opts)
-      sec.puts(*args) if args && !args.empty?
-      sec.__send__(:call, &block) if block
-      sec
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'section'
-
-module NattyUI
-  module Features
-    # Creates frame-enclosed section with a highlighted `title` and
-    # prints given additional arguments as lines into the section.
-    #
-    # When no block is given, the section must be closed, see
-    # {Wrapper::Element#close}.
-    #
-    # @param [Array<#to_s>] args more objects to print
-    # @param [Symbol, String] type frame type; see {NattyUI::Frame}
-    # @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(*args, type: :default, &block)
-      _section(:Framed, args, type: NattyUI::Frame[type], &block)
-    end
-  end
-
-  class Wrapper
-    #
-    # A frame-enclosed {Section} with a highlighted title.
-    #
-    # @see Features#framed
-    class Framed < Section
-      protected
-
-      def initialize(parent, type:)
-        super(parent, prefix: "#{type[4]} ", prefix_width: 2, suffix_width: 2)
-        init(type)
-      end
-
-      def init(type)
-        aw = @parent.available_width - 1
-        parent.puts("#{type[0]}#{type[5] * aw}")
-        @finish = "#{type[2]}#{type[5] * aw}"
-      end
-
-      def finish = @parent.puts(@finish)
-    end
-  end
-end

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

@@ -1,60 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'element'
-
-module NattyUI
-  module Features
-    # Prints a H1 title.
-    #
-    # @param [#to_s] title text
-    # @return [Wrapper::Section, Wrapper] it's parent object
-    def h1(title) = _element(:Heading, title, '═══════')
-
-    # Prints a H2 title.
-    #
-    # @param (see #h1)
-    # @return (see #h1)
-    def h2(title) = _element(:Heading, title, '━━━━━')
-
-    # Prints a H3 title.
-    #
-    # @param (see #h1)
-    # @return (see #h1)
-    def h3(title) = _element(:Heading, title, '━━━')
-
-    # Prints a H4 title.
-    #
-    # @param (see #h1)
-    # @return (see #h1)
-    def h4(title) = _element(:Heading, title, '───')
-
-    # Prints a H5 title.
-    #
-    # @param (see #h1)
-    # @return (see #h1)
-    def h5(title) = _element(:Heading, title, '──')
-  end
-
-  class Wrapper
-    #
-    # A {Element} drawing a title.
-    #
-    # @see Features#h1
-    # @see Features#h2
-    # @see Features#h3
-    # @see Features#h4
-    # @see Features#h5
-    class Heading < Element
-      protected
-
-      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
-    end
-  end
-end

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

@@ -1,37 +0,0 @@
-# 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 = Text.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

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

@@ -1,138 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'element'
-
-module NattyUI
-  module Features
-    #
-    # Print items of a given list as columns.
-    # In the default compact format columns may have diffrent widths and the
-    # list items are ordered column-wise.
-    # The non-compact format prints all columns in same width and order the list
-    # items row-wise.
-    #
-    # @example simple compact list
-    #   ui.ls('apple', 'banana', 'blueberry', 'pineapple', 'strawberry')
-    #   # => apple   banana   blueberry   pineapple   strawberry
-    #
-    # @example (unordered) list with red dot
-    #   ui.ls('apple', 'banana', 'blueberry', 'pineapple', 'strawberry', glyph: '[red]•[/]')
-    #   # => • apple   • banana   • blueberry   • pineapple   • strawberry
-    #
-    # @example ordered list
-    #   ui.ls('apple', 'banana', 'blueberry', 'pineapple', 'strawberry', glyph: 1)
-    #   # => 1 apple   2 banana   3 blueberry   4 pineapple   5 strawberry
-    #
-    # @example ordered list, start at 100
-    #   ui.ls('apple', 'banana', 'blueberry', 'pineapple', 'strawberry', glyph: 100)
-    #   # => 100 apple   101 banana   102 blueberry   103 pineapple   104 strawberry
-    #
-    # @example ordered list using, uppercase characters
-    #   ui.ls('apple', 'banana', 'blueberry', 'pineapple', 'strawberry', glyph: :A)
-    #   # => A apple   B banana   C blueberry   D pineapple   E strawberry
-    #
-    # @example ordered list, using lowercase characters
-    #   ui.ls('apple', 'banana', 'blueberry', 'pineapple', 'strawberry', glyph: :a)
-    #   # => a apple   b banana   c blueberry   d pineapple   e strawberry
-    #
-    # @param [Array<#to_s>] args items to print
-    # @param [Boolean] compact whether to use compact format
-    # @param [nil,#to_s,Integer,Symbol] glyph optional glyph used as element
-    #   prefix
-    # @return [Wrapper, Wrapper::Element] itself
-    def ls(*args, compact: true, glyph: nil)
-      _element(:ListInColumns, args, compact, glyph)
-    end
-  end
-
-  class Wrapper
-    #
-    # An {Element} to print items of a given list as columns.
-    #
-    # @see Features#ls
-    class ListInColumns < Element
-      protected
-
-      def call(list, compact, glyph)
-        return @parent if list.empty?
-        list.flatten!
-        cvt = cvt(glyph, list.size)
-        list.map! { |item| Item.new(item = cvt[item], Text.width(item)) }
-        if compact
-          each_compacted(list, available_width - 1) { @parent.puts(_1) }
-        else
-          each(list, available_width - 1) { @parent.puts(_1) }
-        end
-        @parent
-      end
-
-      def cvt(glyph, size)
-        case glyph
-        when nil, false
-          ->(s) { Text.embellish(s) }
-        when :hex
-          pad = size.to_s(16).size
-          glyph = 0
-          lambda do |s|
-            "#{(glyph += 1).to_s(16).rjust(pad, '0')} #{Text.embellish(s)}"
-          end
-        when Integer
-          pad = (glyph + size).to_s.size
-          glyph -= 1
-          ->(s) { "#{(glyph += 1).to_s.rjust(pad)} #{Text.embellish(s)}" }
-        when Symbol
-          lambda do |s|
-            "#{
-              t = glyph
-              glyph = glyph.succ
-              t
-            } #{Text.embellish(s)}"
-          end
-        else
-          ->(s) { "#{Text.embellish(glyph)} #{Text.embellish(s)}" }
-        end
-      end
-
-      def each(list, max_width)
-        width = list.max_by(&:width).width + 3
-        list.each_slice(max_width / width) do |slice|
-          yield(slice.map { _1.to_s(width) }.join)
-        end
-      end
-
-      def each_compacted(list, max_width)
-        found, widths = find_columns(list, max_width)
-        fill(found[-1], found[0].size)
-        found.transpose.each do |row|
-          row = row.each_with_index.map { |item, col| item&.to_s(widths[col]) }
-          yield(row.join)
-        end
-      end
-
-      def find_columns(list, max_width)
-        found = [list]
-        widths = [list.max_by(&:width).width]
-        1.upto(list.size - 1) do |slice_size|
-          candidate = list.each_slice(list.size / slice_size).to_a
-          cwidths = candidate.map { _1.max_by(&:width).width + 3 }
-          cwidths[-1] -= 3
-          break if cwidths.sum > max_width
-          found = candidate
-          widths = cwidths
-        end
-        [found, widths]
-      end
-
-      def fill(ary, size)
-        (diff = size - ary.size).positive? && ary.fill(nil, ary.size, diff)
-      end
-
-      Item =
-        Struct.new(:str, :width) do
-          def to_s(in_width) = "#{str}#{' ' * (in_width - width)}"
-        end
-
-      private_constant :Item
-    end
-  end
-end