natty-ui 0.35.0 → 1.0.2

data/lib/natty-ui/margin.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative 'element'
+
+module NattyUI
+  # An {Element} that adds horizontal indentation and vertical spacing.
+  #
+  # Instances are created by {#margin}.
+  #
+  # All {Features} methods are available on this element.
+  #
+  # @example Horizontal indent via block
+  #   ui.margin 0, 4 do
+  #     ui.puts 'This line is indented by 4 characters on each side.'
+  #   end
+  #
+  # @example Manual close with left spacing
+  #   m = ui.margin left: 2
+  #   ui.puts 'Indented content.'
+  #   m.end
+  class Margin < Element
+    # @private
+    def puts(*, **options)
+      return self if @done != 0
+      options[:width] = @parent.columns - @prefix.width - @suffix.width
+      super
+    end
+
+    private
+
+    def done
+      @parent.space(@bottom) if (@done += 1) == 1
+    end
+
+    def initialize(parent, *args)
+      super(parent)
+
+      top, right, @bottom, left =
+        case args.size
+        when 0
+          [0, 1, 0, 1]
+        when 1
+          if (arg = args[0]).is_a?(Hash)
+            [
+              arg.fetch(:top, 0),
+              arg.fetch(:right, 0),
+              arg.fetch(:bottom, 0),
+              arg.fetch(:left, 0)
+            ]
+          else
+            Array.new(4, arg)
+          end
+        when 2
+          args * 2
+        when 3
+          args << args[1]
+        when 4
+          args
+        else
+          raise(
+            ArgumentError,
+            "wrong number of arguments (given #{args.size}, expected 0..4)"
+          )
+        end
+
+      top = [0, Float === top ? top.round : top.to_int].max
+      @bottom = [0, Float === @bottom ? @bottom.round : @bottom.to_int].max
+
+      width = parent.columns
+      if width < 2
+        @prefix = @suffix = StrConst.empty
+        return parent.space(top)
+      end
+
+      right = (width * right).round if Float === right
+      left = (width * left).round if Float === left
+
+      parent.space(top)
+      @prefix = StrConst.spacer(left.to_int.clamp(0, width))
+      @suffix = StrConst.spacer(right.to_int.clamp(0, width))
+    end
+  end
+end

data/lib/natty-ui/progress.rb

@@ -1,185 +1,149 @@
 # frozen_string_literal: true
 
-require_relative 'element'
+require_relative 'temporary'
 
 module NattyUI
-  # @todo This chapter needs more documentation.
+  # A {Temporary} element that displays an progress indicator.
   #
-  # Progress indictaor helper used by {Features.progress}.
+  # Instances are created by {#progress}. When a `max` value is set the
+  # progress is displayed as a percentage bar that fills as {#value} increases.
+  # Without a `max`, an open-ended dot animation grows.
   #
-  module ProgressHelper
-    include WithStatus
-
-    # @return [String]
-    attr_reader :title
-
-    # @attribute [w] title
-    def title=(value)
-      @title = value
-      redraw
-    end
+  # All {Features} methods are available on this element, making it possible to
+  # nest output or sub-tasks inside a progress block.
+  #
+  # @example Bounded progress (percentage bar)
+  #   ui.progress 'Loading files', max: files.size do |bar|
+  #     files.each { load(it); bar.step }
+  #   end
+  #
+  # @example Open-ended progress (dot animation)
+  #   ui.progress 'Connecting…' do
+  #     loop { ui.step; break if connected? }
+  #   end
+  class Progress < Temporary
+    # Maximum value set at creation time.
+    #
+    # @return [Numeric] the maximum value
+    # @return [nil] when no maximum was set (open-ended mode)
+    attr_reader :max
 
-    # @return [Float]
+    # Current progress value.
+    #
+    # When {#max} is set the value is clamped to `0..max`. When there is no
+    # maximum the value is clamped to a minimum of `0`.  Setting the same
+    # value twice is a no-op.
+    #
+    # @example
+    #   bar.value += 42
+    #
+    # @return [Numeric] current value
     attr_reader :value
 
     # @attribute [w] value
     def value=(val)
-      @value = val.to_f
-      @value = 0.0 if @value < 0
-      @max = @value if @max&.<(@value)
-      redraw
+      return if @done != 0
+      val = @max ? val.clamp(0, @max) : [0, val].max
+      return if @value == val
+      @value = val
+      draw_bar
     end
 
-    # @return [Float]
-    attr_reader :max
-
-    # @attribute [w] max
-    def max=(val)
-      @max = val.to_f
-      if @max <= 0
-        @max = nil
-      elsif @max < @value
-        @max = @value
-      end
-      redraw
-    end
-
-    # Increment {value} and/or change {title}.
+    # Updates the progress title and/or value.
+    #
+    # Any number of the positional `title` arguments and the `value:` keyword
+    # may be omitted independently.
+    #
+    # @example Update title only
+    #   bar.update 'Finalising…'
+    #
+    # @example Update value only
+    #   bar.update value: 50
+    #
+    # @example Update both
+    #   bar.update 'Step 2 of 3', value: 66
     #
-    # @param count [Integer] increment
-    # @param title [#to_s] new title
-    # @return [ProgressHelper] itself
-    def step(count: 1, title: nil)
-      @title = title if title
-      self.value += count
+    # @param title [#to_s, ...] new title text
+    # @param value [Numeric] new progress value
+    # @param popts [Hash] title print options, see {Features#puts}
+    # @return [Progress] itself
+    def update(*title, value: nil, **popts)
+      return if @done != 0
+      draw_title(*title, **popts) unless title.empty?
+      self.value = value if value
       self
     end
 
-    # @private
-    def end = NattyUI.__send__(:_end, self)
-
-    alias _to_s to_s
-    private :_to_s
-
-    # @private
-    def to_s
-      return "#{title}: #{format('%5.2f', @value)}" unless @max
-      "#{@title}: #{
-        format(
-          '%5.2f of %5.2f - %5.2f%%',
-          @value,
-          @max,
-          100.0 * (@value / @max)
-        )
-      }"
+    # Increments the progress value and optionally updates the title.
+    #
+    # @example Increment by 1
+    #   bar.step
+    #
+    # @example Increment by a custom amount
+    #   bar.step count: 5
+    #
+    # @example Increment and update the title
+    #   bar.step 'Processing item 3', count: 1.5
+    #
+    # @param title (see #update)
+    # @param count [Numeric] amount to add
+    # @param popts (see #update)
+    # @return (see #update)
+    def step(*title, count: 1, **popts)
+      update(*title, value: @value + count, **popts)
     end
 
-    # @private
-    def inspect = "#{_to_s.chop} #{self}>"
-  end
-
-  class Progress
-    include ProgressHelper
-
     private
 
-    def _done(text)
-      NattyUI.back_to_line(@pin_line)
-      cm = Theme.current.mark(:checkmark)
-      @parent.puts(
-        *text,
-        pin: @pin,
-        first_line_prefix: cm,
-        first_line_prefix_width: cm.width
-      )
-    end
-
-    def _failed
-      NattyUI.back_to_line(NattyUI.lines_written - 1) if @last&.size == 2
-    end
-
-    def initialize(parent, title, max, pin)
-      @parent = parent
-      @value = 0
-      @title = title
-      @pin = pin
-      @pin_line = NattyUI.lines_written
-      @style = Theme.current.task_style
-      cm = Theme.current.mark(:current)
-      @redraw_opts = {
-        first_line_prefix: "#{cm}#{@style}",
-        first_line_prefix_width: cm.width
-      }
-      max ? self.max = max : redraw
-    end
-
-    def redraw
-      return if @status
-      bar = @max ? bar(@value / @max) : moving_bar
-      curr = bar ? [@title, bar] : [@title]
-      return if @last == curr
-      @pin_line = NattyUI.back_to_line(@pin_line) if @last
-      @parent.puts(*curr, **@redraw_opts)
-      @last = curr
-    end
-
-    def moving_bar
-      "#{@style}#{'•' * @value}" if @value >= 1
+    def draw_bar
+      @bar_line = NattyUI.back_to_line(@bar_line)
+      if @max
+        @parent.puts(bar(@value / @max.to_f), prefix: @prefix, align: :right)
+      else
+        @parent.puts(simple, prefix: @prefix)
+      end
+      @pins&.each do |objects, opts|
+        @parent.puts(*objects, **opts, prefix: @prefix)
+      end
     end
 
     def bar(diff)
-      size = [@parent.columns, 72].min - 11
-      percent = format('%5.2f', 100.0 * diff)
-      return percent if size < 10
-      fill = '█' * (size * diff)
-      "#{percent}% [bright_black]┃#{@style}#{fill}[bright_black]#{
-        '░' * (size - fill.size)
-      }┃[/]"
-    end
-  end
-
-  class DumbProgress
-    include ProgressHelper
-
-    private
-
-    def _done(text)
-      cm = Theme.current.mark(:checkmark)
-      @parent.puts(
-        *text,
-        pin: @pin,
-        first_line_prefix: cm,
-        first_line_prefix_width: cm.width
-      )
+      size = @parent.columns - 8
+      size -= @prefix.width if @prefix
+      return diff == 1 ? '100.0%' : format('%.2f%%', 100 * diff) if size < 10
+
+      if diff == 1
+        "[bright_green]100.0%[bright_black]▕[bright_green on_bright_black]#{
+          '█' * (size * diff)
+        }[/bg bright_black]▏"
+      else
+        "[bright_green]#{
+          format('%.2f%%', 100 * diff)
+        }[bright_black]▕[green on_bright_black]#{
+          fill = '█' * (size * diff)
+        }[/bg bright_black]#{'░' * (size - fill.size)}▏"
+      end
     end
 
-    def _failed
-      # nop
+    def simple
+      v = Float === @value ? @value.round(2) : @value
+      "[bright_green]#{'•' * @value}▏[/fg]#{v}"
     end
 
-    def initialize(parent, title, max)
-      @parent = parent
-      @value = @last_value = 0.0
-      @title = title
-      max ? self.max = max : redraw
+    def draw_title(*, **options)
+      @start_line = NattyUI.back_to_line(@start_line)
+      options[:cprefix] = Utils.mark[:active]
+      options[:prefix] = @prefix = Utils.mark[:none]
+      @parent.puts(*, **options)
+      @bar_line = NattyUI.lines_written
     end
 
-    def redraw
-      return if @status
-      if @last_title != @title
-        @parent.puts(
-          @last_title = @title,
-          first_line_prefix: '➔ ',
-          first_line_prefix_width: 2
-        )
-      end
-      return if @max.nil? || @value < 1
-      percent = format('%3.0f %%', 100.0 * (@value / @max))
-      return if @last_percent == percent
-      @parent.puts(percent, first_line_prefix: '  ', first_line_prefix_width: 2)
-      @last_percent = percent
+    def initialize(parent, max, *title, **)
+      super(parent)
+      @value = 0
+      @max = [0, max].max if max
+      draw_title(*title, **) unless title.empty?
+      draw_bar
     end
   end
-
-  private_constant :Progress, :DumbProgress
 end

data/lib/natty-ui/renderer/bars.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module NattyUI
+  # @private
+  class VBars
+    def initialize(values, min, max, normalize)
+      @integers = values.all?(Integer)
+      @values = values.map(&:to_f)
+      @min = min
+      @max = max
+      @normalize = normalize
+    end
+
+    def empty? = @values.empty?
+    def valid? = @values.all?(&:positive?)
+
+    def lines(columns, height, bar_width, style)
+      return nil if (height = height.to_int) < 3
+      width = columns - 1
+      values = adjusted(height)
+      rbw = (width - values.size) / values.size
+      rbw = bar_width.to_int.clamp(0, rbw) if rbw > 0 && bar_width != :auto
+      style, elyts = Utils.affix(style)
+      if rbw < 2
+        values = values.take(width) if values.size > width
+        db = '▉'
+        ds = ' '
+        el = values.size
+      else
+        db = "#{'█' * rbw} "
+        ds = ' ' * (rbw += 1)
+        el = (rbw * values.size) - 1
+      end
+      (height - 1)
+        .downto(1)
+        .map do |i|
+          "#{style}#{values.map { it < i ? ds : db }.join}#{elyts}"
+        end << "#{style}#{'▔' * el}#{elyts}"
+    end
+
+    protected
+
+    def adjusted(size)
+      return normalized(size) if @normalize
+      max = @values.max
+      max = @max.to_f if @max&.>(max)
+      return Array.new(@values.size, size) if max <= 0
+      @values.map { ((it / max) * size).round }
+    end
+
+    private
+
+    def normalized(size)
+      min, max = @values.minmax
+      min = @min.to_f if @min&.<(min)
+      max = @max.to_f if @max&.>(max)
+      max -= min
+      return Array.new(@values.size, size) if max <= 0
+      @values.map { (((it - min) / max) * size).round }
+    end
+  end
+
+  # @private
+  class HBars < VBars
+    def with_text(style)
+      @texts =
+        if @integers
+          @values.map { StrConst[it] }
+        else
+          @values.map { StrConst[it.round(2)] }
+        end
+      @texts_width = @texts.max_by(&:width).width
+      style, elyts = Utils.affix(style)
+      @texts.map! { "#{style}#{it.rjust(@texts_width)}#{elyts}" }
+      @texts_width += 1
+      self
+    end
+
+    def lines(columns, width, style)
+      width = Utils.as_width(width, columns)
+      return if width < 2
+      if @texts_width
+        w = width - @texts_width
+        w < 2 ? @texts = nil : width = w
+      end
+      style, elyts = Utils.affix(style)
+      lines = adjusted(width).map! { "#{style}▕#{'▆' * it}#{elyts}" }
+      @texts ? @texts.zip(lines).map!(&:join) : lines
+    end
+  end
+
+  private_constant :VBars, :HBars
+end

data/lib/natty-ui/renderer/choice.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module NattyUI
+  # @private
+  class Choice
+    def select(abortable, selected)
+      start_line = pin_line = NattyUI.lines_written
+      draw(last = current = @results.index(selected) || 0)
+      Terminal.on_key_event do |event|
+        case event.name
+        when 'Esc', 'Ctrl+c'
+          break if abortable
+        when 'Enter', 'Space'
+          break @results[current]
+        when 'Home'
+          current = 0
+        when 'End'
+          current = @results.size - 1
+        when 'Up', 'Back', 'Shift+Tab', 'i', 'w'
+          current = @results.size - 1 if (current -= 1) < 0
+        when 'Down', 'Tab', 'k', 's'
+          current = 0 if (current += 1) == @results.size
+        else
+          next unless event.simple?
+          c = event.key.ord
+          current = (c - 48).clamp(0, @results.size - 1) if c.between?(48, 57)
+        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 draw(current)
+      @texts.each_with_index do |str, idx|
+        @parent.puts(
+          str,
+          cprefix: Utils.mark[idx == current ? :current_item : :item],
+          prefix: Utils.mark[:none]
+        )
+      end
+    end
+
+    def initialize(parent, texts, results)
+      @parent = parent
+      @texts = texts
+      @results = results
+    end
+  end
+
+  private_constant :Choice
+end

data/lib/natty-ui/renderer/dumb_choice.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module NattyUI
+  # @private
+  class DumbChoice
+    def select(abortable, _selected)
+      Terminal.on_key_event do |event|
+        break if abortable && %w[Esc Ctrl+c].include?(event.name)
+        next unless event.simple?
+        code = event.raw.upcase
+        if @results.size <= 9
+          next unless ('1'..'9').include?(code)
+          code = @results[code.ord - 49] and return code
+        elsif ('A'..'Z').include?(code)
+          code = @results[code.ord - 65] and return code
+        end
+      end
+    end
+
+    private
+
+    def initialize(parent, texts, results)
+      @results = results
+      glyph = results.size <= 9 ? 1 : 'A'
+      prefix = StrConst.spacer(4)
+      texts.each do |str|
+        parent.puts(str, prefix:, cprefix: StrConst.new("[#{glyph}] ", 4))
+        glyph = glyph.succ
+      end
+    end
+  end
+
+  private_constant :DumbChoice
+end

data/lib/natty-ui/renderer/dumb_select.rb

@@ -0,0 +1,60 @@
+module NattyUI
+  # @private
+  class DumbSelect
+    def select(abortable)
+      draw
+      Terminal.on_key_event do |event|
+        if abortable && %w[Esc Ctrl+c].include?(event.name)
+          @parent.space
+          break []
+        end
+        if event.name == 'Enter'
+          @parent.space
+          break @items.filter_map { |ret, _str, selected| ret if selected }
+        end
+        next unless event.simple?
+        code = event.raw.upcase
+        if @items.size <= 9
+          next unless ('1'..'9').include?(code)
+          current = code.ord - 49
+        elsif ('A'..'Z').include?(code)
+          current = code.ord - 65
+        else
+          next
+        end
+        next if current >= @items.size
+        *last, selected = @items[current]
+        @items[current] = last << !selected
+        @parent.space
+        draw
+      end
+    end
+
+    private
+
+    def draw
+      @parent.ls(
+        *@items.map do |_ret, str, selected|
+          "[\\#{selected ? 'X' : ' '}] #{str}"
+        end,
+        glyph: @items.size <= 9 ? 1 : 'A'
+      )
+      # # glyph = @items.size <= 9 ? 1 : 'A'
+      # # @items.each do |_ret, str, selected|
+      # #   @parent.puts(
+      # #     str,
+      # #     cprefix: true,
+      # #     prefix: "#{glyph}: [\\#{selected ? 'X' : ' '}] "
+      # #   )
+      # #   glyph = glyph.succ
+      # # end
+    end
+
+    def initialize(parent, items)
+      @parent = parent
+      @items = items
+    end
+  end
+
+  private_constant :DumbSelect
+end

data/lib/natty-ui/renderer/dumb_shell_runner.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module NattyUI
+  # @private
+  module DumbShellRunner
+    def self.render(parent, _tail, *, **)
+      out, err = [], []
+      width = parent.columns
+      ret =
+        Terminal.sh(*, **) do |line, kind|
+          (kind == :error ? err : out) << line
+          parent.puts(line, width:, spaces: true, prefix: Utils.mark[kind])
+        end
+      [ret, out, err] if ret
+    end
+  end
+
+  private_constant :DumbShellRunner
+end

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module NattyUI
+  # @private
+  class Heading
+    def self.render(parent, level, title)
+      prefix, suffix = @defined[level.to_int.clamp(1, 6) - 1]
+      parent.puts(title, prefix: prefix, suffix: suffix, eol: false)
+    end
+
+    attr_reader :to_ary
+
+    def initialize(str, style)
+      @to_ary = [
+        StrConst["#{style}#{str}#{Ansi::RESET} "],
+        StrConst[" #{style}#{str.reverse}#{Ansi::RESET}"]
+      ]
+    end
+
+    style = Ansi[:bright_blue]
+    @defined =
+      %w[╸╸╺╸╺━━━ ╴╶╴╶─═══ ╴╶╴╶─── ════ ━━━━ ────].map! { new(it, style) }
+  end
+
+  private_constant :Heading
+end