natty-ui 0.27.0 → 0.29.0

data/lib/natty-ui/features.rb

@@ -15,12 +15,12 @@ module NattyUI
     # Print given text as lines.
     #
     # @example Print two lines text, right aligned
-    #   ui.puts("Two lines", "of nice text", align: :right)
+    #   ui.puts "Two lines", "of nice text", align: :right
     #   # =>    Two lines
     #   # => of nice text
     #
     # @example Print two lines text, with a prefix
-    #   ui.puts("Two lines", "of nice text", prefix: ': ')
+    #   ui.puts "Two lines", "of nice text", prefix: ': '
     #   # => : Two lines
     #   # => : of nice text
     #
@@ -38,7 +38,16 @@ module NattyUI
     #   itself
     def puts(*text, **options)
       bbcode = true if (bbcode = options[:bbcode]).nil?
+
       max_width = options[:max_width] || Terminal.columns
+      return self if max_width == 0
+      if max_width < 1
+        if max_width > 0
+          max_width *= Terminal.columns
+        elsif max_width < 0
+          max_width += Terminal.columns
+        end
+      end
 
       prefix_width =
         if (prefix = options[:prefix])
@@ -89,7 +98,7 @@ module NattyUI
 
       if (align = options[:align]).nil?
         lines.each do |line|
-          Terminal.print(prefix, line, suffix, EOL__, bbcode: false)
+          Terminal.print(prefix, line, suffix, __eol, bbcode: false)
           @lines_written += 1
           prefix, prefix_next = prefix_next, nil if prefix_next
         end
@@ -109,7 +118,7 @@ module NattyUI
             ' ' * (max_width - width),
             line,
             suffix,
-            EOL__,
+            __eol,
             bbcode: false
           )
           @lines_written += 1
@@ -124,7 +133,7 @@ module NattyUI
             line,
             ' ' * (space - lw),
             suffix,
-            EOL__,
+            __eol,
             bbcode: false
           )
           @lines_written += 1
@@ -137,7 +146,7 @@ module NattyUI
             line,
             ' ' * (max_width - width),
             suffix,
-            EOL__,
+            __eol,
             bbcode: false
           )
           @lines_written += 1
@@ -147,6 +156,20 @@ module NattyUI
       self
     end
 
+    # Print given text with a decoration mark.
+    #
+    # @param text (see puts)
+    # @param mark [Symbol, #to_s]
+    #   marker type
+    #
+    # @return (see puts)
+    def mark(*text, mark: :default, **options)
+      mark = Theme.current.mark(mark)
+      options[:first_line_prefix] = mark
+      options[:first_line_prefix_width] = mark.width
+      puts(*text, **options)
+    end
+
     # Print given text as lines like {#puts}. Used in elements with temporary
     # output like {#task} the text will be kept ("pinned").
     #
@@ -168,21 +191,7 @@ module NattyUI
     #
     # @return (see puts)
     def pin(*text, mark: nil, **options)
-      options[:pin] = true
-      options[:first_line_prefix] = Theme.current.mark(mark) if mark
-      puts(*text, **options)
-    end
-
-    # Print given text with a decoration mark.
-    #
-    # @param text (see puts)
-    # @param mark [Symbol, #to_s]
-    #   marker type
-    #
-    # @return (see puts)
-    def mark(*text, mark: :default)
-      mark = Theme.current.mark(mark)
-      puts(*text, first_line_prefix: mark, first_line_prefix_width: mark.width)
+      mark(*text, mark: mark, pin: true, **options)
     end
 
     # Print given text as a quotation.
@@ -197,7 +206,7 @@ module NattyUI
         *text,
         prefix: quote,
         prefix_width: quote.width,
-        max_width: width < 20 ? nil : width.to_i
+        max_width: width < 20 ? nil : width.round
       )
     end
 
@@ -272,8 +281,8 @@ module NattyUI
 
     # Print a horizontal rule.
     #
-    # @example
-    #   ui.hr(:heavy)
+    # @example Print double line
+    #   ui.hr :double
     #
     # @param type [Symbol]
     #   border type
@@ -305,10 +314,10 @@ module NattyUI
     # - any text as prefix
     #
     # @example Print all Ruby files as a numbered list
-    #   ui.ls(Dir['*/**/*.rb'], glyph: 1)
+    #   ui.ls Dir['*/**/*.rb'], glyph: 1
     #
     # @example Print all Ruby files as a bullet point list (with green bullets)
-    #   ui.ls(Dir['*/**/*.rb'], glyph: '[green]•[/fg]')
+    #   ui.ls Dir['*/**/*.rb'], glyph: '[green]•[/fg]'
     #
     # @param items [#to_s]
     #   one or more convertible objects to list
@@ -416,6 +425,86 @@ module NattyUI
       table(**tab_att) { |table| table.add { _1.add(*text, **att) } }
     end
 
+    # Dump given values as vertical bars.
+    #
+    # @example Draw green bars
+    #   ui.vbars 1..10, style: :green
+    #
+    # @example Draw very big bars
+    #   ui.vbars 1..10, bar_width: 5, height: 20
+    #
+    # @param values [#to_a, Array<Numeric>] values to print
+    # @param normalize [true, false] whether the values should be normalized
+    # @param height [Integer] output height
+    # @param bar_width [:auto, :min, Integer] with of each bar
+    # @param style [Symbol, Array<Symbol>, nil] drawing style
+    #
+    # @raise [ArgumentError] if any value is negative
+    #
+    # @return (see puts)
+    def vbars(
+      values,
+      normalize: false,
+      height: 10,
+      bar_width: :auto,
+      style: nil
+    )
+      return self if (values = values.to_a).empty?
+      if values.any?(&:negative?)
+        raise(ArgumentError, 'values can not be negative')
+      end
+      puts(
+        *VBarsRenderer.lines(
+          values,
+          columns,
+          height,
+          normalize,
+          bar_width,
+          Terminal.ansi? ? style : nil
+        )
+      )
+    end
+
+    # Dump given values as horizontal bars.
+    #
+    # @example Draw green bars
+    #   ui.hbars 1..10, style: :green
+    #
+    # @example Draw bars in half sreen width
+    #   ui.hbars 1..10, style: :blue, width: 0.5
+    #
+    # @param values [#to_a, Array<Numeric>] values to print
+    # @param with_values [true, false] whether the values should be printed too
+    # @param normalize [true, false] whether the values should be normalized
+    # @param height [Integer] output height
+    # @param bar_width [:auto, :min, Integer] with of each bar
+    # @param style [Symbol, Array<Symbol>, nil] bar drawing style
+    # @param text_style [Symbol, Array<Symbol>, nil] text style
+    #
+    # @raise [ArgumentError] if any value is negative
+    #
+    # @return (see puts)
+    def hbars(
+      values,
+      with_values: true,
+      normalize: false,
+      width: :auto,
+      style: nil,
+      text_style: nil
+    )
+      return self if (values = values.to_a).empty?
+      if values.any?(&:negative?)
+        raise(ArgumentError, 'values can not be negative')
+      end
+      style = text_style = nil unless Terminal.ansi?
+      size = Utils.as_size(3..columns, width)
+      if with_values
+        puts(*HBarsRenderer.lines(values, size, normalize, style, text_style))
+      else
+        puts(*HBarsRenderer.lines_bars_only(values, size, normalize, style))
+      end
+    end
+
     # Dynamically display a task progress.
     # When a `max` parameter is given the progress will be displayed as a
     # progress bar below the `title`. Otherwise the progress is displayed just
@@ -434,15 +523,15 @@ module NattyUI
     #   end
     #
     # @example Display simple progress
-    #   progress = ui.progress('Check some stuff')
+    #   progress = ui.progress 'Check some stuff'
     #   10.times do
     #     # simulate some work
-    #     sleep(0.1)
+    #     sleep 0.1
     #
     #     # here we actualize the progress
     #     progress.step
     #   end
-    #   progress.ok('Stuff checked ok')
+    #   progress.ok 'Stuff checked ok'
     #
     # @overload progress(title, max: nil, pin: false)
     #   @param title [#to_s]
@@ -491,10 +580,10 @@ module NattyUI
     #
     # @example
     #   ui.section do |section|
-    #     section.h1('About Sections')
+    #     section.h1 'About Sections'
     #     section.space
-    #     section.puts('Sections are areas of text elements.')
-    #     section.puts('You can use any other feature inside such an area.')
+    #     section.puts 'Sections are areas of text elements.'
+    #     section.puts 'You can use any other feature inside such an area.'
     #   end
     #   # => ╭────╶╶╶
     #   # => │ ╴╶╴╶─═══ About Sections ═══─╴╶╴╶
@@ -643,22 +732,19 @@ module NattyUI
     #
     #   @return [true, false]
     #     wheter the user inputs a positive result
+    #   @return nil
+    #     in error case
     #
     def await(yes: 'Enter', no: 'Esc')
-      temporary do |arg|
-        yield(arg) if block_given?
-        while (key = Terminal.read_key)
-          if (no == key) || (no.is_a?(Enumerable) && no.include?(key))
-            return false
-          end
-          if (yes == key) || (yes.is_a?(Enumerable) && yes.include?(key))
-            return true
-          end
-        end
+      return __await(yes, no) unless block_given?
+      temporary do |temp|
+        yield(temp)
+        __await(yes, no)
       end
     end
 
-    # Request a user's chocie.
+    # Allows the user to select an option from a selection.
+    # The selected option is returned.
     #
     # @overload choice(*choices, abortable: false)
     #   @param [#to_s] choices
@@ -696,6 +782,8 @@ module NattyUI
     #     one or more alternatives to select from
     #   @param [true, false] abortable
     #     whether the user is allowed to abort with 'Esc' or 'Ctrl+c'
+    #   @param [#to_s, nil] selected
+    #     optionally pre-selected option
     #
     #   @return [Object]
     #     key for selected choice
@@ -718,6 +806,8 @@ module NattyUI
     #     one or more alternatives to select from
     #   @param [true, false] abortable
     #     whether the user is allowed to abort with 'Esc' or 'Ctrl+c'
+    #   @param [Integer] selected
+    #     pre-selected option index
     #
     #   @yieldparam temp [Temporary]
     #     temporary displayed section (section will be erased after input)
@@ -727,20 +817,82 @@ module NattyUI
     #   @return [nil]
     #     when user aborted the selection
     #
-    def choice(*choices, abortable: false, **kwchoices, &block)
+    def choice(*choices, abortable: false, selected: nil, **kwchoices, &block)
       return if choices.empty? && kwchoices.empty?
       choice =
-        case NattyUI.input_mode
-        when :default
-          Choice.new(self, choices, kwchoices, abortable)
-        when :dumb
-          DumbChoice.new(self, choices, kwchoices, abortable)
+        if Terminal.ansi?
+          Choice.new(self, choices, kwchoices, abortable, selected)
         else
-          return
+          DumbChoice.new(self, choices, kwchoices, abortable)
         end
       __with(choice) { choice.select(&block) }
     end
 
+    # Allows the user to select from several options.
+    # All options are returned with their selection status.
+    #
+    # @param [{#to_s => [true,false]}] choices
+    #   Hash of options and their selection state
+    # @param [true, false] abortable
+    #   whether the user is allowed to abort with 'Esc' or 'Ctrl+c'
+    # @param [#to_s, nil] selected
+    #   optionally pre-selected key
+    #
+    # @yieldparam temp [Temporary]
+    #   temporary displayed section (section will be erased after input)
+    #
+    # @return [{#to_s => [true,false]}]
+    #   Hash of options and their selection state
+    # @return [nil]
+    #   when user aborted the selection
+    def options(abortable: false, selected: nil, **choices, &block)
+      return {} if choices.empty?
+      options =
+        if Terminal.ansi?
+          Options.new(self, choices, abortable, selected)
+        else
+          DumbOptions.new(self, choices, abortable, selected)
+        end
+      __with(options) { options.select(&block) }
+    end
+
+    # Allows the user to select from several options.
+    # The selected options are returned.
+    #
+    # @example Select a terminal
+    #   ui.select %w[Kitty iTerm2 Ghostty Tabby Rio] do
+    #    ui.puts '[i]Which terminal applications did you already tested?[/i]'
+    #   end
+    #
+    # @param [Array<#to_s>] choices
+    #   selectable options
+    # @param [true, false] abortable
+    #   whether the user is allowed to abort with 'Esc' or 'Ctrl+c'
+    # @param [Integer, :all, nil] selected
+    #   optionally pre-selected option index or `:all` to pre-select all items
+    # @yieldparam temp [Temporary]
+    #   temporary displayed section (section will be erased after input)
+    #
+    # @return [Array<#to_s>]
+    #   selected options
+    # @return [nil]
+    #   when user aborted the selection
+    def select(*choices, abortable: false, selected: nil, &block)
+      return [] if choices.empty?
+      choices = choices[0] if choices.size == 1 && choices[0].is_a?(Enumerable)
+      if selected == :all
+        sel = true
+      elsif selected
+        selected = choices[selected.to_i]
+      end
+      options(
+        abortable: abortable,
+        selected: selected,
+        **choices.to_h { [_1, sel] },
+        &block
+      ).filter_map { |key, selected| key if selected }
+    end
+
     #
     # @!endgroup
     #
@@ -757,7 +909,7 @@ module NattyUI
     #
     # @example Show tempoary information
     #   ui.temporary do
-    #     ui.info('Information', 'This text will disappear when you pressed ENTER.')
+    #     ui.info 'Information', 'This text will disappear when you pressed ENTER.'
     #     ui.await
     #   end
     #
@@ -783,16 +935,31 @@ module NattyUI
       __sec(color, "#{Theme.current.mark(color)}#{title}", text, &block)
     end
 
-    EOL__ = Terminal.ansi? ? "\e[m\n" : "\n"
-    private_constant :EOL__
+    def __await(yes, no)
+      while (event = Terminal.read_key_event&.name)
+        if (no == event) || (no.is_a?(Enumerable) && no.include?(event))
+          return false
+        end
+        if (yes == event) || (yes.is_a?(Enumerable) && yes.include?(event))
+          return true
+        end
+      end
+    end
+
+    def __eol
+      @__eol ||= Terminal.ansi? ? "\e[m\n" : "\n"
+    end
   end
 
   dir = __dir__
   autoload :Choice, "#{dir}/choice.rb"
-  autoload :CompactLSRenderer, "#{dir}/ls_renderer.rb"
   autoload :DumbChoice, "#{dir}/dumb_choice.rb"
+  autoload :DumbOptions, "#{dir}/dumb_options.rb"
+  autoload :CompactLSRenderer, "#{dir}/ls_renderer.rb"
   autoload :Framed, "#{dir}/framed.rb"
+  autoload :HBarsRenderer, "#{dir}/hbars_renderer.rb"
   autoload :LSRenderer, "#{dir}/ls_renderer.rb"
+  autoload :Options, "#{dir}/options.rb"
   autoload :Progress, "#{dir}/progress.rb"
   autoload :DumbProgress, "#{dir}/progress.rb"
   autoload :Section, "#{dir}/section.rb"
@@ -801,6 +968,20 @@ module NattyUI
   autoload :Temporary, "#{dir}/temporary.rb"
   autoload :Theme, "#{dir}/theme.rb"
   autoload :Utils, "#{dir}/utils.rb"
-
-  private_constant :Choice, :DumbChoice, :LSRenderer, :CompactLSRenderer
+  autoload :VBarsRenderer, "#{dir}/vbars_renderer.rb"
+
+  private_constant(
+    :Choice,
+    :DumbChoice,
+    :DumbOptions,
+    :CompactLSRenderer,
+    :Framed,
+    :HBarsRenderer,
+    :LSRenderer,
+    :Options,
+    :Progress,
+    :DumbProgress,
+    :Utils,
+    :VBarsRenderer
+  )
 end

data/lib/natty-ui/hbars_renderer.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require_relative 'utils'
+
+module NattyUI
+  module HBarsRenderer
+    class << self
+      def lines(vals, width, normalize, style, text_style)
+        if text_style
+          bots = Ansi[*text_style]
+          eots = Ansi::RESET
+        end
+        texts = vals.map { Str.new(_1) }
+        tw = texts.max_by(&:width).width
+        size = width - tw - 1
+        if size < 2 # text only
+          return texts.map { "#{bots}#{' ' * (tw - _1.width)}#{_1}#{eots}" }
+        end
+        if style
+          bos = Ansi[*style]
+          eos = Ansi::RESET
+        end
+        vals = normalize ? normalize!(vals, size) : adjust!(vals, size)
+        texts.map.with_index do |str, idx|
+          "#{bots}#{' ' * (tw - str.width)}#{str}#{eots}#{bos}▕#{
+            '▆' * vals[idx]
+          }#{eos}"
+        end
+      end
+
+      def lines_bars_only(vals, width, normalize, style)
+        if style
+          bos = Ansi[*style]
+          eos = Ansi::RESET
+        end
+        width -= 1
+        vals = normalize ? normalize!(vals, width) : adjust!(vals, width)
+        vals.map { "#{bos}▕#{'▆' * _1}#{eos}" }
+      end
+
+      private
+
+      def adjust!(vals, size)
+        max = vals.max.to_f
+        vals.map { ((_1 / max) * size).round }
+      end
+
+      def normalize!(vals, size)
+        min, max = vals.minmax
+        return Array.new(vals.size, size) if min == max
+        max = (max - min).to_f
+        vals.map { (((_1 - min) / max) * size).round }
+      end
+    end
+  end
+
+  private_constant :HBarsRenderer
+end

data/lib/natty-ui/ls_renderer.rb

@@ -47,7 +47,6 @@ module NattyUI
 
       class Item
         attr_reader :width
-
         def to_s(in_width) = "#{@str}#{' ' * (in_width - @width)}"
 
         def initialize(str)

data/lib/natty-ui/options.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require_relative 'element'
+
+module NattyUI
+  class Options < Element
+    def select
+      yield(self) if block_given?
+      pin_line = NattyUI.lines_written
+      draw
+      last = @current
+      while (event = Terminal.read_key_event)
+        case event.name
+        when 'Esc', 'Ctrl+c'
+          return if @abortable
+        when 'Enter'
+          return @opts.transform_values(&:last)
+        when 'Space'
+          (last = @opts[@current])[-1] = !last[-1]
+        when 'a'
+          @opts.transform_values { _1[-1] = true }
+          last = nil
+        when 'n'
+          @opts.transform_values { _1[-1] = false }
+          last = nil
+        when 'Home'
+          @current = @opts.first.first
+        when 'End'
+          @current = @opts.keys.last
+        when 'Up', 'Back', 'Shift+Tab', 'i'
+          keys = @opts.keys
+          @current = keys[keys.index(@current) - 1]
+        when 'Down', 'Tab', 'k'
+          keys = @opts.keys
+          @current = keys[keys.index(@current) + 1] || keys[0]
+        end
+        next if last == @current
+        pin_line = NattyUI.back_to_line(pin_line, erase: false)
+        draw
+        last = @current
+      end
+    ensure
+      NattyUI.back_to_line(@start_line)
+    end
+
+    private
+
+    def initialize(parent, opts, abortable, selected)
+      super(parent)
+      @opts =
+        opts.to_h do |k, v|
+          v.is_a?(Enumerable) ? [k, [v[0], !!v[-1]]] : [k, [k, !!v]]
+        end
+      @abortable = abortable
+      @current = @opts.key?(selected) ? selected : @opts.first.first
+      @start_line = NattyUI.lines_written
+      theme = Theme.current
+      @style = {
+        false => theme.choice_style,
+        true => theme.choice_current_style
+      }.compare_by_identity
+    end
+
+    def draw
+      states = NattyUI::Theme.current.option_states
+      @opts.each_pair do |key, (str, selected)|
+        mark = states.dig(current = key == @current, selected)
+        @parent.puts(
+          "#{@style[current]}#{str}",
+          first_line_prefix: mark,
+          first_line_prefix_width: mark.width
+        )
+      end
+    end
+  end
+  private_constant :Options
+end

data/lib/natty-ui/table_renderer.rb

@@ -156,6 +156,7 @@ module NattyUI
         ["#{@style}#{' ' * @padding[3]}", "#{' ' * @padding[1]}[/]"]
       end
     end
+    private_constant :Cell
   end
   private_constant :TableRenderer
 end

data/lib/natty-ui/task.rb

@@ -11,7 +11,7 @@ module NattyUI
     private
 
     def _done(text)
-      NattyUI.back_to_line(@start_line, erase: :all)
+      NattyUI.back_to_line(@start_line)
       @start_line = nil
       cm = Theme.current.mark(:checkmark)
       @parent.puts(

data/lib/natty-ui/temporary.rb

@@ -8,11 +8,10 @@ module NattyUI
   #
   class Temporary < Element
     # @!visibility private
-    def puts(*objects, **options)
+    def puts(*objects, **opts)
       return self if @state
-      if options.delete(:pin)
-        @pins ||= []
-        @pins << [objects, options.except(:prefix_width, :suffix_width)]
+      if opts.delete(:pin)
+        (@pins ||= []) << [objects, opts.except(:prefix_width, :suffix_width)]
       end
       super
     end
@@ -20,8 +19,8 @@ module NattyUI
     # @!visibility private
     def done
       return self if @state
-      NattyUI.back_to_line(@start_line, erase: :all) if @start_line
-      @pins&.each { |objects, options| puts(*objects, **options) }
+      NattyUI.back_to_line(@start_line) if @start_line
+      @pins&.each { |objects, opts| puts(*objects, **opts) }
       @state = :ok
       self
     end