natty-ui 0.29.0 → 0.31.0

data/lib/natty-ui/features.rb

@@ -37,52 +37,61 @@ module NattyUI
     # @return [Features]
     #   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
+      if options.empty?
+        bbcode = true
+        max_width = Terminal.columns
+      else
+        bbcode = true if (bbcode = options[:bbcode]).nil?
+        ignore_newline = options[:eol] == false || options[:ignore_newline]
 
-      prefix_width =
-        if (prefix = options[:prefix])
-          prefix = Ansi.bbcode(prefix) if bbcode
-          options[:prefix_width] || Text.width(prefix, bbcode: false)
-        else
-          0
+        if (max_width = options[:max_width]).nil?
+          return self if (max_width = Terminal.columns).zero?
+        elsif max_width < 1
+          if max_width > 0
+            max_width *= Terminal.columns
+          elsif max_width < 0
+            max_width += Terminal.columns
+          else
+            return self
+          end
         end
 
-      if (first_line = options[:first_line_prefix])
-        first_line = Ansi.bbcode(first_line) if bbcode
-        first_line_width =
-          options[:first_line_prefix_width] ||
-            Text.width(first_line, bbcode: false)
+        prefix_width =
+          if (prefix = options[:prefix])
+            prefix = Ansi.bbcode(prefix) if bbcode
+            options[:prefix_width] || Text.width(prefix, bbcode: false)
+          else
+            0
+          end
 
-        if prefix_width < first_line_width
-          prefix_next = "#{prefix}#{' ' * (first_line_width - prefix_width)}"
-          prefix = first_line
-          prefix_width = first_line_width
-        else
-          prefix_next = prefix
-          prefix =
-            if first_line_width < prefix_width
-              first_line + (' ' * (prefix_width - first_line_width))
-            else
-              first_line
-            end
+        if (first_line = options[:first_line_prefix])
+          first_line = Ansi.bbcode(first_line) if bbcode
+          first_line_width =
+            options[:first_line_prefix_width] ||
+              Text.width(first_line, bbcode: false)
+
+          if prefix_width < first_line_width
+            prefix_next = "#{prefix}#{' ' * (first_line_width - prefix_width)}"
+            prefix = first_line
+            prefix_width = first_line_width
+          else
+            prefix_next = prefix
+            prefix =
+              if first_line_width < prefix_width
+                first_line + (' ' * (prefix_width - first_line_width))
+              else
+                first_line
+              end
+          end
         end
-      end
 
-      max_width -= prefix_width
+        max_width -= prefix_width
 
-      if (suffix = options[:suffix])
-        suffix = Ansi.bbcode(suffix) if bbcode
-        max_width -= options[:suffix_width] || Text.width(suffix, bbcode: false)
+        if (suffix = options[:suffix])
+          suffix = Ansi.bbcode(suffix) if bbcode
+          max_width -=
+            options[:suffix_width] || Text.width(suffix, bbcode: false)
+        end
       end
 
       return self if max_width <= 0
@@ -93,12 +102,14 @@ module NattyUI
           limit: max_width,
           bbcode: bbcode,
           ansi: Terminal.ansi?,
-          ignore_newline: options[:eol] == false || options[:ignore_newline]
+          ignore_newline: ignore_newline
         )
 
+      @__eol ||= Terminal.ansi? ? "\e[m\n" : "\n"
+
       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
@@ -118,7 +129,7 @@ module NattyUI
             ' ' * (max_width - width),
             line,
             suffix,
-            __eol,
+            @__eol,
             bbcode: false
           )
           @lines_written += 1
@@ -133,7 +144,7 @@ module NattyUI
             line,
             ' ' * (space - lw),
             suffix,
-            __eol,
+            @__eol,
             bbcode: false
           )
           @lines_written += 1
@@ -146,7 +157,7 @@ module NattyUI
             line,
             ' ' * (max_width - width),
             suffix,
-            __eol,
+            @__eol,
             bbcode: false
           )
           @lines_written += 1
@@ -301,7 +312,7 @@ module NattyUI
     #
     # @return (see puts)
     def space(count = 1)
-      puts("\n" * count) if (count = count.to_i).positive?
+      (count = count.to_i).positive? ? puts("\n" * count) : self
     end
 
     # Print given items as list (like 'ls' command).
@@ -474,10 +485,11 @@ module NattyUI
     #   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 min [#to_f] start value
+    # @param max [#to_f] end value
     # @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 text [true, false] whether the values should be printed too
+    # @param 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
     #
@@ -486,8 +498,10 @@ module NattyUI
     # @return (see puts)
     def hbars(
       values,
-      with_values: true,
+      min: nil,
+      max: nil,
       normalize: false,
+      text: true,
       width: :auto,
       style: nil,
       text_style: nil
@@ -497,12 +511,9 @@ module NattyUI
         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
+      renderer = HBarsRenderer.new(values, min, max)
+      renderer.with_text(text_style) if text
+      puts(*renderer.lines(Utils.as_size(3..columns, width), style, normalize))
     end
 
     # Dynamically display a task progress.
@@ -567,6 +578,31 @@ module NattyUI
       block ? __with(progress, &block) : progress
     end
 
+    # Run a shell program
+    #
+    # @return [Process::Status] when command was executed
+    # @return [nil] in error case (like command not found)
+    def sh(*cmd, shell: false, input: nil)
+      m = (theme = Theme.current).mark(:sh_out)
+      opts_out = {
+        bbcode: false,
+        prefix: "#{m}#{theme.sh_out_style}",
+        prefix_width: m.width
+      }
+      m = theme.mark(:sh_err)
+      opts_err = {
+        bbcode: false,
+        prefix: "#{m}#{theme.sh_err_style}",
+        prefix_width: m.width
+      }
+      ShellCommand.call(*cmd, shell: shell, input: input) do |line, kind|
+        puts(
+          line.gsub("\t", '    ').gsub(/[[:space:]]/, ' '),
+          **(kind == :error ? opts_err : opts_out)
+        )
+      end
+    end
+
     #
     # @!endgroup
     #
@@ -945,43 +981,45 @@ module NattyUI
         end
       end
     end
-
-    def __eol
-      @__eol ||= Terminal.ansi? ? "\e[m\n" : "\n"
-    end
   end
 
   dir = __dir__
-  autoload :Choice, "#{dir}/choice.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"
+  autoload :ShellCommand, "#{dir}/shell_command.rb"
   autoload :Table, "#{dir}/table.rb"
   autoload :Task, "#{dir}/task.rb"
   autoload :Temporary, "#{dir}/temporary.rb"
   autoload :Theme, "#{dir}/theme.rb"
   autoload :Utils, "#{dir}/utils.rb"
+
+  autoload :Choice, "#{dir}/choice.rb"
+  autoload :DumbChoice, "#{dir}/dumb_choice.rb"
+  autoload :Options, "#{dir}/options.rb"
+  autoload :DumbOptions, "#{dir}/dumb_options.rb"
+  autoload :Progress, "#{dir}/progress.rb"
+  autoload :DumbProgress, "#{dir}/progress.rb"
+
+  autoload :CompactLSRenderer, "#{dir}/ls_renderer.rb"
+  autoload :HBarsRenderer, "#{dir}/hbars_renderer.rb"
+  autoload :LSRenderer, "#{dir}/ls_renderer.rb"
   autoload :VBarsRenderer, "#{dir}/vbars_renderer.rb"
 
   private_constant(
+    :Framed,
+    :ShellCommand,
+    :Utils,
+    # -
     :Choice,
     :DumbChoice,
+    :Options,
     :DumbOptions,
+    :Progress,
+    :DumbProgress,
+    # -
     :CompactLSRenderer,
-    :Framed,
     :HBarsRenderer,
     :LSRenderer,
-    :Options,
-    :Progress,
-    :DumbProgress,
-    :Utils,
     :VBarsRenderer
   )
 end

data/lib/natty-ui/hbars_renderer.rb

@@ -3,54 +3,62 @@
 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
+  class HBarsRenderer
+    def initialize(values, min, max)
+      @values = values
+      @min = min
+      @max = max
+    end
+
+    def with_text(style)
+      @texts = @values.map { Str.new(_1) }
+      @texts_width = @texts.max_by(&:width).width
+      @texts.map!(&format_text(style, @texts_width))
+      self
+    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}" }
+    def lines(width, style, normalize)
+      if @texts
+        width -= @texts_width
+        return @texts if width < 3
       end
+      width -= 1
+      fmt = format(style)
+      vals = normalize ? normalized(width, &fmt) : adjusted(width, &fmt)
+      vals = @texts.zip(vals).map!(&:join) if @texts
+      vals
+    end
 
-      private
+    private
 
-      def adjust!(vals, size)
-        max = vals.max.to_f
-        vals.map { ((_1 / max) * size).round }
-      end
+    def format_text(style, width)
+      return ->(l) { "#{' ' * (width - l.width)}#{l}" } unless style
+      bot = Ansi[*style]
+      eot = Ansi::RESET
+      ->(l) { "#{bot}#{' ' * (width - l.width)}#{l}#{eot}" }
+    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
+    def format(style)
+      return ->(l) { "▕#{'▆' * l}" } unless style
+      bos = Ansi[*style]
+      eos = Ansi::RESET
+      ->(l) { "#{bos}▕#{'▆' * l}#{eos}" }
+    end
+
+    def adjusted(size)
+      vals = @values.map(&:to_f)
+      max = vals.max
+      max = @max.to_f if @max&.>(max)
+      vals.map! { yield(((_1 / max) * size).round) }
+    end
+
+    def normalized(size)
+      vals = @values.map(&:to_f)
+      min, max = vals.minmax
+      min = @min.to_f if @min&.<(min)
+      max = @max.to_f if @max&.>(max)
+      max -= min
+      vals.map! { yield((((_1 - min) / max) * size).round) }
     end
   end
 

data/lib/natty-ui/progress.rb

@@ -100,8 +100,10 @@ module NattyUI
       @pin_line = NattyUI.lines_written
       @style = Theme.current.task_style
       cm = Theme.current.mark(:current)
-      @flp = "#{cm} #{@style}"
-      @flpw = cm.width + 1
+      @redraw_opts = {
+        first_line_prefix: "#{cm} #{@style}",
+        first_line_prefix_width: cm.width + 1
+      }
       max ? self.max = max : redraw
     end
 
@@ -111,11 +113,7 @@ module NattyUI
       curr = bar ? [@title, bar] : [@title]
       return if @last == curr
       @pin_line = NattyUI.back_to_line(@pin_line) if @last
-      @parent.puts(
-        *curr,
-        first_line_prefix: @flp,
-        first_line_prefix_width: @flpw
-      )
+      @parent.puts(*curr, **@redraw_opts)
       @last = curr
     end
 

data/lib/natty-ui/shell_command.rb

@@ -0,0 +1,132 @@
+module NattyUI
+  module ShellCommand
+    class << self
+      def call(*cmd, shell: false, input: nil, **options)
+        options = options.except(:in, :out, :err)
+        env = (cmd[0].is_a?(Hash) ? cmd.shift.dup : {}).freeze
+        if shell
+          cmd = cmd.map! { _escape(it) }.join(' ')
+        elsif cmd.size == 1 && cmd[0].include?(' ')
+          cmd = cmd[0]
+        end
+        cmd.freeze
+        input = Input.for(input)
+        ret = nil
+        with_io(options, input) do |cio, out_r, err_r, in_w|
+          thread = Process.detach(Process.spawn(env, *cmd, options))
+          begin
+            cio.each(&:close)
+            read = [out_r, err_r]
+            write = [in_w] if in_w
+            while !read.empty? || write
+              rr, wr, = IO.select(read, write)
+              if rr.include?(out_r)
+                begin
+                  yield(out_r.readline(chomp: true), :output)
+                rescue SystemCallError, IOError
+                  read.delete(out_r)
+                end
+              end
+              if rr.include?(err_r)
+                begin
+                  yield(err_r.readline(chomp: true), :error)
+                rescue SystemCallError, IOError
+                  read.delete(err_r)
+                end
+              end
+              next if wr.empty?
+              begin
+                next if input.call(in_w)
+              rescue SystemCallError, IOError
+                # nop
+              end
+              in_w.close
+              write = nil
+            end
+          ensure
+            ret = thread.join.value
+          end
+        end
+        ret
+      rescue SystemCallError, IOError
+        nil
+      end
+
+      private
+
+      def with_io(options, input)
+        IO.pipe do |out_r, out_w|
+          IO.pipe do |err_r, err_w|
+            cio = [options[:out] = out_w, options[:err] = err_w]
+            return yield(cio, out_r, err_r) unless input
+            IO.pipe do |in_r, in_w|
+              cio << (options[:in] = in_r)
+              in_w.sync = true
+              yield(cio, out_r, err_r, in_w)
+            end
+          end
+        end
+      end
+
+      def _escape(str)
+        return +"''" if str.empty?
+        str = str.dup
+        str.gsub!(%r{[^A-Za-z0-9_\-.,:+/@\n]}, "\\\\\\&")
+        str.gsub!("\n", "'\n'")
+        str
+      end
+    end
+
+    module Input
+      def self.for(obj)
+        return unless obj
+        return CopyWriter.new(obj) if obj.respond_to?(:readpartial)
+        return CopyWriter.new(obj.to_io) if obj.respond_to?(:to_io)
+        return ArrayWriter.new(obj) if obj.is_a?(Array)
+        return EnumerableWriter.new(obj) if obj.respond_to?(:each)
+        return ArrayWriter.new(obj.to_a) if obj.respond_to?(:to_a)
+        Writer.new(obj)
+      end
+
+      class Writer
+        def call(io) = (io.write(_next) if @obj)
+        def initialize(obj) = (@obj = obj)
+        def _next = (_, @obj = @obj, nil).first
+      end
+
+      class CopyWriter < Writer
+        def call(io) = (IO.copy_stream(_next, io) if @obj)
+      end
+
+      class ArrayWriter
+        def call(io) = io.write(@ry[@idx += 1] || return)
+
+        def initialize(ary)
+          @ry = ary
+          @idx = -1
+        end
+      end
+
+      class EnumerableWriter
+        def call(io)
+          io.write(@enum.next)
+        rescue StopIteration
+          false
+        end
+
+        def initialize(enum)
+          @enum =
+            if enum.respond_to?(:enum_for)
+              enum.enum_for(:each)
+            else
+              Enumerator.new { |y| enum.each { y << it } }
+            end
+        end
+      end
+    end
+
+    private_constant :Input
+  end
+
+  private_constant :ShellCommand
+end

data/lib/natty-ui/table.rb

@@ -9,8 +9,8 @@ module NattyUI
   # Collection of rows and columns used by {Features.table}.
   #
   class Table
-    class Column < NattyUI::Attributes::Base
-      include NattyUI::Attributes::Width
+    class Column < NattyUI::Attributes
+      include Width
 
       # @return [Integer] column index
       attr_reader :index
@@ -22,6 +22,12 @@ module NattyUI
       def to_s = "#{super.chop} @index:#{@index} @width:#{width.inspect}>"
       alias inspect to_s
 
+      def assign(**attributes)
+        return self if attributes.empty?
+        @parent.each_cell_of(@index) { _1.attributes.merge!(**attributes) }
+        self
+      end
+
       private
 
       def find_width
@@ -137,6 +143,12 @@ module NattyUI
         self
       end
 
+      def assign(**attributes)
+        return self if attributes.empty?
+        @cells.each { _1.attributes.merge!(**attributes) }
+        self
+      end
+
       private
 
       def respond_to_missing?(name, _)
@@ -169,19 +181,42 @@ module NattyUI
     class Cell
       include TextWithAttributes
 
-      class Attributes < NattyUI::Attributes::Base
-        prepend NattyUI::Attributes::Width
-        prepend NattyUI::Attributes::Padding
-        prepend NattyUI::Attributes::Align
-        prepend NattyUI::Attributes::Vertical
-        prepend NattyUI::Attributes::Style
+      class Attributes < NattyUI::Attributes
+        prepend Width
+        prepend Padding
+        prepend Align
+        prepend Vertical
+        prepend Style
+
+        # Whether the text's line breaks are processed.
+        #
+        # @return [true, false]
+        attr_reader :eol
+
+        # @attribute [w]  eol
+        def eol=(value)
+          @eol = value ? true : false
+        end
+
+        protected
+
+        def _assign(opt)
+          @eol = opt[:eol]
+          @eol = true if @eol.nil?
+          super
+        end
+
+        def _store(opt)
+          opt[:eol] = false unless @eol
+          super
+        end
       end
     end
 
-    class Attributes < NattyUI::Attributes::Base
-      prepend NattyUI::Attributes::Border
-      prepend NattyUI::Attributes::BorderStyle
-      prepend NattyUI::Attributes::Position
+    class Attributes < NattyUI::Attributes
+      prepend Border
+      prepend BorderStyle
+      prepend Position
 
       # Whether the table has a border around.
       #

data/lib/natty-ui/table_renderer.rb

@@ -115,12 +115,12 @@ module NattyUI
         @align = att.align
         @vertical = att.vertical
         @style = att.style_bbcode
-        @text = width_corrected(cell.text, width)
+        @text = width_corrected(cell.text, width, att.eol == false)
       end
 
       private
 
-      def width_corrected(text, width)
+      def width_corrected(text, width, ignore_newline)
         @width, @padding[3], @padding[1] =
           WidthFinder.adjust(width, @padding[3], @padding[1])
         @empty = @style ? "#{@style}#{' ' * width}[/]" : ' ' * width
@@ -130,6 +130,7 @@ module NattyUI
             *text,
             limit: @width,
             bbcode: true,
+            ignore_newline: ignore_newline,
             ansi: Terminal.ansi?
           ).map(&txt_fmt),
           Array.new(@padding[2], @empty)