highline 1.7.10 → 2.0.0.pre.develop.2

data/lib/highline/builtin_styles.rb

@@ -0,0 +1,109 @@
+#coding: utf-8
+
+class HighLine
+  module BuiltinStyles
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    STYLE_LIST = {
+      erase_line: "\e[K",
+      erase_char: "\e[P",
+      clear:      "\e[0m",
+      reset:      "\e[0m",
+      bold:       "\e[1m",
+      dark:       "\e[2m",
+      underline:  "\e[4m",
+      underscore: "\e[4m",
+      blink:      "\e[5m",
+      reverse:    "\e[7m",
+      concealed:  "\e[8m"
+    }
+
+    STYLE_LIST.each do |style_name, code|
+     style = String(style_name).upcase
+
+     const_set style, code
+     const_set style + "_STYLE", Style.new(name: style_name, code: code, builtin: true)
+    end
+
+    STYLES = %w{CLEAR RESET BOLD DARK UNDERLINE UNDERSCORE BLINK REVERSE CONCEALED}
+
+    COLOR_LIST = {
+      black:   { code: "\e[30m", rgb: [0, 0, 0] },
+      red:     { code: "\e[31m", rgb: [128, 0, 0] },
+      green:   { code: "\e[32m", rgb: [0, 128, 0] },
+      blue:    { code: "\e[34m", rgb: [0, 0, 128] },
+      yellow:  { code: "\e[33m", rgb: [128, 128, 0] },
+      magenta: { code: "\e[35m", rgb: [128, 0, 128] },
+      cyan:    { code: "\e[36m", rgb: [0, 128, 128] },
+      white:   { code: "\e[37m", rgb: [192, 192, 192] },
+      gray:    { code: "\e[37m", rgb: [192, 192, 192] },
+      grey:    { code: "\e[37m", rgb: [192, 192, 192] },
+      none:    { code: "\e[38m", rgb: [0, 0, 0] }
+    }
+
+    COLOR_LIST.each do |color_name, attributes|
+     color = String(color_name).upcase
+
+     style = Style.new(
+      name: color_name,
+      code: attributes[:code],
+      rgb:  attributes[:rgb],
+      builtin: true
+     )
+
+     const_set color + "_STYLE", style
+    end
+
+    BASIC_COLORS = %w{BLACK RED GREEN YELLOW BLUE MAGENTA CYAN WHITE GRAY GREY NONE}
+
+    colors = BASIC_COLORS.dup
+    BASIC_COLORS.each do |color|
+      bright_color = "BRIGHT_#{color}"
+      colors << bright_color
+      const_set bright_color + '_STYLE', const_get(color + '_STYLE').bright
+
+      light_color = "LIGHT_#{color}"
+      colors << light_color
+      const_set light_color + '_STYLE', const_get(color + '_STYLE').light
+    end
+    COLORS = colors
+
+    colors.each do |color|
+      const_set color, const_get("#{color}_STYLE").code
+      const_set "ON_#{color}_STYLE", const_get("#{color}_STYLE").on
+      const_set "ON_#{color}", const_get("ON_#{color}_STYLE").code
+    end
+
+    ON_NONE_STYLE.rgb = [255,255,255] # Override; white background
+
+    module ClassMethods
+      RGB_COLOR = /^(ON_)?(RGB_)([A-F0-9]{6})(_STYLE)?$/
+
+      def const_missing(name)
+        if name.to_s =~ RGB_COLOR
+          on = $1
+          suffix = $4
+
+          if suffix
+            code_name = $1.to_s + $2 + $3
+          else
+            code_name = name.to_s
+          end
+
+          style_name = code_name + '_STYLE'
+          style = Style.rgb($3)
+          style = style.on if on
+
+          const_set(style_name, style)
+          const_set(code_name, style.code)
+
+          suffix ? style : style.code
+        else
+          raise NameError, "Bad color or uninitialized constant #{name}"
+        end
+      end
+    end
+  end
+end

data/lib/highline/color_scheme.rb

@@ -1,3 +1,6 @@
+# coding: utf-8
+
+#--
 # color_scheme.rb
 #
 # Created by Jeremy Hinegardner on 2007-01-24
@@ -48,7 +51,7 @@ class HighLine
     #
     def initialize( h = nil )
       @scheme = Hash.new
-      load_from_hash(h) unless h.nil?
+      load_from_hash(h) if h
       yield self if block_given?
     end
 

data/lib/highline/compatibility.rb

@@ -1,3 +1,5 @@
+# coding: utf-8
+
 unless STDIN.respond_to? :getbyte
   class IO
     alias_method :getbyte, :getc

data/lib/highline/custom_errors.rb

@@ -0,0 +1,19 @@
+class HighLine
+  module CustomErrors
+    # Internal HighLine errors.
+    class QuestionError < StandardError
+    end
+
+    class NotValidQuestionError < QuestionError
+    end
+
+    class NotInRangeQuestionError < QuestionError
+    end
+
+    class NoConfirmationQuestionError < QuestionError
+    end
+
+    class NoAutoCompleteMatch < StandardError
+    end
+  end
+end

data/lib/highline/import.rb

@@ -1,3 +1,5 @@
+# coding: utf-8
+
 # import.rb
 #
 #  Created by James Edward Gray II on 2005-04-26.
@@ -33,9 +35,9 @@ class Object
   #
   def or_ask( *args, &details )
     ask(*args) do |question|
-      question.first_answer = String(self) unless nil?
+      question.first_answer = String(self)
 
-      details.call(question) unless details.nil?
+      details.call(question) if details
     end
   end
 end

data/lib/highline/list.rb

@@ -0,0 +1,93 @@
+# coding: utf-8
+
+class HighLine
+  class List
+    attr_reader :items, :cols
+    attr_reader :transpose_mode, :col_down_mode
+
+    def initialize(items, options = {})
+      @items          = items
+      @transpose_mode = options.fetch(:transpose) { false }
+      @col_down_mode  = options.fetch(:col_down)  { false }
+      @cols           = options.fetch(:cols)      { 1 }
+      build
+    end
+
+    def transpose
+      first_row = @list[0]
+      other_rows = @list[1..-1]
+      @list = first_row.zip(*other_rows)
+      self
+    end
+
+    def col_down
+      slice_by_rows
+      transpose
+      self
+    end
+
+    def slice_by_rows
+      @list = items_sliced_by_rows
+      self
+    end
+
+    def slice_by_cols
+      @list = items_sliced_by_cols
+      self
+    end
+
+    def cols=(cols)
+      @cols = cols
+      build
+    end
+
+    def to_a
+      list
+    end
+
+    def list
+      @list.dup
+    end
+
+    def to_s
+      list.map { |row| stringfy(row) }.join
+    end
+
+    def row_join_string
+      @row_join_string ||= "  "
+    end
+
+    def row_join_string=(string)
+      @row_join_string = string
+    end
+
+    def row_join_str_size
+      row_join_string.size
+    end
+
+    private
+
+    def build
+      slice_by_cols
+      transpose if transpose_mode
+      col_down  if col_down_mode
+      self
+    end
+
+    def items_sliced_by_cols
+      items.each_slice(cols).to_a
+    end
+
+    def items_sliced_by_rows
+      items.each_slice(row_count).to_a
+    end
+
+    def row_count
+      (items.count / cols.to_f).ceil
+    end
+
+    def stringfy(row)
+      row.compact.join(row_join_string) + "\n"
+    end
+  end
+end

data/lib/highline/list_renderer.rb

@@ -0,0 +1,232 @@
+# coding: utf-8
+
+require 'highline/template_renderer'
+require 'highline/wrapper'
+require 'highline/list'
+
+class HighLine::ListRenderer
+  attr_reader :items, :mode, :option, :highline
+
+  def initialize(items, mode = :rows, option = nil, highline)
+    @highline = highline
+    @mode     = mode
+    @option   = option
+    @items    = render_list_items(items)
+  end
+
+  #
+  # This method is a utility for quickly and easily laying out lists.  It can
+  # be accessed within ERb replacements of any text that will be sent to the
+  # user.
+  #
+  # The only required parameter is _items_, which should be the Array of items
+  # to list.  A specified _mode_ controls how that list is formed and _option_
+  # has different effects, depending on the _mode_.  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 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 = ERB.new(item, nil, "%")
+      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 or # last guess
+        inside_line_size_limit?(widths) or # 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.inject(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
+
+  def row_join_string=(string)
+    @row_join_string = string
+  end
+
+  def row_join_str_size
+    row_join_string.size
+  end
+
+  def get_col_count
+    (line_size_limit + row_join_str_size) /
+      (items_max_length + row_join_str_size)
+  end
+
+  def col_count
+    option || get_col_count
+  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