# File lib/highline.rb, line 76
  def self.color_scheme
    @@color_scheme
  end

# File lib/highline.rb, line 71
  def self.color_scheme=( setting )
    @@color_scheme = setting
  end

# File lib/highline.rb, line 149
  def initialize( input = $stdin, output = $stdout,
                  wrap_at = nil, page_at = nil )
    @input   = input
    @output  = output
    
    self.wrap_at = wrap_at
    self.page_at = page_at
    
    @question = nil
    @answer   = nil
    @menu     = nil
    @header   = nil
    @prompt   = nil
    @gather   = nil
    @answers  = nil
    @key      = nil
  end

# File lib/highline.rb, line 58
  def self.track_eof=( setting )
    @@track_eof = setting
  end

# File lib/highline.rb, line 63
  def self.track_eof?
    @@track_eof
  end

# File lib/highline.rb, line 45
  def self.use_color=( setting )
    @@use_color = setting
  end

# File lib/highline.rb, line 50
  def self.use_color?
    @@use_color
  end

# File lib/highline.rb, line 81
  def self.using_color_scheme?
    not @@color_scheme.nil?
  end

# File lib/highline.rb, line 183
  def agree( yes_or_no_question, character = nil )
    ask(yes_or_no_question, lambda { |yn| yn.downcase[0] == ?y}) do |q|
      q.validate                 = /\Ay(?:es)?|no?\Z/i
      q.responses[:not_valid]    = 'Please enter "yes" or "no".'
      q.responses[:ask_on_error] = :question
      q.character                = character
      
      yield q if block_given?
    end
  end

# File lib/highline.rb, line 208
  def ask( question, answer_type = String, &details ) # :yields: question
    @question ||= Question.new(question, answer_type, &details)
    
    return gather if @question.gather
  
    # readline() needs to handle it's own output, but readline only supports 
    # full line reading.  Therefore if @question.echo is anything but true, 
    # the prompt will not be issued. And we have to account for that now.
    say(@question) unless (@question.readline and @question.echo == true)
    begin
      @answer = @question.answer_or_default(get_response)
      unless @question.valid_answer?(@answer)
        explain_error(:not_valid)
        raise QuestionError
      end
      
      @answer = @question.convert(@answer)
      
      if @question.in_range?(@answer)
        if @question.confirm
          # need to add a layer of scope to ask a question inside a
          # question, without destroying instance data
          context_change = self.class.new(@input, @output, @wrap_at, @page_at)
          if @question.confirm == true
            confirm_question = "Are you sure?  "
          else
            # evaluate ERb under initial scope, so it will have
            # access to @question and @answer
            template  = ERB.new(@question.confirm, nil, "%")
            confirm_question = template.result(binding)
          end
          unless context_change.agree(confirm_question)
            explain_error(nil)
            raise QuestionError
          end
        end
        
        @answer
      else
        explain_error(:not_in_range)
        raise QuestionError
      end
    rescue QuestionError
      retry
    rescue ArgumentError, NameError => error
      raise if error.is_a?(NoMethodError)
      if error.message =~ /ambiguous/
        # the assumption here is that OptionParser::Completion#complete
        # (used for ambiguity resolution) throws exceptions containing 
        # the word 'ambiguous' whenever resolution fails
        explain_error(:ambiguous_completion)
      else
        explain_error(:invalid_type)
      end
      retry
    rescue Question::NoAutoCompleteMatch
      explain_error(:no_completion)
      retry
    ensure
      @question = nil    # Reset Question object.
    end
  end

# File lib/highline.rb, line 286
  def choose( *items, &details )
    @menu = @question = Menu.new(&details)
    @menu.choices(*items) unless items.empty?
    
    # Set _answer_type_ so we can double as the Question for ask().
    @menu.answer_type = if @menu.shell
      lambda do |command|    # shell-style selection
        first_word = command.to_s.split.first || ""

        options = @menu.options
        options.extend(OptionParser::Completion)
        answer = options.complete(first_word)

        if answer.nil?
          raise Question::NoAutoCompleteMatch
        end

        [answer.last, command.sub(/^\s*#{first_word}\s*/, "")]
      end
    else
      @menu.options          # normal menu selection, by index or name
    end
    
    # Provide hooks for ERb layouts.
    @header   = @menu.header
    @prompt   = @menu.prompt
    
    if @menu.shell
      selected = ask("Ignored", @menu.answer_type)
      @menu.select(self, *selected)
    else
      selected = ask("Ignored", @menu.answer_type)
      @menu.select(self, selected)
    end
  end

# File lib/highline.rb, line 333
  def color( string, *colors )
    return string unless self.class.use_color?
    
    colors.map! do |c|
      if self.class.using_color_scheme? and self.class.color_scheme.include? c
        self.class.color_scheme[c]
      elsif c.is_a? Symbol
        self.class.const_get(c.to_s.upcase)
      else
        c
      end
    end
    "#{colors.flatten.join}#{string}#{CLEAR}"
  end

# File lib/highline.rb, line 376
  def list( items, mode = :rows, option = nil )
    items = items.to_ary.map do |item|
      ERB.new(item, nil, "%").result(binding)
    end
    
    case mode
    when :inline
      option = " or " if option.nil?
      
      case items.size
      when 0
        ""
      when 1
        items.first
      when 2
        "#{items.first}#{option}#{items.last}"
      else
        items[0..-2].join(", ") + "#{option}#{items.last}"
      end
    when :columns_across, :columns_down
      max_length = actual_length(
        items.max { |a, b| actual_length(a) <=> actual_length(b) }
      )

      if option.nil?
        limit  = @wrap_at || 80
        option = (limit + 2) / (max_length + 2)
      end

      items     = items.map do |item|
        pad = max_length + (item.length - actual_length(item))
        "%-#{pad}s" % item
      end
      row_count = (items.size / option.to_f).ceil
      
      if mode == :columns_across
        rows = Array.new(row_count) { Array.new }
        items.each_with_index do |item, index|
          rows[index / option] << item
        end

        rows.map { |row| row.join("  ") + "\n" }.join
      else
        columns = Array.new(option) { Array.new }
        items.each_with_index do |item, index|
          columns[index / row_count] << item
        end
      
        list = ""
        columns.first.size.times do |index|
          list << columns.map { |column| column[index] }.
                          compact.join("  ") + "\n"
        end
        list
      end
    else
      items.map { |i| "#{i}\n" }.join
    end
  end

# File lib/highline.rb, line 488
  def output_cols
    return 80 unless @output.tty?
    terminal_size.first
  rescue
    return 80
  end

# File lib/highline.rb, line 499
  def output_rows
    return 24 unless @output.tty?
    terminal_size.last
  rescue
    return 24
  end

# File lib/highline.rb, line 480
  def page_at=( setting )
    @page_at = setting == :auto ? output_rows : setting
  end

# File lib/highline.rb, line 446
  def say( statement )
    statement = statement.to_str
    return unless statement.length > 0
    
    template  = ERB.new(statement, nil, "%")
    statement = template.result(binding)
    
    statement = wrap(statement) unless @wrap_at.nil?
    statement = page_print(statement) unless @page_at.nil?
    
    if statement[-1, 1] == " " or statement[-1, 1] == "\t"
      @output.print(statement)
      @output.flush  
    else
      @output.puts(statement)
    end
  end

# File lib/highline.rb, line 470
  def wrap_at=( setting )
    @wrap_at = setting == :auto ? output_cols : setting
  end