natty-ui 0.30.0 → 0.31.0

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)