natty-ui 0.35.0 → 1.0.2

data/lib/natty-ui/dumb_options.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'element'
-
-module NattyUI
-  class DumbOptions < Element
-    def select
-      yield(self) if block_given?
-      draw
-      Terminal.on_key_event do |event|
-        return if @abortable && %w[Esc Ctrl+c].include?(event.name)
-        return @opts.transform_values(&:last) if event.name == 'Enter'
-        next true unless event.simple?
-        code = event.raw.upcase
-        if @opts.size <= 9
-          next true unless ('1'..'9').include?(code)
-          offset = 49
-        elsif ('A'..'Z').include?(code)
-          offset = 65
-        else
-          next true
-        end
-        key = @opts.keys[code.ord - offset] or next true
-        @opts[key][-1] = !@opts[key][-1]
-        @parent.space
-        draw
-      end
-    ensure
-      @parent.space
-    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
-      theme = Theme.current
-      @marks = {
-        true => theme.mark(:checkmark),
-        false => theme.mark(:choice)
-      }.compare_by_identity
-    end
-
-    def draw
-      glyph = @opts.size <= 9 ? 1 : 'A'
-      @opts.each_pair do |_, (str, selected)|
-        mark = @marks[selected]
-        @parent.puts(
-          str,
-          first_line_prefix: "[\\#{glyph}] #{mark}",
-          first_line_prefix_width: mark.width + 2
-        )
-        glyph = glyph.succ
-      end
-    end
-  end
-
-  private_constant :DumbOptions
-end

data/lib/natty-ui/framed.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'element'
-
-module NattyUI
-  # {Element} with a frame around the content used by {Features.framed}.
-  #
-  class Framed < Element
-    # @private
-    def closed? = @bottom ? false : true
-
-    # @private
-    def puts(*objects, **options)
-      return self if closed?
-      options[:align] = @align
-      options[:expand] = true
-      super
-    end
-
-    # @private
-    def done
-      return if closed?
-      @parent.puts(@bottom)
-      @bottom = nil
-    end
-
-    # @private
-    def inspect = "#{_to_s.chop} align=#{@align.inspect} closed?=#{closed?}>"
-
-    private
-
-    def initialize(parent, align, chars, style)
-      super(parent)
-      @align = align
-      if style
-        style = Ansi[*style]
-        @prefix = "#{style}#{chars[9]}[/] "
-        @suffix = " #{style}#{chars[9]}[/]"
-      else
-        @prefix = "#{chars[9]} "
-        @suffix = " #{chars[9]}"
-      end
-      @prefix_width = 2
-      @suffix_width = 2
-      line = chars[10] * (parent.columns - 2)
-      parent.puts("#{style}#{chars[0]}#{line}#{chars[2]}")
-      @bottom = "#{style}#{chars[6]}#{line}#{chars[8]}"
-    end
-  end
-end

data/lib/natty-ui/hbars_renderer.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'utils'
-
-module NattyUI
-  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(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
-
-    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 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
-
-  private_constant :HBarsRenderer
-end

data/lib/natty-ui/options.rb

@@ -1,78 +0,0 @@
-# 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
-      Terminal.on_key_event do |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 true 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/shell_renderer.rb

@@ -1,91 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'theme'
-
-module NattyUI
-  module ShellRenderer
-    def self.sh(parent, cmd, options, space)
-      opts_out, opts_err = opts_from(Theme.current)
-      Terminal.sh(*cmd, **options) do |line, kind|
-        parent.puts(
-          space ? line.gsub("\t", '    ').gsub(/[[:space:]]/, ' ') : line,
-          **(kind == :error ? opts_err : opts_out)
-        )
-      end
-    end
-
-    if Terminal.ansi?
-      def self.opts_from(theme)
-        out = theme.mark(:sh_out)
-        err = theme.mark(:sh_err)
-        [
-          {
-            bbcode: false,
-            prefix: "#{out}#{theme.sh_out_style}",
-            prefix_width: out.width
-          },
-          {
-            bbcode: false,
-            prefix: "#{err}#{theme.sh_err_style}",
-            prefix_width: err.width
-          }
-        ]
-      end
-
-      def self.run(parent, cmd, options, space, tail)
-        theme = Theme.current
-        opref = "#{theme.mark(:sh_out)}#{theme.sh_out_style}"
-        epref = "#{theme.mark(:sh_err)}#{theme.sh_err_style}"
-        out, err, show = [], [], []
-        start = NattyUI.lines_written
-        [
-          Terminal.sh(*cmd, **options) do |line, kind|
-            start = NattyUI.back_to_line(start)
-            ol = space ? line.gsub("\t", '    ').gsub(/[[:space:]]/, ' ') : line
-            if kind == :error
-              err << line
-              show << "#{epref}#{ol}"
-            else
-              out << line
-              show << "#{opref}#{ol}"
-            end
-            parent.puts(*show, bbcode: false, tail: tail)
-          end,
-          out,
-          err
-        ]
-      end
-    else
-      def self.opts_from(theme)
-        out = theme.mark(:sh_out)
-        err = theme.mark(:sh_err)
-        [
-          { bbcode: false, prefix: out, prefix_width: out.width },
-          { bbcode: false, prefix: err, prefix_width: err.width }
-        ]
-      end
-
-      def self.run(parent, cmd, options, _space, _tail)
-        theme = Theme.current
-        opref, epref = theme.mark(:sh_out), theme.mark(:sh_err)
-        out, err = [], []
-        [
-          Terminal.sh(*cmd, **options) do |line, kind|
-            ol = line.gsub("\t", '    ').gsub(/[[:space:]]/, ' ')
-            if kind == :error
-              err << line
-              parent.puts("#{epref}#{ol}", bbcode: false)
-            else
-              out << line
-              parent.puts("#{opref}#{ol}", bbcode: false)
-            end
-          end,
-          out,
-          err
-        ]
-      end
-    end
-  end
-
-  private_constant :ShellRenderer
-end

data/lib/natty-ui/table.rb

@@ -1,325 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'attributes'
-require_relative 'table_renderer'
-
-module NattyUI
-  # @todo This chapter needs more documentation.
-  #
-  # Collection of rows and columns used by {Features.table}.
-  #
-  class Table
-    class Column < NattyUI::Attributes
-      include Width
-
-      # @return [Integer] column index
-      attr_reader :index
-
-      def width
-        @width ||= find_width
-      end
-
-      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
-        min = max = nil
-        @parent.each_cell_of(@index) do |cell|
-          next unless cell
-          m = cell.attributes.min_width
-          min = m if m && (min.nil? || m < min)
-          m = cell.attributes.max_width
-          max = m if m && (max.nil? || max < m)
-        end
-        wh_from(min, max)
-      end
-
-      def respond_to_missing?(name, _)
-        return suoer unless name.end_with?('=')
-        Cell::Attributes.public_method_defined?(name) || super
-      end
-
-      def method_missing(name, *args, **kwargs)
-        return super unless name.end_with?('=')
-        return super unless Cell::Attributes.public_method_defined?(name)
-        @parent.each_cell_of(@index) { _1.attributes.__send__(name, *args) }
-        args[0]
-      end
-
-      def initialize(parent, index, **attributes)
-        super(**attributes)
-        @parent = parent
-        @index = index
-      end
-    end
-
-    class ColumnsCollection
-      include Enumerable
-
-      # @return [Integer] count of columns
-      def count = columns.size
-
-      def empty? = columns.empty?
-
-      # @return [Column, nil] column at given index
-      def [](index) = columns[index]
-
-      def each(&block) = columns.each(&block)
-
-      def to_s = "#{super.chop} @columns:#{columns.inspect}>"
-      alias inspect to_s
-
-      private
-
-      def columns
-        cc = @parent.column_count
-        case cc <=> @columns.size
-        when -1
-          @columns = @columns.take(cc)
-        when 1
-          bi = @columns.size
-          @columns +=
-            Array.new(cc - @columns.size) { Column.new(@parent, bi + _1) }
-        else
-          @columns
-        end
-      end
-
-      def initialize(parent)
-        @parent = parent
-        @columns = []
-      end
-
-      def initialize_copy(*_)
-        super
-        @columns = []
-      end
-    end
-
-    class Row
-      include Enumerable
-
-      def empty? = @cells.empty?
-
-      # @return [Integer] count of cells
-      def count = @cells.size
-
-      def each(&block) = @cells.each(&block)
-
-      # @return [Cell, nil] cell at given index
-      def [](index) = @cells[index]
-
-      # @return [Cell] created cell
-      def []=(index, *args)
-        @cells[index] = create_cell(args)
-        @cells.map! { _1 || Cell.new }
-      end
-
-      # Add a new cell to the row with given `text` and `attributes`.
-      # @return [Cell] created cell
-      def add(*text, **attributes)
-        nc = Cell.new(*text, **attributes)
-        @cells << nc
-        block_given? ? yield(nc) : nc
-      end
-
-      def delete(cell)
-        cell.is_a?(Cell) ? @cells.delete(cell) : @cells.delete_at(cell)
-        self
-      end
-
-      # Add a new cell to the row with given `text`.
-      # @return [Row] itself
-      def <<(text)
-        add(text)
-        self
-      end
-
-      def assign(**attributes)
-        return self if attributes.empty?
-        @cells.each { _1.attributes.merge!(**attributes) }
-        self
-      end
-
-      private
-
-      def respond_to_missing?(name, _)
-        return super unless name.end_with?('=')
-        Cell::Attributes.public_method_defined?(name) || super
-      end
-
-      def method_missing(name, *args, **_)
-        return super unless name.end_with?('=')
-        return super unless Cell::Attributes.public_method_defined?(name)
-        @cells.each { _1.attributes.__send__(name, *args) }
-        args[0]
-      end
-
-      def initialize
-        @cells = []
-      end
-
-      def initialize_copy(*_)
-        super
-        @cells = @cells.map(&:dup)
-      end
-
-      def create_cell(args)
-        args.flatten!(1)
-        Cell.new(*args)
-      end
-    end
-
-    class Cell
-      include TextWithAttributes
-
-      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
-      prepend Border
-      prepend BorderStyle
-      prepend Position
-
-      # Whether the table has a border around.
-      #
-      # @return [true, false]
-      attr_reader :border_around
-
-      # @attribute [w]  border_around
-      def border_around=(value)
-        @border_around = value ? true : false
-      end
-
-      # Maximum table width.
-      #
-      # @return [Integer, nil]
-      attr_reader :max_width
-
-      # @attribute [w] max_width
-      def max_width=(value)
-        if value.is_a?(Float)
-          return @max_width = nil if value < 0
-          return @max_width = value if value < 1
-        end
-        value = value.to_i
-        @max_width = value <= 0 ? nil : value
-      end
-
-      protected
-
-      def _assign(opt)
-        @border_around = opt[:border_around]
-        self.max_width = opt[:max_width]
-        super
-      end
-
-      def _store(opt)
-        opt[:border_around] = true if @border_around
-        opt[:max_width] = @max_width if @max_width
-        super
-      end
-    end
-
-    include Enumerable
-    include WithAttributes
-
-    # @return [ColumnsCollection] table columns
-    attr_reader :columns
-
-    def empty? = @rows.empty?
-
-    # @return [Integer] count of rows
-    def count = @rows.size
-
-    # @return [Integer] count of columns
-    def column_count = @rows.empty? ? 0 : @rows.max_by(&:count).count
-
-    def each(&block) = @rows.each(&block)
-
-    def [](row_index, column_index = nil)
-      row = @rows[row_index] or return
-      column_index ? row[column_index] : row
-    end
-
-    # @return [Row] created row
-    def add(*text, **attributes)
-      unless text[0].is_a?(Hash)
-        @rows << (nr = Row.new)
-        text.each { nr.add(_1, **attributes) }
-        return block_given? ? yield(nr) : nr
-      end
-      new_rows = []
-      text[0].each_pair do |key, value|
-        new_rows << (nr = Row.new)
-        @rows << nr
-        nr.add(key, **attributes)
-        nr.add(value, **attributes)
-        yield(nr) if block_given?
-      end
-      new_rows
-    end
-
-    def delete(row)
-      row.is_a?(Row) ? @rows.delete(row) : @rows.delete_at(row)
-    end
-
-    def each_cell_of(column_index)
-      return to_enum(__method__, column_index) unless block_given?
-      return if (column_index = column_index.to_i) >= column_count
-      @rows.each { yield(_1[column_index]) }
-      nil
-    end
-
-    private
-
-    def initialize(**attributes)
-      super
-      @rows = []
-      @columns = ColumnsCollection.new(self)
-    end
-
-    def initialize_copy(*_)
-      super
-      @columns = ColumnsCollection.new(self)
-      @rows = @rows.map(&:dup)
-    end
-  end
-end