class HighLine

# File lib/highline/string_extensions.rb, line 27
def self.String(s)
  HighLine::String.new(s)
end

# File lib/highline/style.rb, line 12
def self.Style(*args)
  args = args.compact.flatten
  if args.size==1
    arg = args.first
    if arg.is_a?(Style)
      Style.list[arg.name] || Style.index(arg)
    elsif arg.is_a?(::String) && arg =~ /^\e\[/ # arg is a code
      if styles = Style.code_index[arg]
        styles.first
      else
        Style.new(:code=>arg)
      end
    elsif style = Style.list[arg]
      style
    elsif HighLine.color_scheme && HighLine.color_scheme[arg]
      HighLine.color_scheme[arg]
    elsif arg.is_a?(Hash)
      Style.new(arg)
    elsif arg.to_s.downcase =~ /^rgb_([a-f0-9]{6})$/
      Style.rgb($1)
    elsif arg.to_s.downcase =~ /^on_rgb_([a-f0-9]{6})$/
      Style.rgb($1).on
    else
      raise NameError, "#{arg.inspect} is not a defined Style"
    end
  else
    name = args
    Style.list[name] || Style.new(:list=>args)
  end
end

# File lib/highline.rb, line 377
def self.color( string, *colors )
  return string unless self.use_color?
  Style(*colors).color(string)
end

# File lib/highline.rb, line 383
def self.color_code(*colors)
  Style(*colors).code
end

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

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

# File lib/highline/string_extensions.rb, line 95
def self.colorize_strings
  ::String.send(:include, StringExtensions)
end

# File lib/highline.rb, line 150
def self.const_missing(name)
  if name.to_s =~ /^(ON_)?(RGB_)([A-F0-9]{6})(_STYLE)?$/ # 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)
    if suffix
      style
    else
      style.code
    end
  else
    raise NameError, "Bad color or uninitialized constant #{name}"
  end
end

# File lib/highline.rb, line 178
def initialize( input = $stdin, output = $stdout,
                wrap_at = nil, page_at = nil )
  @input   = input
  @output  = output
  if JRUBY
    require 'java'
    java_import 'java.io.OutputStreamWriter'
    java_import 'java.nio.channels.Channels'
    java_import 'jline.ConsoleReader'
    java_import 'jline.Terminal'

    @java_input = Channels.newInputStream($stdin.to_channel)
    @java_output = OutputStreamWriter.new(Channels.newOutputStream($stdout.to_channel))
    @java_terminal = Terminal.getTerminal
    @java_console = ConsoleReader.new(@java_input, @java_output)
    @java_console.setUseHistory(false)
    @java_console.setBellEnabled(true)
    @java_console.setUsePagination(false)
  end
  
  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 56
def self.supports_rgb_color?
  true
end

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

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

# File lib/highline.rb, line 398
def self.uncolor(string)
  Style.uncolor(string)
end

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

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

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

# File lib/highline.rb, line 227
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/
    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 252
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 330
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 393
def color(*args)
  self.class.color(*args)
end

# File lib/highline.rb, line 388
def color_code(*colors)
  self.class.color_code(*colors)
end

# File lib/highline.rb, line 440
def list( items, mode = :rows, option = nil )
  items = items.to_ary.map do |item|
    ERB.new(item, nil, "%").result(binding)
  end
  
  if items.empty?
    ""
  else
    case mode
    when :inline
      option = " or " if option.nil?
      
      if items.size == 1
        items.first
      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.to_s.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
    when :uneven_columns_across
      if option.nil?
        limit = @wrap_at || 80
        items.size.downto(1) do |column_count|
          row_count = (items.size / column_count.to_f).ceil
          rows      = Array.new(row_count) { Array.new }
          items.each_with_index do |item, index|
            rows[index / column_count] << item
          end

          widths = Array.new(column_count, 0)
          rows.each do |row|
            row.each_with_index do |field, column|
              size           = actual_length(field)
              widths[column] = size if size > widths[column]
            end
          end

          if column_count == 1 or
             widths.inject(0) { |sum, n| sum + n + 2 } <= limit + 2
            return rows.map { |row|
              row.zip(widths).map { |field, i|
                "%-#{i + (field.to_s.length - actual_length(field))}s" % field
              }.join("  ") + "\n"
            }.join
          end
        end
      else
        row_count = (items.size / option.to_f).ceil
        rows      = Array.new(row_count) { Array.new }
        items.each_with_index do |item, index|
          rows[index / option] << item
        end

        widths = Array.new(option, 0)
        rows.each do |row|
          row.each_with_index do |field, column|
            size           = actual_length(field)
            widths[column] = size if size > widths[column]
          end
        end

        return rows.map { |row|
          row.zip(widths).map { |field, i|
            "%-#{i + (field.to_s.length - actual_length(field))}s" % field
          }.join("  ") + "\n"
        }.join
      end
    when :uneven_columns_down
      if option.nil?
        limit = @wrap_at || 80
        items.size.downto(1) do |column_count|
          row_count = (items.size / column_count.to_f).ceil
          columns   = Array.new(column_count) { Array.new }
          items.each_with_index do |item, index|
            columns[index / row_count] << item
          end

          widths = Array.new(column_count, 0)
          columns.each_with_index do |column, i|
            column.each do |field|
              size      = actual_length(field)
              widths[i] = size if size > widths[i]
            end
          end

          if column_count == 1 or
             widths.inject(0) { |sum, n| sum + n + 2 } <= limit + 2
            list = ""
            columns.first.size.times do |index|
              list << columns.zip(widths).map { |column, width|
                field = column[index]
                "%-#{width + (field.to_s.length - actual_length(field))}s" %
                field
              }.compact.join("  ").strip + "\n"
            end
            return list
          end
        end
      else
        row_count = (items.size / option.to_f).ceil
        columns   = Array.new(option) { Array.new }
        items.each_with_index do |item, index|
          columns[index / row_count] << item
        end

        widths = Array.new(option, 0)
        columns.each_with_index do |column, i|
          column.each do |field|
            size      = actual_length(field)
            widths[i] = size if size > widths[i]
          end
        end

        list = ""
        columns.first.size.times do |index|
          list << columns.zip(widths).map { |column, width|
            field = column[index]
            "%-#{width + (field.to_s.length - actual_length(field))}s" % field
          }.compact.join("  ").strip + "\n"
        end
        return list
      end
    else
      items.map { |i| "#{i}\n" }.join
    end
  end
end

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

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

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

# File lib/highline.rb, line 612
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 403
def uncolor(string)
  self.class.uncolor(string)
end

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

# File lib/highline.rb, line 972
def actual_length( string_with_escapes )
  string_with_escapes.to_s.gsub(/\e\[\d{1,2}m/, "").length
end

# File lib/highline.rb, line 937
def continue_paging?
  command = HighLine.new(@input, @output).ask(
    "-- press enter/return to continue or q to stop -- "
  ) { |q| q.character = true }
  command !~ /\A[qQ]\Z/  # Only continue paging if Q was not hit.
end

# File lib/highline.rb, line 678
def explain_error( error )
  say(@question.responses[error]) unless error.nil?
  if @question.responses[:ask_on_error] == :question
    say(@question)
  elsif @question.responses[:ask_on_error]
    say(@question.responses[:ask_on_error])
  end
end

# File lib/highline.rb, line 693
def gather(  )
  @gather           = @question.gather
  @answers          = [ ]
  original_question = @question
  
  @question.gather = false
  
  case @gather
  when Integer
    @answers << ask(@question)
    @gather  -= 1

    original_question.question = ""
    until @gather.zero?
      @question =  original_question
      @answers  << ask(@question)
      @gather   -= 1
    end
  when ::String, Regexp
    @answers << ask(@question)

    original_question.question = ""
    until (@gather.is_a?(::String) and @answers.last.to_s == @gather) or
          (@gather.is_a?(Regexp) and @answers.last.to_s =~ @gather)
      @question =  original_question
      @answers  << ask(@question)
    end
    
    @answers.pop
  when Hash
    @answers = { }
    @gather.keys.sort.each do |key|
      @question     = original_question
      @key          = key
      @answers[key] = ask(@question)
    end
  end
  
  @answers
end

# File lib/highline.rb, line 743
def get_line(  )
  if @question.readline
    require "readline"    # load only if needed

    # capture say()'s work in a String to feed to readline()
    old_output = @output
    @output    = StringIO.new
    say(@question)
    question = @output.string
    @output  = old_output
    
    # prep auto-completion
    Readline.completion_proc = lambda do |string|
      @question.selection.grep(/\A#{Regexp.escape(string)}/)
    end
    
    # work-around ugly readline() warnings
    old_verbose = $VERBOSE
    $VERBOSE    = nil
    raw_answer  = Readline.readline(question, true)
    if raw_answer.nil?
      if @@track_eof
        raise EOFError, "The input stream is exhausted."
      else
        raw_answer = String.new # Never return nil
      end
    end
    answer      = @question.change_case(
                      @question.remove_whitespace(raw_answer))
    $VERBOSE    = old_verbose

    answer
  else
    if JRUBY
      enable_echo_afterwards = @java_terminal.isEchoEnabled
      @java_terminal.disableEcho
      begin
        raw_answer = @java_console.readLine(nil, nil)
      ensure
        @java_terminal.enableEcho if enable_echo_afterwards
      end
    else
      raise EOFError, "The input stream is exhausted." if @@track_eof and
                                                          @input.eof?
      raw_answer = @input.gets
    end

    @question.change_case(@question.remove_whitespace(raw_answer))
  end
end

# File lib/highline.rb, line 813
def get_response(  )
  return @question.first_answer if @question.first_answer?

  stty = (CHARACTER_MODE == "stty")

  if @question.character.nil?
    if @question.echo == true and @question.limit.nil?
      get_line
    else
      if JRUBY
        enable_echo_afterwards = @java_terminal.isEchoEnabled
        @java_terminal.disableEcho
      elsif stty
        raw_no_echo_mode
      end

      line            = ""
      backspace_limit = 0
      begin

        while character = get_single_character(stty)
          # honor backspace and delete
          if character == 127 or character == 8
            line.slice!(-1, 1)
            backspace_limit -= 1
          else
            line << character.chr
            backspace_limit = line.size
          end
          # looking for carriage return (decimal 13) or
          # newline (decimal 10) in raw input
          break if character == 13 or character == 10
          if @question.echo != false
            if character == 127 or character == 8
              # only backspace if we have characters on the line to
              # eliminate, otherwise we'll tromp over the prompt
              if backspace_limit >= 0 then
                @output.print("\b#{HighLine.Style(:erase_char).code}")
              else
                  # do nothing
              end
            else
              if @question.echo == true
                @output.print(character.chr)
              else
                @output.print(@question.echo)
              end
            end
            @output.flush
          end
          break if @question.limit and line.size == @question.limit
        end
      ensure
        if JRUBY
          @java_terminal.enableEcho if enable_echo_afterwards
        elsif stty
          restore_mode
        end
      end
      if @question.overwrite
        @output.print("\r#{HighLine.Style(:erase_line).code}")
        @output.flush
      else
        say("\n")
      end

      @question.change_case(@question.remove_whitespace(line))
    end
  else
    if JRUBY
      enable_echo_afterwards = @java_terminal.isEchoEnabled
      @java_terminal.disableEcho
    end
    begin
      if @question.character == :getc
        response = get_single_character(true).chr
      else
        response = get_single_character(stty).chr
        if @question.overwrite
          @output.print("\r#{HighLine.Style(:erase_line).code}")
          @output.flush
        else
          echo = if @question.echo == true
            response
          elsif @question.echo != false
            @question.echo
          else
            ""
          end
          say("#{echo}\n")
        end
      end
    ensure
      if JRUBY
        @java_terminal.enableEcho if enable_echo_afterwards
      end
    end
    @question.change_case(response)
  end
end

# File lib/highline.rb, line 794
def get_single_character(is_stty)
  if JRUBY
    @java_console.readVirtualKey
  elsif is_stty
    @input.getbyte
  else
    get_character(@input)
  end
end

# File lib/highline.rb, line 922
def page_print( output )
  lines = output.scan(/[^\n]*\n?/)
  while lines.size > @page_at
    @output.puts lines.slice!(0...@page_at).join
    @output.puts
    # Return last line if user wants to abort paging
    return (["...\n"] + lines.slice(-2,1)).join unless continue_paging?
  end
  return lines.join
end

# File lib/highline.rb, line 949
def wrap( text )
  wrapped = [ ]
  text.each_line do |line|
    while line =~ /([^\n]{#{@wrap_at + 1},})/
      search  = $1.dup
      replace = $1.dup
      if index = replace.rindex(" ", @wrap_at)
        replace[index, 1] = "\n"
        replace.sub!(/\n[ \t]+/, "\n")
        line.sub!(search, replace)
      else
        line[$~.begin(1) + @wrap_at, 0] = "\n"
      end
    end
    wrapped << line
  end
  return wrapped.join
end