lib/highline/list_renderer.rb
# coding: utf-8
require "highline/template_renderer"
require "highline/wrapper"
require "highline/list"
class HighLine
#
# This class is a utility for quickly and easily laying out lists
# to be used by HighLine.
#
class ListRenderer
# Items list
# @return [Array]
attr_reader :items
# @return [Symbol] the current mode the List is being rendered
# @see #initialize for more details see mode parameter of #initialize
attr_reader :mode
# Changes the behaviour of some modes. Example, in :inline mode
# the option is treated as the 'end separator' (defaults to " or ")
# @return option parameter that changes the behaviour of some modes.
attr_reader :option
# @return [HighLine] context
attr_reader :highline
# The only required parameters are _items_ and _highline_.
# @param items [Array] the Array of items to list
# @param mode [Symbol] controls how that list is formed
# @param option has different effects, depending on the _mode_.
# @param highline [HighLine] a HighLine instance to direct the output to.
#
# Recognized modes are:
#
# <tt>:columns_across</tt>:: _items_ will be placed in columns,
# flowing from left to right. If given,
# _option_ is the number of columns to be
# used. When absent, columns will be
# determined based on _wrap_at_ or a
# default of 80 characters.
# <tt>:columns_down</tt>:: Identical to <tt>:columns_across</tt>,
# save flow goes down.
# <tt>:uneven_columns_across</tt>:: Like <tt>:columns_across</tt> but each
# column is sized independently.
# <tt>:uneven_columns_down</tt>:: Like <tt>:columns_down</tt> but each
# column is sized independently.
# <tt>:inline</tt>:: All _items_ are placed on a single
# line. The last two _items_ are
# separated by _option_ or a default of
# " or ". All other _items_ are
# separated by ", ".
# <tt>:rows</tt>:: The default mode. Each of the _items_
# is placed on its own line. The _option_
# parameter is ignored in this mode.
#
# Each member of the _items_ Array is passed through ERb and thus can
# contain their own expansions. Color escape expansions do not contribute to
# the final field width.
def initialize(items, mode = :rows, option = nil, highline)
@highline = highline
@mode = mode
@option = option
@items = render_list_items(items)
end
# Render the list using the appropriate mode and options.
# @return [String] rendered list as String
def render
return "" if items.empty?
case mode
when :inline
list_inline_mode
when :columns_across
list_columns_across_mode
when :columns_down
list_columns_down_mode
when :uneven_columns_across
list_uneven_columns_mode
when :uneven_columns_down
list_uneven_columns_down_mode
else
list_default_mode
end
end
private
def render_list_items(items)
items.to_ary.map do |item|
item = String(item)
template = if ERB.instance_method(:initialize).parameters.assoc(:key) # Ruby 2.6+
ERB.new(item, trim_mode: "%")
else
ERB.new(item, nil, "%")
end
template_renderer =
HighLine::TemplateRenderer.new(template, self, highline)
template_renderer.render
end
end
def list_default_mode
items.map { |i| "#{i}\n" }.join
end
def list_inline_mode
end_separator = option || " or "
if items.size == 1
items.first
else
items[0..-2].join(", ") + "#{end_separator}#{items.last}"
end
end
def list_columns_across_mode
HighLine::List.new(right_padded_items, cols: col_count).to_s
end
def list_columns_down_mode
HighLine::List.new(
right_padded_items,
cols: col_count,
col_down: true
).to_s
end
def list_uneven_columns_mode(list = nil)
list ||= HighLine::List.new(items)
col_max = option || items.size
col_max.downto(1) do |column_count|
list.cols = column_count
widths = get_col_widths(list)
if column_count == 1 || # last guess
inside_line_size_limit?(widths) || # good guess
option # defined by user
return pad_uneven_rows(list, widths)
end
end
end
def list_uneven_columns_down_mode
list = HighLine::List.new(items, col_down: true)
list_uneven_columns_mode(list)
end
def pad_uneven_rows(list, widths)
right_padded_list = Array(list).map do |row|
right_pad_row(row.compact, widths)
end
stringfy_list(right_padded_list)
end
def stringfy_list(list)
list.map { |row| row_to_s(row) }.join
end
def row_to_s(row)
row.compact.join(row_join_string) + "\n"
end
def right_pad_row(row, widths)
row.zip(widths).map do |field, width|
right_pad_field(field, width)
end
end
def right_pad_field(field, width)
field = String(field) # nil protection
pad_size = width - actual_length(field)
field + (pad_char * pad_size)
end
def get_col_widths(lines)
lines = transpose(lines)
get_segment_widths(lines)
end
def get_row_widths(lines)
get_segment_widths(lines)
end
def get_segment_widths(lines)
lines.map do |col|
actual_lengths_for(col).max
end
end
def actual_lengths_for(line)
line.map do |item|
actual_length(item)
end
end
def transpose(lines)
lines = Array(lines)
first_line = lines.shift
first_line.zip(*lines)
end
def inside_line_size_limit?(widths)
line_size = widths.reduce(0) { |sum, n| sum + n + row_join_str_size }
line_size <= line_size_limit + row_join_str_size
end
def actual_length(text)
HighLine::Wrapper.actual_length text
end
def items_max_length
@items_max_length ||= max_length(items)
end
def max_length(items)
items.map { |item| actual_length(item) }.max
end
def line_size_limit
@line_size_limit ||= (highline.wrap_at || 80)
end
def row_join_string
@row_join_string ||= " "
end
attr_writer :row_join_string
def row_join_str_size
row_join_string.size
end
def col_count_calculate
(line_size_limit + row_join_str_size) /
(items_max_length + row_join_str_size)
end
def col_count
option || col_count_calculate
end
def right_padded_items
items.map do |item|
right_pad_field(item, items_max_length)
end
end
def pad_char
" "
end
def row_count
(items.count / col_count.to_f).ceil
end
end
end