Class: IRB::RelineInputMethod

# File 'lib/irb/input-method.rb', line 529

def prompting?
  true
end

# File 'lib/irb/input-method.rb', line 306

def check_termination(&block)
  @check_termination_proc = block
end

# File 'lib/irb/input-method.rb', line 392

def command_doc_dialog_contents(command_name, width)
  command_class = IRB::Command.load_command(command_name)
  return unless command_class

  [PRESS_ALT_D_TO_READ_FULL_DOC, ""] + command_class.doc_dialog_content(command_name, width)
end

# File 'lib/irb/input-method.rb', line 301

def completion_info
  autocomplete_message = Reline.autocompletion ? 'Autocomplete' : 'Tab Complete'
  "#{autocomplete_message}, #{@completor.inspect}"
end

# File 'lib/irb/input-method.rb', line 433

def dialog_doc_position(cursor_pos_to_render, autocomplete_dialog, screen_width)
  width = 40
  right_x = cursor_pos_to_render.x + autocomplete_dialog.width
  if right_x + width > screen_width
    right_width = screen_width - (right_x + 1)
    left_x = autocomplete_dialog.column - width
    left_x = 0 if left_x < 0
    left_width = width > autocomplete_dialog.column ? autocomplete_dialog.column : width
    if right_width.positive? && left_width.positive?
      if right_width >= left_width
        width = right_width
        x = right_x
      else
        width = left_width
        x = left_x
      end
    elsif right_width.positive? && left_width <= 0
      width = right_width
      x = right_x
    elsif right_width <= 0 && left_width.positive?
      width = left_width
      x = left_x
    else
      return nil
    end
  else
    x = right_x
  end
  [x, width]
end

# File 'lib/irb/input-method.rb', line 464

def display_document(matched)
  target = retrieve_document_target(matched)
  return unless target

  case target
  when CommandDocument
    command_class = IRB::Command.load_command(target.name)
    if command_class
      content = command_class.help_message || command_class.description
      Pager.page(retain_content: true) do |io|
        io.puts content
      end
    end
  when MethodDocument
    driver = rdoc_ri_driver
    return unless driver

    if matched =~ /\A(?:::)?RubyVM/ && !ENV['RUBY_YES_I_AM_NOT_A_NORMAL_USER']
      IRB.__send__(:easter_egg)
      return
    end

    if target.names.length > 1
      out = RDoc::Markup::Document.new
      target.names.each do |m|
        begin
          driver.add_method(out, m)
        rescue RDoc::RI::Driver::NotFoundError
        end
      end
      driver.display(out)
    else
      begin
        driver.display_names([target.name])
      rescue RDoc::RI::Driver::NotFoundError
      end
    end
  end
end

# File 'lib/irb/input-method.rb', line 310

def dynamic_prompt(&block)
  @prompt_proc = block
end

# File 'lib/irb/input-method.rb', line 399

def easter_egg_dialog_contents
  type = STDOUT.external_encoding == Encoding::UTF_8 ? :unicode : :ascii
  lines = IRB.send(:easter_egg_logo, type).split("\n")
  lines[0][0, PRESS_ALT_D_TO_SEE_MORE.size] = PRESS_ALT_D_TO_SEE_MORE
  lines
end

# File 'lib/irb/input-method.rb', line 507

def gets
  Reline.input = @stdin
  Reline.output = @stdout
  Reline.prompt_proc = @prompt_proc
  Reline.auto_indent_proc = @auto_indent_proc if @auto_indent_proc
  if l = Reline.readmultiline(@prompt, false, &@check_termination_proc)
    Reline::HISTORY.push(l) if !l.empty? && l != Reline::HISTORY.to_a.last
    @line[@line_no += 1] = l + "\n"
  else
    @eof = true
    l
  end
end

# File 'lib/irb/input-method.rb', line 534

def inspect
  config = Reline::Config.new
  str = "RelineInputMethod with Reline #{Reline::VERSION}"
  inputrc_path = File.expand_path(config.inputrc_path)
  str += " and #{inputrc_path}" if File.exist?(inputrc_path)
  str
end

# File 'lib/irb/input-method.rb', line 406

def rdoc_dialog_contents(name, width)
  driver = rdoc_ri_driver
  return unless driver

  name = driver.expand_name(name)

  doc = if name =~ /#|\./
    d = RDoc::Markup::Document.new
    driver.add_method(d, name)
    d
  else
    found, klasses, includes, extends = driver.classes_and_includes_and_extends_for(name)
    if found.empty?
      d = RDoc::Markup::Document.new
      driver.add_method(d, name)
      d
    else
      driver.class_document(name, found, klasses, includes, extends)
    end
  end

  formatter = RDoc::Markup::ToAnsi.new
  formatter.width = width
  [PRESS_ALT_D_TO_READ_FULL_DOC] + doc.accept(formatter).split("\n")
rescue RDoc::RI::Driver::NotFoundError
end

# File 'lib/irb/input-method.rb', line 331

def rdoc_ri_driver
  return @rdoc_ri_driver if defined?(@rdoc_ri_driver)

  begin
    require 'rdoc'
  rescue LoadError
    @rdoc_ri_driver = nil
  else
    options = {}
    options[:extra_doc_dirs] = IRB.conf[:EXTRA_DOC_DIRS] unless IRB.conf[:EXTRA_DOC_DIRS].empty?
    @rdoc_ri_driver = RDoc::RI::Driver.new(options)
  end
end

# File 'lib/irb/input-method.rb', line 318

def retrieve_document_target(matched)
  preposing, _target, postposing, bind = @completion_params
  result = @completor.doc_namespace(preposing, matched, postposing, bind: bind)
  case result
  when DocumentTarget, nil
    result
  when Array
    MethodDocument.new(*result)
  when String
    MethodDocument.new(result)
  end
end

# File 'lib/irb/input-method.rb', line 345

def show_doc_dialog_proc
  input_method = self # self is changed in the lambda below.
  ->() {
    dialog.trap_key = nil

    if just_cursor_moving && completion_journey_data.nil?
      return nil
    end
    cursor_pos_to_render, result, pointer, autocomplete_dialog = context.pop(4)
    return nil if result.nil? || pointer.nil? || pointer < 0

    matched_text = result[pointer]
    show_easter_egg = matched_text&.match?(/\ARubyVM/) && !ENV['RUBY_YES_I_AM_NOT_A_NORMAL_USER']
    target = show_easter_egg ? nil : input_method.retrieve_document_target(matched_text)

    x, width = input_method.dialog_doc_position(cursor_pos_to_render, autocomplete_dialog, screen_width)
    return nil unless x

    dialog.trap_key = ALT_D_SEQUENCES

    if key.match?(dialog.name)
      begin
        print "\e[?1049h"
        input_method.display_document(matched_text)
      ensure
        print "\e[?1049l"
      end
    end

    contents = case target
    when CommandDocument
      input_method.command_doc_dialog_contents(target.name, width)
    when MethodDocument
      input_method.rdoc_dialog_contents(target.name, width)
    else
      if show_easter_egg
        input_method.easter_egg_dialog_contents
      end
    end
    return nil unless contents

    contents = contents.take(preferred_dialog_height)
    y = cursor_pos_to_render.y
    Reline::DialogRenderInfo.new(pos: Reline::CursorPos.new(x, y), contents: contents, width: width, bg_color: '49')
  }
end